Why Writing Code Still Matters in 2026

Doug Turnbull argues that even in an era where AI agents generate the majority of code, software engineers should still write code themselves. His reasoning isn't about nostalgia or ego—it's about attention, understanding, and long-term system health.

The software factory analogy

Turnbull frames the engineer's role as building and maintaining a 'software factory'—the infrastructure, prompts, tests, and guardrails that make agents effective. In this view, agents are like assembly-line workers that need clear constraints and fresh context to produce good-enough changes. But occasionally, you need to step onto the factory floor and get your hands dirty.

Why writing code helps

Writing code forces you to think directly in the execution environment, not proxied through English. English is under-specified for computation. When you write code, you experience the system's fragility firsthand—you feel where it's hard to build on, where tests are weak, where architecture breaks down. That visceral experience is hard to replicate by passively reviewing diffs or agent outputs.

Turnbull notes that when he only reads and approves AI-generated code, he loses a sense of ownership. Slip-ups fly under the radar. The accumulated 'slop' hurts both humans and agents in the long run. In contrast, when a human spikes an approach and then lets an agent stamp out the patterns, the human participates and owns the result.

Agents are not compilers

A common misconception is that coding agents are like compilers—take a high-level spec and produce correct code. Turnbull argues they're more like freshly onboarded interns: they read partial, possibly sloppy code, take an imprecise description, and must generate a change. That mindset gives us permission to ship terrible code. Humans can't surrender their thinking and taste to armies of interns.

He gives a concrete example: an agent followed a bad human decision to use browser local storage for state that should have been in the backend. The agent conservatively wrapped and indirected around the mistake, tripling the lines of code. Writing code himself allowed him to delete the cruft and arrive at a better architecture.

The takeaway

Writing code is not about being better than AI. It's about maintaining attention, understanding, and ownership. It helps you connect minute details to the big picture. In a world where agents handle the bulk of coding, the engineer's job is to occasionally take apart the assembly line, dig into the details, and make the whole system better.