We don't write code anymore

Vincent Quigley · article · 2026-06-12 source ↗ Reader 🖥️

Agentic SDLC AI Cost Visibility & FinOps AI Slop Burnout & Recovery Coordination Cost Orchestration Tax / Human Review Bottleneck Technical Leadership Track (IC / Staff-Plus Ladder)

Software engineering has entered a fourth generation of abstraction in which implementation is cheap and the hardest, most valuable work has moved up a level to framing, specifying, steering, and reviewing — which requires engineers, teams, and engineering management itself to reorganize around judgment and review capacity rather than code production.

practical · mixed — A field report (expository/narrative) that builds toward explicit prescriptions for how engineers, reviews, and engineering management should change; written by an engineering manager at Sanity who still codes.

Structure

Part	Role
The four generations of coding (assembly, high-level languages, frameworks/cloud, AI-first) framing device	context/premise
'Code was the cost, the product was always the point' — reframing why engineering rituals existed	premise
The new 9-step development pipeline (context -> spec -> agent build -> review -> push back -> tests -> ship -> monitor -> iterate)	evidence/mechanism
'The uncomfortable parts' — cost, judgment amplification, slop, ownership, review load, exhaustion/addiction	counter-evidence / honest costs
'What this changes for teams' — managing people who direct agents, smaller teams, clarity as constraint	generalization to team/org level
'What this changed for me' — personal EM/IC split dissolving	personal evidence
'You should be in the room' — call to action	conclusion

Key terms

Fourth generation of coding
AI-first development, where the unit of work is intent, context, and conversation with models rather than code syntax — following assembly, high-level languages, and frameworks/cloud as prior generations.
Orchestration tax / review becoming sharper
The claim that as agents absorb implementation, human review must intensify rather than relax, because the understanding that used to accumulate automatically while hand-typing code must now be rebuilt entirely during a single review pass.
Intent === ownership
Directing an agent to produce work does not transfer or dilute accountability; if your name is on it, you must be able to explain, defend, and revise it regardless of how much of it an agent wrote.

Propositions

explicitcorroboratedEach of the four generations of coding abstraction (assembly, high-level languages, frameworks/cloud, AI-first) moved the hardest problem in the job up a level; 'we no longer write code' means literally that the job's center has shifted from typing code to shaping context, writing specs, steering implementation, and reviewing results.conf: high
supports ←What happens when the coding becomes the least interesting part of the work · p1 — Both independently describe the center of the engineering job moving from typing code to the judgment/framing work that precedes or surrounds it.
explicitCode was always the cost of building, not the point — the product was the point — so now that AI has made implementation dramatically cheaper, many rituals built to protect expensive code (heavy upfront design, long estimation cycles) have lost their original justification, even though some of those activities (review, spec quality, judgment) matter more than before.conf: high
explicitThe development pipeline reorganizes around context, autonomy, and review: a nine-step loop (shape context, produce a spec, let an agent build and iterate, review the diff, push back, tighten tests, ship, monitor, iterate) in which the agent remains a partner through the whole change lifecycle, not just drafting code.conf: high
explicitKeeping agent-generated pull requests small (around 500 lines) is a hard discipline because review, not generation, is the bottleneck; a PR that reaches 10,000 lines means the process has failed, since no one reviews that properly.conf: high
supportsGitHub Brings Stacked Pull Requests to Public Preview · p8 — Both argue the point of splitting into small/stacked PRs is to reduce total review burden, not just repackage it into more numerous small reviews.
explicitHuman review must become sharper, not softer, as implementation gets cheaper: the review ideal never changed, but the cost of skipping it rose, because understanding used to come free from the act of writing code and must now be rebuilt entirely during the review pass — making the work cognitively heavier despite removing typing.conf: high
supportsThe Orchestration Tax is You · p22 — Both identify human review as the slowest stage that caps overall throughput regardless of how fast agents generate code.
explicitAI does not create good engineering judgment or product instinct — it accelerates whatever habits already exist, amplifying strong taste and discipline but also amplifying weak habits (producing exactly what was asked without considering the outcome) louder, producing a distinct failure mode: output that is technically good but product-wrong.conf: high
explicitEngineering management is changing into managing people whose job is to direct agents — a different craft (framing problems, constraining work, steering implementation, deciding whether what shipped actually moved the product) that most engineers were never explicitly trained for, requiring months of coaching for some good engineers to reach the new standard.conf: high
supportsThe engineering manager role is splitting in two · p3 — Quigley's EM-who-still-codes-via-agents is a concrete, lived instance of the 'tech lead manager' path that piece describes abstractly.
supportsStop Just Writing Code. Start Leading Agents: The Staff Engineer’s AI Edge · p2 — An engineering manager's independent field report corroborates the Staff Engineer's claim that leading agents uses the identical managerial loop (direction, context, review, correction) as leading people.
explicitSmaller teams with strong shared context can carry more of the problem-to-production path themselves, reducing handoffs and coordination drag — but this benefit is entirely conditional on the clarity of the team's product thinking, since AI exposes ambiguity faster rather than resolving it.conf: high
explicitCollapsed implementation cost dissolved the author's personal split between engineering-manager work (people, planning, stakeholders) and individual-contributor work (code, product) — he can now be an EM and still ship meaningful production work as a normal part of how he operates, not a nostalgic side project.conf: high
supportsAI productivity is burning out your best engineers · p7 — Both insist speed/output is not the same as sustainability and that the field currently lacks adequate practice for managing the human cost.
implicitThere is a real, unaddressed sustainability risk in agent-heavy workflows: managing several concurrent agent threads produces a compulsive, dopamine-driven pull toward 'one more fix, one more review pass' that can compress multiple days of output into one day — a pattern the author explicitly says the field lacks good practices for.conf: medium
explicitAI-generated volume creates a new quality failure mode distinct from bad code: 'slop' — polished-sounding docs, specs, and messages that people send without having really read, understood, or being able to defend — and this must not be allowed to become normalized just because generation is fast.conf: high

