We run OpenAI's Codex and Anthropic's Claude side by side on every build — AI produces most of the code by volume, humans own every merge. The stack works because of the guardrails around it, not the models inside it: frozen specs, typed languages, small reviewable diffs, cross-model review, CI that gates everything, and human eyes on every line that touches money or personal data.
The honest framing first
"AI writes our code" is either the most overhyped or most underhyped sentence in software right now, depending on who says it. Here's our version, precisely: AI produces most of the code by volume. Humans make every decision that matters and own every line that ships. The distinction is everything. Shops that skip the second sentence are shipping plausible bugs at scale.
The stack
- Codex — OpenAI's coding agent. Strongest for us on well-specified implementation: take a written spec for a slice, produce the code and tests, iterate against CI.
- Claude (Claude Code) — Anthropic's coding agent. Our pick for architecture-heavy work, refactors that span many files, and review — it reads a codebase like a senior engineer with unlimited patience.
- A boring foundation — TypeScript end to end, Postgres, one repo per client, CI on every push, preview deploys on every branch. The less exotic the foundation, the better both models perform: they've seen a million codebases shaped like this.
Why two models instead of one? Partly strengths, mostly independence. Two models with different training don't share blind spots — which we exploit directly in review.
The loop, step by step
- Spec first, always. Every slice of work starts as written English: what it does, what's out of scope, what the edge cases are. Vague prompts produce confident garbage. Tight specs produce drafts worth reviewing. (The specs come from the same discipline as our sprint scoping.)
- AI implements the slice. Code plus tests, in a branch, sized so a human can genuinely review it — a few hundred lines, not a few thousand. Oversized diffs get split before review, not skimmed.
- The other model reviews it. Claude reviews Codex's diff (or vice versa) with an adversarial brief: find the bug, the missed edge case, the hallucinated API. It's remarkable how often one model catches what the other invented.
- A human owns the merge. We read the diff like it came from a talented junior with infinite speed and no accountability — because that's what it is. Business logic gets traced against the spec by hand.
- CI gates everything. Types, tests, lint, build. Red means no merge, no exceptions, no "it's probably fine".
Where AI is genuinely 10×
- Scaffolding and CRUD — admin tables, forms, list/detail screens. Most of an app by volume, near-zero novelty.
- Test coverage — models write more patient, more paranoid tests than humans ever have. We ask for failure-mode tests specifically.
- Mechanical refactors — rename across 60 files, swap a library, tighten types. Perfect delegation targets.
- Integration boilerplate — the 80% of a Stripe or email integration that is documented, standard plumbing.
- First drafts of anything — a migration, a webhook handler, an error taxonomy. Editing a competent draft beats a blank file every time.
Where it's 1× — or negative
- Deciding what to build. Models optimize for the spec they're given. Writing the right spec is the job.
- Undocumented reality. The client's legacy system that behaves nothing like its docs. AI confidently codes against the docs; a human discovers the truth with curl and patience.
- Money paths and auth. AI drafts them; humans verify line by line. A plausible bug in checkout isn't a bug, it's an incident with a dollar amount — we learned to budget for this in every store build.
- Taste. Spacing, motion, microcopy, the feel of quality. Models get you to "fine". The gap between fine and good is human, and it's the gap clients pay for.
The failure modes, and what catches them
Anyone who tells you AI code has no characteristic failure modes hasn't reviewed enough of it. Ours, ranked by frequency:
- Plausible-but-wrong logic — code that reads correctly and mishandles the one case that matters. Caught by: spec-tracing in human review, failure-mode tests.
- Hallucinated or stale APIs — a method that doesn't exist, or a pattern deprecated two majors ago. Caught by: types and CI instantly.
- Silent scope-creep — the model "helpfully" adds behaviour nobody asked for. Caught by: diff review against the spec; if it's not in the spec, it comes out.
- Over-engineering — three abstraction layers for a feature with one caller. Caught by: a standing instruction — the simplest thing that passes the tests — and reviewers empowered to delete.
Why this matters to you (the non-engineer version)
This stack is the reason our prices look wrong next to agency quotes. The repetitive 80% of a build got radically cheaper; we pass that through. The judgment 20% didn't get cheaper — and that's exactly where the humans you'd actually talk to spend their time. You get senior attention on the parts that need it, at a price that reflects what the rest now actually costs to produce.