The constraint moved, it didn't vanish
For two decades the scarce resource in software was the ability to turn a design into correct, maintainable code — writing speed bound to correctness. Tooling chipped away at that cost piece by piece: IDEs, typed languages, frameworks, package ecosystems, CI pipelines. Generative coding assistants are the largest single cut yet, and like every previous cut they don't remove the constraint so much as relocate it.
When a model can emit a plausible implementation of a well-specified function in seconds, the expensive part of the job stops being production and becomes judgement. Deciding what should exist. Verifying that what exists is correct, safe, and consistent with everything around it. Keeping a system coherent while it grows faster than any human on the team can read.
This reframing matters because most public argument about AI and engineering is aimed at the wrong variable. The interesting question isn't headcount — it's the shape of the pipeline. Review, testing, ownership, and on-call structures were all designed around a human authoring rate. Multiply that rate and those structures become the ceiling, not the safety net.
The mechanism: what actually changes when generation dominates
Authoring collapses; verification does not
Code generation is a probabilistic retrieval-and-composition task. It is fast precisely because it recombines patterns it has seen; it is unreliable precisely where a system is novel — integration seams, stateful edge cases, performance envelopes, security boundaries, and anything that depends on organisational context the model cannot observe.
So the volume of output rises sharply while the density of subtle error per unit of novelty stays roughly flat. The gap between the cost of producing code and the cost of trusting it widens every quarter. That gap is the real story.
The context ceiling
A model's usefulness is bounded by what fits in its working context and by how much of the surrounding system it can be shown. Real repositories are not self-describing. Intent lives in tickets, in chat threads, in the heads of the two people who built the payments path three years ago, and in conventions that were never written down because everyone senior already knew them.
Generation scales; context does not. The practical consequence is a hard ceiling on how much of a genuinely complex system can be handed over without a human in the loop who holds the missing model. Teams that treat context assembly — good docs, explicit interfaces, tight module boundaries — as a first-class engineering deliverable get far more out of these tools than teams that paste files into a chat window.
Review becomes the throughput limit

Figure: Editorial context image from the source page (preview only; rights remain with the publisher) · Credit / further reading: newsletter.pragmaticengineer.com
If a team can generate ten times the diff it can carefully read, throughput is set by reading. This is not a new problem — large organisations have been review-bound for years — but the ratio changes qualitatively. Reviewers now face volume that is syntactically clean, stylistically consistent, plausibly commented, and occasionally wrong in a way that requires domain knowledge to spot. Superficial plausibility is exactly the property that makes review expensive, because it defeats the heuristics reviewers use to triage.
Two adaptations follow. First, review shifts from line-level inspection toward contract-level scrutiny: does this function's behaviour match its specification, its invariants, and its failure modes? Second, automated verification has to get genuinely stronger — property-based tests, fuzzing, type-level guarantees, integration harnesses — because human attention is now the scarce input and should be spent on judgement, not syntax.
Trade-offs that don't appear in the demo
Velocity now, comprehension later
Generated code is code nobody on the team has internalised. It works, and then six months later an incident arrives and the on-call engineer is debugging a system they have never read, authored by a process that cannot explain itself. Comprehension debt accrues silently and compounds, and unlike technical debt it isn't visible in the diff — the diff looks fine.
The junior pipeline problem
The profession has always reproduced itself through apprenticeship: juniors build judgement by writing a lot of code badly, shipping it, and absorbing review feedback. Remove the volume of hands-on authoring and you remove the practice ground. A senior-heavy team can adopt generation aggressively and look brilliant for two years; the bill arrives when nobody has been trained to be the next senior. This is the most under-discussed risk in the whole adoption wave, and it is an organisational design problem, not a tooling problem.
Standardisation pressure and monoculture
When most code comes from a small number of models trained on overlapping corpora, systems converge on similar idioms, similar dependency choices, and similar blind spots. Homogeneity is efficient — it makes review cheaper and onboarding faster — but it concentrates risk. If a class of defect is common to a model's output distribution, it will be common across every team using that model, and the same mistake appears in ten codebases on the same afternoon.
Who benefits, who pays

