We Don't Reject AI. We Use It Like Surgeons.

We write production code with Claude Code every day. We've written up how that works, down to how we structure the prompts. We also get hired to take over codebases that AI agents wrote with nobody steering. One we can talk about is Oria, an oral history platform that now runs with 12 partner institutions.

That isn't a contradiction. The tool is the same in both stories. What differs is who makes the decisions the tool can't take back.

A power tool in the wrong hands

A surgeon's saw and a hardware-store saw cut the same way. What makes one of them surgery is everything around the cut: a plan made beforehand, and a person who knows what not to touch.

Vibe coding is the saw without the surgeon. The model writes the code and the founder commits it without reading the diff. That holds up for a demo. It stops holding up the day a second organization signs up, or a customer sends over a security questionnaire.

Where we draw the line

Kent Beck calls the alternative augmented coding. You still use the agent for most of the typing, but you care about the code, its complexity, the tests and their coverage.

We put the line in one place. A human owns every decision that's expensive to reverse or that touches trust: the schema, authorization, money and what reaches production. Everything else is fair game.

What we hand the agent

• Boilerplate. CRUD endpoints, form wiring, API clients, types that mirror the schema.
• Test scaffolding. We write the assertions that say what should happen. The agent writes the setup around them.
• Refactors under green tests. The agent moves code around. The tests tell us whether it broke something.
• First drafts of docs and changelogs. The agent drafts, we edit.

What the agent never does alone

• Migrations. A human reads every line, and the migration runs against a copy of production data before it runs anywhere real.
• Auth and permission code. Read top to bottom by someone who could explain every branch.
• Anything that moves money, including every call to Stripe or any other API that bills the client.
• Production deploys. The agent can open the pull request. A human merges it.
• Security headers and CORS. Agents write config here that looks right and quietly allows far more than it should.

The rule we hold ourselves to

If we can't say what a piece of code does without reading it again, it doesn't merge.

That sounds slow. It is slower than letting the agent run, and that's the point. A model writes code faster than anyone can read it, and reading is the only step that catches a wrong assumption. So when review can't keep up with generation, we slow the agent down. We don't start skimming.

In practice it looks like this: a short spec before any prompt, prompts fenced to the files they may touch, a commit before anything that edits more than one file, and a human pass on the cases the model never sees, like the error states and the second user. I'd rather ship one feature that works than five that demo well.

What this means when we take over an AI-built codebase

We don't throw the AI's work away. We filter it. Code we can read and trust stays. Code we can't gets rewritten.

In AI-built products the split tends to fall the same way: the screens and flows survive, the foundation doesn't. That's how it went at Oria. The institution platform had been built fast with AI coding agents, and institutions liked what it did. Underneath, authorization was broken, organizations could see each other's data, uploads and transcription failed, and there was no deploy process. We rebuilt the foundation so the product on top could keep doing what institutions were paying for. The full write-up has the details.

Five questions for your own team

Two "no" or "not sure" answers mean the agent is making decisions nobody signed off on.

1. Does a human read every migration before it runs in production?
2. Could someone on the team explain every branch of your authorization code without opening it?
3. Is there a test for the path where money moves, with assertions a person wrote?
4. Does anything reach production without a human merging it?
5. When the agent adds a dependency, does anyone ask why?

Related reading

• Burning tokens is not shipping: why token usage is the wrong way to measure AI-assisted engineering
• How we use Claude Code in production: the daily workflow behind the rule above
• We inherited an AI-generated codebase. Here is what we found: the Oria rebuild in full

How we build with AI for clients: AI-Native Development. Cleaning up after it: Vibe Code Rescue, or the page for Claude Code projects.