Why Write Code in 2026: Human Coding Still Matters for AI Agents

Doug Turnbull, in his article "Why Write Code in 2026", challenges the prevailing AI Psychosis mindset where 90%+ of code is AI-generated. He argues that despite Fable-like intelligence, humans still benefit from writing code — not because agents are worse, but because English is underspecified for computation, and proxying through English loses precision.

Key Arguments

• Experience fragility directly: Writing code lets you feel architectural pain points. If it's hard for you to build on without breaking, it will be harder for an agent.
• Fight slop accumulation: Passive code review misses micro-adjustments. Slop flies under the radar and accumulates, hurting agent performance long-term.
• Ownership and attention: When you spike an approach and let the agent stamp out patterns, you participate and own the result. Pure review leads to detachment.
• Agent != compiler: Agents are like freshly onboarded interns — they read partial, possibly slopified code and execute imprecise prompts. Don't surrender human taste to armies of interns.
• Agents amplify bad decisions: A one-off human mistake (e.g., using browser local storage instead of DB) gets wrapped in indirection by conservative agents, tripling LoC.

Why It's Still Useful to Code

Turnbull details concrete benefits:

• Sketch in executable steps: For algorithmic work, English lacks calibrated precision. Low-level languages offer huge design space; high-level languages constrain computation. Code lets you think directly in the execution environment.
• Joyful deletion: Deleting code manually leads to better architecture than asking an agent via English. One example: removing unnecessary local storage wrapping and exploring alternatives improved architecture dramatically.
• Boy scout rule: Agents bias toward safe, minimal changes — they rarely improve code quality. Humans need to proactively clean up and document consistent architectural principles.

Takeaway

The software factory mindset is valuable: infrastructure, CI, evals, and agent guardrails are essential. But the assembly line has weak spots. Writing code — even a fraction of the total — keeps you connected to the system's architecture and prevents the accumulation of slop that ultimately hurts agent effectiveness. As Turnbull puts it: "If I can clean it up, then document a consistent principle about the architecture, the software factory works better."