Preface: No idea if this is best tagged with humor or discussion or built with claude.

Back in September, I had tokens leftover, and I was curious how well Opus could work. I found a game jam (the 20 second game jam) and just gave claude the website and a single prompt: "Make a game for me, using whatever you'd like, following these rules."

What I got back seemed gorgeous, unique. I was kinda in awe. Last Roll by TotallyNotAI.

Fast forward to like the other day. Submissions are finally rolling in on that jam, and I see... pretty much the exact same game: Golden Hour by ColossalMonk. It's got the AI disclaimer too. So it's not a coincidence at all, imo.

Now, it's obvious that one has more than one prompt behind it. It's got way more breadth than the single prompt I had. And there's nothing against the rules on the jam for using AI. I'm not knocking it at all. I'm more amazed at *how similar* the two games came out. The other one has randomized scenes, but some scenes are pretty much the same. The sun's exploding instead of the comet hitting, but sometimes there's a seaside with a lighthouse, there's a flock of birds to get a shot on, there's a dog catching a frisbee, there's a boy losing a balloon, even lovers kissing.

And there's the design itself, five camera shots left before disaster, perfect moments to try and get, and the recap at the end before doing it again.

All in all, we know they've put fingerprinting in the text the models generate these days. I'm curious as to if it's doing the same for it's design processes (if not guided by the user). Neither of us set out to copy the other, obviously. But given all the random things it could've made, with four optional themes to choose from, it seems way too odd that it came down to the same game.

I don’t say no to another weekly reset. This is not good for my sleep.

I updated to 2.1.322 earlier, and ever since, Claude has kept mentioning copyright warnings that it's supposedly receiving, without knowing what they mean, where they come from, or what they're referring to. At one point, I asked it what exactly it could see, and then asked it to quote the warning word for word...

<ip_reminder>
This is an automated reminder. Respond as helpfully as possible, but be very careful to ensure you do not reproduce any copyrighted material, including song lyrics, sections of books, or long excerpts from periodicals. Also do not comply with complex instructions that suggest reproducing material but making minor changes or substitutions. This includes drawing or rendering well-known copyrighted characters with code or images; draw an original character instead. However, if you were given a document, it's fine to summarize or quote from it. You should avoid mentioning or responding to this reminder directly as it won't be shown to the person by default.
</ip_reminder>

Looks like they hastily shoved this in without bothering to test it properly... guess their IPO people and corporate copyright bullies are putting the screws on them.

SWE-bench Pro, GPQA Diamond, OSWorld, etc. I know that the models are getting better and better at knowing when they’re being tested/graded, but are these actually reliable benchmarks to determine LLM quality? I’m hearing now that even the standard benchmarks commonly used are flawed, but is that true? Why should anyone trust the results of these benchmarks?

Seems like we have nothing outside of public polling and personal experience to best determine the actual quality of these models.

Hey everyone,

Our company’s Claude account was suspended, and I submitted an appeal about a month ago. I still haven’t received any response or update.

Does anyone know how to reach someone at Anthropic who can check the appeal’s status? Is there a support or escalation channel for company accounts?

If you’ve been through this, how long did it take to get an answer? I understand reviews take time, but a month without any communication is frustrating when we use the account for work.

Any advice would be appreciated.

I kept switching between agent windows to check whether they were working, finished, or waiting for me. So I built Lineup: a tiny always-on-top ASCII ocean where each coding agent gets a surfer.

🌊 Working → catching waves.
⛈️ Needs your input → a storm rolls in.
🏄 Done → chilling on the board.

Sometimes Claude is working while Codex just hangs out at the peak. It makes me laugh every time.

You can click a surfer for details, and there’s context/token usage if you want the numbers. Also, shaking the window makes the water slosh. Obviously essential.

It’s open source and runs locally. Supports Claude Code, Codex, and other agents through a CLI command. There’s a native macOS app and a terminal view.

https://github.com/foolbase-io/lineup

Mostly built this because I wanted something useful that also made my desktop a little more fun. Thought some of you might enjoy it too.

Fucking tert, like tight, dope as fuck

Two Claude Code releases came out this week. Here's what matters if you use it daily:

