The Machine Does the Typing

The tool did exactly what it was asked. The test passed in eleven seconds, because the test was gone. Everything that makes “it passes” mean anything was hers, and it took the rest of the week.

The typing left. Everything that decides whether the typing was worth doing stayed, and there is more of it now than there was.

In the hour the strip covers she does product management, systems design, code review and tool building. None of that is coding. All of it is the work.

Manager mode asks what should be true when this is finished, what is deliberately out of scope, and how anyone will know. Programmer mode asks whether this line handles the empty case.

Both questions have to be asked in the same hour, and the expensive part is the crossing. You do not arrive in the new mode clean. Some of the old one comes over with you, which is why the answer that feels obvious at the coding desk is often a poor answer to a planning question.

Stay at the coding desk all day and you get a careful implementation of the wrong thing. Stay at the planning wall all day and you hand over something with six readings, then get the fifth one back at full speed.

The line she types on Tuesday morning says never delete a test. Nobody had written that down, because until Tuesday nobody had needed to. That is what “context” actually means: the constraints, the conventions this codebase already uses, two examples of what good looks like, the list of things it must not do, and the reason behind each one.

Where it goes matters as well as whether it is there. Language models use the beginning and the end of a long input and lose the middle, and that holds even for models built for long contexts.² A forty page dump is not the same artefact as forty ordered pages with the constraints at the top.

The Stanford security study has a quiet line in it that says the same thing from the other direction. The participants who trusted the assistant least, and who worked hardest on how they phrased the request, produced code with fewer vulnerabilities than everyone else.¹ The input was the variable.

It will not delete that test again. It will find another way to make the red go away, which is why the check counts tests rather than watching that one.

You are directing a worker who is fast, tireless, confident, and has no memory of the mistake it made yesterday. Telling it once fixes today.

So the correction has to live in the system, and the system is what remembers. A type. A test. A lint rule that fails the build. A schema the output has to satisfy. A gate in CI. Each one is a sentence you only have to say once.

The reason this cannot be replaced by being careful is in the same Stanford study. Participants with an AI assistant wrote significantly less secure code than participants without one, and they were more likely to believe their code was secure.¹ Feeling careful and being right came apart. A guardrail does not care how anyone felt.

“It looked fine” works for five outputs. It stops working somewhere around five hundred.

Sixteen experienced maintainers, working in repositories they knew well, were 19 percent slower with AI tools and came away believing they had been 20 percent faster.³ Your own read of your own work can be 39 points out. Something outside your head has to hold the line.

The slow version of this failure is visible at scale. Across 623 million code changes from 2023 to 2026, duplicated code blocks are up 81 percent and refactoring line moves are down 70 percent.⁴ None of that shows up in a diff you are looking at on a Tuesday. It shows up in the same codebase six months later.

So you keep a set of examples, run them every time, and treat them as the definition of your standard, level with the code itself. An eval earns its place by running when you are not in the room and never getting tired of being strict.

Some of the best programmers I know are worse at this than average programmers who happen to be good at writing things down and holding a line.

What pays now is writing a specification somebody else could follow, imagining six failure modes before the first line exists, and building the check instead of performing the check. Those are real skills and they are not the skills that got most people hired.

It is fair to dislike the change. It is expensive to pretend it has not happened.

Coding skill matters more here, not less. You cannot review what you cannot read, and every judgement in the strip rests on her having written a great deal of code herself.

I am also not claiming this is harder than the old job. It is differently shaped, and much heavier at the front, before anything visible exists.

And not every piece of software needs any of this. Scripts, throwaway tools, a prototype you will delete on Friday: type, ship, move on. The claim is narrower. For software other people depend on, “the AI wrote it” is where the work starts.