“AI does not reduce work; it moves work from writing to reviewing.”
Standards that fail the build
We didn’t get faster because of AI. We got faster because the rules were enforced, which is what made generated code cheap to accept.
By 2026 the team used Claude Code every day — components, tests, integrations — with design connected to Figma. Throughput improved roughly 50% by ticket cycle, and tests stopped being written by hand.
The interesting part is what had to exist first. AI does not reduce work; it moves work from writing to reviewing. If review is where your bottleneck already is, generating more code makes things worse rather than better.
So the rules came first. Engineering standards written as executable checks, enforced before commit and again in CI, with a different set per codebase — because one set for a backend and a component library is either too loose for one or too strict for the other.
The problem
The constraint
What we did
Rules as code, not as documentation
The standards we enforced: no
any, with a prescribed way of declaring types; a component may not exceed 200 lines; every API call must have a request type and a response type. Written as checks, not as a style guide.Checks, not a style guideA different set per codebase
The web app, the backend and the component library each had their own set. This matters more than it sounds: a single set of rules for a backend and a design system is either permissive enough to be useless for one or strict enough to be routinely bypassed in the other. Deciding what matters where is a leadership call, not a configuration task.
Three sets, three codebasesThree severities, by stage
The same rule behaved differently depending on where you were. This is the part we’d recommend to anyone: most teams pick one severity and get one of two failures — too strict and people fight the tooling or disable it, too soft and the rule quietly stops existing.
Present throughout, blocking where cheapOnly then, AI
With the checks in place, Claude Code went into daily use for components, tests and integrations, and design was connected to Figma. The order is the whole argument: generated code is only cheap if accepting it is cheap, and accepting it is only cheap if something other than a human is checking the boring half.
The order is the argument
Tells you without interrupting the work. Formatting and linting go in the hook because they are fast and local; types and tests in CI because they are slow and definitive.
The result
- Team throughput up roughly 50%, measured by ticket cycle
- Tests stopped being written by hand — which matters because tests are the first thing dropped under deadline pressure
- Standards enforced identically regardless of who reviews, or whether anyone does
The single most valuable rule, in hindsight, was the size limit on components. Not the type rules, not the API contracts — the 200-line ceiling. It is the one that pays back over years rather than weeks, because it forces decomposition at the moment something starts to sprawl, when splitting it is still easy.
What we’d do differently
The 50% figure is an estimate from ticket cycle, not a controlled measurement — and you should treat it as one.
There is good reason for caution here. METR ran a randomized controlled trial in July 2025 with 16 experienced developers across 246 real tasks in repositories they’d worked in for years. The developers predicted AI would make them 24% faster. Afterwards they reported being 20% faster. Measured, they were 19% slower.
The gap between perceived and actual was 39 percentage points. METR has since revised the study’s design and treats the result as historical, partly because in a follow-up many developers declined to participate if they had to work without AI.
Our setup differs from theirs in ways that plausibly matter — a team rather than individuals, a product in active development rather than a codebase known for five years, rules enforced automatically rather than AI used ad hoc in an editor, and 2026 tooling rather than early 2025. Those are reasons to think our number might be real. They are not evidence that it is.
What we’d do differently: measure cycle time properly. Three months before, three months after, from the data we already had. It was available and we estimated instead.
- Claude Code
- pre-commit hooks
- CI
- ESLint
- TypeScript
- Figma