It’s our job to build the software factory - not just the software. Software engineers maintain the assembly line allowing anyone to prompt for a change and ship immediately.

We set up the infrastructure that makes agents successful. We act proactively through prompts (skills, AGENTS.md, knowledge bases etc). We protect software reactively through automated evaluation (tests, linting, type systems, evals, other AI, etc).

It all keeps the agent on track. Even a stupid model, with fresh context, can work within these constraints and produce a good-enough change. It starts to seem ridiculous to even look at the code. And definitely laughable to ever want to write code.

I disagree. It’s still useful to write code.

Even with Fable-like intelligence humans get value from writing code. Not because agents are worse at coding that humans. But to think directly in the execution environment, not proxied through English.

It’s about attention and understanding. To keep my attention, I must go beyond ‘read code’ like a passive observer of agents from afar. To really connect with the architecture of the system, it helps to truly experience the code. I don’t want your flat 2D system of diffs and patches. From time-to-time, I need the full, 4DX virtual reality experience with pain sensors attached to my nethers to experience what’s happening.

And no, it’s not because this “code isn’t pretty”, it’s about experiencing fragility. If it’s hard for me to build on top of this code without something breaking, it’ll harder for an agent to make sense of it. If I can clean it up, then document a consistent principle about the architecture, without half-a-dozen exceptions the software factory works better. If I can debug, find where the testing strategy is weak, and find a fix I can squash an entirely new class of bugs.

Yeah, you can do that without writing code. I’m not going to lecture you, call you slop-kitty, and say the only way to really experience software is by a magnetized needle and a steady hand. I, too, am infected with AI Psychosis. The vast majority of my code is AI generated.

Nevertheless, I find writing code to be a useful tool. I encourage others to do it. I struggle to pay attention when I’m just a reverse centaur. When I read and approve code, I observe I don’t have the same sense of ownership. Slop flies under the radar. It’s harder to micro-adjust. And in the long run slop hurts agents too. The fragility accumulates precisely because we’re not paying attention to the details. On the other hand, when the human does some work, spikes an approach, and then the agent stamps out the patterns I participate and own the result.

Writing code helps me think.

English is an under-specified language. It’s not a precise way to express computation. For truly algorithmic work, I want to sketch and think in executable steps. I want a calibrated degree of precision. Sometimes a low-level language with a huge design space. Sometimes a high-level language with a more limited computation environment.

Instead, we’re switching to this wrong-headed mindset that coding agents are like compilers. That mindset gives us permission to ship terribly written code. Agents aren’t compilers - they’re more like freshly onboarded interns. They read partial possibly slopified code, take an imprecise description of the change, and must generate a change.

Humans can’t surrender their thinking and taste to armies of interns. And being hands-on, rather than consumers, helps.

For example, have you ever seen an agent follow the boy scout rule? Where they leave code better than they found it? And would you WANT them to try to do this?

Agents bias to making the current change as safely as possible. I had a situation in a previous codebase where one morning, pre-caffeinated, my meat brain mentioned using browser local storage. So some random state was managed in local storage. Everything else through a backend database. When I looked at the code, the amount of wrapping and indirection to preserve this idiotic human mistake probably tripled the LoC. Agents can amplify our one-off bad decisions by being so conservative.

Going through and joyfully deleting code and exploring helped me arrive at a better architecture than just trying to proxy this through English. My thinking, my authorship, my ability to guide the factor was massively amplified by caring about the code.

If we’re building a software factory, details matter. The details that establish architectural patterns. Down to algorithms and performance. Agents push us to evaluate, measure, and guard. They’ve made it cool to add CI into side projects early, not as an afterthought.

That’s massive improvement to the state of software.

But any assembly line has its weak spots.

Occasionally at the car factory, we need to take apart the assembly line. Or dig into the details of internal combustion engines to make a 10% improvement. Or spend an entire day observing brake pad testing to figure out why some issue in the field isn’t detected early.

We need to do that not while keeping the entire picture of the factory in our heads. We connect the minute details to the big picture. Drawing arbitrary boundaries about what you can touch in software gets in the way of that endeavor.