← Writing

Code is for
compilers.

A Harvard study on 700,000 developers confirmed what every lead already knew: AI wrote 30% more code, and shipped zero extra features. Generating syntax was never the bottleneck. Software works only when someone gives a damn about the person on either side of the screen.

Last month, two Harvard economists published the largest empirical study of AI coding tools yet: roughly 300 million work events across 718 enterprise companies and over 700,000 developers, tracking Git commits, Jira resolution, and generative AI adoption.1

The numbers cut through the hype.

AI coding agents increased lines of code by 30%. Commits rose 20%. Pull requests jumped 23%.

And completed deliverables, the actual epics and resolved tickets that deliver software to users, did not budge. The estimates ruled out any output gain larger than twelve percent, with the median sitting near zero. Employment was equally flat: no mass layoffs, no junior wipeout, ruling out even a 3% drop in headcount.

More code arrived. Nothing more shipped. Nobody was replaced.

On synthetic benchmarks like SWE-bench Verified, frontier models now score above 90%. Yet Anthropic's own research into enterprise deployment shows a stubborn delegation gap: developers still trust agents with barely 0% to 20% of high-stakes tasks without human oversight.3 A recent paper by Balepur and others at Maryland and Stanford puts a name to the reason: code understanding, not code generation, is the actual bottleneck.2

Typing was only ever a third of an engineer's day. The other two thirds went on figuring out what to build, untangling dependencies, talking to users, and reviewing diffs. When you make drafting instant, you do not accelerate delivery. You just create inventory for a review queue that climbed 49% in duration.

01 Compilers do not have feelings

The industry treats this bottleneck as a temporary technical constraint waiting for larger context windows. That misses the line between code and software.

Code is for compilers. Software is for people.

A compiler does not care about human experience. It checks grammar, type signatures, lifetime bounds, and memory layout. If a function is syntactically valid and satisfies the type checker, the compiler succeeds and shuts down.

Software lives somewhere else entirely. It runs on an operator dashboard during a live broadcast where a five second hang ruins the event, or on a phone held by someone trying to catch a bus in the rain.

An AI is not human, and by its nature it never will be. It cannot experience panic, tiredness, or relief. It does not live through anything.

Processing millions of tokens about human frustration is not the same as having perspective. A model can digest every bug report ever filed, but it still only knows what the words look like next to each other. It cannot feel what it is like to have your time wasted by bad software, because it has no life to waste.

Without lived experience, there is no real perspective. An LLM writes code that satisfies compilers faster than any human can type. What it cannot supply is the human context that made the software necessary in the first place.

Empathy in software engineering is not a soft sentiment. It is a strict technical requirement that dictates architecture, error handling, interface simplicity, and operational safety.

02 Empathy is not taking dictation

That gap shows up first upstream, where problems get defined.

In real world engineering, users almost never ask for what they actually need. They ask for a patch over a symptom: another toggle, an export to CSV with sixty columns, or a confusing confirmation modal because an underlying workflow makes no sense.

There is an old line often attributed to Henry Ford: if he had asked people what they wanted, they would have asked for faster horses. Steve Jobs put it more bluntly: people do not know what they want until you show it to them.

That principle is usually quoted by designers to justify arrogance, but in software engineering it is really about empathy. Designing the right thing often means ignoring what users are asking for, precisely so you can understand them at a deeper level.

Empathy is not taking dictation. Taking dictation is clerical work. Real empathy is understanding human fatigue, confusion, and daily friction so intimately that you can look past their prescribed workaround and build the real answer. You take what you understand about human behaviour and combine it creatively with what you know the technology can do, finding an answer the user could never have framed into a ticket.

An AI agent cannot do that. An agent takes dictation by definition. It treats the prompt as gospel truth. If a user asks for a faster horse, the agent will happily generate 500 lines of type checked horse breeding logic and automated saddle polishing scripts in thirty seconds. It cannot step back and ask whether an engine makes more sense.

You get polite garbage. You asked for a bridge to nowhere, and the machine built it cleanly out of concrete. The tests pass. The user is still stuck, the product is more confusing, and you own 500 more lines of maintenance debt.

03 Code is just the artifact of thinking

The same dynamic breaks downstream.

I have argued before in my essay on containment that if your plan for agentic coding is to read every line, you have already lost. You cannot review your way to safety at machine speed.

The 49% review delay in the Harvard study is the measurable cost of teams trying to do exactly that: using human engineers as brakes on an automated conveyor belt.

What matters downstream is not stylistic cleanliness or reviewing syntax line by line. What matters is systems understanding: Why was this database chosen over that one? Why are the relationships between these tables modeled this way? Why is there a hard boundary between these two services? What is the blast radius when this component fails?

Code is not the work itself. Code is just the recorded documentation of all that thinking.

An AI agent does not think through constraints. It is shortsighted by nature. It does not care why a problem exists; it simply presses forward until it hits its immediate goal, patching over symptoms until the tests pass. It does not have to live with the consequences of what it built.

Vibe coding raw output hides the learning. When you build a system by wrestling with the tradeoffs, you learn where the traps are. You understand why three alternative architectures failed before you pick the one that worked. When an agent brute forces a draft, the code arrives stripped of that thinking. The prompter never learned it, the machine never cared, and the code only works by coincidence.

Empathy for your team is not dumping a 1,200 line diff on them and asking them to audit it. Empathy is doing the architectural thinking yourself: setting the boundaries, containing the failure modes, understanding why each piece exists, and leaving a system that does not require heroes to keep it from collapsing.

04 Restraint is the hardest feature

AI has no concept of restraint. It cannot look at a feature request and say: "This makes the product worse. A database index and a clearer label solves this without adding new endpoints."

Models are trained on volume, and their entire utility is demonstrated by producing output.

Yet the most senior skill in software has always been the refusal to write code. Deleting a setting that clutters the interface. Merging two redundant database tables. Talking a product manager out of a feature nobody asked for.

When typing becomes free, the pressure to add features becomes toxic. If every loose idea turns into a pull request in two minutes, the codebase rots. Interfaces bloat, systems become fragile, and the cognitive load on the engineers keeping the lights on gets unbearable.

Taste is knowing what to leave out. Restraint requires empathy for the human mind using the software. A prompt cannot supply taste.

05 Standing behind the work

The Harvard paper did not prove that AI is useless. It proved that software development was never a typing competition.

The reason headcount did not drop across those 718 companies is that the hard part of software was never writing loops or implementing algorithms. The hard part has always been turning messy human intentions into reliable systems, and shielding people from the complexity underneath.

As typing code approaches zero cost, the economic value in engineering moves to the edges:

Upstream: listening beneath the request, understanding where people struggle, exercising restraint, and defining the right problem.

Downstream: owning the architecture, guarding the containment boundaries, and carrying the pager.

A machine can generate the syntax, satisfy the linter, and pass the tests. What it can never do is care about the human on the other side of the screen, feel the weight of a broken promise, or look a user in the eye and say: I built this for you, and I stand behind it.