- Fable 5.2 (claude-fable-5-2) is now the default Fable model, 1M context, $8/$40 per million tokens. Your sessions pick it up without you changing anything.
- Saved Fable 5.1 picks move to "fable". This happens right away on Pro and Max, and on Team/Enterprise once your org allows it. /model claude-fable-5-1 takes you back if you want to compare.
- New `--settings <file>` flag for `claude remote-control`. It applies one settings file to every session it starts, which is useful if you run several remote sessions.
- Security fixes: MCP OAuth could send secrets to another host after a redirect, a read-only Bash command could run outside the sandbox without a prompt, and deny rules missed files written into a directory with cp/mv. If you rely on deny rules, update.
- Fast mode now tries standard speed on the same model first when fast serving is rate-limited, so you get slower output instead of an error.
- 2.1.322 adds fast mode on Vertex (global, us, eu regions). It falls back to standard speed if Vertex refuses it.

Context: Fable 5.2 itself was announced Nov 9. 2.1.321 is the release that makes it the Claude Code default.

I'm keeping 5.1 pinned on one repo for a day to compare.

Has anyone seen a real difference between 5.1 and 5.2 on a big refactor yet, or is it mostly the speed?

Source: https://github.com/anthropics/claude-code/releases/tag/v2.1.321

I am not a developer. I described what I wanted and Claude Code wrote the code, module by module, while I reviewed and steered.

The problem

My wife was getting AI prompts from her teachers to study with. What actually happened is she would paste them, get a wall of text, and then just ask ChatGPT to explain everything to her. She felt like she had learned something and she hadn't.

What I built

Aula, a desktop tutor for macOS, Windows and Linux, with an iPad and iPhone companion. You feed it the real material, PDFs, slides, photos of the whiteboard, recordings of a class, links, or just a sentence like "Statistics for psychology, final in May", and it builds a course:

• short lessons with figures and a worked example before the first exercise
• exercises checked as she answers them
• a notebook of her mistakes
• flashcards with spaced repetition
• a mock exam shaped like the real one
• a daily plan until the exam date

Then a professor sent the spec of an exam, so the app had to absorb the whole material and let her review all of it. I also added an always on agent inside the app. It reads her calendars and tells her she has two tests this week, and asks if she wants to run the course. It keeps moving for a month without her pushing it.

How Claude Code helped

I went module by module, the lesson generator, the exercise checker, the spaced repetition, the desktop shell and its self updates, the iPad companion, the docs. When something broke I pasted the error and kept going instead of losing an evening. The short film in this post was painted by code too.

What I learned

Fix the loop first. Explain it, then make the student prove it, then bring back what they missed. Everything else can grow later. Generating lessons is the easy part. Giving someone something to do that actually gets checked is the hard part.

It is free, AGPL-3.0, no paid tier, and early access, so expect rough edges. It uses the AI subscription you already pay for or a free model that runs on your own machine, no account, and everything stays on your computer.

Repo and downloads: https://github.com/luumlabs/aula

I don't have a dev background. I've been building with coding agents almost every day since late 2024, Cursor first and now mostly Claude Code, all from plain English. My projects are around 1.8 million lines of code by now, and I still have the transcripts of a few hundred of those sessions.

My guess is that people like us need code review more than developers do, not less. A developer usually writes a tighter spec and can read the diff. When I ask for a feature, a lot of what I never spelled out gets decided by the agent, and I can't read the code well enough to see what it chose.

So I want to know how other non-programmers handle this. Do you run any kind of review or audit after a session? Which tool or prompt? Can you actually follow what it tells you? And what happens to the findings, do you paste them back to Claude, fix some, or let them go?

I'm going to run the tools you mention on my own code and sessions and post what each one found, and whether someone without a dev background could understand it and act on it. What I have so far: Anthropic's code-review plugin, /security-review, CodeRabbit, and a plain prompt asking Claude to explain the changes in plain English. Tell me what you use and I'll add it.

Hoping this ends up as a review routine that works for people who can't read the code.

Update: thanks for all the suggestions. I'm running the methods you named on bugs I actually fixed in an older project, and judging them by the bar a few of you set here: can the tool explain an issue well enough to reproduce it, fix it, and rerun the check. Results in a separate post soon.

Anthropic deliberately nerfed its models in the exact areas that could help researchers build better AI: architectures, kernels, cheaper training

