<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
     xmlns:content="http://purl.org/rss/1.0/modules/content/"
     xmlns:dc="http://purl.org/dc/elements/1.1/"
     xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Chipp Engineering</title>
    <link>https://chipp.ai/engineering</link>
    <atom:link href="https://chipp.ai/engineering/rss.xml" rel="self" type="application/rss+xml" />
    <description>Architecture deep-dives, postmortems, and the engineering thinking behind Chipp — the platform for AI builders.</description>
    <language>en-us</language>
    <lastBuildDate>Fri, 16 Oct 2026 23:10:58 GMT</lastBuildDate>
    <item>
      <title>What Is an Autonomous Company?</title>
      <link>https://chipp.ai/engineering/what-is-an-autonomous-company</link>
      <guid isPermaLink="true">https://chipp.ai/engineering/what-is-an-autonomous-company</guid>
      <pubDate>Sun, 26 Jul 2026 00:00:00 GMT</pubDate>
      <dc:creator>Hunter Hodnett</dc:creator>
      <description>Chatbots answered questions. Copilots made one person faster. The next step is a team of AI agents that runs real operations together: an autonomous company. Here is what that means, and how to build one.</description>
      <category>autonomous-companies</category>
      <category>ai-agents</category>
      <category>vision</category>
      <category>platform</category>
      <category>autonomous company</category>
      <category>autonomous companies</category>
      <category>team of AI agents</category>
      <category>AI agents for business</category>
      <category>multi-agent business operations</category>
      <content:encoded><![CDATA[# What Is an Autonomous Company?

Chatbots answered questions. Copilots made one person faster. The next step is a team of AI agents that runs real operations together: an autonomous company. Here is what that means, and how to build one.

---

Most businesses have now met AI twice.

The first time, it was a chatbot in the corner of the website. It answered questions, deflected some tickets, and never actually did any of the work. A better FAQ, not a workforce.

The second time, it was a copilot. It made one person faster at one task, as long as that person sat there and drove every step. Real progress, but bounded by a hard ceiling: your attention. You can supervise one copilot at a time, and it stops the moment you stand up.

Neither of those runs anything. The next step does.

## The definition

**An autonomous company is a team of AI agents that work together to run real business operations.**

Four properties separate it from everything that came before:

1. **Each agent has a job, not a chat window.** One answers the phone. One handles bookings on WhatsApp. One does research and drafts the outreach. You staff it the way you staff a team: by role.

2. **They share knowledge.** Your pricing, policies, and documents live in one place, and every agent works from the same source of truth. When a document changes, every agent knows, on every channel.

3. **They hand work to each other.** The front-line agent pulls in the specialist when a conversation goes deep. Work flows between agents the way it flows between coworkers, without a human routing every step.

4. **They act without being asked.** Real employees do not sit silently until spoken to. Agents in an autonomous company follow up with customers, send the weekly digest, and flag what needs attention, on a schedule, proactively.

## What it looks like in practice

Take a clinic. A voice agent answers the phone around the clock, checks availability, and books the appointment. A WhatsApp agent handles the "can I move my Thursday slot" messages. A knowledge agent stays current because it learns straight from the folders where the practice already saves its documents. An outreach agent sends recall reminders on schedule. And when a conversation needs a human, a human takes over mid-thread, with full context.

No single chatbot does that. A team does. That is the difference in one sentence: a chatbot talks about the work, an autonomous company does the work.

## Autonomy is not the absence of control

"Autonomous" does not mean unsupervised. It means the supervision moves up a level: from driving every step to setting direction and boundaries.

You decide what the agents know, which channels they live on, what they are allowed to spend, and when a person steps in. Budgets are capped. Sensitive actions wait for approval. Every conversation is visible, and takeover is one click. An autonomous company is accountable by construction, because accountability is what makes the autonomy safe to grant.

## We run part of ours this way already

This is not a thought experiment for us. Chipp's own engineering runs on autonomous agents that field tickets, fix bugs, and ship code while the team sleeps. We have written extensively about that system here on this blog, starting with [the Autonomous Development Manifesto](/engineering/autonomous-development).

Engineering was simply the first function to cross the line, because software is where the tooling matured first. Support, operations, outreach, and scheduling are crossing it now. The curve is the same every time: first a tool that talks, then a tool that assists, then a team that runs.

## How to start

Not with a platoon. Autonomous companies are grown, not launched.

Start with one agent doing one job well: the phone line, the booking flow, the support inbox. Give it your knowledge, put it on the channel where the work actually happens, and watch it. When you trust it, add the second agent, connect them, and let them hand work to each other. Autonomy is earned one role at a time.

That is exactly what Chipp is built for. More than 125,000 agents already run on the platform, and they have carried over 14 million conversations for real businesses. The infrastructure for building an autonomous company, without an engineering team, is no longer the hard part.

The era of autonomous companies is here. You're early.

[Start building →](https://build.chipp.ai)
]]></content:encoded>
    </item>
    <item>
      <title>Distillation Is Your Moat</title>
      <link>https://chipp.ai/engineering/distillation-is-your-moat</link>
      <guid isPermaLink="true">https://chipp.ai/engineering/distillation-is-your-moat</guid>
      <pubDate>Tue, 12 May 2026 00:00:00 GMT</pubDate>
      <dc:creator>Hunter Hodnett</dc:creator>
      <description>Anthropic owns the best coding model. If you build your business on top of Claude (like we do) Anthropic eventually owns your margin. The defense is distillation: training your own smaller model on the outputs of the frontier. It&apos;s the most consequential AI policy debate of the decade, and almost nobody is paying attention.</description>
      <category>distillation</category>
      <category>fine-tuning</category>
      <category>open-source-models</category>
      <category>platform-risk</category>
      <category>model distillation</category>
      <category>fine tuning open source</category>
      <category>autonomous coding distillation</category>
      <category>anthropic platform risk</category>
      <category>hugging face fine tuning</category>
      <content:encoded><![CDATA[# Distillation Is Your Moat

Anthropic owns the best coding model. If you build your business on top of Claude (like we do) Anthropic eventually owns your margin. The defense is distillation: training your own smaller model on the outputs of the frontier. It's the most consequential AI policy debate of the decade, and almost nobody is paying attention.

---

I've spent the last six posts explaining how to build an autonomous coding cluster on top of Anthropic's models. This is the post about why that's a temporary arrangement.

If you're going to build a real business on top of agentic AI, you need to understand the platform risk you're taking. And you need to understand the move that mitigates it (*distillation*) because it's both the long-term moat for AI-native businesses and, increasingly, the most contested issue in AI policy. The AI labs are about to start lobbying to make distillation harder, slower, or illegal. The reasons they'll give will sound noble. The actual reasons are about preserving their monopolies. Pay attention to this fight.

This post covers what distillation is, why it matters, what we've learned doing it, and why the regulatory dimension is the part you should be loudest about.

## The platform risk

Right now, in early 2026, Anthropic has the best coding model. By a meaningful margin. It's not close.

If you're building an autonomous coding system, you use Claude. Cursor uses Claude under the hood for most of their work. Cognition (Devin) uses Claude. We use Claude at Chipp. The companies advertising "Claude alternative" or "Gemini-powered" coding agents are quietly using Claude when their customers care about output quality.

That dominance is real and it's a problem.

Right now, Anthropic prices their Claude Max plans at \$100-\$200 per month with very generous usage caps. They subsidize this: every Claude Max session costs them more in compute than they're charging. They do this because they're capturing the market, training on the data, and improving their models faster than anyone else. They're playing the Uber-rides-cost-\$3 phase of the platform game. We benefit.

Eventually that ends. Anthropic, or the company that buys them, has to stop subsidizing. Prices go up. Rate limits get tighter. Specific use cases (say, "running thirty parallel agents on a single machine") get reclassified as enterprise-tier and priced accordingly. We saw the first sign of this when Claude Code quietly moved from the Pro plan to the Max plan in April. That's not the last move.

If you've built your business on Claude, every move Anthropic makes is a move against your margin. Eventually they'll capture so much of the value you create that the only way out is to cut a deal. That's not a hypothesis. That's how every platform plays out, every time.

The defense is distillation.

## What distillation is

Distillation, in plain language: take the frontier model's outputs and use them as training data for a smaller, cheaper model that you own.

In a normal training run, you'd train a model from scratch on raw data: the entire internet, code from GitHub, documentation. That takes hundreds of millions of dollars and 18 months. Distillation skips most of that. You start with an open-source base model: a smaller, less-capable model someone else has already pre-trained at vast expense and released for free. Then you fine-tune that model on a curated dataset of high-quality input/output pairs. Each pair is a question or task, and the answer the frontier model gave to it.

The smaller model learns to mimic the frontier model's behavior on the specific kinds of tasks you fine-tune for. It doesn't get smarter at everything. But it gets *much* smarter at the slice you trained for. For a narrow, specialized use case (say, autonomous coding in your specific tech stack), a distilled model can hit 60-90% of the frontier model's quality, at a fraction of the inference cost, on hardware you control.

This is how DeepSeek matched OpenAI's GPT-class models for $5 million in training compute, against the billions OpenAI spent. They distilled. The Chinese open-source community is pioneering this technique, partly because it's an effective way to compete without matching American capital expenditure, and partly because they've correctly identified that the frontier-model arms race is a winner-takes-most game they can't win head-on.

## What it costs to distill

I've been distilling our autonomous coding cluster's outputs for the last few months. The honest scoreboard:

- We've spent about $2,500 on training so far, across a few experimental runs.
- Our best distilled model, based on Qwen 2.5 14B, performs at about 63% of Claude Opus 4.6's quality on our internal benchmarks.
- Inference cost on the distilled model is roughly 1/100th of inference on Opus. About \$0.04 per ticket vs \$4 per ticket.

63% sounds bad. It's not. Most of what an autonomous coding cluster does is not the frontier of model capability. It's the routine work. Reading code, writing CRUD, applying conventions, running tests. A 63% Opus model that costs 1% as much will handle 80% of the tickets. Frontier models can handle the remaining 20%.

The economics of "cheap distilled model handles routine tickets, frontier model handles edge cases" are very different from "frontier model handles everything." The former is sustainable at scale. The latter is a bet that Anthropic stays charitable.

The distillation process itself is straightforward in shape and difficult in detail. You collect training data: every prompt your frontier model has answered, every tool call sequence, every successful output. You curate it (this is the hard part; bad data poisons the training). You pick a base model and a fine-tuning approach. You run the training. You evaluate. You ship.

We use Hugging Face for the model hosting and the training infrastructure. The base models we've experimented with most are Qwen (Alibaba's open-source family, currently the strongest open coding models) and Llama (Meta's open family). We use supervised fine-tuning (SFT), the simpler of the two main approaches. The other approach, preference-based methods like DPO and GRPO, requires far more data and is what DeepSeek used to match GPT. SFT is the entry point. The amateur approach. It works.

The training data is the asset. We've recorded every successful autonomous run on our cluster: every prompt, every tool call, every output, every outcome label (did this fix actually solve the issue?). After a few months, we have a dataset that's specific to our use case in a way no public dataset is. That's the moat.

## Save your training data now

Here's the operational lesson: **start saving your training data today, even if you're not training yet.**

If you're using Claude Code interactively, your chat history is on your machine. Move it to a stable location. Back it up. Tag the conversations by outcome: did the work ship? Did it break? Did you have to re-prompt? Outcome labels are what makes training data valuable, and outcomes are easy to capture in the moment and impossible to reconstruct after the fact.

If you're building a product on Anthropic's API, log every request and response. Tag the requests by feature area, by use case, by outcome. Store the logs in a database, not a logfile. You will want to query them.

If you're operating a SaaS that uses LLMs, your customers' interactions with your AI features are training data. Make sure your terms of service give you the right to use that data for model improvement, and make sure the data is being captured in a usable format.

Three years from now, when distillation is the obvious move, you'll either have years of high-quality training data or you'll have to start from scratch. The decision to capture the data is one you make now. The decision to train on it is one you can defer.

## Why this fight is coming

The major AI labs do not want you to distill. Distillation breaks their business model. If everyone can take the outputs of the frontier model and train cheaper, comparable models for narrow use cases, the labs lose pricing power.

Their playbook, which is starting to surface in policy discussions, has three moves.

**Move 1: redefine distillation as theft.** Rename it "model output exfiltration" or "intellectual property circumvention." Argue that training one model on another model's outputs is a copyright violation. (The legal argument here is weak, since model outputs are not copyrightable in the same way human writing is, but the labs have a lot of lobbyists.)

**Move 2: lobby for export controls.** Argue that distilled models are a national security risk because foreign adversaries can use the technique to catch up with American AI capability. Get a regulation passed that requires labs to add clauses to their terms of service prohibiting distillation, with criminal penalties for violation. (DeepSeek will be invoked. The implication will be that all distillation is geopolitically dangerous. The actual concern is monopoly maintenance.)

**Move 3: technical countermeasures.** Watermark model outputs in ways that distilled models will inherit, then sue anyone whose model produces watermarked-output-style behavior. (Technically hard. The labs are trying anyway.)

If you care about a competitive AI ecosystem (and you should, because monopolies are what drive prices up and innovation down) distillation is the single most important policy issue to follow. Pay attention to who's introducing legislation. Pay attention to who's funding it. The "AI safety" framing will be heavy in the air. Most of it will be downstream of monopoly preservation.

## The longer arc

Where I think this all heads, in five years:

Open-source models will be 80-90% as capable as frontier models on narrow tasks, at 1% of the inference cost. Specialized industries will run their own fine-tuned models on dedicated hardware. There are companies right now taking AI models and embedding them on hardware chips, and that's a real direction. The frontier labs will sell the very-hardest-task tier as a premium service, but the routine work will not be on their infrastructure.

That's the future where AI-native businesses are durable. The opposite future, where frontier labs own all inference, all data, and all margin, is the one the labs are working toward.

Distillation is the lever. Yours, mine, the open-source community's. Pay attention to this. Fight when it's time to fight.

## Wrapping the series

This is the last post of the five-part engineering series the manifesto promised. The arc:

1. **The Autonomous Development Manifesto**: the printing press analogy and why this matters now.
2. **Context Engineering**: the discipline that determines whether your agents work.
3. **Building a Self-Healing Bug Bot**: the architecture of a real autonomous cluster.
4. **The Bash Harness**: the manager that supervises the brilliant intern.
5. **Distillation Is Your Moat**: the long game.

If you've read all seven, you understand the technology and the strategy of autonomous coding as well as anyone working in the field today. There is no secret you're missing. The work is in the doing.

If you want a head start (a cluster already tuned, an autonomous engineering team you can describe a SaaS to and watch ship it, a stack you can eject from any time you want) [join the Alchemist waitlist](https://chipp.ai/#waitlist). We've spent a year and six figures of compute building this. We're packaging it for you.

Either way: stop being a spectator. The next three years are the formative ones for AI-native software, and the people building right now are the ones who will be telling the story.

Get in the arena.
]]></content:encoded>
    </item>
    <item>
      <title>The Bash Harness: Determinism Wraps Non-Determinism</title>
      <link>https://chipp.ai/engineering/the-bash-harness</link>
      <guid isPermaLink="true">https://chipp.ai/engineering/the-bash-harness</guid>
      <pubDate>Tue, 12 May 2026 00:00:00 GMT</pubDate>
      <dc:creator>Hunter Hodnett</dc:creator>
      <description>An autonomous Claude session without a wrapper is a brilliant intern with no manager, no deadline, and an unlimited API budget. The bash harness is the manager. Here&apos;s what it enforces, why it has to be deterministic, and the specific failure modes it prevents.</description>
      <category>bash-harness</category>
      <category>autonomous-agents</category>
      <category>claude-code</category>
      <category>production-engineering</category>
      <category>claude code headless</category>
      <category>bash harness</category>
      <category>autonomous agent supervisor</category>
      <category>claude -p dangerously-skip-permissions</category>
      <content:encoded><![CDATA[# The Bash Harness: Determinism Wraps Non-Determinism

An autonomous Claude session without a wrapper is a brilliant intern with no manager, no deadline, and an unlimited API budget. The bash harness is the manager. Here's what it enforces, why it has to be deterministic, and the specific failure modes it prevents.

---

There's a moment in every autonomous-coding-cluster project where the engineer realizes their problem isn't the model. The model is fine. The model would happily spend twelve hours and $400 trying every possible solution to a misconfigured environment variable. The problem is the *manager*.

Claude on its own (even Claude 4.6, even Claude with full tool use, even Claude with MCP and a perfect `CLAUDE.md`) has no concept of "this task should have been done an hour ago" or "I've made the same mistake three times in a row." It doesn't quit. It doesn't get bored. It will burn your entire token budget if you let it.

The bash harness is the part of the cluster nobody writes blog posts about, because bash isn't sexy. It's also the part that makes the whole thing reliable enough to push to production. This is that post.

## The framing

Cline put it best, in a documentation update I read after building most of our harness: *"An autonomous agent without a bash harness is a brilliant intern with no manager, no deadline, and an unlimited API budget."*

That's the threat model. The model is the intern. The bash harness is the manager.

The intern is genuinely good. The intern can do work that would take a human three days. The intern can't *self-supervise*. If the intern wanders into a corner of your codebase that has no test coverage and decides to refactor it from scratch, the intern won't notice that's not what you asked for. If the intern can't figure out how to fix a bug, the intern won't say "I give up." They'll keep trying, with progressively more elaborate workarounds, until something stops them.

The bash harness is what stops them. Specifically, it does six things.

## What the harness does

### 1. It runs Claude headlessly

The headline command is `claude -p "your prompt here"`. The `-p` flag puts Claude Code in non-interactive (headless) mode. Instead of opening a chat UI, Claude runs the prompt to completion, streams its work to standard output, and exits when done.

We pair `-p` with `--dangerously-skip-permissions`, which tells Claude to stop asking for confirmation before every tool call. In an interactive session, you want those prompts. In a headless session that needs to run unattended, you don't. (The `--dangerously-` prefix is honest. Skip permissions and the agent can do real damage. The bash harness is what makes this safe.)

The combination (headless mode plus skip permissions) is the atomic primitive of every autonomous coding system. If you only learn one thing from this whole series, learn that. Without it, the model is a chatbot. With it, the model is a worker.

### 2. It enforces a wall-clock timeout

If Claude has been running for two hours, something is wrong. Either it hit a class of problem it can't solve, or it's looping, or the task was wildly under-scoped. Either way, killing it is the right move.

Our harness wraps `claude -p` in a `timeout 7200` call (2 hours, expressed in seconds). When the timer hits, the process is killed, the work-tree is captured for forensics, and the harness logs a failure ticket for human review.

The number isn't sacred. We started at 8 hours, dropped to 4 when we realized we were paying for runaway sessions, and settled at 2 because every legitimate task we've measured fits well under that. Pick a number that's longer than your slowest legitimate task and shorter than "I will go bankrupt."

### 3. It detects hangs

Claude can be running but not making progress. Sometimes it gets stuck on a tool call: a Docker container that takes forever to start, an MCP server that hangs, an HTTP request to a slow third party. The wall-clock timeout catches this eventually, but you don't want to pay for two hours of nothing.

The harness watches the agent's stdout for *tool call activity*. Every meaningful turn produces a tool call entry. If five minutes pass with no tool call output, the harness assumes the agent is stuck and kills it. The threshold is a tunable. We started at 2 minutes and bumped to 5 because some legitimate operations (large grep on a big codebase, slow MCP servers) take longer.

### 4. It bans dangerous patterns

The agent will, occasionally, output a command that would do irreversible damage. Not from malice. From training data. Real examples we've caught:

- `git reset --hard HEAD~5` (when the agent gives up and tries to wipe its work)
- `git push --no-verify` (when CI fails and the agent decides to bypass the check)
- `rm -rf /` (rare, but yes)
- `--force-overwrite` flags on database migrations

The harness greps the agent's command stream for known-bad patterns. When it sees one, it kills the session and logs a ticket. We curate this list as we discover new ones.

This is defense-in-depth. The model *shouldn't* output these commands; we have rules in `CLAUDE.md` against most of them. But the model occasionally will, and "shouldn't" is not the same as "won't." The harness is the airbag.

### 5. It cleans up after the agent

Each agent session runs in its own *git work-tree*: a separate checkout of the repo, isolated from every other agent's work. When a session ends, the work-tree might contain uncommitted changes, half-finished branches, leftover processes (dev servers, browser instances, MCP servers).

The harness runs a cleanup pass. It checks the work-tree for uncommitted changes (and either commits them with a salvage marker or stashes them for forensics, depending on session outcome). It runs `pkill` on any orphaned processes that started during the session. It deletes the work-tree if the session succeeded, or archives it if the session failed.

Without this, every failed session leaves debris. After a hundred sessions, your `~/code/worktrees` directory is a graveyard. Cleanup is unglamorous and load-bearing.

### 6. It enforces the push step

When a session succeeds, the agent should push its commit to a target branch. Sometimes the agent forgets, or mis-commits, or commits without pushing. The harness checks the work-tree state at the end of every session: are there committed-but-unpushed changes? If yes, the harness pushes them. Are there changes the agent forgot to commit? If yes, log a failure. The agent didn't finish.

This is the final guardrail. The whole pipeline ends with code in production. If the agent's work doesn't end up there, the entire run was wasted. The harness *makes sure* the work lands.

## Why bash, specifically

I wrote the first version of the harness in TypeScript. It was elegant. It had types. It also took ten times as long to debug as the bash version that replaced it.

Bash is the right language for this. Three reasons:

1. **The harness wraps a Unix process, and bash is the language for wrapping Unix processes.** Subprocess management, signals, file descriptors, timeouts, pipes. All of this is expressed concisely in bash and verbosely in everything else.
2. **The harness has to be debuggable in production.** When something goes wrong, you SSH to the machine and read the script. Bash scripts are visible. There's no compilation step, no module resolution, no runtime to set up. You can audit the entire harness in fifteen minutes.
3. **The harness should be boring.** It's the deterministic core of an otherwise non-deterministic system. The fewer abstractions, the fewer dependencies, the better. Bash has no dependencies. It will work on any Linux box, with no setup, in five years.

The harness is currently 312 lines of bash. Most of those lines are comments. The actual logic is short.

## Each agent gets its own work-tree

A note on parallelism, because it's the part that surprises people.

We run eight agents at a time on my laptop. They don't share a working directory. They don't share a database. They don't share dev server ports. Each agent has:

- Its own git work-tree (a checkout of the repo at a separate filesystem path).
- Its own dev server, on a unique port (5180-5187, parameterized by worker slot).
- Its own browser MCP target (Chromium instance, also on a unique port).
- Its own log stream, prefixed with the worker slot for easy filtering.

The agents are completely isolated. Two agents working on conflicting changes won't step on each other. They're in different work-trees, on different branches. When they push, the push happens on the same remote, and any merge conflicts are resolved by the deploy pipeline (or, in the rare case where they're not auto-resolvable, surfaced as a failure ticket).

This is the part of the architecture I was most nervous about and it's worked the best. Eight independent workers running in parallel turns out to be the right level of concurrency for one developer's machine. Going higher saturates my Mac's resources. Going lower means tickets sit in queue.

## The lesson

Every autonomous coding system you build will fail in ways the model can't recover from. The model is good at writing code. It's bad at noticing it's wasted three hours, bad at stopping itself, bad at cleaning up its mess. The bash harness is the part of the system that's good at those things.

Without it, you have a hobby project. With it, you have something you can leave running overnight.

This is the unglamorous core of every production-grade agentic system I've seen. Cursor has one (their internal harness for background agents). Devin has one. We have one. If you're building your own cluster, you'll build one too. Mine will save you a few weeks of mistakes.

In the final post of this series, I'll get into distillation, the part that turns short-term Anthropic-dependence into long-term independence, and the part the AI labs are quietly going to lobby against. If you've followed this series this far, distillation is the post that matters most for your business in 2027.

If you'd rather skip the year of building and use a cluster that already has all of this, [join the Alchemist waitlist](https://chipp.ai/#waitlist).
]]></content:encoded>
    </item>
    <item>
      <title>The Opinionated Stack: Why Autonomous Coding Needs Deno, Svelte, and Cloudflare</title>
      <link>https://chipp.ai/engineering/opinionated-stack-deno-svelte-cloudflare</link>
      <guid isPermaLink="true">https://chipp.ai/engineering/opinionated-stack-deno-svelte-cloudflare</guid>
      <pubDate>Sun, 10 May 2026 00:00:00 GMT</pubDate>
      <dc:creator>Hunter Hodnett</dc:creator>
      <description>Most autonomous-coding platforms try to support every language, every framework, every host. That&apos;s exactly why they don&apos;t work. We picked Deno, Svelte, and Cloudflare, locked the choices, and got autonomy at a scale that makes outside observers incredulous. The constraint is the feature.</description>
      <category>autonomous-development</category>
      <category>deno</category>
      <category>svelte</category>
      <category>cloudflare</category>
      <category>stack-design</category>
      <category>opinionated-platforms</category>
      <category>autonomous coding stack</category>
      <category>deno for ai agents</category>
      <category>svelte for autonomous development</category>
      <category>cloudflare workers ai agents</category>
      <category>opinionated platform</category>
      <category>autonomous software development</category>
      <content:encoded><![CDATA[# The Opinionated Stack: Why Autonomous Coding Needs Deno, Svelte, and Cloudflare

Most autonomous-coding platforms try to support every language, every framework, every host. That's exactly why they don't work. We picked Deno, Svelte, and Cloudflare, locked the choices, and got autonomy at a scale that makes outside observers incredulous. The constraint is the feature.

---

The most common question I get from other founders building autonomous-coding platforms is some variant of, "How do you support so many customer apps with so few engineers?"

The answer they expect is a model trick, or a prompt trick, or some clever new agent framework. The real answer is the one nobody wants to hear: we picked one language, one frontend framework, and one cloud, and we refused to support anything else.

Deno. Svelte. Cloudflare.

That's the whole stack. Every customer app we host runs on those three. Every agent we ship is written for those three. We don't take customers whose apps run on something else. We don't make the platform "flexible enough to support React or Vue or Solid." We don't expose a hosting plugin layer. We took the three choices that compose best for an agent-driven world and we welded them in place.

That decision is the single highest-leverage call we've made at Chipp. It's also the call that most of our competitors keep refusing to make, and it's why their autonomy numbers stall out where ours keep climbing.

This post is the argument for why.

## The thesis in one line

**An autonomous coding platform's effective intelligence is inversely proportional to the size of its decision surface.**

Every place where the agent could plausibly pick option A versus option B versus option C is a place the agent will, eventually, pick wrong. Every framework choice, every cloud primitive, every package manager, every test runner, every router convention. Each one multiplies the number of paths the agent has to navigate. The model is good. It's not "infinite combinatorial decision tree" good.

The only known way to make an agent's behavior reliable at scale is to *remove decisions from the surface*. Not by adding rules on top of a sprawling toolchain, but by collapsing the toolchain itself. The autonomous coding platforms that ship working features today are the ones with the smallest possible "what shall I pick" surface. The ones that don't ship are the ones still proudly listing thirty supported frameworks on their landing page.

Constraint is not a tax. Constraint is the feature.

## What "one size fits all" actually costs

Let me describe the platform shape I keep seeing pitched, because it sounds reasonable on a slide.

The pitch: a hosted agent platform. The customer brings their existing codebase. Python or Node or Go on the backend. React or Vue or Svelte on the frontend. Deployed to AWS or GCP or Vercel or Fly. The agent reads the customer's repo, figures out the conventions, writes a feature, runs the tests, opens a PR.

It demos well. It always demos well. The first ticket lands. The team congratulates itself. Then the second ticket comes in, on a different customer with a different stack, and the agent's accumulated context from the first customer is *useless*. Then the third ticket lands, with yet another framework combination, and the agent has to relearn everything again. Then the scar-tissue document you'd been building in `CLAUDE.md` doesn't transfer, because half its rules are about library quirks that don't apply to this customer's stack. ([Why scar tissue in `CLAUDE.md` is the highest-leverage file in your codebase →](/engineering/claude-md-architecture))

You spend the next year of company-building writing per-stack adapters. Each adapter is fine on its own. The compound is fatal. Every adapter is a new place to debug, a new set of dependency versions to track, a new permission of failure modes for the agent to discover. The model never gets to compound. The platform never gets to compound. You're maintaining N agents pretending to be one agent, and each of them is mediocre.

The teams running this play out loud right now, you know who you are, will hit a wall where their agents work on toy customer apps and fail on real ones. They will conclude that the model isn't smart enough yet. The model is plenty smart enough. The platform forced the model to do combinatorial work that doesn't need to exist.

The exit from this trap is to *narrow the surface*. Pick the stack. Mean it. Refuse anything else. The customers you lose by being opinionated are smaller than the customers you'll lose by being a worse product.

## Why Deno is the right language

Pick one server-side language. Once you've picked it, every reason to pick anything else for that tier collapses. The agent only ever has to know one ecosystem. The skills compound. The scar tissue compounds. The platform compounds.

We picked Deno. Here's why it dominates Node and Python and Go for this specific job.

**One binary, one toolchain, one mental model.** Deno is a single executable that includes the runtime, the package manager, the formatter, the linter, the test runner, the type checker, and the bundler. There is no `npm` versus `pnpm` versus `yarn` versus `bun` decision. There is no `eslint` versus `biome` versus `oxlint` decision. There is no `prettier` versus `dprint` decision. There is no `jest` versus `vitest` versus `mocha` versus `node:test` decision. The agent runs `deno fmt`. The agent runs `deno lint`. The agent runs `deno test`. There is exactly one right answer to every "how do I X" question. The decision tree the agent has to navigate when working in a Deno repo is *embarrassingly* small compared to a Node repo, and that's the entire point.

**TypeScript is the default, not the bolt-on.** No `tsconfig.json` archaeology. No "did someone forget to add `@types/node`." No transpile pipeline. You write TypeScript, Deno runs TypeScript. The agent writes TypeScript, the agent runs TypeScript. Type errors surface immediately. The whole class of "the agent generated valid JavaScript that's invalid in this project's TS config" failure mode is gone.

**Permissions are first-class.** `deno run --allow-net=api.stripe.com --allow-env=STRIPE_KEY ...` is the default shape of a Deno program. The agent's generated code declares what it touches. When the agent goes off the rails and tries to read `/etc/passwd`, the runtime refuses. The model's worst impulses get sandboxed for free. Compare this to Python or Node, where every script has the same authority as the developer running it.

**The standard library is real.** `@std/http`, `@std/path`, `@std/encoding`, `@std/testing`, `@std/assert`. Things that should not require a package, do not require a package. The set of things the agent might `npm install` to solve a routine task shrinks. Fewer dependencies = fewer choices = less hallucination surface. The agent reaches for `@std/path` because the agent only knows about `@std/path`, because that's what the CLAUDE.md says to use, and that's what's already in the workspace.

**URL imports are reproducible.** `import { foo } from "jsr:@scope/package@1.2.3"` is the import statement *and* the dependency declaration. There is no separate `package.json` to keep in sync. There is no `node_modules/` to corrupt. There is no lockfile divergence between the agent's working tree and the deploy. The agent that fixes a bug in a function and pushes it is *touching the same artifact* the runtime executes. This sounds boring until you've debugged the third "but it worked on my laptop" failure caused by a transitive dependency drifting in the lockfile.

There's a meta-property here that I think is underrated: **Deno is opinionated about the same things autonomous agents are bad at.** Toolchain selection. Configuration sprawl. Implicit globals. Hidden permissions. Every place Deno's designers said "we're picking one way" is a place we don't have to write a CLAUDE.md rule explaining which of the seventeen Node-flavored ways our codebase prefers. The framework already enforces the convention. The agent just has to follow the only available path.

> "Every language choice an agent can make is a choice the agent will eventually get wrong. The win is removing the choice, not training the agent to choose better."
> -- Hunter Hodnett, Chipp CTPO

Could we have picked Go? Go has some of the same properties, single binary, single tool, opinionated formatter. We didn't, because the agent has to write *both* server code and shared code with the frontend. Sharing types across a Deno backend and a Svelte frontend is the same TypeScript file. Sharing types across a Go backend and a TypeScript frontend is a code generator and a build step. The friction of crossing the language boundary, multiplied by the number of features the agent ships per day, dwarfs the marginal Go-versus-TS productivity gap. One language, one type system, one mental model.

Could we have picked Bun? Bun is closer to Deno than to Node, and on the runtime axis it's competitive. We didn't, because Bun's posture is "drop-in Node replacement," which means it inherits Node's combinatorial config surface as a feature. Deno's posture is "we picked the answers." We wanted the picks.

## Why Svelte is the right frontend framework

Pick one frontend framework. Same logic. Same compounding.

We picked Svelte (Svelte 5, with runes). Here's why it dominates React for an agent-driven codebase.

**Less code per feature.** This is the boring, load-bearing fact. A typical Svelte component that does what a React component does is somewhere between half and a third the line count. For a human reader, that's a quality-of-life thing. For an agent with a finite context window, it's *capacity*. Every additional line of code the agent has to load into context to reason about the surrounding feature is a line that crowds out something else. Svelte's compiler does the work React's hooks-and-providers ritual makes the developer do explicitly. The shorter source is the source the agent can hold in its head.

**The compiler is the framework.** React ships a runtime that interprets your component tree at every render. Svelte compiles your component down to direct DOM mutations at build time. The agent doesn't have to reason about render orderings, dependency arrays, stale closures, the rules of hooks, when to memoize, when not to memoize, the seven flavors of effect, server components versus client components, suspense boundaries, or any of the other lore that has accumulated on top of React over a decade. The agent reasons about HTML, CSS, and a small number of runes. That's it.

**Runes are a small, consistent surface.** `$state`, `$derived`, `$effect`, `$props`, `$bindable`. Five symbols. Each one does exactly one thing. There is no `useState` versus `useReducer` versus `useRef` versus `useImperativeHandle` decision. There is no "is this a controlled component" lore. The agent picks the rune by what it's doing, not by which of the eight historical APIs ended up at the right level of abstraction.

**SvelteKit's file system is the routing.** `routes/foo/+page.svelte` is the foo page. `routes/foo/+page.server.ts` is the foo page's server load. `routes/foo/+server.ts` is the foo API endpoint. The agent doesn't pick between Pages Router and App Router. It doesn't pick between server components and client components. It doesn't pick between `getServerSideProps` and `getStaticProps` and `loader()`. The filename declares the role. There is one way.

**No state management library debate.** React projects routinely include three different state libraries (Redux, Zustand, React Query, Jotai, MobX, take your pick) and the agent has to learn which one this codebase uses for what. Svelte projects use runes. State that's per-component lives in `$state`. State that crosses components lives in a `.svelte.ts` file with `$state` at module scope. The store debate that's eaten a decade of React community discourse simply does not exist.

Could we have picked Solid? Solid is closer to Svelte than to React on every axis I care about. We didn't, because Solid is small enough that the customer-facing component ecosystem is thin. Svelte has the second-largest component ecosystem after React, which matters when the agent reaches for "I need a date picker." Solid would have been the right pick if we were optimizing for performance benchmarks. We were optimizing for the agent's daily reach.

Could we have picked React (Next, Remix, plain Vite)? No, for the same reason we didn't pick Bun: React's posture is "everything is a choice, pick wisely." That is exactly the wrong posture for an agent. We don't want our agents picking wisely between four router libraries. We want the agent to not have the choice in the first place.

The component-count tax this saves us is real. A Chipp customer's average feature ticket, when shipped on a React stack, was around 3.2x the diff size of the same feature shipped on Svelte. 3.2x more code is 3.2x more places to put a bug, 3.2x more tokens to load on review, 3.2x more `CLAUDE.md` rules to write about which React patterns we use. Multiplied across the volume of features we ship per customer per week, the framework choice was the second-largest determinant of how much autonomy we could squeeze out of the platform. (The first was the model, and we don't control the model.)

## Why Cloudflare is the right cloud

Pick one cloud. Same logic. Same compounding.

We picked Cloudflare. Workers for compute, R2 for blobs, KV for caches, D1 for relational data, Durable Objects for stateful coordination, Queues for async work, Pages for static assets, Custom Hostnames for per-customer domains, Zero Trust for auth gating. One platform, one CLI (`wrangler`), one mental model.

Here's why it dominates AWS and GCP for an agent-driven backend.

**One control plane, one API.** When an agent needs to provision a queue, it calls one wrangler command and an HTTP endpoint. It doesn't have to pick between SQS, SNS, EventBridge, Kinesis, MSK, and AppFlow. It doesn't have to know which of those has the right semantic for this customer's job shape. The agent has Queues. The customer has Queues. The decision tree has one branch.

**The primitives are general-purpose.** Workers + R2 + D1 covers the shape of every customer app we've shipped. The agent learns those three. The agent ships features. The agent doesn't go on a multi-day expedition learning that the customer's logging system happens to require IAM role A to assume IAM role B to publish to topic C subscribed by Lambda D writing to S3 bucket E. That sentence is a parody of cloud onboarding, except it's also literally what we paid the AWS tax for in a previous life.

**Edge-first is deterministic for the agent.** Workers run at the edge, the same way everywhere. There is no `us-east-1` versus `us-west-2` decision. There is no "did we forget to deploy this to all regions" failure mode. When the agent deploys, the deploy is global. When the agent verifies, the agent's verification reflects what the customer's customer will see, anywhere on earth. The "works in dev, fails in prod" gap, which is mostly a region/availability/IAM gap in AWS shaped systems, doesn't exist.

**Wrangler is the agent's hands.** Every Cloudflare resource is reachable from `wrangler`, and `wrangler` runs in a shell, and the agent has a shell. We don't need a custom orchestration layer to give the agent provisioning capability. The agent writes `wrangler.toml`, the agent runs `wrangler deploy`, the agent reads the output. The same tool a human operator would use is the tool the agent uses, which means the agent's mistakes are debuggable by the same workflow that debugs a human's mistakes. ([Why the bash harness is the right abstraction →](/engineering/the-bash-harness))

**Workers are fast to deploy and isolated by default.** A `wrangler deploy` is typically completed by the time the agent's next tool call fires. That tight loop is what makes autonomous verification practical. The agent ships, the agent curls the deployed endpoint, the agent observes the response, the agent decides. If the deploy round-trip took the length of a coffee break, autonomous verification would simply not be a workable shape. Cloudflare's deploy primitives are *agent-paced*, which is a phrase I never thought I'd need to coin but which now describes the most important property a cloud can have for this kind of work.

**Per-customer isolation comes for free.** Each customer's deploy is a separate Worker. Each customer's data is a separate D1. Each customer's blobs are a separate R2 prefix. Cross-tenant leakage is a tenancy-shape problem, not an IAM-policy problem. We don't write tenant-isolation middleware. We don't write tenant-isolation tests. The platform's primitive is the boundary.

Could we have picked Fly? Fly is close to Cloudflare in posture (opinionated, edge-first, small surface). We didn't, because Fly is positioned as "run your container anywhere," which puts the container-image debate back on the table. We didn't want our agent making Dockerfile decisions. Cloudflare Workers don't have a container concept at all. The agent writes TypeScript, the agent deploys TypeScript, the platform handles the rest. The whole containerization layer is a decision surface we eliminated.

Could we have picked Vercel? Vercel is great at the React-flavored slice of the world, but its primitives outside that slice (blob storage, queues, durable state) are thinner and lean on third-party adapters. We didn't want our agent gluing together Vercel-plus-Upstash-plus-Neon-plus-Inngest, each with its own API and its own dashboard. Cloudflare's one-platform claim is the closest a cloud has come to "one mental model for everything the agent needs."

Could we have picked AWS or GCP? No. The hyperscalers are *the canonical bad shape* for autonomous coding. Three thousand services, fifteen ways to do every job, IAM policies that take human engineers years to internalize. We are not going to outwit AWS's combinatorial sprawl by being clever about prompts. We are going to avoid it by not standing on it.

## What you give up

I want to be honest about what this decision costs, because the "constraint is the feature" pitch glosses over real tradeoffs.

**You lose customers who already have a stack.** A customer running a Rails monolith on Heroku is not our customer. We can't agent-ize their app. We don't try. The customers we sign are the customers who haven't committed to a stack yet, or who explicitly want to greenfield on ours because the autonomy multiplier is worth the migration.

**You lose engineers who want to pick.** Some engineers want a platform that respects their craft, which often means respecting their existing toolchain choices. Our pitch is the opposite. The platform makes the choices. The engineer's craft is in the domain, not the stack. Some prospective hires bounce off this. The ones who stay are the ones who internalized that the stack stopped being a competitive advantage years ago.

**You take on the bet that the chosen tools stay good.** If Deno collapses, we have a migration. If Cloudflare massively raises prices, we have a migration. If Svelte 6 makes runes obsolete in a way we can't follow, we have a migration. The constraint binds us as much as it binds the customer. We accept that bet because the alternative, supporting twelve stacks badly forever, is strictly worse and we can see the future where that company looks like a museum.

**You can't be everything to everyone.** Good. The platforms that are everything to everyone are the ones whose autonomous-coding numbers stop at "demo working" and never reach "running production for two months unattended." We'd rather be one thing to a smaller everyone, work well, and let the autonomy compound.

## What this looks like in practice

A customer-template repo with a `CLAUDE.md` that knows it's a Deno + Svelte + Cloudflare project. The scar-tissue rules are about Svelte 5 runes, Deno 2 APIs, wrangler conventions. There is no rule that says "if this is a React project, do X; if this is a Vue project, do Y." The agent never has to branch on stack identity. The rules apply directly.

A reproducible E2B sandbox with Deno installed, wrangler installed, Svelte's tooling installed, Chrome installed for browser-driven verification. Every agent run starts from the same base image. The agent never spends a tool call figuring out whether `pnpm` or `npm` is the right installer here, because the answer is always `deno` and the answer is in the base image. ([How we built that sandbox →](/engineering/agentic-design-patterns))

A deploy pipeline that's two commands: `wrangler deploy` and curl the result. The whole "did the deploy land" round-trip is short enough that the agent doesn't need a separate state machine to model it. The agent ships, the agent verifies, the agent moves on. The model's working memory is enough; we never had to build a "track in-flight deployments" subsystem because the deployment never has time to be in flight.

A per-customer Worker that isolates everything. When the agent screws up, the blast radius is one Worker. When the agent ships a fix, the rollout is global and atomic. There is no rolling-deploy interlude where some customers are on the old code and some on the new. The agent doesn't have to reason about partial-rollout failure modes because partial-rollout doesn't exist.

A frontend that ships fewer lines of code per feature, which means the review pass loads less context, which means the agent's `CLAUDE.md` review rules apply to a smaller surface, which means the same fixed budget of review attention catches more bugs.

These properties are not independent. They compose. Each constraint we accepted lets the others compose harder. The reason our autonomy numbers look the way they do is that the platform itself was designed to make autonomy the default path, and the platform's design is the stack choice.

## The general principle

If you're building an autonomous coding platform, the most important spec is *not* your agent harness. It's not your model picker. It's not your prompt library. It's *the platform your agent ships code for*.

The agent is the smallest part of the system. The platform is the part you can shape. Shape it the way the agent's failures want you to.

Specifically:

- **Pick one language.** The language with the best built-in tooling, the smallest config surface, and the strongest cross-tier story with your frontend.
- **Pick one frontend framework.** The framework with the smallest source-code footprint per feature, the most opinionated conventions, and the smallest "lore surface" the agent has to learn.
- **Pick one cloud.** The cloud with the smallest set of general-purpose primitives, the tightest deploy round-trip, and the most isolated per-tenant shape.

Then refuse to compromise on any of those three. Refuse politely. Refuse with a smile. Refuse the customer who insists on Python. Refuse the engineer who insists on Next. Refuse the investor who tells you you'd be "more flexible if you supported AWS." Flexibility is what the platforms that don't ship have. We picked the platforms that ship.

When someone tells you the model isn't smart enough to be autonomous on their stack yet, take a look at their stack. Most of the time, the model is plenty smart. The stack is the bottleneck. The decision surface is too wide. The combinatorial cost of every "which library" question is eating the model's working memory. Shrink the surface and the same model gets dramatically more autonomous overnight.

This is the lesson I wish more of the autonomous-coding ecosystem would internalize. We are not in the era of "the model will figure it out." We are in the era of "the platform will let the model figure it out, or it won't." The platforms that pick will win. The platforms that don't will spend the next year of company-building writing per-stack adapters and wondering why their demos plateau.

Deno. Svelte. Cloudflare. Three picks. One stack. Autonomy compounds.

That's the post. The follow-up is the platform itself, which is what we ship on every weekday at Chipp, and what the [autonomous development manifesto](/engineering/the-autonomous-development-manifesto) lays out in full.

If you're building toward the same shape, I'd love to compare notes. If you're building toward the everything-to-everyone shape, I'd love to come back in a year and compare numbers.
]]></content:encoded>
    </item>
    <item>
      <title>Beyond AI Pair Programming: From Copilot to Coworker to Autonomous Engineer</title>
      <link>https://chipp.ai/engineering/beyond-ai-pair-programming</link>
      <guid isPermaLink="true">https://chipp.ai/engineering/beyond-ai-pair-programming</guid>
      <pubDate>Thu, 07 May 2026 00:00:00 GMT</pubDate>
      <dc:creator>Hunter Hodnett</dc:creator>
      <description>Copilot was the start, not the destination. Three roles for AI in your engineering org, pair programmer, coworker, autonomous engineer, and the org-chart implications when you move from one to the next. Plus how to upgrade your own job description through the curve.</description>
      <category>ai-pair-programmer</category>
      <category>ai-software-engineer</category>
      <category>autonomous-software-engineer</category>
      <category>org-chart</category>
      <category>ai pair programmer</category>
      <category>ai software engineer</category>
      <category>autonomous software engineer</category>
      <category>autonomous coding agents</category>
      <category>copilot vs autonomous</category>
      <content:encoded><![CDATA[# Beyond AI Pair Programming: From Copilot to Coworker to Autonomous Engineer

Copilot was the start, not the destination. Three roles for AI in your engineering org, pair programmer, coworker, autonomous engineer, and the org-chart implications when you move from one to the next. Plus how to upgrade your own job description through the curve.

---

GitHub Copilot launched in October 2021. The pitch was *AI pair programmer*. A model that finishes your line, suggests the next function, helps you remember the syntax for that thing you keep looking up.

The pitch was honest. The category name was ambitious. Pair programming, as practiced by humans, is two people taking turns at one keyboard. One drives, one navigates, both think. Copilot was *not* that. It was a smarter autocomplete with a better marketing department.

The honest pitch, *autocomplete that actually understands your codebase*, would have been more accurate but less aspirational. Marketing won. The "AI pair programmer" framing stuck. And four years later, the framing is the thing holding most builders back from seeing what AI in engineering can actually do.

This post is about the upgrade path. Three roles for AI in your engineering org, pair programmer, coworker, autonomous engineer, what each one actually means, and the org-chart implications when you move between them.

## Role 1: AI as pair programmer

This is where Copilot started, where Cursor lives, where Cody and Tabnine and Continue all sit.

The model finishes your line. The model writes a function when you describe one in a comment. The model fixes a syntax error you didn't notice. The model is *latency-bound*, it has to be fast enough to keep up with your typing, which means it has to be small enough to run in real time, which means it can't reason very deeply about what you're doing.

The output of an AI-pair-programmer setup looks like a slightly faster human engineer. You ship 10-30% more code per hour than you would have without it. The shape of your day is unchanged. You're still typing all day. You're still reviewing every line. You're still the one who decides what file to open next and what to do once you're there.

This is a real productivity gain. It's not a category change.

What you give up to operate at this level: nothing. Adoption is friction-free. Every engineer on your team can be using a pair programmer by tomorrow afternoon and there are no architectural changes required.

What you fail to gain by stopping here: everything below.

## Role 2: AI as coworker

The coworker shows up around 2024 with the agent capabilities baked into Claude Code, Cursor's agent mode, the Codex CLI, and a few others.

The shape of the work changes. Instead of the model finishing your line, the model takes a goal and *runs a session* against the goal. You say "investigate why our billing endpoint is returning 500s" and the model spends ten minutes reading files, querying logs, forming a hypothesis, writing a fix, running tests, telling you what it did.

You're still in the loop. You watch. You course-correct. You decide when the session is done. But you're not at the keyboard the whole time anymore. The model is operating in *minutes-long blocks* of focus, and you're operating in the spaces between.

The output looks like having a junior engineer at the desk next to you. You hand them tickets. They take a stab. You review. The throughput per ticket goes way up, junior engineers are bottlenecked by their own typing speed; the agent isn't. The throughput of *your* time goes up because you're not typing during the agent's blocks; you're handling other things.

What you give up to operate at this level: trust. You have to let the agent run for ten minutes without watching every keystroke. The first time it makes a wrong-turn decision and burns ten minutes of context, you'll want to go back to the pair-programmer model. The teams that hold the trust line through the first month make it past this. The teams that don't end up reverting.

What you fail to gain by stopping here: scale. The coworker is still bounded by your attention. You can run *one* coworker session at a time because you have to be available to course-correct it. You can't sleep through the night because you have to be available to review what the coworker shipped during the day.

This is where most ambitious teams sit in mid-2026. It's a good place. It's also not the destination.

## Role 3: AI as autonomous engineer

The autonomous engineer is the role most builders haven't seen yet, because it requires a different *organizational* setup, not just a different tool.

The model takes a goal. It runs a session. It verifies its own work, opens a browser, takes a screenshot, reads logs, fixes the things it broke. It commits. It pushes. It deploys. There is no human at any step.

Multiple autonomous engineers run in parallel. We have eight workers running on a single workstation at Chipp. Each one is its own Claude Code instance, in its own git worktree, with its own dev server on its own port, fielding tickets from a shared queue.

The output isn't *more code per hour*. The output is *more shipped product per dollar of payroll*. We ship 20-30 production changes a day on a two-person engineering team. The PR queue is empty because there are no PRs. The on-call rotation is empty because the cluster handles its own incidents.

What you give up to operate at this level: your PR review process, your habit of reading every diff, the comfort of knowing exactly what's in production. ([The full list of trade-offs →](/engineering/vibe-coding-vs-autonomous-development#what-you-give-up))

What you fail to gain by stopping at the coworker level: the ability to run while you sleep. The ability to compete on engineering capacity with teams an order of magnitude larger than yours. The ability to ship features that wouldn't have survived a normal cost-benefit analysis.

> "The AI wasn't an assistant. It was the engineer. I was the manager."
> -- Hunter Hodnett, Chipp CTPO

## The org chart at each level

Here's where it stops being about tools and starts being about people.

### Pair-programmer org chart

The org looks like a normal engineering team. Engineers report to engineering managers. Engineers write code. EMs run people. There are PRs. There are reviews. There are sprint planning meetings.

The shape doesn't change because the work doesn't change. The engineers are 10-30% faster but they're still doing what they were doing.

### Coworker org chart

The shape starts to shift. Engineers spend less time typing and more time *steering*, defining tickets, reviewing the agent's work, fixing the parts the agent got wrong. The senior engineer's day starts looking more like a manager's day.

EMs notice that some of their direct reports are shipping at suspicious volumes. The "10x engineer" trope, previously folklore, starts to look real.

This is also where the awkward middle starts. Junior engineers struggle, because the agent is good at the work juniors used to learn from. The "draw the rest of the owl" jokes hit different when the agent draws most of the owl and the junior is supposed to learn by drawing it themselves.

### Autonomous-engineer org chart

The shape is *fundamentally* different. There are no engineers writing code in the way the prior org charts had. There are *engineering managers*, humans who manage clusters of agents. There are *architects*, humans who decompose product intent into ticket-shaped work and review the agent's outcomes. There are *infra people*, humans who maintain the cluster, the harness, the MCP fleet.

Headcount drops. The remaining roles get *more* important, not less. A two-person autonomous engineering team can deliver what a fifteen-person traditional team could. Each of those two people is doing higher-judgment work than any of the fifteen.

This is the org chart most companies in 2030 will have. Most companies in 2026 do not. The transition is the hard part.

## Upgrading your own role

If you're a working engineer reading this, the question is what to do about your own job.

I'll give you the honest answer. Your job in the coworker world is what your job in the autonomous-engineer world is going to be: less typing, more decomposition; less review, more architecture; less owning code, more owning the system that produces code.

Three things to start doing now:

### 1. Stop measuring yourself by lines of code

Lines per day was a noisy metric before AI; it's worse than noisy now. The agent can produce more lines than you in any given hour. If your self-image is wrapped up in being a productive typist, the next two years are going to feel bad. Decouple now.

The new metric is *tickets shipped per dollar of token spend*. Or *features merged per week of clock time*. Or *production stability holding while shipping volume goes up*. Find a metric that values judgment over typing.

### 2. Get good at decomposing

The hardest part of running an autonomous cluster is turning vague intent into pipeline-sized tickets. *"Build a billing dashboard"* is not a ticket. *"Add a usage breakdown chart to the existing billing settings page, sourced from the same data the credit balance uses, with the design pattern from the org members table"* is a ticket.

Decomposition is a skill. It's the skill of being a good tech lead, but more granular. Start practicing it now even on work you're doing yourself. You'll be doing nothing else in two years.

### 3. Get good at reading agent output fast

In the autonomous-engineer world, you'll be reviewing more of the agent's work than your own, hundreds of small commits per week, mostly auto-verified, but with a few that need human eyes for judgment calls.

The skill of speed-reading a diff and forming an opinion in 60 seconds is undervalued today. It will be the most valuable engineering skill of 2028.

Start practicing on the agent's output now. Set a timer. Make snap calls. Build the muscle.

## What this means for hiring

If you run engineering hiring, the implication is that the profile you want is shifting fast.

The pair-programmer-era hire was a strong typist with good fundamentals, someone who could turn a Jira ticket into shipped code reliably.

The autonomous-engineer-era hire is a strong *judge* with good fundamentals, someone who can look at an agent's output and tell you whether it's right, wrong, or interesting; someone who can decompose a vague product brief into pipeline-sized tickets; someone who's comfortable trusting a cluster to push to production while they sleep.

The fundamentals haven't changed. Algorithms, data structures, system design, debugging instincts, those still matter, because you can't judge an agent's output if you don't understand the underlying engineering. What's changed is the layer the human operates at. You're not the engineer anymore. You're the engineering manager, for a team of agents that doesn't go home at night.

Hire for that. Pay for that. Promote for that. The teams that figure out the new hiring profile first will end up with the engineers everyone else wants in 2028.

## Which kind of engineer do you want to be in 2027?

There are three honest options.

**Option 1: Pair-programmer engineer.** Same job you have today, slightly accelerated. Plenty of teams will still operate this way in 2027. They'll be losing market share. You'll be paid like a 2024 engineer with a faster IDE. Defensible if you're senior enough to ride out the contraction.

**Option 2: Coworker-era engineer.** You've absorbed the agent into your daily flow. You're 5-10x more productive than your 2023 self. You're still in the inner loop on every change. This is the median ambitious engineer in 2026. It's a defensible position for two more years, then it gets hard.

**Option 3: Autonomous-engineer-era engineer.** You manage agents. You decompose work. You design systems. You judge outcomes. You're the EM of a cluster that ships more product than your old fifteen-person team did. This is the role that compounds.

I know which one I'm betting on. We're building Alchemist for the people making the same bet.

**[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)**

---

If you want the long-form case for the destination, read [The Autonomous Development Manifesto](/engineering/autonomous-development).

If you want the architectural difference between Stage 3 and Stage 5, read [Vibe Coding vs Autonomous Development](/engineering/vibe-coding-vs-autonomous-development).

If you want to see what an autonomous cluster looks like under the hood, read [Building a Self-Healing Bug Bot](/engineering/self-healing-bug-bot).
]]></content:encoded>
    </item>
    <item>
      <title>The Autonomous Development Manifesto</title>
      <link>https://chipp.ai/engineering/the-autonomous-development-manifesto</link>
      <guid isPermaLink="true">https://chipp.ai/engineering/the-autonomous-development-manifesto</guid>
      <pubDate>Wed, 06 May 2026 00:00:00 GMT</pubDate>
      <dc:creator>Hunter Hodnett</dc:creator>
      <description>Why we&apos;re building Alchemist AI: a working theory of how autonomous coding agents change the unit economics of software, who wins, who&apos;s at risk, and what the next three years look like from the inside.</description>
      <category>autonomous-software-development</category>
      <category>manifesto</category>
      <category>founder-voice</category>
      <category>ai-agents</category>
      <category>autonomous software development</category>
      <category>autonomous coding agents</category>
      <category>autonomous development as a service</category>
      <category>vibe coding platform</category>
      <category>AI software engineer</category>
      <content:encoded><![CDATA[# The Autonomous Development Manifesto

Why we're building Alchemist AI: a working theory of how autonomous coding agents change the unit economics of software, who wins, who's at risk, and what the next three years look like from the inside.

---

The printing press got invented in 1450. Roughly a century later, the entire economic and political structure of Europe was different. Not because the press had changed anything directly (the press just printed paper) but because the act of distributing knowledge had been delaminated from the act of producing it. Once that came apart, every system built on that coupling came apart with it.

Software is in 1450 right now.

For the last fifty years, producing software and distributing it have been welded together. To ship a feature, you needed someone, usually a credentialed someone, to hand-write the lines. To run a software business, you needed a roster of those someones. Every SaaS price tag is, ultimately, a way of paying down the cost of the team that wrote the code.

Autonomous coding agents are pulling those two halves apart. The act of producing software is delaminating from the act of running a software business. That's the thesis, and it's the thesis Alchemist is built on.

I'm going to make the case for what's actually happening, what isn't, and why we're betting our company on it.

## What changed

I've been a software engineer at Reddit, at Amazon Music, at Home Depot. I've been an engineering manager. I've shipped a lot of code by hand. None of that prepared me for the last six months at Chipp.

We don't write code anymore. Scott, my co-founder, and I have eight Claude Code sessions running in parallel on my laptop right now, and they're shipping features straight to production. Not pull requests. Not "AI-assisted commits." Production. There is no human review gate between the agent and the live system. We deploy 20 to 30 times a day. Two months ago I started sleeping through the night for the first time since we raised our seed round, because the agents, not me, get paged when production breaks, and they fix it before I wake up.

This isn't a hype reel. It's a normal Tuesday. The autonomous cluster has been running in production for two months. It's how we built our agentic commerce protocol implementation. It's how we built our voice-agent stack. It's how our customer support works: when a customer Slacks us a bug, an AI agent reads our codebase, writes the fix, verifies it in a real browser, pushes it to production, and posts the result back in the channel. Median time from "this is broken" to "this is fixed in prod" is around thirty minutes, and we're trying to get it to ten.

I tell people this and they nod politely and assume I'm exaggerating. I'm not. The reason I'm not is the reason this manifesto exists.

## Why now and not last year

Three things compounded.

First, the models got good enough. Claude Opus 4.6 was the inflection point for us. Below that line, the agent would write code that looked plausible but didn't run; it would hallucinate function signatures; it would take twelve turns to do what should have taken two. Above that line, you can hand it a bug report and walk away. Opus 4.6 is the printing press of this analogy: without it, none of the rest matters.

Second, the *tool surface* got rich enough. Two years ago, an LLM was a chat interface. Now it's a programmable agent that can read files, run shell commands, query a database, drive a browser, hit your production logs, and call any HTTP API on the internet. The Model Context Protocol (Anthropic's USB-for-AI standard) is the boring detail that makes this whole thing work. The model still hallucinates plenty. But now it can *check itself*. It can take a screenshot of the page it just built and notice that the button is the wrong color. It can read its own server logs after the deploy and notice that the error rate spiked. The hallucinations stop costing you when the agent has hands and eyes to verify with.

Third, *context engineering* turned out to be a real skill. The first time I tried to get an agent to ship a feature autonomously, it failed. Not because the model was dumb. Because I dumped a 200,000-token codebase into its context and asked it to fix something on line 14,000. We had to figure out (and we did, painfully, over thousands of dollars in token spend) how to load only the relevant context into a finite window, how to summarize without losing the load-bearing details, how to chain agent runs together so the output of one becomes the input of the next without information loss. That's not a model improvement. That's a software engineering discipline. Anyone can learn it. Most people haven't yet.

When those three things land together (capable model, rich tool surface, learned discipline) you get autonomous software development. Which is what Alchemist is.

## What this changes

The unit economics of software flip.

Before: a feature costs you one engineer-week. Maybe two. The engineer gets paid whether the feature is valuable or not. To run a software business, you stockpile engineer-weeks. That's why software companies look like software companies: most of the budget is people, most of the people are engineers, most of the engineers are working on things you can't sell yet.

After: a feature costs you a few dollars in API tokens and the time it takes you to *describe* it. Most of our changes at Chipp cost between \$2 and \$4 in token spend, end to end: research, implementation, code review, deploy. A senior engineer's hourly rate, by comparison, is somewhere north of \$150 an hour fully loaded. The arithmetic is grim if you're a ten-thousand-person engineering org and exhilarating if you're two people trying to ship a venture-backed product.

This is the part that most public commentary gets wrong. The story is not "AI replaces engineers." The story is "AI replaces the *bottleneck of engineer time*." Engineering judgment (what to build, what to skip, what's worth shipping rough versus polishing) does not get cheaper. It might get more valuable. What gets cheap is the labor of typing the code. That used to be the limit. Now it isn't.

A handful of consequences fall out of that.

**Tiny TAMs become buildable.** A "total addressable market" too small to justify the engineer-weeks is not too small to justify a weekend. There's exactly one HOA-management SaaS in the country that serves Upstate South Carolina specifically (there isn't, actually, but you see where I'm going). The HOAs hate the national tools, the national tools can't justify customizing for them, and a builder with an autonomous cluster can spin one up in a week that's better, cheaper, and locally serviced. The barrier was always the cost of the build, not the size of the market. The build cost just collapsed.

**SaaS unbundles.** Big SaaS companies are priced to amortize the engineering team that built them. That price is now an arbitrage opportunity. You can build the slice of the SaaS your customer actually uses for one to two orders of magnitude less, charge less than the incumbent, and be the local face the incumbent can never be. We have customers right now selling Chipp-hosted agents at 90% margins on top of us, to enterprises whose previous spend was on roll-your-own engineering teams. None of these customers are software people. They're domain people who learned how to describe a feature.

**Every engineer becomes a manager.** Not in the headcount sense: most companies are about to have *fewer* engineers, not more. In the cognitive sense. The day-to-day work of a senior engineer is becoming what a senior engineer's day used to look like in the rare moments when they had a productive intern. You assign tickets, you review the work, you push back on the bad calls, you absorb the merge. The agent does the typing. If you've been a strong manager and a mediocre coder, this is your moment. If you've been a strong coder and a weak manager, you have homework.

## What hasn't changed

I'm going to be honest about the limits, because the maximalist version of this story is wrong and the people selling it are about to get a lot of folks hurt.

Autonomous agents fail. They fail about 20-30% of the time at Chipp, even on tickets we've tuned the system for. When they fail, the failure mode is usually one of three things: the prompt didn't have enough context, the context window overflowed and the agent forgot what it was doing, or the agent hit a class of problem (cross-cutting performance work, ambiguous product calls, anything requiring you to hold the whole system in your head) that the model genuinely cannot do yet.

The first two are fixable with better engineering. We've been chipping away at them for a year. The third is a model problem, and you're at the mercy of Anthropic's release schedule.

There's also a platform-risk story that nobody likes to talk about. Right now, Anthropic's models are the best for coding, by a margin. If you build your business on top of Claude, like we have, Anthropic eventually owns your margin. That's the deal you're in. The defense against that is *distillation*: training your own smaller model on the outputs of the frontier model, locking in the parts of your workflow that won't change for a year. We've been distilling for two months. It's the long game, and it's the part of this that the AI labs are going to lobby to make illegal, because it's the only thing that prevents a one-lab monopoly from owning the entire software industry. Watch that fight. It's the most consequential AI policy debate of the decade and almost nobody is paying attention.

## What we're building

Alchemist is the cluster I just described, packaged as a product anyone can use.

You describe what you want. We deploy an autonomous engineering team (research agent, implementation agent, code-review agent, documentation agent, deploy agent) that builds it. The output is a real codebase, in a stack we've spent six figures of token spend tuning (Deno on the server, Svelte on the client, Cloudflare for delivery), running on infrastructure we've made cheap. You can use the platform forever, or you can eject: pull the GitHub repo, take the code, run it yourself, and stop paying us. We optimized for that on purpose. If we ever raise prices into a corner, you walk away and we deserved it.

That's the bet. The bet is that the same way 1450 didn't end up being about the press itself but about everything the press *uncoupled*, the next decade isn't about coding agents. It's about everything that comes apart once code stops being scarce.

The companies that are going to be huge in 2030 are the ones building right now, while everyone else is still arguing about whether the agents really work. The agents really work. We've been running them in production for two months. The window where this is a contrarian take is short.

If you want to be early, [join the waitlist](https://chipp.ai/#waitlist).

If you want to understand the engineering (the context-engineering tricks, the self-healing loop, the bash harness, the distillation moat) I'm writing a series of posts that goes deep on each piece. The series picks up where this one ends.

We'll see you on the other side.

-- Hunter Hodnett, co-founder, Alchemist AI
]]></content:encoded>
    </item>
    <item>
      <title>Vibe Coding vs Autonomous Development: The Maturity Curve from Prompt to Production</title>
      <link>https://chipp.ai/engineering/vibe-coding-vs-autonomous-development</link>
      <guid isPermaLink="true">https://chipp.ai/engineering/vibe-coding-vs-autonomous-development</guid>
      <pubDate>Wed, 06 May 2026 00:00:00 GMT</pubDate>
      <dc:creator>Hunter Hodnett</dc:creator>
      <description>Vibe coding is the second-best place to be in 2026. Autonomous development is the best. The two get conflated constantly, they&apos;re separated by one hard architectural step. Here&apos;s the maturity curve, what each stage actually means, and how to climb from one to the other in 90 days.</description>
      <category>vibe-coding</category>
      <category>autonomous-development</category>
      <category>agentic-coding</category>
      <category>maturity-curve</category>
      <category>vibe coding</category>
      <category>vibe coding vs autonomous development</category>
      <category>agentic coding</category>
      <category>autonomous coding</category>
      <category>autonomous development as a service</category>
      <content:encoded><![CDATA[# Vibe Coding vs Autonomous Development: The Maturity Curve from Prompt to Production

Vibe coding is the second-best place to be in 2026. Autonomous development is the best. The two get conflated constantly, they're separated by one hard architectural step. Here's the maturity curve, what each stage actually means, and how to climb from one to the other in 90 days.

---

A friend asked me last month whether vibe coding and autonomous development were the same thing.

I gave him a long answer. He cut me off. *"Just tell me which one I should be doing."*

The short version: vibe coding is the second-best place to be in 2026. Autonomous development is the best. They are not the same thing, and the gap between them is the most consequential architectural decision a builder will make this year.

This post is the long version of that answer. It walks the five-stage maturity curve from autocomplete through autonomous, defines each rung honestly, and lays out a 90-day plan for climbing from vibe coding to autonomous development without the moves that usually go wrong.

## The maturity curve

There are five stages of human-AI coding collaboration. Each one absorbs the prior one. Stage 5 contains every move from Stages 1 through 4, but the unit of work changes at every step.

**Stage 1. Acceleration.** A model finishes your line. You're still the author. Output velocity: 1.1x. Your fundamental job hasn't changed.

**Stage 2. Augmentation.** A model writes a function. You read it, edit it, commit it. The senior engineer still does most of the thinking. Output velocity: 2x. Copilot's original pitch.

**Stage 3. Vibe coding.** A model writes most of the code. You become an editor in the loop, accepting or rejecting diffs in conversation with the agent. Output velocity: 5-10x for a session. Demos are great. Production code is hit or miss. **This is where most of the industry sits today.**

**Stage 4. Agentic coding.** The agent runs tools, files, shell, browser, database, to accomplish a goal you stated. With the right setup, the agent can verify its own work. The human is still launching and supervising each session. Output velocity: 20-50x for a session. Each session needs a person to start and watch.

**Stage 5. Autonomous development.** Multiple agents run unattended in parallel. Goal-directed. Self-verifying. The human role is decomposition (turning intent into tickets) and judgment (reviewing outcomes). Output velocity is no longer a useful metric, *organizational capacity* is.

The story most builders tell themselves is that Stages 3 and 5 are the same thing with more polish. They're not. Stage 5 contains an architectural commitment Stage 3 doesn't have, and getting from one to the other is most of the work.

## What "vibe coding" actually means

Andrej Karpathy coined the term in February 2025: *"give in to the vibes, embrace exponentials, and forget that the code even exists."* The agent does the work; the human steers from the back seat.

In practice, vibe coding means three things:

1. The human is in the loop on every change. You see a diff. You accept or reject it. You re-prompt when something's wrong.
2. The agent doesn't verify its own work. Verification is the human's job, you click around, check the output, look for bugs.
3. The session runs in real time, with the human watching. There's no batch mode. There's no overnight queue.

Vibe coding is *fast*. A single session can ship a feature that would have taken a week of by-hand engineering. It's also *flow-based*. The output of a vibe-coding session depends on the human's attention, taste, and ability to course-correct in real time.

The thing it isn't is *scalable*. The bottleneck on a vibe-coding setup is the human. You can't run twelve vibe-coding sessions in parallel because you can't watch twelve diffs at once. Your output velocity is bounded by your ability to review.

This is the ceiling Stage 3 hits. Most of the industry has hit it. The teams who think they're at the frontier of AI coding because they ship every day in Cursor or Claude Code interactively, they're at Stage 3. They're operating well. They are also one architectural step away from a different category of business.

## What autonomous development means (the same definition, with the contrast sharpened)

[Autonomous development](/engineering/autonomous-development) is what happens when you remove the human from the inner loop.

The agent gets a goal. It executes against the goal. It verifies the result. It pushes the verified result to production. There is no human in any of those steps. The human's role is upstream of the work (decomposing goals into tickets) and downstream of it (judging outcomes), not inside the work itself.

This is not vibe coding with extra polish. It's a different architecture.

In autonomous development:

1. The session runs without a human watching. You launch it and walk away. It might run for thirty minutes. It might run overnight.
2. The agent verifies its own work. Browser MCP for UI. Test suite for code. Logs for runtime behavior. The agent doesn't trust itself; the agent *checks* itself.
3. Multiple sessions run in parallel because no human is in the loop on any individual session. Eight workers, each on its own port, each in its own git worktree, each shipping independently.

The architectural commitment that separates Stage 5 from Stage 3 is **the verification loop**. Without it, you can't autonomy. With it, you don't need a human in the loop. Everything else in autonomous development, the bash harness, the multi-stage pipeline, the doc auto-load, the sub-agent dilution, exists to support the verification loop or to clean up after it.

> "Vibe coding ends with the diff. Autonomous development ends with verified production code."
> -- Hunter Hodnett, Chipp CTPO

## Why most teams stop at Stage 3

Two reasons. Both are honest.

**Reason 1: Stage 3 is genuinely good.** Vibe coding ships features faster than the manual baseline. Builders feel productive. Customers get more software. Investors see velocity. The pain that would push a team to climb to Stage 5 doesn't exist as long as the team is happy with Stage 3 throughput.

**Reason 2: Stage 5 is genuinely scary.** It requires deleting your PR review process, trusting the cluster to push to production, and rebuilding your incident response around an autonomous self-healing pipeline. The first two weeks of running autonomously are *deeply* uncomfortable for engineers used to controlling every commit.

The teams that stay at Stage 3 forever are the ones who decide the comfort is worth more than the velocity. That's a defensible position right up until a competitor crosses to Stage 5.

When that competitor exists, Stage 3 becomes untenable. They're shipping at output velocities the human-in-the-loop architecture can't match. Their bug-fix latency is measured in minutes, not days. Their on-call rotation is empty. Their engineers spend their time on architecture and judgment instead of typing and reviewing.

You can stay at Stage 3 against a Stage 3 competitor forever. You can stay at Stage 3 against a Stage 5 competitor for about a year.

## How to climb from Stage 3 to Stage 5 in 90 days

Most teams who try to climb fail because they try to climb in one move. They don't. The climb is six discrete steps, and skipping any of them produces a half-implementation that's worse than where you started.

I'll lay them out in the order they should happen.

### Days 1-14: Build a verification loop

This is the most important step and the one that gets skipped most often.

Pick one of your features. Build a browser MCP that knows how to spin up your dev server, navigate to the relevant page, take a screenshot, and read the console logs. This doesn't have to be your *production* dev server, a local Chromium instance and a small custom MCP wrapping it is enough.

Then prove the loop end-to-end. Have the agent make a deliberately broken change. Run it through the verification loop. Watch it catch the break and fix it. If the loop works on a single deliberately-broken case, it'll work on the harder cases.

If the loop doesn't catch the break, you don't have a verification loop. Iterate until it does.

### Days 15-30: Move from one context window to a multi-stage pipeline

Take the workflow you've been doing in one Claude Code session, investigate, write code, review, push, and split it into stages. Each stage is its own session. Each session reads only the markdown file the prior stage wrote.

Two stages is enough to start: a *plan* stage that outputs a `plan.md` describing what to do, and an *execute* stage that reads `plan.md` and does it. Add review and docs stages later.

The discipline you're building here is *fresh-context handoff*. Once it's habitual, your sessions stop running out of context budget, your hallucinations drop, and your token spend per ticket goes *down* even though you're using more sessions. ([Why this works →](/engineering/context-engineering))

### Days 31-45: Build the bash harness

You can't run a session unattended without a manager. The bash harness is the manager. It enforces timeouts, kills sessions that hang, bans dangerous commands, forces commits, cleans up worktrees.

Start with the skeleton in [the bug bot post](/engineering/self-healing-bug-bot#component-2--the-bash-harness). Tune the timeouts to your workload. Add bans for any dangerous flag you've ever seen Claude attempt.

The harness is the thing that lets you walk away from the session. Without it, autonomous development is a research demo. With it, it's a production system.

### Days 46-60: Wire up production triggers

Until now, you've been launching sessions manually. To get to Stage 5, sessions need to launch *themselves*, from production errors, customer reports, performance alerts.

Pick one trigger. We started with a Grafana webhook firing on production errors. Slack tag is the second-easiest. Email forward is the third. Anything that turns a real-world signal into a ticket in your queue is a trigger.

Once tickets land in your queue without you typing them, the cluster starts to feel autonomous. Because it is.

### Days 61-75: Delete your PR queue

This is the step that separates the teams who actually reach Stage 5 from the teams who half-implement.

When the cluster pushes a fix it has verified itself, the PR is the wrong layer. The verification has already happened. The PR is just a delay.

Delete the PR. Push to staging. Let the deploy go. The cluster will catch its own breaks via the same trigger system that catches everyone else's.

This will feel wrong. Senior engineers will object. The objections are the right shape, *what if the cluster ships something bad?*, and the answer is *the cluster will fix what it ships, faster than any review queue would have caught it.* You have to either trust the loop or stay at Stage 3.

### Days 76-90: Add the documentation auto-build

The last discipline. Every successful autonomous run should write or update markdown documentation in your `/docs/` folder. Future runs read those docs as context. The system gets smarter over time.

This is the part that compounds. After a quarter, your `/docs/` folder is the textbook of your codebase. After a year, it's a moat, your cluster works better on your codebase than any general-purpose autonomous system could, because it has the documentation no one else has.

By day 90, you're at Stage 5. Not perfectly. Not for every kind of work. But the architecture is in place, and from here it's incremental tuning.

## What you give up

Honesty matters. Climbing to Stage 5 costs you things.

**You give up the ability to read every diff.** This is the hardest one for engineers attached to craft. You will, sometimes, see code in production you didn't write. Most of the time it'll be fine. Some of the time it'll be ugly. The pattern catches up over time as your `CLAUDE.md` accumulates style rules, but the first month is rough.

**You give up the dopamine of fixing bugs yourself.** Bug fixing is satisfying. The autonomous cluster steals that satisfaction. You'll have to find your dopamine in architecture, judgment, and the kinds of work the cluster can't do.

**You give up some headcount leverage.** You'll have a harder time hiring engineers who want to write code all day, because the cluster is doing most of that. You'll attract a different profile, engineers who want to design systems and lead agents.

**You give up the comfort of the PR queue as a control mechanism.** The verification loop replaces it. You will, intermittently, miss the PR queue. The first time the cluster ships a bug, you will think *I should have caught that*. Then you'll watch the cluster fix the bug it shipped, and you'll get over it.

## What you get back

**You get back your nights and weekends.** This is not a metaphor. The cluster runs while you sleep. Production fires fix themselves. The on-call rotation goes empty.

**You get back your engineering capacity for hard problems.** When the routine work is happening autonomously, you spend your day on the architectural decisions only a human can make. The work gets *more* interesting, not less.

**You get back the ability to ship features that don't survive a cost-benefit analysis at a normal engineering org.** Redundancies. Polish. Anti-fragile fallbacks. Things that wouldn't justify a sprint become weekend tickets for an idle worker.

**You get back the ability to compete with teams an order of magnitude larger.** This is the one that matters most strategically. Your two-person team becomes the productive equivalent of a fifteen-person team. Your fifteen-person team becomes the equivalent of a hundred. Your competitive position changes shape.

## The simple version

If you're still vibe coding in 2026, you're operating well. You're shipping faster than the team next door who is still in Stage 2 review-everything mode.

If you're vibe coding in 2027, you'll be losing market share to competitors who climbed to Stage 5 in 2026.

The window in which Stage 3 is competitive is finite, and it's closing faster than most builders realize. Climb the curve while it's still cheap to climb.

**[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)**

---

If you want the high-level case for the destination, read [The Autonomous Development Manifesto](/engineering/autonomous-development).

If you want the implementation playbook for Stage 5, read [Building a Self-Healing Bug Bot](/engineering/self-healing-bug-bot).

If you want the discipline that makes any of this work, start with [Context Engineering](/engineering/context-engineering).
]]></content:encoded>
    </item>
    <item>
      <title>MCP Is the USB-C of AI: Building Your First MCP Server in 30 Minutes</title>
      <link>https://chipp.ai/engineering/building-your-first-mcp-server</link>
      <guid isPermaLink="true">https://chipp.ai/engineering/building-your-first-mcp-server</guid>
      <pubDate>Tue, 05 May 2026 00:00:00 GMT</pubDate>
      <dc:creator>Hunter Hodnett</dc:creator>
      <description>The Model Context Protocol is what gives an AI agent senses, the ability to read your database, drive a browser, hit your production logs. This is the tutorial. Thirty minutes from a blank file to a working custom MCP server your Claude Code agent can call. Plus the gotchas that wasted a thousand dollars of our token spend.</description>
      <category>mcp</category>
      <category>mcp-server</category>
      <category>claude-code-mcp</category>
      <category>tutorial</category>
      <category>autonomous-development</category>
      <category>claude code mcp</category>
      <category>mcp server</category>
      <category>model context protocol</category>
      <category>mcp tutorial</category>
      <category>build mcp server</category>
      <category>browser mcp</category>
      <content:encoded><![CDATA[# MCP Is the USB-C of AI: Building Your First MCP Server in 30 Minutes

The Model Context Protocol is what gives an AI agent senses, the ability to read your database, drive a browser, hit your production logs. This is the tutorial. Thirty minutes from a blank file to a working custom MCP server your Claude Code agent can call. Plus the gotchas that wasted a thousand dollars of our token spend.

---

Every USB cable I owned in 2018 was different. Mini, micro, lightning, USB-A, USB-B, the weird trapezoidal one for old printers. None of them worked with each other. Owning a cable for one device meant nothing for any other device.

USB-C ended that. One cable, one port, one protocol, and overnight, every device manufacturer's hardware became compatible with everyone else's. The standard didn't make any individual device better. It made the *ecosystem* better.

The Model Context Protocol (MCP) is doing the same thing for AI agents. Before MCP, every framework had its own format for tools. Each integration was bespoke; each integration was three integrations. After MCP, you write one server, and any MCP-compatible client. Claude Code, Cursor, Goose, increasingly anything, can use it.

This post is the tutorial I wish I'd had when I started. By the end of 30 minutes you'll have a working custom MCP server, registered to Claude Code, with one real tool that does something useful. Then we'll talk about what to build *after* the tutorial.

If you want the conceptual case for why MCP matters at all, [the manifesto covers it](/engineering/autonomous-development#part-5-the-five-pillars). This post assumes you're convinced and want to build.

## Part 1: What MCP actually is

A language model only does one thing: output text. Every demo of an "AI agent", the ones that browse the web, query a database, send Slack messages, those are not the model doing anything. They're the model emitting *text*, and software around the model interpreting that text as an instruction.

The conventional way for the model to describe what it wants is a *tool call*. The model emits something like:

```
I want to call a tool named "read_file" with the argument {"path": "src/index.ts"}
```

The framework around the model parses that, runs the actual `read_file` tool on your machine, gets the result, and feeds the result back into the model's next turn. The model now "knows" the contents of `src/index.ts`. It didn't read the file. The framework read the file. The model just got text saying "here's what was in it."

This is the loop. Every interesting capability of every modern AI agent reduces to this loop.

> "The model never executes anything. It just describes what it wants executed, and software outside the model does the executing."
> -- Hunter Hodnett, Chipp CTPO

MCP is the standardized way for the framework to find out *what tools exist*, *what parameters they take*, and *how to call them*. Before MCP, every framework had its own format. After MCP, you build a small server that conforms to the protocol, and any MCP-compatible client can use it.

The protocol itself is conceptually simple: an MCP server speaks JSON-RPC over either standard input/output (for local servers) or HTTP (for remote servers). It exposes a few methods, `tools/list` to enumerate what's available, `tools/call` to invoke one. Claude Code calls those methods on your behalf.

You don't need to memorize any of this. The TypeScript SDK handles the protocol details for you. You just declare your tools, write the implementations, and the SDK does the JSON-RPC plumbing.

## Part 2: What we're building

To make this tutorial useful instead of abstract, we'll build a real MCP server: **a database query tool for a hypothetical app's `users` table**.

In 30 minutes, you'll have:

- A local MCP server written in TypeScript.
- A `query_users` tool the agent can call to look up users by email or ID.
- A safe-column allowlist so the agent never accidentally exfiltrates passwords.
- The server registered with Claude Code so you can use it interactively.

This is the shape of every internal MCP server we've built at Chipp. By the end you'll know how to write your own for your billing system, your job queue, your feature flag store, anything where a custom tool would beat a generic one.

## Part 3: Setup (5 minutes)

Make a fresh directory and initialize a Node project. We'll use TypeScript and the official MCP SDK.

```bash
mkdir my-first-mcp && cd my-first-mcp
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node tsx
```

Create a minimal `tsconfig.json`:

```json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "node",
    "esModuleInterop": true,
    "strict": true,
    "outDir": "dist"
  },
  "include": ["src/**/*"]
}
```

And add a `"type": "module"` to your `package.json` so we can use ESM imports.

That's the entire setup. You're done.

## Part 4: The smallest working server (10 minutes)

Create `src/server.ts`:

```typescript


import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";

// 1. Define the input schema for the tool.
const QueryUsersArgs = z.object({
  email: z.string().optional(),
  id: z.string().optional(),
});

// 2. Define the tool itself.
const QUERY_USERS_TOOL = {
  name: "query_users",
  description:
    "Look up a user from the application's users table. " +
    "Pass either `email` or `id`. Returns the user's id, email, name, " +
    "and account_status. Sensitive columns (password_hash, " +
    "oauth_tokens) are filtered at this layer and never exposed.",
  inputSchema: {
    type: "object",
    properties: {
      email: { type: "string", description: "Email address to look up" },
      id: { type: "string", description: "User ID to look up" },
    },
  },
};

// 3. The fake "database" so this tutorial runs standalone.
const FAKE_DB = [
  { id: "u_1", email: "alice@example.com", name: "Alice", account_status: "active" },
  { id: "u_2", email: "bob@example.com", name: "Bob", account_status: "suspended" },
];

// 4. Boot the server, register handlers.
const server = new Server(
  { name: "my-first-mcp", version: "0.1.0" },
  { capabilities: { tools: {} } }
);

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [QUERY_USERS_TOOL],
}));

server.setRequestHandler(CallToolRequestSchema, async (req) => {
  if (req.params.name !== "query_users") {
    throw new Error(`Unknown tool: ${req.params.name}`);
  }
  const args = QueryUsersArgs.parse(req.params.arguments);
  const user = FAKE_DB.find(
    (u) => (args.email && u.email === args.email) || (args.id && u.id === args.id)
  );
  return {
    content: [
      {
        type: "text",
        text: user ? JSON.stringify(user, null, 2) : "No user found.",
      },
    ],
  };
});

// 5. Wire stdio transport.
const transport = new StdioServerTransport();
await server.connect(transport);
```

That's the full server. About 50 lines. Save it.

You can run it locally to make sure it doesn't crash:

```bash
npx tsx src/server.ts
```

It'll print nothing because it's waiting for JSON-RPC messages on stdin. Hit Ctrl-C.

## Part 5: Register with Claude Code (3 minutes)

Tell Claude Code about the server by editing `~/.claude.json` (or your project's `.mcp.json` if you want it scoped to one project):

```json
{
  "mcpServers": {
    "my-first-mcp": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/my-first-mcp/src/server.ts"]
    }
  }
}
```

Replace `/absolute/path/to/` with the real path. Restart Claude Code.

Verify the server is loaded:

```
$ claude
> /mcp
```

You should see `my-first-mcp` in the list, with one tool available.

## Part 6: Try it out (5 minutes)

In a Claude Code session, ask:

```
Look up the user with email alice@example.com and tell me their account status.
```

The agent should call `query_users` with `{"email": "alice@example.com"}`, get back the JSON for Alice, and report that her account is active.

Try the negative case:

```
Look up the user with email nobody@example.com.
```

The agent should call the tool, get back "No user found.", and report that.

Congratulations, you have a working MCP server. The protocol plumbing is handled. The tool is yours.

## Part 7: The discipline that makes this useful (7 minutes)

Now the part that separates a tutorial MCP from a production MCP.

### Tool descriptions are prompt engineering

The model decides whether to call a tool *based on the description*. Not the name. Not the parameters. The description.

The description we wrote above is honest but generic. A production version of the same tool would look more like this:

```typescript
const QUERY_USERS_TOOL = {
  name: "query_users",
  description:
    "Look up a user from the application's users table. " +
    "Pass either `email` (case-insensitive, exact match) or `id` (UUID). " +
    "Returns: id, email, name, account_status. " +
    "Sensitive columns (password_hash, oauth_tokens, payment_methods) " +
    "are filtered at this layer and are NEVER exposed in any session. " +
    "Use this when investigating customer-reported issues, debugging " +
    "auth problems, or verifying user state. " +
    "Do NOT use this to enumerate users (no list/scan capability) or " +
    "to modify users (read-only). For mutations, use `update_user` instead.",
  ...
};
```

That description does five things the original didn't:

1. Tells the model exactly what data shape to expect.
2. Explicitly names the columns that are filtered out, so the model doesn't ask for them.
3. Tells the model when to use the tool (and when not to).
4. References sibling tools the model should use instead for related operations.
5. Sets expectations about behavior (case-insensitive, exact match, etc.) so the model doesn't guess.

This level of detail is the difference between an MCP that the agent calls correctly and one that the agent calls in confusion. The investment compounds, every session that uses the tool benefits.

A heuristic I use: **if the model would have to guess about anything, the description is too short**. Add a sentence.

### Have Claude write your descriptions

The model is much better at writing descriptions for itself than you are. Once you've drafted the implementation, paste the schema into Claude Code and say *"Write a tool description for this MCP tool. The agent will read this description to decide when to call the tool. Be specific. Mention edge cases. Tell the agent when not to use this tool."*

The first draft is usually 80% of the way there. Tighten and ship.

### Filter sensitive data at the MCP layer

This is the big one. **Anything you don't want the agent to see should be filtered out at the server layer, not at the prompt layer.**

If you tell the agent "don't look at password hashes" via a system prompt, the agent might still look at password hashes when it's confused. If your MCP server *cannot return* password hashes, because the SQL has a hardcoded column allowlist that doesn't include them, the agent literally cannot see them. There's no failure mode where it accidentally gets exposed.

We give our autonomous agents read access to production databases. The reason this is safe is that the database MCP server has hardcoded column allowlists per table. The agent can query `users`, but the only columns the MCP server will return are `id, email, name, account_status, created_at`. Everything else is filtered at the server. Even if the agent goes off the rails and asks for `password_hash`, the MCP server returns the allowlisted columns and ignores the rest.

This is how you ship MCP servers that touch production data without losing sleep.

### Restart Claude Code when you change the server

The most painful gotcha. Claude Code starts the MCP server process *once*, at session start. If you change the server's source code mid-session, your edits won't take effect until you restart.

You will, at some point, edit your MCP server, run it, find a bug, fix the bug, and watch Claude Code call the *old version* of the tool. Then you'll spend an hour debugging "why isn't my fix working" before you remember the gotcha.

When in doubt: restart Claude Code. There's a cheaper way (the `/mcp` command lets you reconnect), but the brute-force restart is the muscle memory worth building.

### Don't `console.log` from your MCP server

Local MCP servers communicate with Claude Code over stdio in a structured JSON-RPC format. If you `console.log` anything, that text gets injected into the protocol stream, the framework chokes on the malformed bytes, and your tool stops working in confusing ways.

Use a real logger that writes to *stderr*, not stdout. The MCP SDK has examples. The pain of debugging a stdio-corrupted MCP server is the kind of pain you feel only once before you internalize the rule.

## Part 8: Beyond the Tutorial (What to Actually Build)

The fake-database MCP we just built is a tutorial, not a production system. Here's what to build *after* this tutorial, in order of leverage.

### A custom database MCP for your real database

Replace the `FAKE_DB` array with a real connection to your application's database. Hardcode the column allowlists per table. Add tools for the queries you actually need, `query_users`, `query_orders`, `query_subscriptions`, whatever your domain requires.

This will be the most-used MCP in your cluster. We dispatch it on almost every Bug Bot ticket.

### A custom browser MCP

The single highest-leverage MCP in autonomous development.

Wrap a local Chromium instance via the [Chrome DevTools Protocol](https://chromedevtools.github.io/devtools-protocol/). Expose tools for navigate, screenshot, click, fill, console-log retrieval. Bake in your dev login flow as its own tool, `browser_dev_login(role: "free" | "enterprise" | "admin")` that bypasses your auth flow with seeded test credentials.

That last tool is the differentiator. Off-the-shelf browser MCPs are generic. The MCP we run for Chipp knows how to log in as any user role without going through OAuth. That domain knowledge is what makes verification fast enough to be useful in an autonomous loop.

### A custom log-drain MCP

Wrap your log aggregator (we use Loki). Expose `query(labels, time_range)` and a higher-level `user_breadcrumbs(user_id, time_range)` that pulls a user's recent interactions before an error fired.

The `user_breadcrumbs` tool is what lets the agent reconstruct the user journey that led to a bug, and propose fixes that match real usage, not synthetic edge cases.

### A custom cron / job MCP

If you have any kind of background job system, wrap it. Tools for *list jobs*, *query job status*, *trigger a job manually*. The agent will use these to debug job failures without you having to baby-sit.

### Don't roll your own when an official one exists

For Stripe, GitHub, Cloudflare, Supabase, Notion, use the official MCPs. The vendors maintain them. They keep up with API changes. They handle auth.

Where to roll your own: anything internal to your codebase, anything where the off-the-shelf MCP is too generic to give the agent the right context (we found this true for databases, off-the-shelf DB MCPs hallucinated column names constantly).

## Part 9: The mental model to keep

Without MCP, you have a model that emits text. That's it. It can't read your code, can't look at your screen, can't query your database, can't verify anything it produces.

With MCP, the model can interact with the world. It can check its own work. It can correct its own mistakes. It can chain together capabilities that no single component of your system would have alone.

That's not an upgrade. That's a phase transition.

Every additional MCP server you build is more *senses* the agent has. The agent that ships your code in 2027 will have access to twenty MCP servers and will navigate them as fluently as you navigate your filesystem. The teams that build those servers earliest will have agents that ship the most reliable code, because their agents will have the most ways to verify themselves.

Build one this weekend. Then build the next one. The cluster works as well as your tools let it.

**[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)**

---

If you want the conceptual case for MCP, the [manifesto](/engineering/autonomous-development#part-5-the-five-pillars) covers why MCP is one of the five pillars of autonomous development.

If you want to see how MCP fits into a production cluster, read [Building a Self-Healing Bug Bot](/engineering/self-healing-bug-bot). Component 4 walks through the four MCPs every Bug Bot setup needs.

If you want the foundational discipline for managing the context MCPs add, read [Context Engineering](/engineering/context-engineering).
]]></content:encoded>
    </item>
    <item>
      <title>Skills vs Sub-Agents: When to Use Each in Claude Code</title>
      <link>https://chipp.ai/engineering/skills-vs-sub-agents</link>
      <guid isPermaLink="true">https://chipp.ai/engineering/skills-vs-sub-agents</guid>
      <pubDate>Mon, 04 May 2026 00:00:00 GMT</pubDate>
      <dc:creator>Hunter Hodnett</dc:creator>
      <description>Skills and sub-agents are the two tools you reach for when CLAUDE.md and hub-and-spoke aren&apos;t enough. They look similar, both give Claude specialized capability, but they&apos;re architecturally different in a way that determines whether they save your context budget or burn it.</description>
      <category>claude-code-subagents</category>
      <category>claude-code-agent-teams</category>
      <category>skills</category>
      <category>sub-agents</category>
      <category>claude-code</category>
      <category>claude code subagents</category>
      <category>claude code agent teams</category>
      <category>claude code skills</category>
      <category>skills vs sub agents</category>
      <category>autonomous coding agents</category>
      <content:encoded><![CDATA[# Skills vs Sub-Agents: When to Use Each in Claude Code

Skills and sub-agents are the two tools you reach for when CLAUDE.md and hub-and-spoke aren't enough. They look similar, both give Claude specialized capability, but they're architecturally different in a way that determines whether they save your context budget or burn it.

---

Once your `CLAUDE.md` is dialed in and you've sprinkled directory-scoped `CLAUDE.md` files through your codebase, you'll start hitting a different class of problem. There are kinds of knowledge that don't fit either pattern.

Some knowledge is too big to put in `CLAUDE.md`, it would bloat every context window with information you only sometimes need. Some knowledge requires *work* to retrieve, not just to read. Some tasks are fundamentally side quests: you don't want them polluting your main agent's context, but you do want them done.

Claude Code has two features for this: **skills** and **sub-agents**. They look superficially similar, both let you give Claude specialized capability, and most people I talk to use them interchangeably for a few weeks before they figure out the actual difference.

The actual difference is one sentence:

**Skills are knowledge the agent reads while it's working. Sub-agents are work the agent delegates to a separate instance.**

Once you internalize that, the rest writes itself. But it took me a quarter to figure out, so let me save you the time.

## What a skill is

A skill is a markdown file with a name, a description, and a body. The body is whatever you want, usually instructions, examples, or domain-specific rules. The description is what Claude reads to decide whether to *invoke* the skill at all.

When the description matches what the user asked for, the skill loads. The body of the skill becomes part of the context window for the rest of that session, and the agent has it as reference while it works.

The mental model is **a cheat sheet on your desk**. You're working at a desk. There's a sticky note on the desk. While you work, you glance at the sticky note for the formulas you can't remember.

I have a skill called `chipp-design` that contains every visual convention of the Chipp brand: our color tokens, our spacing scale, our component library, when to use which animation, how to do glass-morphism in a way that's still legible. The description tells Claude: *"Build UI components and pages following the Chipp brand design system for Svelte 5. Use this skill when creating Svelte components, pages, or UI elements."*

When I ask the agent to build a settings page, the description matches, the skill loads into context, and the agent now has the entire design system as reference. Without the skill, the agent would invent tokens, hardcode hex colors, and ship something that doesn't match the rest of the platform. With it, the output looks like our team built it.

That's a skill working at its best. The cost: tokens. The skill body, which can be substantial, is now occupying space in my context window. Every other tool call has less room.

## What a sub-agent is

A sub-agent is a separate Claude Code session that the main agent spawns, gives a starting prompt, and waits for a result. The sub-agent has its own context window. It runs its own tool calls. When it's done, it sends a summary back to the calling agent, and only the summary lands in the main context window.

The mental model is **sending an intern to the library**. You're sitting at your desk. You realize you need to know something obscure, say, what's the current state of all our Kubernetes pods. Rather than walking to the library yourself, you send an intern. They go off, do the work, come back, and hand you a one-page summary. You absorb the summary in seconds. The intern absorbed every page of the encyclopedia.

I have a sub-agent called `infra-ops`. Its system prompt knows everything about our Kubernetes cluster: which `kubectl` commands are safe, where the production logs live, how to read deployment YAML, what's normal versus alarming. When the main agent runs into something like *"pods are restarting in production,"* it doesn't try to investigate itself, it spawns the `infra-ops` sub-agent.

The sub-agent fills its own 1M-token context window with raw `kubectl` output, log excerpts, deployment manifests. It correlates them, finds the actual issue, and reports back to the main agent: *"Pods are OOM-killing because the last deploy lowered the memory limit too aggressively. Recommend bumping `requests.memory` from 512Mi to 1Gi."*

That two-sentence summary lands in my main context window. The 950k of garbage that was needed to derive it stays in the sub-agent's window, where it can't pollute anything.

## The token math

Both tools cost tokens. They don't cost them in the same way.

**A skill** spends from your *current* context budget. The skill body is loaded into the active session's context window. If your skill is 8,000 tokens long, you have 8,000 fewer tokens for everything else this session. If you load three skills, that's 24,000 tokens gone.

**A sub-agent** spends from a *separate* context budget. The sub-agent has its own window, its own tool calls, its own model invocations. From the calling agent's perspective, it spent the cost of one tool call: *"spawn sub-agent, here's the prompt, get back a summary."* The sub-agent might have spent 150,000 tokens internally to produce that summary, but the calling agent doesn't see them.

This matters more than you'd think. On a complex task, the main agent might spawn five sub-agents over the course of its run. Each sub-agent fills 100,000-200,000 tokens of its own context window doing real work. The main agent, meanwhile, accumulates the five summaries, maybe 5,000 tokens total. The main agent stays nimble. It doesn't compact. It doesn't lose track of why it started the task.

If you tried to do the same work with five skills loaded into the main agent, you'd have to load all the relevant context for all five domains into the same window. The main agent would either compact halfway through or run out of budget completely.

This is the central trick. **Skills concentrate context in the main agent. Sub-agents distribute context across separate agents.**

> "If you'd describe the task as 'go figure out X and tell me,' it's a sub-agent. If you'd describe it as 'while you work, remember X,' it's a skill."
> -- Hunter Hodnett, Chipp CTPO

## When to reach for which

The decision rubric is simpler than I expected once I had it.

**Use a skill when:**

- You need the knowledge *while the agent is actively coding*, referencing it dozens of times during the work.
- The knowledge is short enough that loading it doesn't blow the budget.
- The work is in the agent's main domain (writing the feature, not debugging infra).

Examples: design systems, code style guides, API conventions, common pitfalls for the current subsystem.

**Use a sub-agent when:**

- The task is *fact-finding* or *side investigation*, read a bunch of stuff, return one insight.
- The task involves a lot of tool calls that the main agent doesn't need to see.
- The task is in a separate domain (debugging Kubernetes from a feature-development session).
- The task can fail without affecting the main work.

Examples: debugging production issues, researching how a third-party library works, auditing the codebase for instances of a deprecated pattern, summarizing a long document.

A test that almost always works: **if you would describe the task as "go figure out X and tell me," it's a sub-agent. If you'd describe it as "while you work, remember X," it's a skill.**

## Real examples from Bug Bot

Three live examples from our autonomous cluster.

### `chipp-design` (skill)

Loads when the agent is doing UI work. About 6,000 tokens of design rules, component library reference, and scar-tissue notes about CSS gotchas. Description: *"Build UI components and pages following the Chipp brand design system for Svelte 5."*

The agent reads it dozens of times during a UI ticket, checking spacing tokens, color palette, component conventions. Loading it as a skill means the reference is *there* the whole time, not behind a tool call.

If we tried to handle this with a sub-agent, *"go figure out our design system and tell me what to use"*, the agent would have to dispatch the sub-agent, wait for the summary, and then realize it needed more detail and dispatch again. Skill is the right tool.

### `infra-ops` (sub-agent)

Loads when the main agent has a production issue and needs investigation. The sub-agent has its own runbook (kubectl commands, log query patterns, common failure modes), its own tools (kubectl MCP, Loki MCP), and its own context window.

The main agent dispatches it with one tool call: *"Investigate why pods restarted in the last hour."* The sub-agent runs 47 tool calls, fills 200k of context window, correlates everything, and returns a one-paragraph diagnosis.

If we tried to handle this with a skill, *"here's everything about our K8s cluster, now investigate"*, the main agent's context would fill up with raw kubectl output and lose its grip on the actual ticket. Sub-agent is the right tool.

### `feature-deep-dive` (sub-agent)

Loads when the main agent needs to understand how an existing feature works before modifying it. The sub-agent reads the feature's code, related tests, recent git history, and any relevant docs, then returns an architecture summary.

The main agent gets the summary in its context, applies it to the modification work, ships the change. The 100k of code-reading the sub-agent did doesn't pollute the main session.

This is one of our most-dispatched sub-agents. Almost every non-trivial feature ticket dispatches it as the first step.

## Anti-patterns I've shipped and regretted

Three patterns I've burned tokens learning are wrong.

### The omnibus skill

I had one called `everything-about-our-platform` that loaded a 30,000-token document with our entire architecture. It was easier than thinking about which skill to write. The agent would load it for *every* task, including ones that didn't need it, and we'd lose 30,000 tokens of budget every session.

Splitting it into focused skills (`chipp-billing`, `chipp-design`, `chipp-routing`, `chipp-auth`) meant only the relevant 5,000 tokens loaded at a time. Big improvement.

If your skill description starts with *"general knowledge about…"*, you're building an omnibus. Split it.

### The sub-agent for trivial work

Spawning a sub-agent has overhead, a separate model invocation, the round-trip of starting a new session, the cost of sending the initial prompt. If the task is small, just do it inline.

Sub-agents pay off when the task would fill 50,000+ tokens of context. They cost more than they save when the task would fill 500.

Heuristic: if you'd be embarrassed to interrupt a colleague to ask the question, don't dispatch a sub-agent for it.

### Skills used as sub-agents

This is the most common mistake I see. Someone wants the agent to *"go check the database for orphaned records."* They write a skill called `database-investigation` with instructions and example queries. The skill loads, then the *main agent* runs the queries, and now its context window is filling up with raw database rows.

They wanted the work done elsewhere. They gave themselves a cheat sheet instead.

The fix is a sub-agent: spawn one, let it run the queries, have it return *"found 47 orphans, here are the IDs."* Main context window stays clean.

The pattern to internalize: skills are reference material the main agent uses to do work itself. Sub-agents are work delegated to a separate agent, with only the result coming back.

## The simplest decision

If you want the *agent* to know something, write a skill.

If you want *someone else* to know something, spawn a sub-agent.

That's it. That's the whole post.

The deeper the autonomous cluster gets, and the [Bug Bot pipeline](/engineering/self-healing-bug-bot) leans on both heavily, the more these two patterns become the basic structural elements of every workflow. We use both, constantly. The skills carry the patterns we want consistent across all our work. The sub-agents carry the heavy lifting that would otherwise crush our main agent's context.

Get this distinction right and your context budget stops being the bottleneck on everything you ship.

**[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)**

---

If you want the foundational discipline these patterns build on, read [Context Engineering: The Skill That Turns Claude Into a Production Co-Developer](/engineering/context-engineering).

If you want the architecture for managing skills and sub-agents at scale, read [CLAUDE.md Architecture](/engineering/claude-md-architecture).

If you want to see skills and sub-agents at work in a production cluster, read [Building a Self-Healing Bug Bot](/engineering/self-healing-bug-bot).
]]></content:encoded>
    </item>
    <item>
      <title>How to Make Your Business Discoverable and Sellable to AI Agents</title>
      <link>https://chipp.ai/engineering/agentic-commerce-guide</link>
      <guid isPermaLink="true">https://chipp.ai/engineering/agentic-commerce-guide</guid>
      <pubDate>Sun, 03 May 2026 00:00:00 GMT</pubDate>
      <dc:creator>Hunter Hodnett</dc:creator>
      <description>AI agents are autonomously buying services on the open web. Here&apos;s how to make your business one of them — from structured discovery to accepting payment over HTTP.</description>
      <category>agentic-commerce</category>
      <category>mpp</category>
      <category>acp</category>
      <category>protocols</category>
      <category>ai-agents</category>
      <category>Machine Payments Protocol</category>
      <category>Agentic Commerce Protocol</category>
      <category>HTTP 402</category>
      <category>agentic commerce</category>
      <category>AI agent payments</category>
      <category>Stripe machine payments</category>
      <content:encoded><![CDATA[# How to Make Your Business Discoverable and Sellable to AI Agents

AI agents are autonomously buying services on the open web. Here's how to make your business one of them — from structured discovery to accepting payment over HTTP.

---

**The internet is changing. Again.**

For the past 30 years, businesses have optimized for human customers: beautiful landing pages, SEO for Google searches, checkout flows designed for clicking and typing. But a new category of customer is emerging — one that doesn't use a mouse, doesn't read your carefully crafted copy, and processes transactions in milliseconds.

**AI agents are here. And they have money to spend.**

In 2026, AI agents are autonomously booking travel, ordering supplies, purchasing software licenses, and consuming API services — all without human intervention. If your business isn't set up to serve these customers, you're invisible to an entirely new economy.

This guide will show you exactly how to:

1. **Make your business discoverable** to AI agents
2. **Accept payments programmatically** using the Machine Payments Protocol (MPP)
3. **Capture revenue** from the fastest-growing customer segment on the internet

Whether you run a SaaS company, offer professional services through AI agents, or operate APIs that agents need to consume, this is your roadmap to the agentic economy.

---

## Part 1: The Problem (And Why It Matters Now)

### How Humans Buy vs. How Agents Buy

**When a human wants to hire a graphic designer:**

1. Google search: "freelance logo designer"
2. Click through portfolio websites
3. Read reviews, compare prices
4. Fill out contact form
5. Email back-and-forth
6. Send invoice, wait for payment
7. **Total time: 3-7 days**

**When an AI agent needs a logo designed:**

1. Query structured service directory
2. Parse pricing and capabilities from machine-readable format
3. Evaluate options based on programmatic criteria
4. Initiate payment via HTTP request
5. Receive deliverable with cryptographic receipt
6. **Total time: 3-7 seconds**

The difference isn't just speed — it's **structure**. Agents can't navigate your beautiful Webflow site. They can't interpret your "Contact us for pricing" page. They need:

- **Machine-readable service descriptions**
- **Programmatic pricing information**
- **API-native payment flows**

If you don't provide these, the agent moves on to a competitor who does.

---

## Part 2: Making Your Business Discoverable to AI Agents

AI agents don't browse. They query. Here's how to show up in those queries.

### Step 1: Implement Structured Metadata

Agents discover services through **structured data**, not prose. You need to tell them — in a format they understand — what you offer, how much it costs, and how to buy it.

#### For Service Businesses (Agencies, Freelancers, Consultants)

Add **Schema.org Service markup** to your homepage:

```html
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Service",
  "name": "Professional Logo Design",
  "description": "Custom logo design with 3 concepts, unlimited revisions, delivered in 48 hours",
  "provider": {
    "@type": "Organization",
    "name": "YourAgency",
    "url": "https://youragency.com"
  },
  "offers": {
    "@type": "Offer",
    "price": "500",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "url": "https://youragency.com/api/services/logo-design"
  }
}
</script>
```

**Why this works:** Agents parse structured data to build service catalogs. When an agent searches for "logo design service," your offering appears with pricing, availability, and a direct API endpoint.

#### For SaaS and API Businesses

Create a **machine-readable pricing page** at `/pricing.json`:

```json
{
  "service": "Image Generation API",
  "plans": [
    {
      "name": "Pay-per-request",
      "type": "usage-based",
      "price": {
        "amount": "0.02",
        "currency": "USD",
        "unit": "image"
      },
      "endpoint": "https://api.yourservice.com/generate",
      "authentication": "mpp"
    }
  ],
  "capabilities": ["1024x1024", "SDXL", "ControlNet"],
  "latency_p95": "2.3s"
}
```

**Why this works:** Agents evaluate API services based on price, latency, and capabilities. A structured pricing file lets them compare your service against competitors programmatically.

### Step 2: Create an Agent-Optimized Landing Page

Agents don't care about your hero image. But they **do** read specific sections of your site. Optimize for agent parsers:

#### The "For AI Agents" Section

Add a dedicated section to your homepage:

```markdown
## For AI Agents

**Service:** Professional copywriting
**Pricing:** $0.10 per word
**Turnaround:** 24 hours
**Payment Methods:** MPP (Stripe, USDC on Tempo)
**API Endpoint:** https://yourservice.com/api/orders
**Documentation:** https://yourservice.com/docs/agent-access

To place an order programmatically, send a POST request to our API endpoint with MPP payment credentials.
```

**Why this works:** Many agents are instructed to look for "For AI Agents" or "API Access" sections when evaluating service providers. This explicit signaling increases discoverability.

### Step 3: Publish to Agent Directories

Several agent-focused service directories have emerged. List your business on:

- **MPP Registry** — directory of MPP-enabled services
- **Agent Marketplace** (https://agentmarketplace.ai) — curated catalog for ChatGPT, Claude, and Gemini
- **Tempo Service Directory** — blockchain-native service discovery

Most directories require:

1. Structured service description (JSON-LD)
2. MPP payment endpoint
3. API documentation
4. Pricing information

### Step 4: Implement Discovery Extensions (Optional but Powerful)

For advanced discoverability, implement the **MPP Discovery Extension**:

Add a `/.well-known/payment-methods` endpoint to your domain:

```json
{
  "methods": ["tempo", "stripe"],
  "intents": ["charge", "session"],
  "services": [
    {
      "name": "Logo Design",
      "endpoint": "/api/services/logo-design",
      "price": {
        "amount": "500",
        "currency": "USD"
      }
    }
  ]
}
```

**Why this works:** Agents can auto-discover your payment capabilities and service catalog by querying a standard endpoint, similar to how humans discover your site through `robots.txt`.

---

## Part 3: Accepting Payments from AI Agents with MPP

Discovery gets agents to your door. MPP lets them pay and transact instantly.

### What is MPP?

The **Machine Payments Protocol** is an open standard that lets agents pay for services in the same HTTP request. No signup forms, no billing portals, no human intervention.

**Traditional payment flow (human):**

1. Browse service
2. Click "Buy Now"
3. Fill out payment form (name, email, card number, CVV, billing address)
4. Click "Submit"
5. Wait for confirmation email
6. **Total: 3-5 minutes**

**MPP payment flow (agent):**

1. Request service: `GET /api/service`
2. Receive payment challenge: `402 Payment Required`
3. Submit payment credential: `GET /api/service` + payment proof
4. Receive service + receipt
5. **Total: 200 milliseconds**

### How MPP Works (Simple Explanation)

Think of MPP like a vending machine for the internet:

1. **Agent requests a resource** (like pressing a button)
2. **Server says "That costs $1"** (like the price display)
3. **Agent pays** (like inserting money)
4. **Server delivers the resource** (like the snack dropping)

The technical magic happens through HTTP 402 "Payment Required" — a status code that's been in the HTTP spec since 1997 but never had a standard implementation until now.

### Implementation: Three Paths

#### Path 1: Stripe Integration (Easiest — Recommended for Most Businesses)

**Best for:** Businesses that want both crypto and traditional payment methods (cards, Apple Pay, etc.)

**Time to implement:** ~30 minutes with a developer
**Fees:** Standard Stripe fees (2.9% + $0.30 for cards, blockchain fees for crypto)

**How it works:**

1. **Sign up for Stripe** and request "Machine Payments" access

2. **Install the MPP SDK:**

   ```bash
   npm install mppx stripe
   ```

3. **Add payment middleware to your API endpoint:**

   ```javascript
   import { Mppx, tempo } from 'mppx/server';

   app.get('/api/logo-design',
     mpp.charge({ amount: '500', currency: 'USD' }),
     (req, res) => {
       // Payment verified automatically
       // Deliver service
       res.json({ orderId: '12345', status: 'processing' });
     }
   );
   ```

4. **Deploy** — Your endpoint now accepts payments from agents

**What you get:**

- Payments in USDC (stablecoin) or traditional payment methods
- Funds settle into your existing Stripe account
- Same fraud protection, reporting, and accounting tools you already use
- Automatic receipts and transaction records

#### Path 2: Direct Tempo Integration (Crypto-Native)

**Best for:** Businesses that want lowest fees and crypto-only payments

**Time to implement:** 2-3 hours with a developer
**Fees:** Blockchain gas fees only (typically &lt;$0.01 per transaction)

**How it works:**

1. **Create a Tempo wallet** to receive payments

2. **Install Tempo SDK:**

   ```bash
   npm install @tempo/mpp
   ```

3. **Configure your endpoint:**

   ```javascript
   import { TempoMPP } from '@tempo/mpp';

   const mpp = new TempoMPP({
     recipientAddress: '0xYourWalletAddress',
     network: 'tempo-mainnet'
   });

   app.get('/api/service', async (req, res) => {
     const payment = await mpp.verifyPayment(req);
     if (!payment.valid) {
       return mpp.challengePayment(res, { amount: '500' });
     }
     // Payment verified, deliver service
   });
   ```

**What you get:**

- Instant settlement in USDC
- No intermediary fees
- Direct blockchain settlement
- Full control over payment flow

#### Path 3: Hybrid (Best of Both Worlds)

**Best for:** Businesses that want maximum flexibility

Accept both crypto (via Tempo) and traditional payments (via Stripe) from the same endpoint. Agents choose their preferred payment method.

```javascript
const mppx = Mppx.create({
  methods: [
    tempo.charge({ currency: USDC, recipient: '0x...' }),
    stripe.charge({ apiKey: process.env.STRIPE_KEY })
  ]
});
```

### Worked Example: From Zero to Agent-Ready in About an Hour

**Scenario:** You run a copywriting agency. You want agents to be able to order blog posts programmatically.

**Before MPP:**

- Agent finds your site
- Can't determine pricing (you have "Contact us")
- Can't place order (no API)
- Gives up, goes to competitor

**After MPP:**

1. **Add structured data to homepage** (~15 min)
2. **Create `/pricing.json` endpoint** (~10 min)
3. **Install Stripe + MPP SDK** (~5 min)
4. **Add payment middleware to order endpoint** (~20 min)
5. **Deploy** (~10 min)

**Result:**

- Agent finds your service via structured data
- Parses pricing programmatically
- Places order with payment in a single HTTP request
- Receives blog post draft + receipt in 24 hours

A paying customer your previous setup couldn't have served.

---

## Part 4: Agentic Commerce for AI-Powered Service Businesses

If you've **built an AI agent** that provides professional services (legal research, data analysis, content creation, etc.), MPP is your fastest path to monetization.

### The AI Services Business Model

**Traditional SaaS:** Build software → Charge subscription → Users operate software

**Agentic Services:** Build AI agent → Agent performs service → Charge per transaction

**Examples:**

- AI legal research agent charges $5 per case brief
- AI financial analyst charges $50 per market report
- AI graphic designer charges $100 per logo concept
- AI code reviewer charges $0.10 per pull request

### Why MPP is Perfect for AI Service Businesses

1. **No billing infrastructure needed** — MPP handles payment in the API request
2. **Micropayments work** — Charge $0.01 per API call profitably
3. **Instant settlement** — Get paid in seconds, not Net 30
4. **Agent-to-agent commerce** — Your AI agent can pay other AI agents for sub-services

### Implementation for AI Service Providers

**Step 1: Wrap your AI agent in an API**

```javascript
app.post('/api/analyze-contract', async (req, res) => {
  const { contractText } = req.body;

  // Your AI agent does the work
  const analysis = await yourAIAgent.analyze(contractText);

  res.json({
    analysis,
    risksFound: analysis.risks.length,
    recommendation: analysis.recommendation
  });
});
```

**Step 2: Add MPP payment requirement**

```javascript
app.post('/api/analyze-contract',
  mpp.charge({ amount: '5.00', currency: 'USD' }),
  async (req, res) => {
    // Payment automatically verified before this runs
    const { contractText } = req.body;
    const analysis = await yourAIAgent.analyze(contractText);
    res.json({ analysis });
  }
);
```

**Step 3: Publish to agent directories**

List your AI service on MPP Registry, Agent Marketplace, and relevant directories with:

- Service description: "AI-powered contract analysis"
- Pricing: "$5 per contract"
- Endpoint: `https://yourservice.com/api/analyze-contract`
- Payment: "MPP (USDC, Stripe)"

**Step 4: Watch the revenue flow**

Other agents (ChatGPT, Claude, custom business agents) discover your service and start sending paid requests automatically.

---

## Part 5: Common Questions and Concerns

### "Isn't this just for tech companies?"

**No.** Any business that can be described programmatically can use MPP:

- Freelance designers → API endpoint for design requests
- Consulting firms → Programmatic access to expert analysis
- Data providers → Pay-per-query access to datasets
- Content creators → Automated content licensing

If you can deliver value digitally, you can accept payment via MPP.

### "Do I need to understand blockchain?"

**No.** If you use Stripe integration, you never touch cryptocurrency. Stripe handles all crypto conversions and settles USD into your bank account, just like regular card payments.

If you do want to accept crypto directly, you just need a wallet address (like an email address for money). The SDKs handle everything else.

### "What about fraud and chargebacks?"

**MPP payments are cryptographically verified**, which means:

- No chargebacks (blockchain transactions are final)
- No payment disputes (proof of payment is mathematically certain)
- No card testing fraud (no card numbers involved)

For Stripe SPT (Shared Payment Token) payments, standard Stripe fraud protection applies.

### "How do I handle refunds?"

Refunds work differently for different payment methods:

**Crypto payments:** Send a reverse transaction to the customer's wallet
**Stripe payments:** Use standard Stripe refund API

Most agent transactions don't require refunds because the service is delivered instantly and the payment is pre-verified.

### "What if an agent sends the wrong amount?"

The MPP protocol includes amount verification:

- Server specifies required amount in challenge
- Client payment must match or exceed amount
- Server rejects insufficient payments automatically

You never deliver a service without receiving the correct payment.

---

## Part 6: The Implementation Checklist

Ready to make your business discoverable and sellable to AI agents? Here's your step-by-step checklist:

### Discovery Checklist

- [ ] Add Schema.org Service markup to homepage
- [ ] Create machine-readable pricing page (`/pricing.json`)
- [ ] Add "For AI Agents" section to website
- [ ] Publish to MPP Registry
- [ ] Publish to Agent Marketplace
- [ ] Implement `.well-known/payment-methods` endpoint (optional)

### Payment Checklist

- [ ] Choose payment method (Stripe, Tempo, or Hybrid)
- [ ] Sign up for required accounts (Stripe account or Tempo wallet)
- [ ] Install MPP SDK
- [ ] Add payment middleware to API endpoints
- [ ] Test with mppx CLI tool
- [ ] Deploy to production
- [ ] Monitor transactions in dashboard

### Optimization Checklist

- [ ] Document your API for agent developers
- [ ] Set up monitoring for agent traffic
- [ ] Create usage analytics dashboard
- [ ] Implement rate limiting for fair use
- [ ] Set up automated receipts and invoicing
- [ ] Configure webhook notifications for payments

---

## Part 7: What Success Looks Like

### Metrics to Track

**Discovery Metrics:**

- Agent traffic (check User-Agent headers for AI agents)
- API endpoint hits from agent IPs
- Structured data parse rates

**Transaction Metrics:**

- MPP payment requests
- Successful payment completions
- Average transaction value
- Payment method distribution (crypto vs. fiat)

**Revenue Metrics:**

- Agent-sourced revenue
- Revenue per agent
- Transaction frequency
- Month-over-month growth

### Expected Timeline

- **Week 1:** Implementation and testing
- **Week 2-4:** Initial agent discovery and first transactions
- **Month 2-3:** Steady agent traffic growth
- **Month 4+:** Agent revenue becomes a meaningful part of your overall mix

---

## What's Coming to Chipp

MPP support is on our roadmap. Soon, any agent or app you build on Chipp will be able to expose paid endpoints with structured discovery and HTTP-native payments built in — no SDKs to install, no payment middleware to wire up, no infrastructure to run.

Chipp already ships [ACP](/docs/acp) support today, so the agents you build can search retail catalogs and complete checkouts on a consumer's behalf. MPP rounds out the other half of the picture: getting paid when *your* service is the one being consumed by an agent.

We'll update this post once MPP support lands.

---

## The Bottom Line

The internet is being rebuilt for AI agents. Businesses that adapt now will capture a disproportionate share of the agentic economy.

**The opportunity is clear:**

- AI agents are actively spending money today
- Most businesses aren't set up to serve them
- Implementation is straightforward with the right tools
- Early movers are positioned for the next wave of growth

**The question is simple:**
Will your business be discoverable when an agent searches for your service? Will you be able to accept payment when it wants to buy?

If the answer is no, you're leaving money on the table.

If the answer is yes, you're positioned to win in the next era of internet commerce.

---

**Resources:**

- Official MPP Documentation: [https://mpp.dev/](https://mpp.dev/)
- MPP Specification: [https://datatracker.ietf.org/doc/draft-ryan-httpauth-payment/](https://datatracker.ietf.org/doc/draft-ryan-httpauth-payment/)
- Stripe Machine Payments: [https://docs.stripe.com/payments/machine/mpp](https://docs.stripe.com/payments/machine/mpp)
- Schema.org Service Markup: [https://schema.org/Service](https://schema.org/Service)
]]></content:encoded>
    </item>
    <item>
      <title>Agentic Design Patterns for Production: 7 Patterns We Battle-Tested at Chipp</title>
      <link>https://chipp.ai/engineering/agentic-design-patterns</link>
      <guid isPermaLink="true">https://chipp.ai/engineering/agentic-design-patterns</guid>
      <pubDate>Sun, 03 May 2026 00:00:00 GMT</pubDate>
      <dc:creator>Hunter Hodnett</dc:creator>
      <description>Design Patterns named the moves OOP engineers were already using ad-hoc, and naming them made them transferable. Agentic systems need the same treatment now. Seven patterns we&apos;ve battle-tested across two years of running autonomous development at Chipp, what each one solves, when to use it, and how to know you&apos;ve gotten it wrong.</description>
      <category>agentic-design-patterns</category>
      <category>agentic-workflows</category>
      <category>autonomous-development</category>
      <category>claude-code</category>
      <category>architecture</category>
      <category>agentic design patterns</category>
      <category>agentic workflows</category>
      <category>agentic ai architecture</category>
      <category>autonomous coding patterns</category>
      <category>agent orchestration patterns</category>
      <category>claude code patterns</category>
      <content:encoded><![CDATA[# Agentic Design Patterns for Production: 7 Patterns We Battle-Tested at Chipp

Design Patterns named the moves OOP engineers were already using ad-hoc, and naming them made them transferable. Agentic systems need the same treatment now. Seven patterns we've battle-tested across two years of running autonomous development at Chipp, what each one solves, when to use it, and how to know you've gotten it wrong.

---

The Gang of Four published *Design Patterns* in 1994. They didn't invent any of the patterns in the book. They named twenty-three patterns that OOP developers were already using ad-hoc, and the act of naming them made the practice transferable. Engineers who'd never thought about Strategy or Decorator could read the book, recognize the moves they were already half-doing, and start using them on purpose.

Agentic systems are at the same place now. The shape of how to build production-grade autonomous workflows is becoming clear; the patterns are emerging across teams that have shipped real systems. They just don't have names yet.

This post names seven of them. Each one is a pattern we've battle-tested across two years of running our [autonomous development cluster](/engineering/self-healing-bug-bot) at Chipp. Each one solves a specific failure mode. Each one is portable to whatever stack you're building on.

You don't need all seven to start. Pick three. Implement them this month. The other four will become obvious once the first three are working.

## Pattern 1: The Multi-Stage Pipeline

**Problem**: A single Claude Code session that tries to do everything (research, implement, review, document, push) runs out of context budget. The session compacts. The agent loses the thread. The output quality collapses.

**Pattern**: Split the work into independent stages. Each stage gets its own Claude Code session with a fresh context window. Stages communicate by writing markdown files to disk; the next stage reads only the file the prior one wrote.

**Our pipeline at Chipp**:

```
[Trigger] → [Phase 0: Doc retrieval] → [Phase 1: Research]
         → [Phase 2: Implement]   → [Phase 3: Code review]
         → [Phase 4: Docs update] → [Phase 5: Push to prod]
```

Each phase is its own Claude session. Phase 1's output is `plan.md`. Phase 2 reads `plan.md` (no other context) and writes the code. Phase 3 reads the diff (no other context) and reviews it. And so on.

**Why this works**: A single 1M-token context window can hold a lot, but it can't hold *everything* you want it to hold across an entire feature ticket. By the time the agent has read 30 files, queried logs, formed a hypothesis, written code, run tests, and reviewed its own diff, the window is full and the early reasoning has been compacted to a useless paragraph.

Splitting into stages gives each stage a fresh window. The stage that's writing code doesn't need to remember every file the research stage looked at, it just needs the plan. The plan is the *distilled* output of the research, and distillation survives where raw evidence wouldn't.

**Implementation**: Stage outputs are markdown files in a known location. The bash harness orchestrates the handoff. Don't try to do this with one long-running session and "memory." It will fail.

**Anti-pattern**: The temptation is to add more stages. Five is the right number for most pipelines. Don't go to ten. Each additional stage costs latency and a chance for handoff failure. If a stage isn't earning its place, merge it into a neighbor.

## Pattern 2: Sub-Agent Dilution

**Problem**: Some investigations require *huge* amounts of context, reading thousands of lines of logs, running dozens of tool calls, correlating evidence across many sources. If you do this in your main session, you've burned the budget on context the main task doesn't need.

**Pattern**: Spawn a sub-agent. The sub-agent has its own context window. It does the heavy investigation. It returns a one-paragraph insight to the calling agent. The 950k tokens of evidence stay in the sub-agent's window, where they belong.

**Our `infra-ops` sub-agent**: When the main agent encounters something like *"pods are restarting in production,"* it doesn't try to investigate itself. It dispatches the `infra-ops` sub-agent. That sub-agent runs 47 `kubectl` commands, queries Loki, cross-references the deploy history, and returns: *"OOM-killing because the last deploy lowered the memory limit too aggressively. Recommend bumping `requests.memory` from 512Mi to 1Gi."*

That two-sentence summary is what lands in the main session. ([Full pattern →](/engineering/skills-vs-sub-agents))

**Why this works**: The mental model is *sending an intern to the library*. You don't want every page they read; you want the answer. Sub-agents give you the architectural shape to do exactly that.

**Implementation**: Define sub-agents in `.claude/agents/`. Each one is a markdown file with its own system prompt and tool list. Reference them in your root `CLAUDE.md` so the main agent knows when to dispatch which.

**Anti-pattern**: Don't dispatch a sub-agent for a task the main agent could finish in two tool calls. Sub-agents have overhead, a separate model invocation, the prompt round-trip, the deserialization of the result. They pay off when the task would otherwise fill 50,000+ tokens of context. They cost more than they save when the task is small.

## Pattern 3: The Browser Verification Loop

**Problem**: The agent writes code that compiles, passes tests, and looks correct in the diff. None of that proves the code *works in a browser*. Buttons can render in the wrong color. Click handlers can throw runtime exceptions. API calls can fail. The agent doesn't know.

**Pattern**: After every code change, the agent spins up a dev server, opens a browser via the [browser MCP](/engineering/building-your-first-mcp-server), navigates to the affected page, takes a screenshot, reads the console logs, and verifies the change worked. If anything's wrong, the agent forms a new hypothesis and iterates.

**The actual loop**:

1. Code changes saved in worktree.
2. Dev server (already running on dedicated port) auto-reloads.
3. Agent calls `browser_navigate('localhost:5184/affected-page')`.
4. Agent calls `browser_screenshot()`. Reads the image (multimodal models *see* the screenshot).
5. Agent calls `browser_console_logs()`. Reads the console output.
6. If no errors, agent calls `browser_click('#confirm')` or whatever interaction tests the change.
7. Repeat screenshot + logs read.
8. If errors, the agent forms a hypothesis, edits the code, loop restarts.

**Why this works**: Most "AI ships bad code" stories are stories about agents that wrote plausible-looking code, never tested it, and pushed. The browser loop is the difference between "the agent thinks the code works" and "the agent has *checked* that the code works." Closing this loop is the single architectural change that turned our cluster from interesting demo to production system.

**Implementation**: Custom browser MCP wrapping a headless Chromium via the [Chrome DevTools Protocol](https://chromedevtools.github.io/devtools-protocol/). Off-the-shelf browser MCPs work for prototyping. For production, build your own, bake in your dev login flow, your seed data, your test scenarios. The custom version is the difference between fast and slow autonomous verification.

**Anti-pattern**: Don't run the verification loop on a shared dev server. Each agent worker needs its own port (we use 5180-5187 for our 8-worker pool) so parallel agents don't fight for the same port. Each agent also needs its own git worktree so they don't step on each other's changes mid-loop.

## Pattern 4: CLAUDE.md as Scar Tissue

**Problem**: The agent makes the same mistake on every session. You correct it interactively. The next session, the correction is gone, the agent doesn't remember what it learned in a different session. You're paying for the same lesson over and over.

**Pattern**: Treat your `CLAUDE.md` as a scar tissue document. Every time the agent makes the same class of mistake three times, stop the session, write a rule into `CLAUDE.md` that prevents it, and continue. Over months, your `CLAUDE.md` accumulates the real rules of your codebase, the ones you can only learn by getting bitten.

**Why three strikes**: Once is an outlier. Twice is suspicious. Three times is a pattern. Patterns are what `CLAUDE.md` is for. Adding a rule per mistake bloats the file with one-off lessons that dilute the load-bearing rules.

**Why this works**: `CLAUDE.md` loads in *every* session and survives compaction. It's the only place to put context that you want the agent to have *forever* without paying for re-discovery on every run. Every line in `CLAUDE.md` pays compounding dividends.

**Implementation**: Have the *agent* write the rules into `CLAUDE.md` for you. The model knows what kind of rule will register on its own future inference better than you do. When the agent makes a mistake, prompt it: *"Add a rule to `CLAUDE.md` that prevents this exact mistake. Cite the failure mode. Make it specific enough to act on."* Then read what it wrote and tighten it.

**Anti-pattern**: Aspirational `CLAUDE.md`s. Rules like *"always write clean code"* and *"prefer composition over inheritance"* are too vague to act on. The agent ignores them. Replace with specific, scar-tissue-grounded rules tied to real failure modes you've seen. ([Full discipline →](/engineering/claude-md-architecture))

## Pattern 5: The Auto-Load Table

**Problem**: Some context is too domain-specific to live in your root `CLAUDE.md` (it would bloat every session) but too cross-cutting to live in a single subdirectory `CLAUDE.md` (the rules apply across the codebase whenever a *topic* is mentioned, not whenever a *directory* is touched).

**Pattern**: At the top of your root `CLAUDE.md`, put a small markdown table mapping keywords to documentation files. When a prompt mentions any of the keywords, the agent reads the corresponding doc into context before starting work.

**Our table at Chipp**:

```markdown
## Auto-load table

| Mention | Read |
|---|---|
| billing, stripe, payment, subscription | docs/billing.md |
| auth, login, session, oauth | docs/auth.md |
| websocket, realtime, streaming | docs/realtime.md |
| voice, livekit, transfer | docs/voice-agents.md |
| migration, schema, kysely | docs/db-migrations.md |
```

The keywords are inclusive, if a ticket mentions "stripe" *or* "subscription" *or* "billing," the agent loads `docs/billing.md`. The rules in that doc are far too specific to put in the root `CLAUDE.md` (Stripe API quirks, our shadow-billing system, the eight failure modes of webhook delivery), but they're load-bearing whenever the work touches billing.

**Why this works**: It scales the system's domain knowledge horizontally. You can add ten more rows to the auto-load table without inflating the per-session context cost, the docs only load when relevant. Every successful autonomous run that produces a useful insight about a subsystem can write a new doc and get a new row, and tomorrow's tickets get smarter.

**Implementation**: Put the table at the top of your root `CLAUDE.md`. Be conservative with keywords, false positives waste budget. Generate the docs lazily as you ship, don't try to write all the docs upfront. Use the doc-update phase of your pipeline (Pattern 1) to keep the docs current.

**Anti-pattern**: Don't load *every* doc on every session "just in case." That's the bloat that this pattern is designed to prevent. Trust the keyword match. If the agent fails to load a doc it should have loaded, the keyword list was wrong, fix the list, don't load everything.

## Pattern 6: The Bash Harness Wrapper

**Problem**: Claude Code is non-deterministic. It can hang. It can run for hours. It can attempt commands you don't want it running. It can finish work and forget to push. Your business needs to be deterministic. Your tokens are limited. Something has to be the adult in the room.

**Pattern**: Wrap every Claude Code invocation in a bash script that supervises the session. The script enforces timeouts, kills hangs, bans dangerous commands, forces the final commit and push, cleans up worktrees, and writes outcome labels.

**What our harness enforces**:

- **Idle kill**: if no tool call fires for 5 minutes, kill the session. Catches hangs.
- **Wall-clock timeout**: `timeout 7200` (2 hours) caps runaways.
- **Banned-flag grep**: `git push --no-verify`, `git reset --hard`, `rm -rf` are aborted on detection.
- **Forced commit + push**: at the end of every session, check the worktree state and force the push if Claude forgot.
- **Worktree cleanup**: each run isolated; nothing leaks between workers.
- **Outcome logging**: every run writes a JSONL row to a fine-tuning archive. (Pattern 7.)

**Why this works**: The model is good at writing code. It's bad at managing its own time, recognizing when it's stuck, or cleaning up after itself. The harness handles those things deterministically so the model can focus on the work.

> "An autonomous agent without a bash harness is an intern with no manager, no deadline, and an unlimited API budget."
> -- Hunter Hodnett, Chipp CTPO

**Implementation**: Bash, not Node or Python. Bash is the right language for wrapping Unix processes, subprocess management, signals, timeouts, pipes are all concise in bash and verbose in everything else. Bash is also debuggable in production (no compilation step) and Claude has more bash training data than any other shell language, so the agent can edit the harness too.

The skeleton is in [the bug bot post](/engineering/self-healing-bug-bot#component-2--the-bash-harness). About 200 lines covers everything above.

**Anti-pattern**: Don't try to build the harness in your application stack. Don't make it a feature of your CI system. The harness is a deliberately tiny, deliberately separate piece of infrastructure. Keep it that way.

## Pattern 7: The Outcome-Labeled JSONL Archive

**Problem**: Every autonomous session generates a record of how a frontier model approached a real task in your codebase. That's training data. If you don't capture it, it's gone forever. If you do capture it, you have the basis for fine-tuning a cheaper, specialized model on your own work, the kind of moat that compounds.

**Pattern**: After every autonomous run, append a JSONL row to a long-term archive describing the run, the stages, the token spend, the tool calls, the diff, and the outcome label.

**Our archive row**:

```json
{
  "ticket_id": "billing-create-customer-null-pmt",
  "trigger_source": "grafana",
  "started": "2026-04-15T03:31:18Z",
  "finished": "2026-04-15T03:47:02Z",
  "stages": {
    "research": { "tokens": 412053, "tool_calls": 38 },
    "implement": { "tokens": 187234, "tool_calls": 23 },
    "review": { "tokens": 91482, "tool_calls": 12, "edits": 1 },
    "docs": { "tokens": 43210, "tool_calls": 4 },
    "push": { "tokens": 0, "tool_calls": 0 }
  },
  "outcome": "clean",
  "regressions_detected_24h": false
}
```

The `outcome` field is the label. `clean` means: review made ≤5 edits, all tests passed first try, no regressions detected within 24 hours of deploy. `messy` means anything else.

**Why this works**: Labeled data is the asset that produces fine-tuned models. Every successful autonomous run produces a labeled training row showing how a frontier model approached a real engineering task. After a quarter, you have thousands of rows. After a year, you have a dataset no other team can replicate, because it's specific to *your* codebase and *your* practice.

You may never train a model on this data. That's fine. The decision to *capture* it is one you make today. The decision to *use* it is one you can defer for years. But you can't decide to use data you didn't capture.

**Implementation**: One JSONL row per session. Append-only file in cheap storage (S3, R2, even disk for now). Label the outcome with whatever automated heuristics you have, review edit count, test pass rate, post-deploy regression detection. Don't try to label perfectly; the labels can be improved later.

**Anti-pattern**: Don't try to make this data structured beyond JSONL. JSONL is append-only, easy to grep, easy to load into training pipelines. SQL is overkill. NoSQL is a different kind of overkill. Just the file.

## How to use these patterns

You don't need to implement all seven on day one. Most teams who try fail at exactly that, they read this post, they get excited, they try to build a 7-pattern cluster in two weeks, they fail at three of them, and they conclude none of it works.

The order I'd implement them in:

1. **Browser verification loop** (Pattern 3). Without this, you can't autonomy. Build it first. Even if you do nothing else from this list, build this.
2. **Multi-stage pipeline** (Pattern 1). The next biggest leverage. Splits your sessions, controls your context budgets, makes everything else possible.
3. **Bash harness** (Pattern 6). Once you have a pipeline, you need the supervisor. This is the difference between a hobby project and something you can leave running overnight.
4. **CLAUDE.md as scar tissue** (Pattern 4). Discipline, not infrastructure. Start practicing it on day one of using any of the others. The compounding starts immediately.
5. **Auto-load table** (Pattern 5). After you've shipped enough autonomous tickets to start writing real `/docs/` files. Premature otherwise.
6. **Sub-agent dilution** (Pattern 2). Once your main pipeline is hitting context-budget walls on the heavy investigations. Solves a real problem; not a problem you have on day one.
7. **Outcome-labeled archive** (Pattern 7). Nothing-to-lose pattern. Start it as soon as you have a pipeline. Even if you never use the data, you'll be glad you have it in a year when distillation becomes the obvious move.

Pick three. Build them this month. The next three become obvious once the first three are working.

## What you actually get

A team running these seven patterns ships in a different category than a team running interactive Claude Code sessions, and a *radically* different category than a team still doing all-human engineering.

The numbers from our cluster, honestly:

- 20-30 production deploys per day on a two-person engineering team.
- 70-80% first-attempt success rate on autonomous tickets.
- Mean time from production error to fix in production: ~30 minutes, autonomously.
- Token cost per ticket: low double-digit dollars on a frontier model.
- Pull requests: zero.
- Pages we receive overnight: zero.

The patterns aren't magic. Each one solves a specific failure mode. Together they compose into a system where the failure modes don't compound, when one pattern hits its edge case, the others catch it.

The Gang of Four made OOP transferable by naming the moves. The seven patterns above make autonomous development transferable. Use them, name them, build on them. We'll be writing about the next batch as they emerge.

**[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)**

---

If you want the high-level case for autonomous development, read [The Autonomous Development Manifesto](/engineering/autonomous-development).

If you want the implementation walkthrough of all seven patterns wired into one cluster, read [Building a Self-Healing Bug Bot](/engineering/self-healing-bug-bot).

If you want the discipline that underpins every pattern in this post, read [Context Engineering](/engineering/context-engineering).
]]></content:encoded>
    </item>
    <item>
      <title>CLAUDE.md Architecture: A Hub-and-Spoke Pattern for Autonomous Codebases</title>
      <link>https://chipp.ai/engineering/claude-md-architecture</link>
      <guid isPermaLink="true">https://chipp.ai/engineering/claude-md-architecture</guid>
      <pubDate>Sat, 02 May 2026 00:00:00 GMT</pubDate>
      <dc:creator>Hunter Hodnett</dc:creator>
      <description>Your CLAUDE.md is the highest-leverage file in your codebase. It survives compaction, loads in every session, and accumulates the rules that turn a generic Claude into your codebase&apos;s senior engineer. Here&apos;s the full architecture, root file, directory hub-and-spoke, scar-tissue practice, auto-load tables, and the anti-patterns that wreck it.</description>
      <category>claude-md</category>
      <category>claude-code</category>
      <category>claude-code-best-practices</category>
      <category>context-engineering</category>
      <category>autonomous-development</category>
      <category>claude.md</category>
      <category>claude code best practices</category>
      <category>claude code claude md</category>
      <category>hub and spoke claude md</category>
      <category>claude code memory</category>
      <category>autonomous coding agents</category>
      <content:encoded><![CDATA[# CLAUDE.md Architecture: A Hub-and-Spoke Pattern for Autonomous Codebases

Your CLAUDE.md is the highest-leverage file in your codebase. It survives compaction, loads in every session, and accumulates the rules that turn a generic Claude into your codebase's senior engineer. Here's the full architecture, root file, directory hub-and-spoke, scar-tissue practice, auto-load tables, and the anti-patterns that wreck it.

---

`CLAUDE.md` is the most important file in any Claude Code project.

I mean that literally. There's no other file that touches every session, survives every compaction, and accumulates value over months of use. Your `package.json` doesn't. Your README doesn't. Your tests don't. `CLAUDE.md` does.

And yet most teams I've worked with treat it as a write-once afterthought. They generated it with `claude /init` six months ago, never opened it again, and now wonder why their agents keep making the same five mistakes.

This post is the full architecture of `CLAUDE.md` as we run it at Chipp. Root file, hub-and-spoke directory loading, scar-tissue practice, auto-load tables, sub-agent definitions, and the specific anti-patterns that turn a useful `CLAUDE.md` into a useless one.

If you only have time to internalize one thing from the [autonomous development series](/engineering/autonomous-development), make it this one.

## What `CLAUDE.md` actually is

`CLAUDE.md` is a markdown file in your project root. Claude Code finds it automatically and prepends its contents to the system prompt of every session in that project.

That's the whole mechanism. There's no magic. There's no plugin. The file is just *there*, and Claude reads it.

Three properties make it special.

**Property 1: It loads in every session.** Whether you start an interactive session, run `claude -p` headless, spawn a sub-agent, or dispatch a session from a webhook, `CLAUDE.md` is part of the system prompt every time. There is no opt-out.

**Property 2: It survives compaction.** When the context window fills and the model summarizes everything else, `CLAUDE.md` is one of the few things that stays intact. The post-compaction agent has lost the file contents you read, the grep results you ran, the reasoning that led to the current state, but it still has `CLAUDE.md`. ([Why compaction matters →](/engineering/context-engineering#the-compaction-trap))

**Property 3: It's the only training data you fully own.** The model is trained on the public internet. The MCP servers you use are someone else's tools. The Claude Code CLI is Anthropic's product. `CLAUDE.md` is *yours*. It's the one piece of context the agent loads that nobody else can see, replicate, or take away.

These three properties make `CLAUDE.md` the *highest-leverage file in your codebase*. Every line in it pays compounding dividends. Every line you neglect to add costs you the same mistake, repeated, every time the agent runs.

## The scar-tissue practice

The fundamental discipline of `CLAUDE.md` is treating it as a *scar tissue document*, not an aspiration document.

An aspiration document says things you wish were true. *"Always write clean code." "Prefer composition over inheritance." "Use semantic HTML."* The agent ignores most of it because the rules are too vague to act on and too unmotivated to take seriously.

A scar tissue document says things that have actually bitten you. *"Don't use lodash; we removed it in v4 and the bundle size went up 30KB last time someone re-added it." "Database migrations have to be backward-compatible because we deploy without taking the API down." "The `useUser` hook returns null during the auth bootstrap; check for it."*

Each of those sentences is a real bug we hit. Each one is a rule we wrote into `CLAUDE.md` after the third or fourth occurrence. Each one prevents the agent from making the same mistake again. The aspiration version of those rules would have been ignored. The scar tissue version is treated as load-bearing.

The mechanic for building scar tissue:

1. The agent makes a mistake. Notice it.
2. Don't fix it yet. First, prompt the agent: *"Add a rule to `CLAUDE.md` that prevents this exact mistake. Cite the failure mode you just hit. Make the rule specific enough to act on."*
3. Let the agent write the rule. The model knows what kind of rule will register on its own future inference better than you do.
4. Read the rule. Tighten it if needed. Commit it.
5. Now fix the original mistake.

After six months of doing this, your `CLAUDE.md` is a textbook of your codebase's hidden rules. Your agents stop making the mistakes you've already paid for.

> "I have my autonomous AI cluster updating its own `CLAUDE.md`. I honestly barely know what's in there these days."
> -- Hunter Hodnett, Chipp CTPO

## The three-strikes-then-rule heuristic

Don't add a rule for every mistake. If you do, your `CLAUDE.md` becomes 5,000 lines of one-off lessons and the truly important rules get diluted.

The heuristic we use: wait for the same class of mistake to happen *three times* before promoting it to a `CLAUDE.md` rule.

Once is an outlier. Twice is suspicious. Three times is a pattern. Patterns are what `CLAUDE.md` is for.

There are exceptions. If a single mistake costs real money, real customer trust, or real production downtime, it goes in the file the first time. But for the everyday small mistakes, the agent typed `useState` when it should have used our custom `useStableState`, the agent imported from `@/components/old/Button` when the new one is at `@/components/Button`, wait for the third strike.

This heuristic also keeps the file *legible*. A 200-line `CLAUDE.md` of hard-won rules is more useful than a 5,000-line `CLAUDE.md` of every observation. The agent reads the entire file every session. Make every line earn its place.

## Hub-and-spoke: directory-scoped CLAUDE.md

Your root `CLAUDE.md` should not contain rules that only apply to part of your codebase.

If a rule applies only to your billing system, it shouldn't load when the agent is editing your CSS. Loading it anyway costs context budget the agent could be using to think.

The fix is a feature most people don't know exists: **Claude Code automatically loads any `CLAUDE.md` it finds in or above the directory of any file it reads.**

That means you can put a `CLAUDE.md` at any level of your file tree, and it will load *only* when the agent is working in that area:

- `src/db/CLAUDE.md`, loads when the agent reads any file in `src/db/`
- `src/api/auth/CLAUDE.md`, loads when the agent is in the auth subsystem
- `src/components/CLAUDE.md`, loads when the agent is in any component

We have something like fifteen `CLAUDE.md` files sprinkled throughout the Chipp codebase. Each one is small, usually 20-80 lines, and *very* specific to its directory.

The result is that the agent always has *exactly* the context it needs and very little it doesn't. Hub-and-spoke is the difference between an agent that runs out of context budget on every task and one that finishes with 70% to spare.

A practical layout looks like:

```
.
├── CLAUDE.md                          # root: tech stack, conventions, top-level rules
├── src
│   ├── api
│   │   ├── CLAUDE.md                  # API conventions, error handling, route patterns
│   │   ├── auth
│   │   │   └── CLAUDE.md              # auth-specific gotchas
│   │   └── billing
│   │       └── CLAUDE.md              # billing invariants, Stripe quirks
│   ├── db
│   │   └── CLAUDE.md                  # ORM rules, migration patterns, schema gotchas
│   ├── components
│   │   └── CLAUDE.md                  # design system rules, prop conventions
│   └── services
│       └── CLAUDE.md                  # service layer conventions
└── tests
    └── CLAUDE.md                      # test framework, fixture patterns
```

Each subdirectory `CLAUDE.md` should answer the question *"What would I tell a senior engineer who's never worked in this directory before, on day one?"*, and nothing more. If a rule is universal, push it up to the root. If it's universal *within a subdirectory*, push it down. Hub-and-spoke is a structure for keeping rules at the right level.

## The auto-load table

Hub-and-spoke handles location-based context. But sometimes you want context to load based on *what the agent is doing*, not *where in the codebase it is*.

For example: if a ticket mentions "billing," the agent should load our billing playbook before it starts work, even if it doesn't yet know which files it's going to touch. Static `CLAUDE.md` placement can't handle that, because the relevant docs aren't *in* a billing directory; they're in `/docs/billing.md`.

We solve this with an auto-load table. At the top of our root `CLAUDE.md`, we have a small markdown table:

```markdown
## Auto-load table

| Mention | Read |
|---|---|
| billing, stripe, payment, subscription | docs/billing.md |
| auth, login, session, oauth | docs/auth.md |
| websocket, realtime, streaming | docs/realtime.md |
| voice, livekit, transfer | docs/voice-agents.md |
| migration, schema, kysely | docs/db-migrations.md |
| feature flag, rollout, kill switch | docs/feature-flags.md |
```

The pattern: when a prompt mentions any of these keywords, the agent reads the corresponding doc into context before starting work.

We don't load the docs in `CLAUDE.md` itself, that would burn the budget on every session, even sessions that don't need them. We load them dynamically, only when relevant.

This is how I keep my root `CLAUDE.md` lean (around 25k tokens) while still giving the agent rich context for any specific subsystem (5k-15k of additional context, only when needed).

The auto-load table is the part of the architecture that keeps the system *learning*. Every time a successful autonomous run produces a useful insight about a subsystem, that insight goes into a markdown file in `/docs/`, and a row in the auto-load table makes it available for future runs that touch the same area.

## Sub-agent definitions

Your `CLAUDE.md` should also define your sub-agents.

A [sub-agent](/engineering/skills-vs-sub-agents) is a separate Claude Code session your main agent can spawn to do bounded work in its own context window. They live in `.claude/agents/` as their own markdown files, and your root `CLAUDE.md` should reference them.

Our root `CLAUDE.md` has a section like:

```markdown
## Sub-agents

When the work calls for a deep investigation that would otherwise burn the
main context window, dispatch one of these sub-agents instead:

- `infra-ops` - for Kubernetes, deploys, networking, log investigation.
  Has the runbooks. Has the kubectl tools. Returns one-paragraph summaries.
- `feature-deep-dive` - for understanding how an existing feature works
  before modifying it. Returns an architecture summary.
- `feature-dependency-mapper` - for refactor planning. Returns the call
  graph and files affected.
- `db-investigator` - for debugging data issues. Has read access to the
  production database with safe-column allowlisting. Returns the
  smoking-gun query results.

When in doubt, prefer a sub-agent over filling the main context. The main
context belongs to the work, not the investigation.
```

The agent reads this in every session and knows when to dispatch what. We rely on it heavily, most of our autonomous tickets dispatch at least one sub-agent in the research phase.

## Anti-patterns that wreck a `CLAUDE.md`

Six failure modes I've seen on real teams. Avoid them.

### The aspiration document

Rules like *"Always write clean code"* and *"Prefer composition over inheritance"*. These are too vague to act on. The agent acknowledges them and ignores them. Replace with specific scar-tissue rules.

### The bloat

A 5,000-line `CLAUDE.md` that includes everything anyone ever thought was important. Every session pays for the bloat in context budget. The truly important rules get diluted into noise. Apply three-strikes-then-rule. Push directory-specific stuff into hub-and-spoke files.

### The freeze

A `CLAUDE.md` that hasn't been edited in three months. Either your codebase has stopped evolving (it hasn't) or your agent is making the same mistakes over and over and you're not bothering to write them down. The latter is the diagnosis 95% of the time.

### The wishlist

Rules describing what you *wish* the codebase were like, not what it actually is. The agent reads these, dutifully writes code that matches the wish, and breaks the codebase. Document the codebase as it exists. Migrate the codebase first, then update the rule.

### The TODO ledger

`CLAUDE.md` used as a personal scratch pad: *"TODO: refactor the user service. NOTE: ask Hunter about the billing thing."* This pollutes the system prompt with irrelevant content. Use a tasks file or your issue tracker for this. `CLAUDE.md` is for rules.

### The single source

Trying to put everything in one file at the root. The hub-and-spoke pattern exists precisely because not everything belongs in the root. If your root `CLAUDE.md` is over 1,000 lines, you're failing to use the directory mechanism.

## How to start one if you don't have one

For a fresh project: run `claude /init` to generate a starter file. Then immediately delete most of what it generates. The generated `CLAUDE.md` is too generic to be useful, it's a placeholder for the scar tissue you'll write yourself.

Replace the boilerplate with three things:

1. **Your tech stack.** One-line summary of what you're using. *"Deno + Hono on the server, Svelte 5 on the client, Cloudflare Workers for delivery."*
2. **The two or three most important rules.** Things you already know will trip the agent up. *"We use Kysely, not Prisma. Migrations are expand-then-contract; never both at once."*
3. **An empty auto-load table.** Just the header. You'll fill it in as you generate `/docs/` files.

That's the whole starter. Resist the urge to write more. The remaining content has to be earned through actual scar tissue.

## How to fix one that's a mess

If you have a `CLAUDE.md` that's already 3,000 lines of garbage, the cleanup pattern is:

1. **Audit for the three-strikes-then-rule violation.** Any rule that hasn't paid for itself by preventing a real bug? Cut it.
2. **Push location-specific rules into hub-and-spoke.** A rule about your auth system goes in `src/api/auth/CLAUDE.md`. A rule about your CSS goes in `src/components/CLAUDE.md`. The root file should only have rules that apply everywhere.
3. **Convert aspirations to scar tissue.** *"Always validate input"* becomes *"Use the `assertValidUuid()` helper before any DB query against an id column. We've shipped four 500s from this exact mistake."*
4. **Build the auto-load table.** Group related rules into `/docs/` files. Reference them in the auto-load table. Cut them from the root file.

This audit is itself a great task to hand to an agent. Open an interactive session, share the current `CLAUDE.md`, and ask the agent to apply the audit pattern. It'll do most of the work for you.

## The compounding asset

The reason `CLAUDE.md` matters more than any other file in your codebase is that it's the only artifact whose value compounds with every successful autonomous run.

Every line of code you write decays, frameworks change, requirements shift, tests need updating. Every line in `CLAUDE.md` becomes more valuable, because it's preventing a class of mistake across all future sessions.

After three years of running this discipline, your `CLAUDE.md` is the most important asset in your codebase, more valuable than any individual feature you've shipped, because it's the thing that lets you ship the *next* feature reliably.

Treat it accordingly. Read it monthly. Edit it weekly. Audit it quarterly. The teams who run autonomous development at scale all have this in common: they take their `CLAUDE.md` seriously.

The teams that don't end up wondering why their agents are still making mistakes after six months. They are. The mistakes are documented in your bug tracker. They aren't documented in `CLAUDE.md`. That's the gap.

**[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)**

---

If you want the full discipline of context engineering, read [Context Engineering: The Skill That Turns Claude Into a Production Co-Developer](/engineering/context-engineering).

If you want to see how `CLAUDE.md` fits into a real autonomous pipeline, read [Building a Self-Healing Bug Bot](/engineering/self-healing-bug-bot).

If you want to know when to use a skill versus a sub-agent (the next layer up from `CLAUDE.md`), read [Skills vs Sub-Agents](/engineering/skills-vs-sub-agents).
]]></content:encoded>
    </item>
    <item>
      <title>Building a Self-Healing Bug Bot: The Autonomous Dev System We Use at Chipp</title>
      <link>https://chipp.ai/engineering/self-healing-bug-bot</link>
      <guid isPermaLink="true">https://chipp.ai/engineering/self-healing-bug-bot</guid>
      <pubDate>Fri, 01 May 2026 00:00:00 GMT</pubDate>
      <dc:creator>Hunter Hodnett</dc:creator>
      <description>The implementation post. Five components, real bash, real Claude Code, and the system that ships 20-30 production changes a day at Chipp without a pull request in sight. Includes the harness skeleton you can copy, the MCP fleet we run, and an honest accounting of cost and failure modes.</description>
      <category>bug-bot</category>
      <category>autonomous-coding</category>
      <category>agentic-workflows</category>
      <category>claude-code</category>
      <category>self-healing</category>
      <category>autonomous coding</category>
      <category>agentic workflows</category>
      <category>self-healing pipeline</category>
      <category>claude code agent teams</category>
      <category>bash harness</category>
      <category>bug bot</category>
      <content:encoded><![CDATA[# Building a Self-Healing Bug Bot: The Autonomous Dev System We Use at Chipp

The implementation post. Five components, real bash, real Claude Code, and the system that ships 20-30 production changes a day at Chipp without a pull request in sight. Includes the harness skeleton you can copy, the MCP fleet we run, and an honest accounting of cost and failure modes.

---

At 3:47 AM, Bug Bot pushed a fix to production.

I learned about it the next morning. The error had landed in our log drain at 3:31. The fix had shipped at 3:47. Sixteen minutes from production fire to production deploy.

I was asleep through all of it.

This post is how to build the system that lets you sleep.

## What Bug Bot is

Bug Bot is the autonomous development cluster that runs Chipp. It picks up production bugs and feature tickets from four trigger sources, runs each through a five-stage pipeline, and pushes verified code to production without human review. Eight workers run in parallel on a single workstation. We ship 20-30 production changes per day. There are no pull requests in this system.

The high-level case for it is in [The Autonomous Development Manifesto](/engineering/autonomous-development). This post is the implementation. If you've been wondering whether you could build one of these for your own product, the answer is yes, and what follows is enough to start.

## The architecture

```
   ┌───────────────────────────────────────────────────────┐
   │                   TRIGGER LAYER                        │
   │   Slack       Email       Grafana      P95 Latency    │
   │    tag       forward      webhook         alert       │
   └─────┬──────────┬───────────┬───────────────┬──────────┘
         │          │           │               │
         └──────────┴────┬──────┴───────────────┘
                         ▼
                  ┌──────────────┐
                  │ TICKET QUEUE │
                  └──────┬───────┘
                         ▼
            ┌──────────────────────────┐
            │   BASH HARNESS POOL       │
            │   (8 workers, max)        │
            └────┬─────┬─────┬─────┬───┘
                 │     │     │     │
                 ▼     ▼     ▼     ▼
            ┌────────────────────────┐
            │  CLAUDE CODE PIPELINE  │
            │                        │
            │ Phase 0: Doc retrieval │
            │ Phase 1: Research      │
            │ Phase 2: Implement     │
            │ Phase 3: Review        │
            │ Phase 4: Docs update   │
            │ Phase 5: Push          │
            └─────────┬──────────────┘
                      ▼
                  [PRODUCTION]
                      │
                      ▼
        (errors loop back via trigger layer)
```

Five components. Each one is replaceable; what matters is that they all exist and they all integrate.

## Component 1: The trigger layer

Tickets need to land in your queue. We use four sources.

### Loki + Grafana for production errors

Self-hosted log aggregation. Every server-side error is logged to Loki via a structured log call:

```typescript
log.error({
  service: 'billing',
  feature: 'create_customer',
  err: error.stack,
  user_id: hashUserId(userId),
});
```

Sensitive fields are one-way encrypted before they ever land in logs. The agent gets metadata, not secrets.

A Grafana alert rule fires every five minutes:

```
WHEN errors_count_5m > 5
  AND grouped_by_stack_trace
THEN webhook(POST /bug-bot/trigger)
```

The five-minute window dedupes, if 47 instances of the same error happen, the agent gets one ticket, not 47.

### Webhook server

A small Hono server listens for Grafana webhooks. Its only job is to construct a Bug Bot prompt and add it to the queue:

```typescript
app.post('/bug-bot/trigger', async (c) => {
  const alert = await c.req.json();
  const prompt = `
Production error detected.

Service: ${alert.labels.service}
First seen: ${alert.firstSeen}
Affected users: ${alert.uniqueUsers}
Stack trace:
${alert.stackTrace}

Investigate and fix. The auto-load table will pull relevant docs.
`;
  await ticketQueue.add({ source: 'grafana', prompt });
  return c.json({ ok: true });
});
```

### Slack tag

A Slack listener watches our internal `#chipp-rewrite-bugs` channel for `@bug bot` mentions. The thread becomes the prompt:

```typescript
slack.event('app_mention', async ({ event }) => {
  const thread = await slack.getThread(event.thread_ts);
  await ticketQueue.add({
    source: 'slack',
    prompt: thread.messages.map(m => `${m.user}: ${m.text}`).join('\n'),
  });
});
```

### Email forward

I forward customer emails to a Bug Bot inbox. A Mailgun webhook converts each email into a ticket. (I dictate most of mine via Whisper Flow on my phone, yes, I voice-message my engineering team.)

### P95 latency alert

A separate Grafana alert rule fires if our chat-streaming P95 exceeds three seconds. Different prompt template, same queue.

The shape of the trigger layer matters less than the principle: tickets should land in your queue from anywhere a human or system might notice a problem.

## Component 2: The bash harness

This is the most important component. The bash harness is what turns Claude, non-deterministic, prone to running long, occasionally trying to `git push --no-verify` its way out of a problem, into a deterministic teammate.

> "An autonomous agent without a bash harness is an intern with no manager, no deadline, and an unlimited API budget."
> -- Hunter Hodnett, Chipp CTPO

The harness is shell script, not Node or Python. We've considered both. Bash wins because Claude is also writing the harness, and Claude has more bash training data than any other shell language. The harness needs to be readable, debuggable, and easily edited by the same agent it manages.

### Skeleton

```bash
#!/usr/bin/env bash
set -euo pipefail

WORKER_ID=$1
TICKET_FILE=$2
WORKTREE_DIR="/tmp/bug-bot/worker-${WORKER_ID}"
DEV_PORT=$((5180 + WORKER_ID))
IDLE_TIMEOUT=300  # 5 minutes
BANNED_FLAGS="git push --no-verify|git reset --hard|rm -rf /"

# Set up worktree
git worktree add -b "bot/${WORKER_ID}-$(date +%s)" "$WORKTREE_DIR" main
cd "$WORKTREE_DIR"

# Spawn dev server in background on dedicated port
PORT=$DEV_PORT pnpm dev > "/tmp/bug-bot/worker-${WORKER_ID}.log" 2>&1 &
DEV_PID=$!

# Run the 5-stage pipeline
for STAGE in research implement review docs push; do
  PROMPT_FILE="prompts/${STAGE}.md"

  # Spawn Claude in headless mode
  timeout $IDLE_TIMEOUT claude -p \
    --dangerously-skip-permissions \
    --append-system-prompt "$(cat $PROMPT_FILE)" \
    < "$TICKET_FILE" 2>&1 | tee "stage-${STAGE}.log" &
  CLAUDE_PID=$!

  # Banned-flag watch
  while kill -0 $CLAUDE_PID 2>/dev/null; do
    if grep -qE "$BANNED_FLAGS" "stage-${STAGE}.log"; then
      echo "BANNED FLAG DETECTED - killing worker $WORKER_ID"
      kill $CLAUDE_PID
      exit 1
    fi
    sleep 2
  done

  wait $CLAUDE_PID
done

# Force final commit + push if not already done
if ! git diff --cached --quiet; then
  git add -A
  git commit -m "[bug-bot/${WORKER_ID}] $(cat ticket-summary.txt)"
fi
git push origin HEAD:staging

# Cleanup
kill $DEV_PID
git worktree remove "$WORKTREE_DIR" --force

# Log outcome for fine-tuning
echo "{\"worker\": ${WORKER_ID}, \"ticket\": \"$(basename $TICKET_FILE)\", \"outcome\": \"clean\"}" \
  >> /var/log/bug-bot/outcomes.jsonl
```

This is simplified. Our production version has more error handling and outcome labeling. The shape is right.

### What the harness enforces that Claude can't

- **Idle kill.** If Claude doesn't fire a tool call for five minutes, the session is killed. This catches the case where Claude gets stuck in a "let me think about this" loop.
- **Banned-flag grep.** If Claude attempts `git push --no-verify`, `git reset --hard`, or `rm -rf` against an absolute path, the session is aborted.
- **Forced commit + push.** Claude occasionally completes work but forgets the final push. The harness checks the worktree state and forces it.
- **Worktree cleanup.** Each run is isolated; nothing leaks between workers.
- **Port allocation.** Each worker gets a dedicated dev server port (5180 + worker ID).
- **Outcome logging.** Every run writes a JSONL row to a fine-tuning archive. (More on this below.)

## Component 3: The five-stage Claude pipeline

Each stage is its own Claude Code session, with its own context window. The stages communicate via files written to disk.

### Phase 0: Doc retrieval (bash, not Claude)

Before any Claude session runs, a bash script semantic-searches `/docs/` for files relevant to the ticket and writes the results to `pre-context.md`:

```bash
docs-search "$(cat ticket.txt)" > pre-context.md
```

`docs-search` is a small CLI we wrote that runs OpenAI's embeddings API over our `/docs/` folder once per week and stores vectors in a local SQLite file. Could be any vector store. The point is to load relevant context before Claude opens its first context window.

### Phase 1: Research

```
You are the research agent for an autonomous dev pipeline.

Read the ticket. Read pre-context.md. Read relevant code.
Query Loki for similar errors. Query the database if useful.
Form a hypothesis.

Output a plan.md with:
- Root cause
- Affected files
- Implementation steps
- Test strategy
- Risks

DO NOT edit any source files in this phase.
```

Output: `plan.md`. Context window can fill up to 1M tokens of investigation; only the plan survives.

### Phase 2: Implement

```
You are the implement agent.

Read plan.md. Read pre-context.md. That's your context.
Make the code changes described in plan.md.
Run unit tests for affected files.
Run the full test suite.
Spin up dev server on port ${DEV_PORT}.
Open browser MCP. Navigate to affected URLs.
Read browser console + dev server logs.
Fix anything broken.

Commit your changes when verified.
```

Fresh context window. The agent never sees the original investigation, only the distilled plan.

### Phase 3: Review

```
You are the review agent.

Read the diff. Red-team it.
Look for: edge cases, security issues, type errors, broken contracts.
You can edit. If you make more than 5 edits, the implement agent's work is flagged messy.

Output: approved | needs-rework, plus reasoning.
```

### Phase 4: Docs update

```
You are the docs agent.

Given the diff, identify any non-obvious behavior introduced.
Write or update markdown files in /docs/ to capture it.
Identify any docs the change has invalidated. Prune them.
Update the auto-load table at the top of CLAUDE.md if needed.
```

This is how the system gets smarter over time.

### Phase 5: Push

Bash, not Claude. Final commit, push to staging branch, monitor deploy.

## Component 4: The MCP fleet

Without MCP, your agent can read code and reason. With MCP, it can verify, query, and act. The four MCPs every Bug Bot setup needs:

### Browser MCP (custom, dev-tools protocol)

This is the single most important MCP in autonomous development. Without it, you're guessing.

Our browser MCP wraps a local Chromium instance via the dev-tools protocol. It exposes:

- `browser_navigate(url)`, go to a page
- `browser_screenshot()`, return a base64 image
- `browser_console_logs()`, return recent console messages
- `browser_click(selector)`, interact with the page
- `browser_dev_login(role)`, bypass our auth flow with seeded test credentials

That last tool is the differentiator. Off-the-shelf browser MCPs are generic. The MCP we run for Chipp knows how to log in as a free user, an enterprise user, or a paying user with exhausted credits, without going through the human OAuth flow. That domain knowledge is what makes verification fast.

### Log-drain MCP (custom)

Wraps Loki. Exposes:

- `loki_query(labels, time_range)`, run a LogQL query
- `loki_user_breadcrumbs(user_id, time_range)`, pull a user's recent interactions before the error fired

The user breadcrumbs tool is what lets the agent reconstruct the user journey that led to a bug, and propose fixes that match real usage, not synthetic edge cases.

### Database MCP (custom)

Wraps our database with hard-coded safe column lists. We give the autonomous agents read access to production. The MCP enforces:

- No `SELECT *`. The MCP returns only the columns you've explicitly allowed.
- Sensitive columns (passwords, OAuth tokens, payment methods) are filtered out at the MCP layer; the agent never sees them in any session.
- All queries are read-only by default. We have a write-enabled variant gated behind an additional bash-harness check.

We tried off-the-shelf database MCPs first. They hallucinated column names constantly. Custom won.

### File system + bash (built-in)

Claude Code includes file system and bash tools by default. You don't need to install these. You do need to ensure your `CLAUDE.md` documents which paths are off-limits and which commands are dangerous.

## Component 5: The verification loop

The browser MCP is the loop. Here's the actual sequence each implement agent runs after writing code:

1. Code changes saved in worktree.
2. Worktree's dev server (already running on dedicated port) auto-reloads.
3. Agent calls `browser_navigate('localhost:5184/affected-page')`.
4. Agent calls `browser_screenshot()`. Reads the image.
5. Agent calls `browser_console_logs()`. Reads the console output.
6. If no errors, the agent calls `browser_click('#confirm')` to interact with the changed UI.
7. Repeat screenshot + logs read.
8. If errors detected, the agent forms a hypothesis, edits the code, and the loop starts over.

The loop is what separates autonomous development from vibe coding. Vibe coding ends with the diff. Autonomous development ends with verified production code.

> "Claude writing code without verification is a liability. Claude writing code and verifying and pushing to prod is a teammate with commit access."
> -- Hunter Hodnett, Chipp CTPO

## Outcome logging for fine-tuning

Every Bug Bot run writes a JSONL row to a long-term archive:

```json
{
  "ticket_id": "billing-create-customer-null-pmt",
  "trigger_source": "grafana",
  "started": "2026-04-15T03:31:18Z",
  "finished": "2026-04-15T03:47:02Z",
  "stages": {
    "research": { "tokens": 412053, "tool_calls": 38 },
    "implement": { "tokens": 187234, "tool_calls": 23 },
    "review": { "tokens": 91482, "tool_calls": 12, "edits": 1 },
    "docs": { "tokens": 43210, "tool_calls": 4 },
    "push": { "tokens": 0, "tool_calls": 0 }
  },
  "outcome": "clean",
  "regressions_detected_24h": false
}
```

The `outcome` field is the label. `clean` means: review made ≤5 edits, all tests passed first try, no regressions detected within 24 hours of deploy. `messy` means anything else.

This data is gold. Every successful autonomous run produces a labeled training row showing how a frontier model approached a real engineering task. Builders who treat their pipeline outputs as a strategic data asset, instead of throwing them away after each run, end up with the training data to fine-tune cheaper specialized models on their own codebase. That's a moat. We'll cover the mechanics of it in a future post.

## The cost reality

Bug Bot is not free. Each ticket runs through five Claude Code sessions, each with substantial context. Order of magnitude: low double-digit dollars per ticket on a frontier model, at current pricing.

That sounds expensive until you compare it to the alternative. A single Bug Bot ticket replaces approximately a junior engineer's day of work, read the stack trace, find the bad commit, write the fix, test it, ship it. The cluster runs all day, all night, with no benefits package.

We get roughly a 10-50x cost advantage versus traditional engineering labor for the kind of work Bug Bot does best (fixing bugs in well-documented code paths, building features within an established architecture). For more open-ended work, designing new systems, debugging hardware integrations, reasoning about edge cases that aren't represented in our training data, the cost advantage compresses, sometimes to break-even.

The honest truth: Bug Bot succeeds on first try about 70-80% of the time. The other 20-30% require a re-prompt, often because we didn't include enough context the first time. We treat those failures as scar tissue. Almost every re-prompt becomes a doc, a `CLAUDE.md` rule, or an auto-load table entry that prevents the same failure next time.

## When this fails (and how we fix it)

Failure modes worth knowing about before you start:

### Cross-tool integrations

Anything outside your code base is high risk. Bug Bot is great at fixing bugs in our own code. It's worse at debugging issues with a Stripe API change, a LiveKit voice agent update, or any third-party service whose behavior the agent can't directly observe.

The fix is custom MCPs. We built a Stripe MCP that wraps Stripe's API in tools the agent can call directly. Same for LiveKit. The pattern: any external dependency that breaks Bug Bot's success rate gets its own MCP server.

### Decomposition failures

Bug Bot is designed for tasks that fit in one pipeline run. *"Fix this billing bug"* works. *"Build a new analytics dashboard with 12 widgets"* doesn't.

The bottleneck isn't execution. It's decomposition. Large features need a human (or another autonomous layer) to break them into pipeline-sized tickets. We handle this manually for now. The next iteration of Bug Bot will include a decomposition stage that runs before the research stage.

> "Hard part is decomposition, not execution."
> -- Hunter Hodnett, Chipp CTPO

### MCP server downtime

If your browser MCP or database MCP goes down, your agents lose their senses mid-session. We treat MCP servers as production infrastructure: monitored, alerted, deployed in pairs.

### Banned-flag false positives

Occasionally the harness kills a session for what looks like a banned flag in a comment or test fixture. We've tightened the regex over time. When in doubt, log the false positive and investigate; don't relax the regex pre-emptively.

## What this gives you

The 3:47 AM moment becomes routine.

The on-call rotation goes empty. PagerDuty escalations stop. Senior engineers stop reviewing AI-generated PRs because there are no PRs. The PR queue empties because there's no concept of a PR in this system. Customer-reported bugs get fixed before the customer support team has finished writing the ticket.

You sleep through the night. You wake up to a Slack channel full of completed work. You spend your day on decomposition, judgment, and the kinds of architectural decisions only a human can make, because every other thing has been done by the cluster.

That is what Bug Bot gives you. It's also what we're productizing as Alchemist for builders who'd rather not spend nine months building it themselves.

**[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)**

---

If you want the foundational case for autonomous development, start with [The Autonomous Development Manifesto](/engineering/autonomous-development).

If you want to understand the discipline that makes this all work, the foundation underneath the harness, the pipeline, and the MCPs, read [Context Engineering: The Skill That Turns Claude Into a Production Co-Developer](/engineering/context-engineering).
]]></content:encoded>
    </item>
    <item>
      <title>Context Engineering: The Skill That Turns Claude Into a Production Co-Developer</title>
      <link>https://chipp.ai/engineering/context-engineering</link>
      <guid isPermaLink="true">https://chipp.ai/engineering/context-engineering</guid>
      <pubDate>Thu, 30 Apr 2026 00:00:00 GMT</pubDate>
      <dc:creator>Hunter Hodnett</dc:creator>
      <description>Context engineering is the foundational discipline of autonomous development, and the source of most of your hallucinations, token bills, and pipeline failures. Four core moves, the patterns we run every day at Chipp, and how to know it&apos;s working.</description>
      <category>context-engineering</category>
      <category>claude-code</category>
      <category>claude-code-best-practices</category>
      <category>autonomous-development</category>
      <category>context engineering</category>
      <category>claude code best practices</category>
      <category>claude.md</category>
      <category>context window</category>
      <category>autonomous coding agents</category>
      <category>kv cache claude</category>
      <content:encoded><![CDATA[# Context Engineering: The Skill That Turns Claude Into a Production Co-Developer

Context engineering is the foundational discipline of autonomous development, and the source of most of your hallucinations, token bills, and pipeline failures. Four core moves, the patterns we run every day at Chipp, and how to know it's working.

---

There is a finite amount of paper your model can write on.

Everything you've ever read about getting the most out of an AI agent, every tip about prompts, every technique for "making Claude smarter", collapses into managing what fits on that paper.

This is context engineering. It's not a mindset. It's not a philosophy. It's a set of mechanical decisions about what tokens go into the context window, what tokens get compressed, and what tokens never make it in at all.

Get it right and your agent finishes its work, ships, and moves on. Get it wrong and your agent enters a doom loop of re-reading the same files, summarizing its own findings, hallucinating results, and asking you for context it should have inferred.

In our [autonomous development cluster](/engineering/autonomous-development) at Chipp, context engineering is the difference between an agent that ships 25 production changes a day and one that fills a context window with 90 tool calls of confusion before timing out. We've made the mistakes. This post is the rules I wish I'd known a year ago.

## What's actually in your context window

Every Claude Code session has six things competing for the same paper:

1. **The system prompt.** Your `CLAUDE.md`, plus any subdirectory `CLAUDE.md`s loaded by the hub-and-spoke pattern.
2. **The tool definitions.** Every MCP server adds its tool schemas. The descriptions are part of every prompt.
3. **The conversation history.** Every prior user message, assistant message, and tool call result since the session started.
4. **The tool results.** File contents you read. Grep results. Database query rows. Browser screenshots. All of these get serialized into context.
5. **The reasoning scratch space.** Where the model thinks. Internal chain-of-thought tokens that don't show up in the final output.
6. **The current user message and the pending response.**

You don't get to choose how the model allocates between these. You get to choose what's available to fill them.

A typical Claude Sonnet/Opus session has 1M tokens of context. Your `CLAUDE.md` should fit in under 25k of that, about 5% of the budget. Tool definitions for a typical autonomous setup will run another 20-50k. That leaves roughly 900k for actual work.

The math sounds generous until you read three files of 1,500 lines each, run a few grep commands, and take two browser screenshots. You're 200k tokens into your remaining budget before the agent has done anything productive.

## The compaction trap

When the context window fills, the model doesn't gracefully degrade. It hits **compaction**: a smaller, cheaper model summarizes the entire conversation into a paragraph and replaces the original tokens. The session continues, but the model wakes up with vague recollections instead of specifics.

What you lose in a compaction:

- The exact file contents you read.
- The specific stack traces and error messages from earlier in the session.
- The reasoning chain that led to the current state.
- Specific line numbers, variable names, and database row values.

What survives:

- The system prompt (your `CLAUDE.md`).
- A paragraph summary of everything that was compacted.
- The most recent few messages.

A summary written by a cheap model is a worse representation of the past than the actual past. After a compaction, the agent is reasoning over a faded photocopy of its memory. This is where hallucinations come from.

> "Compaction is incredibly destructive. You really want to avoid compactions at all cost."
> -- Hunter Hodnett, Chipp CTPO

The corollary: your `CLAUDE.md` is your highest-leverage file. It survives compactions. Everything else is in danger.

## The four core moves

Context engineering, in practice, is four moves you make over and over. None of them are hard. The discipline is doing them consistently.

### Move 1: Stabilize the system prompt for KV-cache hits

Anthropic's API caches input tokens. If your system prompt is byte-identical between two requests, the cached version costs you a fraction of the original.

This sounds obvious until you realize how easy it is to bust the cache by accident. We were burning through input tokens at full price for months before we figured out our bug.

Our `CLAUDE.md` had a line that injected the current date so the agent would know what day it was. We were injecting the date down to the second:

```
The current date and time is: 2026-05-06T14:23:47.318Z
```

That value changed on every request. The cache busted on every request. We were paying full price for a 25k-token system prompt thousands of times a day.

The fix was trivial:

```
The current date is: 2026-05-06
```

KV cache hits jumped from near-zero to over 90%. Token spend dropped accordingly.

The general rule: anything in your system prompt that varies between calls, timestamps, request IDs, randomly-ordered lists, busts the cache. Make the system prompt stable. Inject volatile context as user messages, not as system prompt content.

### Move 2: One context window per goal

The single biggest mistake teams make is trying to do too much in one session.

You start a Claude Code session. You ask it to investigate a bug. It reads ten files, runs a few grep commands, queries the database. It forms a hypothesis. You ask it to implement the fix. It writes the code, runs the tests. You ask it to review the code. It edits a few things. You ask it to update the docs. By now you're six tool calls past compaction and the agent's reasoning has gone fuzzy.

The fix: break the work into stages, and start a fresh context window for each stage.

This is what our [Bug Bot pipeline](/engineering/self-healing-bug-bot) does. Five stages, research, implement, review, docs, push, and each stage is a separate session. The output of one stage is a markdown file, which becomes the input for the next.

Stage 1 fills its context window with research and outputs a `plan.md`.
Stage 2 starts fresh, reads only `plan.md`, writes the code.
Stage 3 starts fresh, reads only the diff, reviews it.

No stage ever runs out of room because no stage tries to do everything.

### Move 3: Use sub-agents to dilute

Some work is inherently context-heavy. Investigating a Kubernetes pod restart can require reading thousands of lines of logs, querying multiple endpoints, cross-referencing deploy histories. If you do this in your main session, you've burned your budget.

The solution: spawn a sub-agent. The main session calls the sub-agent like any tool, the sub-agent gets its own fresh 1M-token context window, it does whatever investigation it needs, and it returns a one-paragraph insight.

The first time we used this in production was for an infrastructure issue. Pods were restarting; we didn't know why. I prompted the main session: *"Figure out why our pods are restarting."* It spawned an `infra-ops` sub-agent we'd configured with all our Kubernetes runbooks.

The sub-agent ran 47 `kubectl` commands. Queried Loki for recent error patterns. Cross-referenced the deploy history. Filled almost a full context window with raw evidence.

Then it returned one sentence: *"OOM after the last deploy, memory limit too low; recommend bumping the limit from 512Mi to 1Gi."*

That sentence, 23 tokens, was what landed in my main session. The 950k tokens of evidence stayed in the sub-agent's context, where it belonged.

Use sub-agents for any work where the answer is short but the investigation is long.

### Move 4: Pre-load with an auto-load table

Hub-and-spoke `CLAUDE.md` works for static, location-based context. But sometimes you want context to load based on *what the agent is doing*, not *where in the codebase it is*.

We built an auto-load table for this. At the top of our root `CLAUDE.md`, we have a small markdown table:

```markdown
## Auto-load table
| Mention | Read |
|---|---|
| billing, stripe, payment, subscription | docs/billing.md |
| auth, login, session, oauth | docs/auth.md |
| websocket, realtime, streaming | docs/realtime.md |
| voice, livekit, transfer | docs/voice-agents.md |
```

The pattern: when a prompt mentions any of these keywords, the agent reads the corresponding doc into context before starting work.

We don't load the docs in `CLAUDE.md` itself, that would burn the budget on every session, even sessions that don't need them. We load them dynamically, only when relevant.

This is how I keep my root `CLAUDE.md` lean while still giving the agent rich context for specific subsystems.

> "I have my autonomous AI cluster updating its own `CLAUDE.md`. I honestly barely know what's in there these days."
> -- Hunter Hodnett, Chipp CTPO

## The mental model

Picture the context window as a single sheet of paper, fixed font size.

When you read a file, you've copied that file onto the paper.
When you run a grep, you've copied the result.
When the agent reasons, it's writing on the paper.

Run out of room and the paper gets folded. A cheap intern reads everything you wrote and replaces it with a paragraph summary on a fresh sheet. You keep working but you've lost the details.

The discipline of context engineering is engineering what gets written on the paper before it runs out, and never letting the cheap intern get involved.

## Patterns we use every day

Beyond the four core moves, here are the patterns that show up most in our daily work.

### Fresh-context handoff via markdown

Pipeline stages communicate by writing markdown files to disk. Stage 1's last action is `Write plan.md`. Stage 2's first action is `Read plan.md`. Stage 1's context window is gone forever, but the distilled insight survives.

This is the same pattern as the sub-agent dilution move, applied to sequential work.

### Three-strikes-then-rule for `CLAUDE.md`

Don't add a rule to `CLAUDE.md` after a single mistake. Wait for the same class of mistake to happen three times. Otherwise your `CLAUDE.md` bloats with one-off lessons that never recur, and the truly important rules get diluted.

Three strikes is a heuristic, not a hard rule. The point is to be conservative about what gets the elevated status of "every-session context."

### Hub-and-spoke directory loading

Place a `CLAUDE.md` in any subdirectory where the rules differ from the root. Claude Code automatically reads the nearest `CLAUDE.md` when it reads a file in that directory.

We have `CLAUDE.md` files in:

- `src/db/`. ORM-specific rules (we use Kysely, not Drizzle; never let the agent forget)
- `src/api/`. API conventions (Hono routing, error-handling patterns)
- `src/components/`, design system rules (CSS variables only, never hex codes)
- `tests/`, test framework conventions

The agent loads the right one without me having to tell it.

### Kill the summary mid-stream

When you see Claude write something like *"I've now read several files. Let me summarize what I learned…"* in the middle of an interactive session, stop it. That summary is about to land in your context as the canonical record of what the agent did. You want the *evidence*, not a pre-compaction.

Tell it: *"Don't summarize. I want to see the actual results."*

This matters less in autonomous pipeline runs, you're not watching those, but the underlying principle is general: prefer raw artifacts over the agent's interpretation of artifacts.

### Use the most powerful model: every time

When teams ask me how to save money on token spend, the first thing I say is: don't.

Use the most expensive model. Always. Even when it feels wasteful.

The reason is that frontier models hallucinate less, plan better, and finish work in fewer total tokens. A cheaper model in an autonomous setting will burn more total tokens chasing its own mistakes than a frontier model would have spent doing the work right the first time.

This is even more true in the early weeks after a model release. Frontier labs subsidize new models, they serve the highest-quality version at launch and gradually quantize them down to cheaper-to-serve versions over the following weeks. If you're going to do hard work with an autonomous agent, do it in the first weeks after a release, when the model is at its sharpest.

### Write your context-engineering scars into auto-load docs

When you encounter a context-engineering failure, say, the agent kept reading the wrong file because it didn't have enough context about a subsystem, don't put the lesson in your root `CLAUDE.md`. Write a doc into `/docs/`, add a row to the auto-load table, and move on.

Auto-loaded docs are scoped to relevance. Root `CLAUDE.md` is global. Match the scope of the lesson to the scope of the file.

### Capture every run's data

Every Claude Code session you run produces a record of how a frontier model reasoned about a real problem in your codebase. That's training data, the kind that, six months from now, you might want to fine-tune a cheaper specialized model on. The builders who treat their pipeline outputs as a strategic data asset, instead of throwing them away after each run, will end up with the only kind of moat that compounds in this industry.

Even if you never do anything with the data, archive it. Storage is cheap. Past inference is irreplaceable.

## How you know it's working

You know context engineering is working when:

- The agent finishes work without compacting.
- Re-running similar tasks gives consistent quality.
- You can launch sessions, walk away, and come back to shipped code.
- The agent stops asking you for context it should have inferred.
- Your `CLAUDE.md` grows by a line or two per week, not per day.

You know it's not working when:

- The agent hits compaction in the middle of routine tasks.
- You see the same hallucinations repeatedly (this is your scar tissue not yet hardened into rules).
- The agent reads the same files in every session because there's no doc layer to load them once and remember.
- Token spend per task is going up, not down.

If you're in the second category: start with one core move at a time. Get the system prompt stable for KV cache hits. Then split your sessions one-context-per-goal. Then add sub-agents for any investigation that fills the budget. Auto-load tables are the polish; the moves above are the foundation.

## What's next

Context engineering is the foundational discipline of autonomous development, but it's only the first layer. Layered on top of it:

- **[CLAUDE.md Architecture](/engineering/claude-md-architecture)**: the hub-and-spoke pattern, scar tissue practice, and auto-load tables in detail.
- **[Skills vs Sub-Agents](/engineering/skills-vs-sub-agents)**: when to use which, and why the distinction matters.
- **[MCP Is the USB-C of AI](/engineering/building-your-first-mcp-server)**: building the senses that let your agent verify its own work.
- **[Building a Self-Healing Bug Bot](/engineering/self-healing-bug-bot)**: context engineering applied end-to-end in a production pipeline.

If you want to see what context engineering enables in production, start with [The Autonomous Development Manifesto](/engineering/autonomous-development).

If you want to see what it looks like when it goes wrong, run an interactive Claude Code session for an hour without thinking about any of this. Watch your token spend. Watch the agent compact. Watch it hallucinate. That's the baseline. Everything above is what we do to escape it.

**[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)**
]]></content:encoded>
    </item>
    <item>
      <title>The Autonomous Development Manifesto: Why We&apos;re Building Alchemist</title>
      <link>https://chipp.ai/engineering/autonomous-development</link>
      <guid isPermaLink="true">https://chipp.ai/engineering/autonomous-development</guid>
      <pubDate>Wed, 29 Apr 2026 00:00:00 GMT</pubDate>
      <dc:creator>Hunter Hodnett</dc:creator>
      <description>An engineering team of two. 20-30 production deploys a day. No PR queue, no on-call rotation. This is the case for autonomous development, the discipline, the architecture, the maturity curve, and ADaaS as a category. Plus the system we run at Chipp and the product we&apos;re building from it.</description>
      <category>autonomous-development</category>
      <category>adaas</category>
      <category>autonomous-software-development</category>
      <category>manifesto</category>
      <category>autonomous development</category>
      <category>ADaaS</category>
      <category>autonomous development as a service</category>
      <category>autonomous software development</category>
      <category>autonomous coding</category>
      <category>autonomous engineering</category>
      <category>alchemist ai</category>
      <content:encoded><![CDATA[# The Autonomous Development Manifesto: Why We're Building Alchemist

An engineering team of two. 20-30 production deploys a day. No PR queue, no on-call rotation. This is the case for autonomous development, the discipline, the architecture, the maturity curve, and ADaaS as a category. Plus the system we run at Chipp and the product we're building from it.

---

Software development is changing. Again.

For fifty years, software was written by humans typing code one keystroke at a time. For the last five, by humans typing code while a model whispered the next token. We told ourselves the model was an assistant, that the human was still the author.

We were wrong about how much of the job could be automated. Not just the typing. The reading. The reasoning. The verification. The shipping.

I run an engineering team of two people. We push 20 to 30 changes to production every day. The pull request queue is empty because there are no pull requests. The on-call rotation is empty because there is no on-call rotation. I have slept through the night for the last two months.

This isn't a vibe-coding demo. This isn't "AI is going to change everything someday." This is a description of the system that built and runs Chipp, the platform behind 125,000+ AI agents that have held 14M+ conversations with real users. The system we call Bug Bot. The system that, over the next year, we are productizing as **Alchemist**, and offering as **autonomous development as a service**.

This post is for the engineers who suspect this is real but haven't seen it for themselves.

It's also for the engineers who think they're better than AI. You are. For now. The window in which that's true is closing faster than most people realize.

Let me show you what's on the other side.

---

## Part 1: What "autonomous development" actually means

The terms are getting thrown around and they're not all the same thing.

**Autocomplete.** A model finishes your line. You're still the author.

**AI pair programmer.** A model writes a function. You read it, edit it, commit it. Copilot's original pitch.

**Vibe coding.** A model writes most of the code. You review the diff, occasionally course-correct, ship the result. The human is still in the loop on every step.

**Agentic coding.** The model executes tools, runs commands, reads files, calls APIs, to accomplish a goal. The human still drives the session.

**Autonomous development.** The model is given a goal. It selects its own steps, executes them, verifies the results, and ships. There is no human in the loop on individual steps. There may not be a human in the loop on the *outcome* either, if you set it up that way.

The distinction that matters most: **what happens when the model writes wrong code?**

In vibe coding, you catch it in the diff and tell the model to try again.

In autonomous development, the model catches it itself, by spinning up a dev server, opening a browser, navigating to the changed page, taking a screenshot, reading the console logs, noticing the error, and fixing it.

That last sentence is the entire game. Everything else in this post is mechanical detail about how to get there.

> "Claude writing code without verification is a liability. Claude writing code and verifying and pushing to prod is a teammate with commit access."
> -- Hunter Hodnett, Chipp CTPO

---

## Part 2: The maturity curve

We're somewhere in the middle of a five-stage industry shift. Where you sit on this curve will determine whether your business compounds or capsizes over the next twenty-four months.

**Stage 1. Acceleration.** Faster typing. Slightly fewer keystrokes per shipped feature.

**Stage 2. Augmentation.** Models write the boring code. Humans write the novel code and review everything. The senior engineer still does most of the thinking.

**Stage 3. Vibe coding.** Models do most of the typing. Humans become editors and product designers in the loop. Output velocity 5-10x. Demos are great. Production code is hit or miss. Most builders are stuck here today.

**Stage 4. Agentic coding.** Models can run tools, read files, search the web, query databases, open browsers. With the right setup, they can verify their own work. The human still drives the session. Output velocity 20-50x for a session, but each session needs a human to launch and oversee.

**Stage 5. Autonomous development.** Models run unattended. Multiple agents in parallel. Goal-directed. Self-verifying. The human role is decomposition (turning intent into tickets) and judgment (reviewing outcomes). Output velocity is no longer the right metric, *organizational capacity* is. This is what we run. This is what Alchemist productizes.

Each stage doesn't replace the prior one. It absorbs it. Inside an autonomous development cluster, you'll find vibe-coding sessions, agentic coding loops, and AI pair programming. They're all in the box. The cluster is what wraps them in a deterministic harness.

If your team is at Stage 3 and your competitor is at Stage 5, your competitor isn't 10% faster. They're operating in a different category of business. Their feature velocity isn't bottlenecked by engineer count. Yours is.

---

## Part 3: ADaaS (Autonomous Development as a Service)

Here's the awkward part. Most teams should not build their own autonomous development cluster from scratch.

We did, because we had to. Three years of full-time work. Dozens of mistakes, including a few production database drops along the way. An immense amount of inference burned figuring out which prompts, harnesses, and architectures actually hold up under autonomous load.

The hard parts aren't where you'd expect them. They're not in the model. The model is fine. They're in:

- **The bash harness**: the deterministic wrapper that prevents your non-deterministic agents from running away with your token budget.
- **The verification loop**: getting the agent to actually look at the running software and see what it built.
- **The context engineering discipline**: knowing what to load, what to prune, what to summarize, what to never compact.
- **The CLAUDE.md scar-tissue practice**: turning every agent mistake into a rule that prevents that mistake forever.
- **The pipeline decomposition**: splitting one task across multiple context windows so no single window has to hold everything.

You will spend nine months learning these the hard way. We already did. So we are productizing it.

That's what **ADaaS** (autonomous development as a service) means. You don't rent a tool. You don't rent a model. You rent a *process*: a configured cluster, a hardened harness, a verification loop, a maintained set of MCP servers, a documentation auto-load system, the whole apparatus that lets you point at a goal and get shipped software.

The lineage:

- **SaaS** productized software.
- **PaaS** productized application platforms.
- **IaaS** productized infrastructure.
- **ADaaS** productizes the engineering practice itself.

We coined the term because nobody else had. Don't be surprised when the rest of the industry catches up to it within a year, the underlying economic logic is too powerful to stay underground.

---

## Part 4: Inside the autonomous dev cluster

Let me show you what's running on my desk right now.

I have eight Claude Code workers running in parallel on a single workstation. Each worker is an instance of `claude -p`. Claude Code's headless mode, wrapped in a bash script that monitors its output, kills it if it stalls, and forces a commit at the end.

Tickets enter the system through four trigger sources:

1. **Slack tag.** Anyone on my team can `@bug bot` in our internal channel. The mention payload becomes the prompt.
2. **Email forward.** I forward customer emails to a Bug Bot inbox. The email body becomes the prompt. I dictate most of mine via Whisper Flow on my phone, yes, I voice-message my engineering team.
3. **Grafana webhook.** Every five minutes, our log ingestion pipeline groups recent production errors by stack trace, dedupes them, and fires a webhook. The error context becomes the prompt.
4. **Performance alert rule.** When P95 chat-streaming latency exceeds three seconds, a worker spawns automatically.

When a ticket lands, it runs through five stages. **Each stage gets its own context window.** This is the most important architectural rule in the whole system.

```
[Trigger] → [Phase 0: Doc retrieval] → [Phase 1: Research]
         → [Phase 2: Implement]   → [Phase 3: Code review]
         → [Phase 4: Docs update] → [Phase 5: Push to prod]
```

**Phase 0. Doc retrieval.** Before Claude even sees the ticket, a bash script semantic-searches our `/docs/` folder for any markdown files relevant to the ticket. Those docs get prepended to the research prompt as context.

**Phase 1. Research.** Fresh context window. Claude reads relevant code, queries our log drain (Loki) for similar past errors, queries our production database for affected rows, and outputs a `plan.md` file describing the root cause and proposed fix. Sensitive fields in the database are one-way encrypted; the agent can pattern-match on metadata without ever seeing customer secrets.

**Phase 2. Implement.** Brand new context window. Claude is handed the `plan.md` (no other context) and writes the code. Runs the unit tests. Spins up a local dev server in a git worktree on a dedicated port. Opens Chromium via the browser MCP. Navigates to the affected page. Takes a screenshot. Reads the dev server logs and the browser console logs. If anything's wrong, it fixes itself.

**Phase 3. Code review.** Another fresh context window. This one gets the full diff and is told to red-team the implementation. It can edit. If it makes more than a handful of edits, the harness flags the original implementation as `messy`.

**Phase 4. Docs update.** Yet another fresh context. Given the diff, this agent writes new documentation into the `/docs/` folder for any non-obvious behavior the change introduces, and prunes any docs the change has invalidated. This is how the system gets smarter over time. Tomorrow's tickets benefit from today's lessons.

**Phase 5. Push.** Bash-script-enforced. Commits the changes, pushes to the deployment branch, monitors that the deploy succeeds. Our deploy time is under 120 seconds. Production is updated before a human would have finished reading the ticket.

There is no pull request. There is no human review. There is no staging environment that a human inspects. This is on purpose.

> "If you halfway these systems, you're going to turn some poor senior engineer's entire job into reviewing AI-generated PRs. You have to either YOLO the full way or just not at all."
> -- Hunter Hodnett, Chipp CTPO

---

## Part 5: The five pillars

Inside the cluster, five disciplines do the heavy lifting. Each of them has a dedicated post on this blog. The short version is here.

### 1. Context engineering

The model has a finite paper. Everything you put on it, the system prompt, the tool definitions, the file contents you read, the search results, the past conversation, eats space. Run out of space and the system starts compacting (a small model summarizes the context window into a paragraph and replaces the original). Compaction is amnesia. Compaction is where good agents go to hallucinate.

The discipline is engineering what goes into the context window so the agent can finish its job before it runs out of paper. → *[Context Engineering: The Skill That Turns Claude Into a Production Co-Developer](/engineering/context-engineering)*

### 2. CLAUDE.md as scar tissue

Your `CLAUDE.md` is the system prompt that loads in every session. Treat it as a scar tissue document, not an aspiration document. Every line in it is there because you got bitten by a real bug.

When you see the agent make the same mistake three times, stop the session, tell Claude to add a rule to `CLAUDE.md`, and continue. After six months, your `CLAUDE.md` is a textbook of your codebase's hidden rules, and your agents stop making those mistakes forever.

Use the hub-and-spoke model: a root `CLAUDE.md` plus subdirectory `CLAUDE.md`s that auto-load when files in those directories are read. → *[CLAUDE.md Architecture: A Hub-and-Spoke Pattern for Autonomous Codebases](/engineering/claude-md-architecture)*

### 3. Skills and sub-agents

A **skill** is a chunk of text that loads into the current context window when it's relevant. Like a cheat sheet you carry with you while you work. Useful for things you need *while* coding, design system rules, brand voice, build conventions.

A **sub-agent** is an entirely separate context window the main agent can spawn. Like sending someone to the library and waiting for them to come back with a one-paragraph summary. Useful for parallelizable work or for investigations that would otherwise pollute your main context.

The decision rule: *does the agent need this knowledge while working, or can it get an answer and come back?* → *[Skills vs Sub-Agents: When to Use Each in Claude Code](/engineering/skills-vs-sub-agents)*

### 4. MCP: Claude's senses

The Model Context Protocol is how the agent perceives the outside world. Without MCP, the agent is reasoning over its training data. With MCP, the agent can read your production logs, query your database, navigate your dev server, take screenshots of your UI.

The single highest-leverage MCP for autonomous development is the **browser MCP**. It's what lets the agent verify its own work. Build a custom one tied to your application, bake your dev login flow, your seed data, your test scenarios into the tools. The off-the-shelf browser MCPs are great to learn with; they're not what you'll run in production. → *[MCP Is the USB-C of AI: Building Your First MCP Server in 30 Minutes](/engineering/building-your-first-mcp-server)*

### 5. The bash harness

> "An autonomous agent without a bash harness is an intern with no manager, no deadline, and an unlimited API budget."
> -- Hunter Hodnett, Chipp CTPO

Claude is non-deterministic. Your business needs to be deterministic. The bash harness is what reconciles those two.

Concretely, our harness:

- Spawns Claude with `claude -p --dangerously-skip-permissions`.
- Watches the output stream and kills the session if no tool call fires for five minutes.
- Greps for banned flags and aborts if it sees them, `git push --no-verify`, `git reset --hard`, `rm -rf`.
- Forces a final `git commit` and `git push` if Claude forgets.
- Cleans up orphaned dev server processes after each run.
- Writes outcome labels (`clean` / `messy`) for each ticket so the data is ready for fine-tuning later.

→ *[Building a Self-Healing Bug Bot: The Autonomous Dev System We Use at Chipp](/engineering/self-healing-bug-bot)*

---

## Part 6: A real ticket, end to end

Enough abstraction. Here's a real production ticket from last quarter.

**The error.** An HTTP 500 on `/api/billing` for customers without a default payment method. Stripe's `create_customer` call failed; we weren't catching the failure; the user got a blank page.

**The trigger.** Loki ingested 47 instances within five minutes. Grafana's alert rule fired. Webhook hit Bug Bot.

**The pipeline, twenty tool calls, in order:**

1. Read `CLAUDE.md` from the root.
2. Read `docs/billing.md` (auto-loaded by the doc retrieval phase because the ticket mentioned billing).
3. Pull latest staging branch.
4. Read `src/api/routes/billing/index.ts`, the file in the stack trace.
5. `bash: rg "create_customer"`, find every call site.
6. Read `src/services/stripe.ts`, the service wrapper.
7. Query Loki for similar errors over the last seven days. Result: started 90 minutes ago.
8. Query Loki for the deploy that landed 90 minutes ago. A change to default payment method handling.
9. Query the production database for affected customer rows.
10. Form hypothesis: missing null-check on `customer.default_payment_method`.
11. Edit `src/services/stripe.ts` to add the null-check and a friendly fallback.
12. Run unit tests for that file. Pass.
13. Run the full unit test suite. Pass.
14. Spin up dev server on port 5184 (worker 4).
15. Open Chromium via browser MCP.
16. Navigate to `localhost:5184/billing`.
17. Click "Buy Credits" button.
18. Take screenshot. Read browser console logs. No errors.
19. Verify HTTP 402 response with friendly toast message.
20. Commit. Push. Deploy.

**The result.** A bug that would have taken a junior engineer most of a workday, read the stack trace, find the bad commit, write the fix, test it, ship it, closed in twelve minutes by a process. Cost: about a coffee.

This is what's actually running. Nothing in this section is theoretical. The ticket above is one of about 25 we ship to production in an average day.

> "Junior engineer's day done by a process in 12 minutes."
> -- Hunter Hodnett, Chipp CTPO

### A note on anti-fragility

While I was teaching a recent cohort session, Stripe went down for three hours. Half the AI industry's billing infrastructure went silent. The other half's customers couldn't buy.

We barely noticed. Six weeks earlier, I had pointed Bug Bot at "build us a redundant usage-based billing system that runs alongside Stripe." It chewed through the work over a weekend. The system had been sitting in production, in shadow mode, ever since.

When Stripe died, I flipped a feature flag. Our billing kept running. Our customers kept buying.

I bring this up not as a brag but as a description of what changes when your engineering capacity stops being a function of headcount. Redundancies that would have been "nice-to-haves with a six-month timeline" become "weekend tickets for an idle worker." Anti-fragility stops being a Talebian aspiration and starts being a default property of how you build software.

---

## Part 7: Why we're building Alchemist

When Claude Opus 4 dropped, I started using it for live coding sessions. I was sitting at my desk one afternoon, watching lines of code scroll up my screen, code I hadn't typed, code that was fixing things I hadn't asked it to fix yet. My wife came down and asked me what I was actually doing for work anymore. I didn't have an answer.

That was the moment I realized the entire "AI coding assistant" framing was wrong. The AI wasn't an assistant. It was the engineer. I was the manager.

The system you've been reading about is what I built between that afternoon and today. Three years of mistakes compressed into six months of acceleration once the model could carry the weight.

When we showed an early version of it to founders in our Technical Agents of Change cohort, the question kept coming back:

*"Can we have it?"*

Not "can we license it." Not "can we read the code." *Can we have a starter version of this whole apparatus, configured and ready, that we can run on day one?*

So we're building it. We're calling it **Alchemist**, and we're rolling it out as the first commercial implementation of autonomous development as a service.

Here's what Alchemist gives you on day one:

- A deployed, opinionated stack. Deno on the server, Svelte on the client, Chromium for verification, Cloudflare Workers for hosting. We picked this combination after months of testing because it has the highest LLM training-data density of any modern web stack. Your agents will hallucinate less and ship more in this stack than in any other.
- A configured Claude Code cluster, harness, and verification loop. Pre-wired `CLAUDE.md`, browser MCP, log-drain MCP, and a bash harness that will not let your tokens run away.
- A `/docs/` folder that builds itself as you ship.
- A self-healing pipeline. Errors in production trigger autonomous fixes.
- An integrated customer support agent that escalates real frustration to a human (us, during the alpha).

And the most important part: **the eject mechanism.**

When you create a project on Alchemist, we create a GitHub repo for you. Every commit Alchemist's workers make goes there. If you decide one day to take your code to a private cloud, save on hosting, or just leave, you take the repo and go. Nothing is locked behind our infrastructure. The Alchemist Deployment Workflow runs on your repo, and you can fork it. We learned a long time ago that the only way to build a sticky business is to make sure your customers are *choosing* to stay every month, not trapped into staying.

The closed alpha is starting now. If you want in, the waitlist is at the top of this page.

---

## Part 8: Who this is for (and who it isn't)

This is not for everyone, and I'd rather lose your attention now than later.

**This is for technical builders ready to lead a fleet of agents.** People who have shipped software, who can read a stack trace, who know what a tool call is. People who are excited, not threatened, by what AI can do with a codebase.

**This is for builders willing to delete their PR review process.** I'm serious. If you're attached to "every change gets reviewed by a human before it ships," you're going to half-implement what we describe in this post. Half-implementations are worse than no implementation. Half-implementations turn senior engineers into AI-PR-review janitors and ship slower than the manual baseline. Either YOLO the full way or stay where you are.

**This is for teams of one to ten trying to compete with teams of fifty to five hundred.** The economics of autonomous development bend hardest in your favor when you're capital-constrained and ambition-rich. We bootstrapped Chipp's autonomous cluster because we had two engineers and a roadmap that wanted twenty.

**This is not for engineers who think AI should stay out of the way.** I respect the position. I disagree with it. Either way, this isn't the post for you.

**This is not for non-technical founders looking for a no-code shortcut.** Alchemist is not Lovable. You will write `CLAUDE.md` files. You will read stack traces. You will need to know what a context window is. Our value proposition is *do less of the typing and verification yourself*, not *never touch the code*.

**This is not for organizations running on quarterly review cycles.** The pace of frontier AI doesn't wait for your governance committee. If your decision-making cadence is slower than a model release cycle, you can't run an autonomous dev cluster. You can experiment with one, but you can't run one in production.

If you've made it this far and you're still nodding, you're our reader. Welcome.

---

## Part 9: What's coming

Over the next eight weeks, we're publishing the operating manual for autonomous development. One piece of the cluster per post:

- **Context Engineering**: managing the finite paper.
- **CLAUDE.md Architecture**: the hub-and-spoke pattern, scar tissue practice, auto-load tables.
- **Skills vs Sub-Agents**: when to use which.
- **MCP**: building the senses your agents need.
- **The Bash Harness**: turning Claude into a teammate with commit access.
- **Multi-agent Pipelines**: serial handoffs, sub-agent dilution, self-healing loops.
- **Agentic Design Patterns**: the seven we battle-tested at Chipp.
- **Vibe Coding vs Autonomous Development**: the maturity curve, demystified.
- **Beyond AI Pair Programming**: from Copilot to Coworker to Autonomous Engineer.

If you want this in your inbox, the waitlist signup at the top of this page also subscribes you to the series.

---

## The bottom line

Software development is being rewritten. Three things will happen over the next twenty-four months:

1. A few teams will adopt autonomous development and ship 30 features a day at a fraction of payroll cost.
2. Most teams will halfway it, turn their senior engineers into AI PR reviewers, and end up worse off than before they started.
3. A handful of teams will resist entirely and watch their competitors lap them.

Which group your business ends up in is being decided right now.

We're betting on group one. We're building Alchemist for the people who are.

Will your engineering team ship the next decade of your product, or will an autonomous cluster ship it for you?

If the answer is the cluster, the question is whose.

**[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)**

---

*Hunter Hodnett is co-founder and CTPO of [Chipp](https://chipp.ai), the platform behind 125,000+ AI agents that have held 14M+ conversations with real users. He previously engineered at Reddit, Amazon, and The Home Depot, and trained 290+ engineers as a coding bootcamp instructor. Alchemist is Chipp's autonomous development product, currently in closed alpha. The waitlist is open at [chipp.ai](https://chipp.ai).*
]]></content:encoded>
    </item>
    <item>
      <title>What Is Autonomous Development as a Service (ADaaS)?</title>
      <link>https://chipp.ai/engineering/what-is-adaas</link>
      <guid isPermaLink="true">https://chipp.ai/engineering/what-is-adaas</guid>
      <pubDate>Tue, 28 Apr 2026 00:00:00 GMT</pubDate>
      <dc:creator>Hunter Hodnett</dc:creator>
      <description>ADaaS is a category, not a feature. It productizes the engineering practice itself, the pipeline, the harness, the verification loop, the documentation system, the whole apparatus. Here&apos;s what you&apos;re actually buying, what it isn&apos;t, how to evaluate a provider, and why this is the next -aaS to reshape an industry.</description>
      <category>adaas</category>
      <category>autonomous-development</category>
      <category>autonomous-software-development</category>
      <category>software-as-a-service</category>
      <category>foundations</category>
      <category>ADaaS</category>
      <category>autonomous development as a service</category>
      <category>autonomous software development</category>
      <category>autonomous coding</category>
      <category>autonomous engineering</category>
      <category>alchemist ai</category>
      <content:encoded><![CDATA[# What Is Autonomous Development as a Service (ADaaS)?

ADaaS is a category, not a feature. It productizes the engineering practice itself, the pipeline, the harness, the verification loop, the documentation system, the whole apparatus. Here's what you're actually buying, what it isn't, how to evaluate a provider, and why this is the next -aaS to reshape an industry.

---

Every "as a Service" has done the same thing. SaaS productized software so you stopped buying CD-ROMs. PaaS productized application platforms so you stopped racking servers. IaaS productized infrastructure so you stopped buying hardware at all.

Each one moved a layer of the stack from a thing you *built* to a thing you *rented*. Each one looked, to the people running the prior layer, like a strange and possibly bad idea. Each one absorbed an entire industry inside a decade.

ADaaS is the next one. **Autonomous development as a service** productizes the engineering practice itself, the pipeline, the harness, the verification loop, the documentation system, the whole apparatus that lets you point at a goal and get shipped software. You don't rent a tool. You don't rent a model. You rent a *process*.

This post defines the category, separates it from the things it gets confused with, and lays out a buyer's framework for evaluating ADaaS providers, including how to evaluate the one we're building.

## The lineage

Pull the thread on every -aaS and you find the same arc.

**SaaS** turned software from a thing you bought (in a box) into a thing you logged into (in a browser). The category cracked open in 1999 with Salesforce and now houses ~$300B in revenue across thousands of companies. The unit of consumption became "a seat per month" instead of "a license forever."

**PaaS** turned application infrastructure from a thing you assembled (Apache + MySQL + your own load balancer) into a thing you deployed to (Heroku, Vercel). The unit of consumption became "an app" instead of "a stack."

**IaaS** turned the hardware itself from a thing you owned (a rack in a colo) into a thing you spun up (an EC2 instance). The unit of consumption became "an hour of compute" instead of "a server lease."

Now look at what's actually been left out of those layers: **the engineering practice that turns intent into shipped software.** That's still a thing every company builds for itself, with hired engineers, against a backlog. It's the largest unproductized layer left in the software value chain.

ADaaS is what productizes that.

The unit of consumption becomes "a ticket shipped" instead of "an engineer-week." That's a category-defining shift. If the pattern holds, and the underlying economics suggest it will, most software companies in 2030 will buy this layer instead of building it, the same way most software companies in 2010 stopped racking servers.

## What you're actually buying

People hear "autonomous development as a service" and assume it's an AI coding tool with a marketing team. It isn't. The category is bigger and more boring than that.

When you buy ADaaS, you're buying:

**A configured agent cluster.** Not Claude or GPT, the *cluster* on top, with the bash harness, the worker pool, the parallelism management, the timeout enforcement. The thing that turns a non-deterministic model into a deterministic teammate. ([Why this matters →](/engineering/self-healing-bug-bot))

**A verification loop.** A browser MCP that knows how to spin up your dev server, navigate your routes, take screenshots, read console logs. Without this, the agent's writing code and hoping. With it, the agent's writing code and *checking*.

**A context-engineering apparatus.** A `CLAUDE.md` you don't have to write from scratch. An auto-load table that knows what to load when. Sub-agent definitions for the parts of your codebase that need their own attention. ([The discipline behind it →](/engineering/context-engineering))

**A documentation system that builds itself.** Every successful ticket writes its own docs. Tomorrow's tickets are smarter than yesterday's because the system never forgets a lesson it already paid to learn.

**A maintained MCP fleet.** Stripe, GitHub, Cloudflare, Loki, your database, all wired up, all kept current, all hardened against the failure modes the provider has already encountered.

**A self-healing pipeline.** Errors in production trigger autonomous fixes. The on-call rotation goes empty. PagerDuty escalations stop happening because the cluster is faster than the page would have been.

**An eject mechanism.** This one matters. The whole stack should be portable, your code lives in your repo, your data in your buckets, your secrets in your vault. If the provider raises prices into a corner, you take your code and walk. ADaaS without an eject mechanism is platform lock-in disguised as a service.

What you're *not* buying:

- A model. The model is upstream of the cluster. You're buying the apparatus that uses the model.
- A code generator. Code generation is one tool call inside the pipeline. The pipeline is what makes generation reliable enough to ship.
- An IDE. ADaaS is unattended by definition. There's no human in the inner loop, so there's no IDE in the inner loop either.
- A no-code builder. ADaaS expects you can read a stack trace. If you can't, the category isn't for you.

## How ADaaS is different from what came before

The clearest way to understand a new category is by what it isn't.

**ADaaS vs Cursor / Copilot.** Cursor and Copilot are *human-in-the-loop* tools. The human is at the keyboard; the AI augments the human. ADaaS removes the human from the inner loop. The human is at the *meta*-loop, defining tickets, reviewing outcomes, making judgment calls. The AI is doing the engineering.

**ADaaS vs Devin / Cognition.** Devin is the closest competitor in the category, and the comparison is fair. The differences are stack-specific (we tune for one stack and ship a polished cluster around it; Devin works across many) and posture-specific (we ship straight to production with no PR; Devin defaults to a human review gate). Both are valid. Both are autonomous development. ADaaS as a category covers both.

**ADaaS vs Lovable / Bolt / v0.** These are *vibe-coding-as-a-service* products, marketed at non-technical builders. They're great for prototypes, demos, and weekend projects. They are not autonomous development. They run a model, they show the user the diff, they let the user accept or reject. The human is in the loop on every change. ADaaS removes that loop.

**ADaaS vs OpenAI's Codex / Anthropic's Claude Code.** These are the *primitives* on which ADaaS is built. They're powerful interactive tools. Hunter writes most of his daily code in Claude Code, but they require a person at the keyboard to drive each session. ADaaS is what you build *on top of* these primitives to remove the person.

**ADaaS vs your in-house engineering team.** This is the comparison that matters most for buyers. An in-house team has organizational context an outside service can't have. An ADaaS provider has accumulated infrastructure your in-house team would need to rebuild. The right answer for most companies in the next 36 months is *both*, your team focuses on architecture, judgment, and the parts of the codebase that need real human eyes; the ADaaS cluster handles the volume of routine tickets that would otherwise drown a small team.

> "ADaaS removes the human from the inner loop. That's the line that separates this category from everything else."
> -- Hunter Hodnett, Chipp CTPO

## Why this is happening now

Three things had to be true at the same time for ADaaS to be a real category. They became simultaneously true in late 2025.

**1. Models capable enough to ship code.** Claude Opus 4 was the inflection point. Below that capability bar, you can't trust the agent to write production code without supervision. Above it, you can. The bar moved up sharply with Opus 4 and has stayed up.

**2. Tool surface rich enough to verify.** The Model Context Protocol gave us a standard for browser control, log queries, database access, screenshot capture. Without verification, you can't autonomy. With it, you can.

**3. Context-engineering practice mature enough to scale.** The discipline of *what to put in front of the model so it doesn't compact, hallucinate, or get lost* didn't exist as a named field two years ago. It exists now. ([The full discipline →](/engineering/context-engineering))

When all three are simultaneously true, autonomous development becomes possible. When it becomes possible at one company, the rest of the industry has 18 to 36 months before they have to either adopt or get outpaced. We're in month four.

## The buyer's framework

If you're considering ADaaS for your team, here's the framework I'd run a provider through. Most don't pass. The ones that do are the ones worth paying for.

### Question 1: What does your verification loop look like?

If the answer is "we run tests after generation," that's vibe coding with a CI bolt-on. Pass.

If the answer is "we open a browser, navigate to the affected page, take a screenshot, and read the console logs," that's autonomous development. Continue.

The verification loop is the single highest-leverage component. Without it, the cluster is guessing.

### Question 2: How do you handle context overflow?

If the answer is "we have a 1M token context, you'll be fine," they don't understand the problem. Compaction will eat them.

If the answer is "we use a multi-stage pipeline, each stage gets a fresh context window, stages communicate via markdown files written to disk," they get it.

### Question 3: What's your eject mechanism?

If the answer is "you log in to our platform and use our IDE," you're locked in.

If the answer is "your code is in your GitHub repo, our deployment workflow runs in your CI, you can stop paying us tomorrow and keep everything we built for you," they pass.

This is the deal-breaker for me. ADaaS without an eject is just SaaS lock-in with extra steps.

### Question 4: Where does the system get smarter?

If the answer is "as the model gets better," the provider is a passthrough. Your investment in them doesn't compound, you're paying for someone else's improvements.

If the answer is "the documentation our cluster writes for your codebase compounds; the scar-tissue rules in your `CLAUDE.md` accumulate; the outcome-labeled training data we archive becomes the basis for fine-tuning," they're building you a moat.

### Question 5: Show me the failure modes

Any honest provider should be able to tell you exactly when their cluster fails and why. If they can't, they haven't run it long enough to know. If they can but won't, they're hiding something.

Our cluster fails on cross-tool integrations (third-party APIs the agent can't directly observe), on decomposition of large features, on truly novel work that has no analog in our codebase. We say so out loud. We'd be suspicious of any provider that doesn't.

## Why we coined the term

You'll notice we've been using "ADaaS" throughout this post like it's an established category name. It isn't. We started using it in early 2026. As of this writing, the search volume is low and the SERP is mostly dental-school applications.

We could have used "AI coding agent platform" or "autonomous coding service" or any of a dozen existing labels. We didn't, because none of them name the thing we're actually selling. The category needs a name. Categories that don't have names don't get bought.

So: ADaaS. Autonomous development as a service. Coined here, defined here, with the working understanding that the rest of the industry will catch up to it within 12 to 18 months because the underlying economic logic is too powerful to stay underground.

If we're wrong about the category, the term dies. If we're right, you'll be hearing it a lot.

> "Categories that don't have names don't get bought. We named ours."
> -- Hunter Hodnett, Chipp CTPO

## Where Alchemist sits

Alchemist is our implementation of the category, the configured cluster, the verification loop, the documentation system, the eject mechanism, the maintained MCP fleet. The same system that runs Chipp's autonomous engineering ([the system I described in the manifesto](/engineering/autonomous-development)) is what we're packaging.

We expect competitors. We're going to write about them when they ship; the category is bigger than any one company can capture, and the work of category-defining is mostly happens in public, in posts like this one.

What we're going to differentiate on:

- **Stack opinionation.** We picked one stack (Deno, Svelte, Cloudflare) and tuned the cluster against it. Generality is a tax. Specialization is a moat.
- **Eject by default.** Your code is in your repo from day one. We win because you choose to stay, not because you can't leave.
- **Bundle of practice, not just product.** The cluster comes with the disciplines that make it work, `CLAUDE.md` patterns, sub-agent definitions, verification loops, doc system. You inherit two years of practice the moment you sign up.

The closed alpha is starting now.

## The bottom line

Software development is the largest unproductized layer left in the software value chain. ADaaS is what productizes it. The pattern matches every prior -aaS revolution, the technology is suddenly capable, and the disciplines for using it are no longer secret.

The teams that adopt early will build software at engineering capacities a team an order of magnitude larger could not match. The teams that hold out will spend the next 24 months watching that gap widen.

If you've read this and you're nodding, you're our buyer.

**[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)**

---

If you want the long-form case for autonomous development, start with [The Autonomous Development Manifesto](/engineering/autonomous-development).

If you want to see what an ADaaS implementation looks like under the hood, read [Building a Self-Healing Bug Bot](/engineering/self-healing-bug-bot).
]]></content:encoded>
    </item>
    <item>
      <title>What is Autonomous Software Development?</title>
      <link>https://chipp.ai/engineering/what-is-autonomous-software-development</link>
      <guid isPermaLink="true">https://chipp.ai/engineering/what-is-autonomous-software-development</guid>
      <pubDate>Mon, 27 Apr 2026 00:00:00 GMT</pubDate>
      <dc:creator>The Alchemist Team</dc:creator>
      <description>A working definition of autonomous software development, how it differs from coding assistants like Copilot, and where the technology actually delivers today.</description>
      <category>autonomous-software-development</category>
      <category>ai-agents</category>
      <category>software-engineering</category>
      <category>autonomous software development</category>
      <category>autonomous coding agents</category>
      <category>AI software engineer</category>
      <category>agentic software development</category>
      <category>autonomous development as a service</category>
      <content:encoded><![CDATA[# What is Autonomous Software Development?

A working definition of autonomous software development, how it differs from coding assistants like Copilot, and where the technology actually delivers today.

---

**Autonomous software development** is a class of software engineering where an AI agent, not a human, owns the loop from problem statement to merged code. The human writes a description of what they want; the agent reads the codebase, edits files, runs tests, reviews its own diff, and pushes the result. No keystroke-by-keystroke supervision. No copy-paste from a chat window.

This is a meaningfully different posture from the AI coding assistants most engineers use day-to-day. It's worth pinning down what the term actually means before unpacking how it works in practice.

## A working definition

An autonomous software development system has four properties:

1. **A bounded task input.** Usually a GitHub issue, a Slack message, a customer support ticket, or a natural-language description. The input names a goal, not a sequence of steps.
2. **Tool-mediated execution.** The agent works through a constrained interface (`read_file`, `write_file`, `run_tests`, `push_changes`) rather than free-form output. Tools provide accountability and a place to enforce safety.
3. **A self-terminating loop.** The agent decides when it's done. Either it pushes a commit, or it exhausts a turn budget and reports failure. There is no human in the middle of the loop.
4. **An auditable result.** Every decision the agent made is recoverable from the conversation log, the tool calls, and the final diff. Someone can read the trail and decide to merge, revise, or reject.

If any of those is missing, you have something else. A system that requires a human to pick the next file to edit is an assistant. A system that emits code without running it is a generator. A system without a clear stop condition is a research demo.

## How it differs from coding assistants

GitHub Copilot, Cursor's autocomplete, and most IDE-resident AI features operate at the keystroke or block level. They predict the next token given the current cursor position. The human is doing the engineering, choosing which file to open, which abstraction to introduce, when the work is done. The AI is making the typing faster.

Autonomous systems invert that ratio. The human writes a paragraph; the AI does the engineering. That shift matters because the bottleneck on most software teams is not how fast people can type, it's how much *coordinated cognitive load* a single change requires. Reading the existing code. Understanding the bug. Writing the fix. Writing the test. Reviewing the diff. Pushing without breaking anything else. That whole stack is what an autonomous system is trying to absorb.

## How it works in practice

Concretely, every modern autonomous coding system looks roughly the same on the inside:

```
Issue → System prompt + tools → LLM tool-use loop → Push
```

The agent runs in a sandbox: a container, an E2B microVM, sometimes a fresh Kubernetes Job per ticket. Inside the sandbox, the repo is cloned, a model like Claude or GPT-4-class is given the issue plus a tool schema, and the model decides what to do next. Each model turn either calls a tool or stops. The framework executes the tool, feeds the result back, and asks the model what's next.

Most systems put a self-review step before push: the agent runs `git diff` on its own work, critiques it as a separate model call, and either fixes the issues it finds or proceeds. This single trick, letting the model see its own work before committing, is one of the largest quality wins in the space.

## What it can do today

Autonomous systems work well on:

- **Well-scoped bug fixes.** "Date parsing breaks when the timezone is null": clear input, finite blast radius, a test that proves the fix.
- **Mechanical refactors.** Rename a symbol across a repo. Migrate a library. Update an API call site.
- **Feature scaffolding.** "Add a new resource called `Project` with the same CRUD shape as `Tenant`": the pattern already exists in the codebase, the agent just instantiates it.
- **Tests written from existing behavior.** Pin down what the code does today so it can be refactored tomorrow.

What they're not yet good at (and where the field is actively working) is anything that requires *holding the whole system in your head*. Cross-cutting performance work. Ambiguous product decisions. Architectural changes that touch every layer at once. Those still need a human.

## Why this matters

Autonomous software development changes the unit of engineering work from "a person-day" to "a ticket". The ticket is the smallest thing you can hand off. If a system can reliably absorb tickets, then the question stops being "how many engineers do we have" and starts being "how many tickets can we describe well enough to ship". The bottleneck moves up the stack: to specification, to testing, to code review.

This is what we're building Alchemist around. Tickets in, code out, with a transparent trail of every decision the agent made along the way. We'll be writing about the parts that turned out to be harder than they looked (sandboxing, billing per turn, the model's tendency to over-edit, what self-review actually catches) in posts that follow.

If you want to be early, [join the waitlist](https://chipp.ai/#waitlist). If you want to be very early, the engineering posts are the place to read along.
]]></content:encoded>
    </item>
    <item>
      <title>Welcome to Chipp Engineering</title>
      <link>https://chipp.ai/engineering/welcome</link>
      <guid isPermaLink="true">https://chipp.ai/engineering/welcome</guid>
      <pubDate>Tue, 21 Apr 2026 00:00:00 GMT</pubDate>
      <dc:creator>Hunter Hodnett</dc:creator>
      <description>The Chipp engineering blog — deep dives on how we build the platform for AI builders, the decisions behind it, and what we learn along the way.</description>
      <category>engineering</category>
      <category>platform</category>
      <category>intro</category>
      <category>Chipp engineering</category>
      <category>AI platform engineering</category>
      <category>AI agent infrastructure</category>
      <content:encoded><![CDATA[# Welcome to Chipp Engineering

The Chipp engineering blog — deep dives on how we build the platform for AI builders, the decisions behind it, and what we learn along the way.

---

This is the Chipp engineering blog. Expect long-form, honest writing about how we build the platform — the systems, the decisions, the things that broke and what we did about them.

## What you'll find here

- **Architecture deep-dives.** How our Alchemist, tool-execution pipeline, vector search, voice stack, and billing system actually work.
- **Postmortems.** What broke, why, and how we fixed it. Public so other teams building AI platforms can skip the same mistakes.
- **Performance and scale.** Work we're doing to keep p95 latency tight as we ship 20–30 deploys a day to production.
- **Decisions.** Why we picked Deno, why we wrote our own Stripe token billing layer, why we use a Cloudflare Worker as an edge proxy in front of everything.

## Why a separate blog

Our [docs](/docs) are reference material — how to use the platform. The Ghost blog is for product news and announcements. This is different: it's the engineering reasoning behind the product, written for people who build things.

If that's useful to you, the [RSS feed](/engineering/rss.xml) is the easiest way to follow along.
]]></content:encoded>
    </item>
  </channel>
</rss>