Figure: HEXOPS original illustration inspired by the topic (not a copy of the source article imagery) · Credit / further reading: newsletter.pragmaticengineer.com
The beneficiaries are clear enough. Product organisations get faster iteration on well-bounded work: internal tools, CRUD surfaces, glue code, test scaffolding, migrations, documentation. Small teams get leverage that previously required headcount. Senior engineers with strong systems judgement get their most tedious work removed and their decisions amplified — the bottleneck for them becomes organisational, not technical.
The costs land unevenly. Junior and mid-level engineers absorb the apprenticeship damage first. Reviewers and on-call engineers absorb the verification load, and it rarely shows up in the metrics that justified the tooling spend. Platform and security teams inherit a broader attack surface and a much larger volume of third-party-shaped code to govern.
There is also a quieter cost inside engineering leadership: planning gets harder. When estimation shifts from "how long to write this" to "how long to verify this," historical velocity data stops meaning anything, and roadmaps built on it become fiction.
Risks: interest compounds on code you didn't write
The failure modes are not exotic. Three deserve attention.
Unverified surface area. Generated code that passes tests written by the same process is not verified; it is self-consistent. The dangerous cases are the ones where the specification itself was generated and quietly wrong.
Provenance loss. If a team can't say where a given block came from, whether it was reviewed, and by what standard, then incident response and compliance both degrade. Regulated industries will discover this late and expensively.
Diffused ownership. Code that nobody feels responsible for is code nobody fixes properly. High-generation shops need explicit, named ownership more than low-generation shops, not less — because the implicit ownership that came from having written the thing is gone.
A practical operating model
Make verification the product
Treat test infrastructure, type safety, sandboxed execution, and observability as the throughput multiplier rather than a compliance checkbox. If review is the constraint, invest where review's cost falls: contract tests, schema validation, deterministic fixtures, automated security scanning, and cheap environments where a diff can be exercised before a human sees it.
Instrument provenance
Every generated block should carry a machine-readable trail: which model, which prompt or task, which human reviewed it, which tests cover it. This is unglamorous and pays for itself the first time an incident review needs to answer "why does this line exist." It also gives you the data to know whether the productivity story is real.
Protect the apprenticeship path
If juniors no longer author enough code to build judgement, author it deliberately: pair on hard problems, require hand-written implementations of core subsystems, rotate people through review and incident response, and measure whether people are getting better at reasoning about systems — not just at shipping diffs.
Keep a comprehension budget
Somewhere between aggressive adoption and paralysis there is a policy: this subsystem is human-authored and human-understood; that one is generated and verified heavily. Naming which is which, in writing, prevents the quiet drift into a codebase nobody can reason about.
Key takeaways
- AI generation collapses the cost of producing code but leaves the cost of trusting it largely intact; the constraint migrates from authoring to verification.
- Review becomes the throughput ceiling, and superficial plausibility makes review harder, not easier.
- Context is the hard limit: models scale, organisational knowledge does not.
- The three durable risks are unverified surface area, provenance loss, and the erosion of the junior apprenticeship path.
- The winners are teams that invest in verification infrastructure and explicit ownership; the losers are teams that measure generated lines as if they were delivered value.
- Comprehension debt compounds silently and is invisible in the diff.
Next steps
- Measure your review latency and reviewer load before and after adopting generation tooling — that is where the damage will show first.
- Audit one critical subsystem for comprehension: can an on-call engineer explain its failure modes without reading the diff history?
- Add provenance metadata to the generation pipeline and make it queryable.
- Stand up a verification investment plan for the next two quarters: property-based tests, integration harnesses, security scanning, sandboxed previews.
- Write down an explicit policy for which subsystems may be heavily generated and which must stay human-authored and human-reviewed.
- Review your junior staffing plan against the assumption that hands-on authoring volume will keep falling.
Sources
- The Pragmatic Engineer, "When AI writes almost all code, what happens to software engineering?" — https://newsletter.pragmaticengineer.com/p/when-ai-writes-almost-all-code-what



