The 70/30 split: what AI actually automates in a real build

"AI makes us faster" is now a claim every development shop makes, including the ones whose timelines and team sizes haven't changed. It's worth being specific about what actually got automated, because the parts that did and the parts that didn't behave completely differently — and knowing which is which is how you read a quote.

A build, broken down

Take a typical product build — a few user types, a dozen or so entities, some integrations. Here's roughly where the effort goes, and what has happened to each part.

That's the 70/30. About seventy percent of the effort was predictable work that a machine can now do reliably. About thirty percent was never about typing speed and hasn't moved.

The part that genuinely collapsed

The automated seventy percent shares one property: it is determined by something already decided. Once you know the data model, the migrations follow. Once you know the API contract, the client follows. Once you know the design, the components follow.

This work was always mechanical. It absorbed enormous numbers of billable hours precisely because it was voluminous and low-judgment. It is the reason a hundred-screen platform used to take fifteen people eighteen months — not because any individual screen was hard, but because there were a hundred of them and someone had to type each one.

The part that didn't move at all

The other thirty percent resists automation for a structural reason: it consists of decisions where the information needed to decide correctly is not in the codebase.

Data modelling

A model can produce a schema from a description. It cannot tell you that treating an order and a subscription as the same entity will be catastrophic in month nine, because that depends on where the business is going — which is not written down anywhere it can read.

Knowing what to throw away

Generated code is cheap, which means the cost of producing the wrong thing has dropped to nearly zero while the cost of keeping the wrong thing is unchanged. Somebody has to be willing to delete a working implementation because it's the wrong shape. Machines are not good at this and neither, frankly, are most humans.

Security and edge cases

Both are exercises in imagining what isn't in front of you. What does an attacker try? What happens when this arrives twice? What if the third-party is down mid-transaction? These are adversarial and speculative, and current tools are weak at both.

The part that got harder

This is the bit the optimistic version leaves out. Review load went up — substantially.

When a team produces three times the code, it produces three times the diff surface. And generated code is harder to review than hand-written code of equivalent quality, because it lacks the tells reviewers rely on. Nothing looks uncertain, so nothing triggers a second look.

Writing became cheap. Reading did not.

The teams getting real value from this have restructured around that fact: senior people spend most of their time reviewing rather than writing, and automated review runs before human review to absorb the mechanical checks. Teams that kept the old ratio — seniors writing, juniors reviewing — get the speed and the defects together.

What this means for an estimate

Two consequences follow, and they point in opposite directions.

1. 1Volume stopped predicting cost. Screen count, entity count and endpoint count — the traditional estimating inputs — now correlate with the cheap seventy percent. A large, conventional CRUD application is dramatically cheaper than it was.
2. 2Novelty predicts cost more than it used to. A small product with one genuinely hard mechanism can cost more than a large product with none. When most of a build is free, what's left is the hard part.

So the useful question when scoping is no longer "how big is it?" but "how much of this has been done before?"

How to sanity-check a claim

If a team says AI made them faster, the saving should be visible structurally. Ask:

• How has your team composition changed? Fewer people, more senior, is the expected shape.
• How has your review process changed? If it hasn't, they're carrying more risk than before, not less.
• What proportion of your delivery time is now review rather than writing?
• Show me a timeline for this scope in 2023 and the same scope now.

Unchanged team, unchanged timeline, unchanged process, lower price is not an AI story. It's a discount, and discounts come from somewhere.