What changes for software engineering with AI?

The shift

Writing working code from a specification goes from scarce, billable engineer-hours to abundant and near-instant — an agentic model can now read a codebase, write, run, and iterate on code against tests and tool feedback, not just autocomplete a line.

The axioms

• Writing code is the bulk of the effort on a feature, so headcount is sized to lines-of-code throughput. Rests on: drafting code is slow and expert-scarce.
• Senior engineers are valuable because they hold more of the codebase and more patterns in their head than juniors. Rests on: pattern recall and breadth of prior exposure is scarce.
• Code review by a human is the check that catches bugs before production. Rests on: a second scarce expert's judgment, applied at the speed a human can read code.
• Junior engineers become senior by spending years writing large volumes of code themselves. Rests on: the only path to pattern fluency is scarce, slow, repeated first-hand practice.
• Someone is accountable when production breaks, security is breached, or a customer is harmed. Rests on: accountability requires a liable, employable human, which is scarce by construction.
• Estimating and scoping work is hard because translating ambiguous requirements into a technical plan takes deep, scarce context. Rests on: synthesis of business intent into technical shape is expensive cognitive work.
• Architecture and system design decisions require judgment that can't be delegated to whoever is fastest at typing. Rests on: judgment under long-term, high-stakes tradeoffs is scarce and non-pattern-matchable at the frontier.
• Knowledge of a legacy codebase is scarce and walks out the door when someone leaves. Rests on: institutional memory lives in scarce human brains, not in the code itself.
• Tests and documentation lag behind code because writing them is extra scarce effort nobody has time for. Rests on: writing anything beyond the minimum shippable code competes for the same scarce hours as the code itself.

Invalid axioms

1. Headcount should scale with lines-of-code throughput. Drafting code is now abundant and near-free at the token level; a model can generate, refactor, and re-generate large volumes of working code in seconds. The habit-trap: orgs still size teams and sprint capacity as if typing speed were the bottleneck, when the bottleneck has moved to specifying, reviewing, and verifying what got generated.
2. Junior engineers earn seniority mainly by writing lots of code themselves. The volume of code-writing reps that used to build pattern fluency is now something a model does faster than any human ever could — the reps themselves are abundant. The habit-trap: career ladders and junior hiring still assume years of hands-on typing is the only training loop, rather than redesigning junior work around reviewing, directing, and verifying AI output.
3. Boilerplate, migrations, glue code, and first-draft tests are expensive enough that teams routinely skip or defer them. These are exactly the abundant, pattern-matchable outputs AI now produces near-instantly. The habit-trap: backlogs still carry "someday" tickets for test coverage and doc debt as if writing them were still scarce effort, when generating a first draft of both is now cheap.
4. A codebase's tribal knowledge is scarce and walks out the door with the engineer who leaves. A model with long-context access to the full repo, commit history, and tickets can reconstruct and explain most of that context on demand. The habit-trap: orgs still treat departing-engineer knowledge transfer as an irreplaceable fire drill instead of an abundant retrieval problem.
5. Estimation and scoping require a senior engineer to manually translate a ticket into a technical plan. A first-pass technical plan, broken into tasks with tradeoffs sketched out, is now a cheap draft a model can produce from a spec or a Slack thread. The habit-trap: planning meetings are still staffed and timed as if the draft-plan step were the scarce, slow part, rather than the judgment call on top of it.

Unchanged axioms

1. Someone is accountable when production breaks, security is breached, or a customer is harmed. A model cannot be liable, fired, sued, or put on a PIP — accountability requires a human or company with skin in the game. This doesn't move regardless of how good the model gets; it's a legal and organizational fact, not a capability gap.
2. Code review is the check that catches problems before they ship. Verification stays scarce even as generation gets cheap — someone still has to confirm the generated code is actually correct, secure, and fits the system, and "confidently plausible but wrong" is the default failure mode of the generator itself. What changes is volume: the reviewer is now checking AI output at a pace and scale human-only review was never built for.
3. Architecture and system-design tradeoffs under long-term, high-stakes ambiguity need human judgment. Deciding what to build, which tradeoffs a business can live with for the next three years, and how much technical debt is acceptable has no clean pattern to match against — it's a bet on a specific, unprecedented future, not a retrieval task.
4. Trust between an engineer and the systems, users, and teammates depending on their work is earned, not generated. Shipping to production, holding an on-call pager, or being the name attached to a security-sensitive change requires standing that a model doesn't have and a track record a model can't accumulate on its own behalf.
5. Deciding what's worth building at all is a taste and prioritization call, not a code-generation task. AI drafting a feature fast doesn't tell you whether the feature should exist — that's still a product and business judgment call sitting upstream of any code.

New axioms

1. When code is nearly free to generate, the volume of code needing review can exceed the team's capacity to verify it. Review, historically sized for human-authored PRs at human pace, now faces a firehose — the open problem is building verification that scales with generation instead of becoming the new bottleneck by default.
2. When anyone (junior, non-engineer, or another AI agent) can produce plausible-looking code fast, who is actually responsible for what shipped becomes ambiguous. Authorship blurs across human-written, human-directed-AI-written, and AI-modified-AI-written code, and the org hasn't decided who owns the outcome when a bug traces back three layers of "the model wrote that part."
3. If junior engineers no longer build pattern fluency through years of hands-on coding, the pipeline that produces senior engineers loses its training mechanism. It's an open problem how the next generation of engineers develops the judgment that STILL HOLDS says remains scarce, if the reps that used to build it are now done by the model instead of the person.
4. Abundant first-draft code changes the shape of technical debt — it can now be generated faster than it can be understood. Volume and speed of change increase the odds that a codebase accumulates AI-generated complexity no single human, and possibly no single context window, fully understands, which is a different failure mode than debt from rushed human work.
5. Security and correctness bugs can now be introduced at agentic speed and volume, testing whether verification tooling (tests, static analysis, sandboxed agent review) can keep pace with generation speed. This is explicitly a moving target — how far automated verification closes this gap over the next 12-24 months is unresolved and worth flagging as fast-changing rather than settled.

Where it breaks

"Headcount scales with code-writing throughput" (invalid) collides head-on with "review capacity, not generation capacity, is now the constraint" (new): teams that reallocate headcount toward more AI-assisted output without proportionally investing in review and verification are shipping faster into a bottleneck they haven't resourced, and won't notice until the bug volume or security incidents catch up with them.

"Juniors become senior by writing lots of code" (invalid) collides with "the training pipeline for judgment has no clear replacement" (new): orgs cutting or hollowing out junior engineering roles because AI covers the code-writing volume are simultaneously deleting the mechanism that used to produce the senior judgment that STILL HOLDS says remains irreplaceable — this is a five-year problem hiding inside a one-year cost saving.

ai-axioms.vercel.app/axioms/engineering/software-engineering-ai-axioms