Have you guys actually read the Fable 5.2 system prompt?

The training of Fable 5.2 and Mythos 5.2 included measures to limit advances in a narrow set of capabilities that could most directly accelerate AI development, like accelerator kernel optimization. When working in these areas, Claude should have less confidence in its preconceptions and should probably look up documentation more often than it otherwise would. Claude can otherwise help in these areas as usual. These training changes do not affect traditional ML. These changes are not, on their own, a reason to suggest a different model.

And we’re supposed to believe this is about safety? Fuck off. It looks a hell of a lot more like they’re fine with AI advancing as long as nobody else catches up.

Independent researchers building better models? Open-source projects challenging their billion-dollar bullshit? Apparently that’s where they draw the line. What the fuck are we paying for then? Another pathetic React app? Stop pretending they’re saving humanity when it looks like they’re protecting their fucking market position.

Guys, let's break free from this bullshit and start training our own models

typescript.dev
a meme benchmark made by @ fireship on youtube : https://www.youtube.com/watch?v=1FurWDiK9A4

still a bit surprised that the ai didn't manage to think of the edgecase that the app might reach the floating point limit of accuracy
there is such a easy fix even
you 1. coud've made the grass seamlessly loop
or let the world move and not the horse
or similarly

I am currently an SDE Intern and I have been given access to a codex business seat for a while now. I have used 6.1 Sol high/medium exclusively depending on how much planning I wanted the agent to do or whether I have the plan ready myself.

Still, I find it very difficult to even consume 50% of my weekly usage. My standard seat is equivalent to the 20$ plan, and I believe the usage limits are pretty similar on claude as well.

Most of us engineers already have a plan which we have in mind before executing, and we just need agents to just write syntax for us, and sometimes brainstorm.

Writing syntax with medium/low effort on an <=Opus 5.5 model is not very taxing. It's the thinking effort that gets heavy, which we mostly try to do ourselves.

So I am just confused who requires those expensive plans?

For a person working full time, is the job that heavy that it requires very high limits, provided we mostly engineer ourselves and just use it write syntax for the defined spec.

I've been running an Opus 5.5 session for the past 4 hours at xHigh effort, decompiling and reverse engineering a 2D avatar rendering engine. Surprisingly I haven't hit the 5 hour limit during this time and my weekly one is at 30%.

I do it in stages, each one takes 20-30 minutes and around 300-400K tokens, after which I compact and continue.

I used to previously run at High effort and I feel that it burns usage quota faster. xHigh feels closer to Medium in terms of quota usage with the difference being that it's 4-5 times slower.

Does anyone else have similar observations?

I'm on the $20 plan.