Arguments

The hardest, most valuable part of the engineering job has moved up a level — to judgment, framing, review, and product thinking — requiring both individual engineers and engineering management itself to change. strength: high

Explicit premises:

Implementation cost has collapsed, removing the original justification for cost-protecting rituals
Review must intensify, not relax, because understanding no longer accumulates automatically during writing
AI accelerates existing judgment and habits rather than supplying judgment itself
Engineering management is now partly about directing agents, a craft most engineers were never trained for

Implicit premises:

Senior engineers (10+ years' experience) who adopt this workflow retain enough residual coding intuition that letting go of hand-writing does not erode their ability to review well — an assumption untested for engineers who learn primarily through agents from the start
The author's team (senior, well-resourced, at a company that can absorb significant AI spend) is representative enough that the pipeline and discipline described generalize to less senior or less resourced teams

Inferences:

If review and judgment are now the dominant cost and skill, hiring, onboarding, and promotion criteria should shift toward review/judgment competence rather than implementation speed — a conclusion the piece implies for individuals but doesn't extend into concrete leveling or hiring policy

Narratives

Claude autonomously created a stacked sequence of small pull requests for a change, decided the decomposition itself without being told how to break down the work, verified CI, and responded to independent AI code reviews built into the CI pipeline — all before the author looked at it.
→ Makes concrete what 'the agent stays involved as a partner throughout the change lifecycle' means in practice, and grounds the abstract claim that review can stay rigorous even as generation accelerates.

Questions addressed

✅ Does moving to AI-first development mean engineers stop owning their code?
No — ownership just shows up differently (in review, specs, and intent rather than line-by-line authorship); 'AI helped with this' is not a disclaimer that lowers the bar or transfers accountability.
✅ Can engineering-manager work and individual-contributor coding coexist for one person again, after years of feeling forced to choose?
Yes, for the author personally — collapsed implementation cost lets an EM extend the same management loop (direction, context, inspection, feedback) to include agents alongside people, and ship real production work as part of normal operation.
⭕ What practices prevent the addictive, always-one-more-prompt agentic work pattern from becoming an unsustainable organizational norm?

Gaps

incompleteThe sustainability/addiction risk is named vividly (CPU-scheduling metaphor, dopamine hit, '2.5 days' worth of work in one day') but the piece offers no structural remedy — only a personal admission that 'we need [practices].' It doesn't engage with burnout research or propose organizational guardrails (caps on concurrent agent threads, workload monitoring, mandatory breaks) that would turn this from an individual discipline problem into a team or company policy.
Read next: extract-ai-productivity-burning-out-best-engineers and extract-osmani-orchestration-tax-is-you, both of which treat the review/attention bottleneck as a structural organizational problem rather than purely personal workflow design.
incompleteThe piece asserts 'smaller teams can do more' and 'fewer handoffs, less coordination drag' as the team-shape endpoint, but never engages with the literature on why human cooperation doesn't scale automatically (trust-building, psychological safety, Dunbar-style cognitive limits) — shrinking headcount doesn't automatically shrink the coordination burden if the remaining members still need to build shared context and trust from scratch.
Read next: extract-human-scalability-problem.
uninformedAll reported practice comes from one senior, well-resourced team (10+ years' experience each) at a company absorbing roughly $2,000/month per engineer in AI spend; the piece generalizes 'the review bar cannot drop' and 'months of coaching to get good engineers up to standard' as achievable expectations without addressing whether less senior, less resourced, or more cost-constrained teams can sustain the same review intensity, or what happens to engineers who never built hand-written-code intuition in the first place.

Closes gaps elsewhere

KI, utvikling og følelser · g4 — Quigley supplies concrete, first-person mechanism evidence for the dopamine/attention claim that g4 said was asserted but not demonstrated: the agentic coding loop ('one more fix. one more review pass. move one more agent on so its output is ready for you in the morning') is a specific, coding-agent-native description of a variable-reward loop producing 'a serious dopamine hit' and admitted addictiveness — anecdotal rather than mechanistic research, but a real-world instance of the exact mechanism the gap asked for.