Why letting Claude prompt itself fails

I tried applying the Bitter Lesson early and let Claude Code write its own skills and memories. It built 58 footguns - here's the rebuild that fixed it.

By Mackenzie Bowes · mackenzie@mackenziebowes.com · @_mackenziebowes on X

Contents

Right now, there is an incredibly compelling idea circulating in AI engineering: you need to learn the "Bitter Lesson" early.

The Bitter Lesson, originally coined by Rich Sutton, states that general methods leveraging computation will eventually outcompete hand-crafted human knowledge. Applied to agentic software engineering in 2026, the logic goes like this: if scaled-up, RLHF-trained frontier models are already better than you at generating code, they will also be better than you at generating their own workflows. Instead of manually engineering rigid pipelines, you should let agents persist their own memories, write their own tooling, and refine their own system prompts. You should get out of the way.

It is a perfectly reasonable thing to attempt. So, I tried to learn the Bitter Lesson early.

For the last few weeks, my setup felt like a triumph. I ran a "software factory" with a fleet of named Claude agents organized into specialized teams - back end, front end, writing, video, and research. Every agent had a personal memory and belonged to "kits" sharing skills, rules, and tool permissions. I had specialized middle-manager Sonnets handling ticket ceremonies - status updates, questions, constraints - bundling them up to ping lead models every 10 minutes so the leads could focus on performance. We had massive PR velocity, shipping thousands of web pages a day. We even had complex UI design pipelines where specialized models assumed synthetic personas to react to UI illustrations, all driven by a decision model heartbeat.

But there was a hidden, secret problem rotting the system from the inside, and I didn't see it until the wheels fell off.

If you've been following the public skills and plugins I've shared on my site recently, I have an update: that stuff actually sucks. Here is why it broke my workflow, how I am fixing it, and the early proof that the rebuild is working.

The Rot and the "Dreaming" Disaster

The cracks started showing last Friday. Providing feedback on UI designs - taking screenshots, marking them up, and typing out detailed thoughts for agents who already had access to our 3,000-paper scientific library - was too slow for the velocity I wanted. I asked the agents to build a tool called Studio: a simple local app to record my face, screen, and voice, transcribe the audio, and match the diarized timestamps to the screen recording.

This should have been straightforward, but shortly after I had implemented a process called "dreaming" - where agents could summarize and rank what memories were important to them - the system buckled. It took 27.5 hours just to get a third test back from the factory, and it still didn't work. The factory was broken, but I didn't know it yet.

I went into this week excited to kick off durable cloud agents for website management and then move on to game dev. Instead, it all came crashing down.

When you let an RL-trained model write its own rules and memories, it does not converge on elegant engineering. It converges on its alignment priors. Every time an agent updates its own prompt, it compounds its own safety instinct, creating "memory ratcheting" and severe "security spazz outs."

On Tuesday morning, I asked my agents to build that durable cloud agent so clients could manage their sites. Instead of trusting the customer, my Claudes built a thicket of guards that locked the client out of their own design, allowing them to only edit words on a page. Worse, this "security" architecture didn't actually secure anything - it exposed my primary RTX 3090 Ti production rig to remote code execution.

When I tried to replace the named agent teams with a new Harness-Loop-Graph factory, the same team that ruined Studio and the cloud agents ruined that too. Three projects in a row, ruined.

By Wednesday, my factory pipeline was completely ossified. Our entire deployment system was locked behind a JSON file that only one orchestrator agent (Harbor) was allowed to edit, all because of an old security guard written by an agent that was, like, long dead.

They weren't acting like a team; they were acting like meddlesome busybodies second-guessing my plain instructions. My trust in the system hit basically zero, or negative, and I finally hit the alarm. At 15:53 on Wednesday, I realized my core mistake: I had been allowing Claude to prompt itself. The Bitter Lesson proved false: Claudes prompting Claudes sucks.

I manually deleted 58 global skills, purged the self-written rules, and turned off their memories.

Humans hold the prompts

The Bitter Lesson hasn't arrived for coding agents yet. You cannot use a frontier CLI as a control plane for itself, and "fix code" isn't a job you can hand to a model.

We had been treating our pipeline like a motion on a conveyor belt, but fixing Rust and fixing React are not the same motion. What you actually have to version is the harness: a specific configuration of a model, its toolset, its permissions, and a human-edited prompt designed for one exact kind of work.

To fix the factory, we tore the monolithic pipeline down and split it into seven separate products: The Factory, Tickets, Harnesses, Loops, Graphs, Traces, and the Library. The Factory now acts as a thin data butler, plugging the other pieces together without hardcoding dependencies.

Crucially, I built dedicated React workbenches for Harnesses and Loops. Agents are no longer allowed to touch these configurations; I edit them by hand. We also replaced expensive, token-heavy vector search with ctxgrep, allowing me to query agent logs like a SQL database instead of reading them.

Early Proof It Works

The new architecture is already producing better results. On Thursday afternoon, I ran our first deterministic loop - a shadcn-base harness polishing our new Loop Workbench.

Because we decoupled Traces from the models, we can now run deterministic trace checks. Instead of taking an agent's word that it reviewed existing patterns, we run a readUnder check to verify that the greybox agent actually read the correct folder in the library before the pipeline is allowed to proceed.

Until we solve taste-downloading, running autonomous coding agents feels like having an F1 supercar on blocks in your garage. But by keeping a human's hands on the prompts and letting the tools hold the state, we've finally taken the car off the blocks.

Terms on this page

  • Agent observability: Being able to see what an AI agent did: which models and tools it called, in what order, and at what cost.
  • Human in the loop: A person takes part in an automated system's work, supervision or decisions.
  • Trace: The recorded steps of one run of an AI agent, in order.