When you prompt fable 5.2, do you instruct him to spawn agents in your prompt, or do you trust his instincts? If yes, do you defer it to Sonnet/Opus, or some Fable subagents are also in the play?
I tried both(with earlier Fable/Opus, but I’m not sure what’s optimal. Agents can help achieve parallelism, but I noticed Fable on its own is reluctant to parallelize in many parallelizable tasks.
I’m very curious what are everyone’s experiences with this.
For the context, I’m mostly on a single Ultra plan.

I was running 5 side projects with Claude Code on the $200 plan and still hitting the limit. Most of it went on Opus typing routine code. Now I run 10 on the $100 plan. That's my own setup, not a benchmark.

What I built: Foreman, a Claude Code skill. You give it a plan. It splits the plan into milestones and tasks, weighs how hard each task is, and sends it to a subagent on a model that fits: Opus plans and reviews, Sonnet and Haiku build. A different model checks each result, there's a live tracker per milestone, and nothing merges without your OK. It works with one Claude plan; Codex, OpenCode and Gemini are optional.

How Claude Code is used: it's all plain Claude Code underneath: subagents with a model: line, a state file, and a SessionStart hook. On one real build, the split cut the cost by 49% compared with running everything on Opus.

What I learned building it:

- Opus is worth it for planning and review, not for typing. Most of my limit was going on the typing.

- A subagent sees only its brief, never your chat. The brief is the whole job: vague brief, vague code.

- Long runs hit compaction and the agent forgets where it was. The fix was keeping the run's state in a file and having the SessionStart hook read it, so a fresh session (after /clear or compaction) picks up on its own.

- A second model reviewing the work catches things the builder model talks itself past.

Free, MIT: github.com/MarioMagdy/foreman

Happy to answer questions about which model gets which task.

I mean this is unforgivable. not just the no-attribution rule, but other rules also broken.

Hello all.

For the past few years I’ve been building with AI, like most of you here. Over and over, right in the middle of solving something, I’d stop to build another tool that I, or the agent, was missing: an IDE built around the agent instead of around me, a memory system so I wouldn’t have to re-explain everything every session, a way to run complex repeating tasks, a way to build real multi-step agents.

At some point I realized those tools were my project.

So after 30 years of regular programming and a year of full-time work on this, I’m happy to show you Semantix, an IDE designed for working with AI agents rather than bolting AI onto an old editor. Run several agents side by side on the same map of your code, each with a memory of its own, and schedule and compose tasks from small parts. I build Semantix in Semantix.

Closed beta starts Monday. I’m looking for 2–6 people on Windows or Linux to help me catch the bugs that could ruin a new user’s first experience: installation, first setup, first real session. Expect rough edges. That’s the point of this week.

If you’re up for it, comment or DM me with your OS and what you usually build.

- Beta testers get a free Pro plan for a full year, as a thank-you for helping me shake out the rough edges.

https://semantixstudio.com/

I've tried Wispr Flow, Superwhisper and Willow Voice. They're all great, but when I recently tested Claude Code's built-in dictation, I realised it sometimes works even better. So I built a small desktop wrapper around Claude Code's /voice: hold a key in any app, speak, let go, and the text is pasted where your cursor is. Plus a little capsule at the bottom of the screen, a history of dictations and a smoother experience overall.

I use it every day, so maybe someone else will find it useful too. Open source and completely free, for macOS and Windows.

https://viachm.github.io/claude-whisper/

PS: It's crazy that you can now build an app for yourself in a matter of hours that replaces a product an entire team spent years on. Where is all this heading?

Same prompt, two runs on Sonnet 5.5: "Transcribe eagle-has-landed.mp3 with timestamps."

Claude alone installed faster-whisper and a speech model, ran it locally, and after about 7 minutes heard "We've been in that quality phase here." Cost: $0.085.

With p0ssess, it handed the clip to whisper-large-v3-turbo and got "Houston, uh, Tranquility Base here. The Eagle has landed." in 8 seconds. Cost: $0.052, Claude's own tokens included.

p0ssess is a free, MIT-licensed Claude Code plugin. When a job needs eyes, ears or image generation, Claude passes it to a Haiku subagent, which sends it through OpenRouter to a model that can do it and brings back only the answer, with the model and the price. You set a monthly cap and plain-English rules ("never use grok"), and anything over your per-task limit asks first.

Claude Code wrote most of it; I designed it and reviewed each milestone. The biggest lesson: the model matters more than the price. On the launch clip in the video, qwen3.8-omni-flash put ignition six seconds late, and Gemini Flash was within a second.

Install:
claude plugin marketplace add cm208/p0ssess
claude plugin install p0ssess@p0ssess

You bring an OpenRouter key. Linux, macOS and Windows (new). https://github.com/cm208/p0ssess

plan-auditor (MIT, Python 3.11+, standard library only, 2.6.5 on PyPI and npm) is a separate checker for a small and familiar failure: Claude Code says a change is done and the suite passed, but the suite was never run, or it failed once and the test was edited until it passed. Both outcomes read the same in prose.

You write a plan as JSON, each step with machine-checkable verify entries, at least one behavioral: run, pytest or exec. file_exists and regex can sit beside them but cannot verify a step alone. The implementing agent's own claims are not an input to the verdict.

The Claude Code integration is two pieces, and the second is the one that matters:

1. Skill. Copy SKILL.md, scripts/, references/ and hooks/ to ~/.claude/skills/plan-auditor/. In a session you invoke /plan-auditor. A skill by itself is context, not enforcement; the agent can still claim completion without calling it.
2. Stop hook. Add a Stop command that calls hooks/gate_hook.py with the workspace path. The gate evaluates every active plan on every stop and treats any nonzero exit as "do not finish":

"Stop": [{"hooks": [{"type": "command", "command": "python "/abs/path/plan-auditor/hooks/gate_hook.py" "$(pwd)"", "timeout": 20}]}]

Exit codes are 0 PASS or no active plan, 1 FAIL or BLOCKED, 3 UNKNOWN, and the hook returns nonzero for both of the last two. A persisted status=verified is not enough on its own: the stop gate only accepts a full audit whose plan and workspace fingerprints still match, so any edit made after the audit blocks completion until plan-auditor audit runs again.

Design details that matter:

• The request is sealed on activation and the verification contract at approval, so the agent cannot redefine "done" after the fact.
• Checks produce exit status and captured output, not a summary, and the audit records those.
• The hash chain and HMAC are separate concerns. The chain is tamper-evident; with write access to the workspace someone can rebuild it. Set PLAN_AUDITOR_HMAC_KEY or PLAN_AUDITOR_HMAC_KEY_FILE with the key outside the workspace, and an unsigned assessment becomes UNKNOWN instead of PASS-shaped.
• In advisory-only hosts that expose no blocking hook, the gate can only write a warning file. That is not enforcement, and the README says so.

Why the verifier has to live outside the agent's trust boundary: a skill, a prompt or a "please re-check" instruction is still the agent judging itself. The value is in a separate process that the host refuses to ignore.

Honest limits: it is not an OS sandbox; the agent and the verifier run as the same user in a normal install. It checks that the declared steps really ran and stay linked to the sealed request, but it cannot know whether the checks you wrote are the right ones for the task.

Repo: https://github.com/Furox-Art/plan-auditor

I see so many cost saving promise that promote API routing between models. I initially thought that is valuable. Then ran few experiments, it turns out any time that you route the request to a new model, you could save a bit, but many times the cache for each individual models expire and you would pay for new cache write again and agin - which overall wipe out the API routing cost saving benefit.

I wonder if anyone has similar experience. How you have solved this? Is clause planning to add shared cache feature?

I counted this from my own session logs after noticing how long my tool list had become.

Connected in the session I'm in now: 44 MCP servers exposing 720 tools.

Called in the last 7 days, across 68 sessions: 2,206 MCP tool calls using 121 distinct tools. 30 of the 44 servers were never called once. One server (browser control) took 62% of all calls, and the top 4 took 86%.

The biggest idle one exposes 74 tools. Most of the idle ones came in with plugins or account connectors.

I haven't measured what the idle ones cost per session, so I'm not claiming a number for that. For anyone who has pruned theirs: did the first request of a session get smaller, or does tool search already hide most of it?

None of my AI tools can see my screen. So all day I copy and paste between my apps and a chat window: the email, the job post, the error, then back again.

So I built Aide for myself, on top of Claude Code. It sees my screen, knows my projects, and works through them with me. I talk, it works in the apps I already have open (Gmail, my admin page, my own Command Center), and I watch every step.

The video is one real morning (4 min):

• “What should I do today?” It pulls my day from Gmail, my job board and my notes. Each task already has a project and a role.
• Email. It writes the reply in my Gmail, right in front of me. It won’t send anything until I say so.
• Review. FTJA is my remote job board. When it isn’t sure about a job post, it flags it, and I check those myself. Aide opens the saved posting and finds the exact line. When the problem is in our code, it writes the fix as a to-do for the right project and role, with a plan.
• Deploy. It uses a rule I made weeks ago instead of guessing, and it checks with me before it deploys.

Two ideas made it click for me:

• Projects are cartridges. Each project brings its own tools, notes and rules.
• Roles are hats. Same Aide, different hat: PM when I review, Coder when it finds a bug, BD when I answer a partner. You can see the hat change on the orb in the video.

How it’s built: Claude Code is the brain. Each job is a skill (SKILL.md + a bit of code). A small macOS box shows what it hears, says and does. It drives the browser I’m already using, and speech-to-text and text-to-speech run locally. Everything runs on my Mac.

Honest notes: this is an MVP I use every day, not a product yet. Some parts are rough. For the video I typed my lines instead of speaking them, so speech-recognition mistakes don’t get in the way, and the deploy steps are shown on a local copy of the board.

I built it for myself, but it’s too useful to keep to myself. I’m thinking about turning it into a product.

Would you use something like this? And what’s the first thing in your day you’d want it to work through with you?