The Cognitive Cost of Modern Software Engineering
AI took the typing, and the cost of software engineering did not go away. It moved from the hands to the head and got heavier. The new scarce resource is your attention, and the new discipline is managing it.
The Cognitive Cost of Modern Software Engineering
AI took the typing, and the cost of building software did not go away. It moved, from the hands to the head, and on the way it got heavier. The work is more productive than it has ever been and more tiring than it has ever been, and I think those are the same fact. The pitch only mentions the productive one.
The story I keep hearing about AI and software engineering is a story about speed. The code writes itself. A month of work becomes an afternoon. That story is true, I have lived it, and it is the most misleading version of what happened because it implies the work got easier. The work got more concentrated, and concentration has a price I pay with my mind, all day, without the breaks the old work used to give me for free.
Naming that price is the first step to managing it. The companion to this is Agent Mode Changes the Shape of Thought, which is about the opportunity. This one is about what the opportunity costs me.
The bottleneck moved, and so did the cost
I have said elsewhere, in how AI is changing software engineering, that the headline is short. AI did not replace engineers, it moved the bottleneck. The cost of writing code dropped to near zero, and the cost of deciding what to build, how to architect it, and when to ship became the whole job.
Follow that one step further than the productivity articles do. If the bottleneck moved, the cost moved with it. The weight relocated. It used to sit in my hands and my hours, in the sheer volume of typing and stitching and translating that a week of building required. Now it sits in my head, in the unbroken sequence of decisions that is all that remains when the typing is gone. And the head is a more expensive place to spend than the hands, because the hands can work while the mind rests, and now the mind is the only thing working.
That stayed abstract for me until I felt the specific ways the cost shows up.
Typing was a kind of rest
I did not understand this until it was gone. The mechanical part of programming, the part that AI took, was never the hard part, and the engineers I worked with knew that. What I did not expect is that it was also a kind of rest.
For most of my career a real share of a working week was typing. Boilerplate. Translating a clear idea into a verbose language. Wiring API responses together. Writing the tests that exercise the mechanical paths through code I had just written. Updating the documentation after the refactor. None of that was where the engineering lived. But it was where the day had its valleys. After I made the hard decision I got to spend an hour or two executing it, and the executing was a place the mind could idle. Real work and recovery at the same time. The hands moved and the deeper part of me got to coast.
Take that away and the valleys disappear. The day becomes a ridgeline. Decision after decision, with no flat stretch in between, because the flat stretches were exactly the parts the agent now does in seconds. I describe what I want, and before I have finished my coffee the change is back and it needs a judgment from me. There is no longer an hour of mechanical typing to hide inside while my mind catches its breath. The breath-catching has to be scheduled now, deliberately, because the work will not hand it to me the way it used to.
I do not miss the typing, and this is no nostalgia for boilerplate. What I am pointing at is an ergonomic fact the productivity framing erases. The old work had recovery built in. The new work does not, and if I do not put that recovery back on purpose I run myself down at a rate the old job could never have managed.
What is left is judgment, and judgment is expensive
When the typing goes, what remains is louder, and all of it is the costly kind of work.
I read more code now than I ever have, and most of it I did not write. Reading code was once a small slice of the job. It is most of mine now. I absorb an unfamiliar stretch the agent just produced and decide whether it is correct, whether the error handling is right, whether it interacts cleanly with the rest of the system, whether it quietly made an architectural choice while I was looking away. Reading is more tiring than writing. Writing my own code carries me forward on my own intent. Reading someone else's, even a machine's, means reconstructing an intent from the outside and checking it against what I actually wanted, at speed, all day.
Deciding what to build is now the front of the work instead of the preface to it. A model will build the wrong thing beautifully and fast, and the cost of a wrong decision used to be amortized across the weeks it took to implement. Now the wrong thing arrives in an afternoon, fully formed, and I either live with it or back it out. The pressure on the quality of the specification, on knowing what I actually want before the machine commits me to a polished version of a guess, is constant.
And there is a decision that barely existed before and is now one of the most draining, which is knowing when to stop the agent. Agents do not get tired and they do not stop. They will refactor what did not need refactoring and scaffold for problems I do not have. They keep going, confidently, past the point where they should have asked. The discipline to interrupt and redirect is the new craft, and the lack of restraint is the most expensive new way to fail. The temptation to do more, faster, simply because I can, is always right there, and saying no to it dozens of times a day is its own kind of fatigue.
None of these are the parts of engineering that let the mind coast. The job got distilled down to its hardest fraction, and I do that fraction continuously.
The new failure mode is overload, not slowness
For my whole career the limiting factor was throughput. I could only produce so much in a day, and the way to fail was to be too slow, the project that took too long, the backlog that grew faster than I could burn it down.
That failure mode is mostly gone, and a stranger one took its place. When a two-week project ships in two days the obvious move is to run ten of them at once across the same calendar, because I can, and I have done exactly this. What came back was ten times the judgment to supply, ten streams to keep coherent, ten contexts to hold and switch between, ten places where a confident mistake can slip through because my attention was on stream seven when stream three went wrong, and none of it was leisure.
The bottleneck is how much I can hold without losing the thread. That is a cognitive limit, and it is a real ceiling. Past a certain number of live streams the coherence starts to fray, I stop catching the thing heading the wrong direction, and the capability that let me take on ten projects becomes the reason all ten degrade at once. The new way to fail is to take on more than one mind can keep clear, at exactly the speed that makes it easy to do without noticing.
The intensity is real, and it has a body
The cost is not abstract. I lived its sharpest version in a stretch I wrote about as six weeks living at machine speed.
In those weeks time stopped behaving normally. I wrote in my journal that a single month felt like a year. The line between my own thinking and the machine's processing mostly stopped existing. I was meeting more frameworks and systems in a week than I used to read about in a year, all of it at once, none of it letting up. My computer ran hot from the load, and that heat was a fair picture of what was happening inside my head. I wrote that working with a partner all day, whether human or not, is tiring. The tiredness came with a charge to it. We were building about as fast as I could think, and thinking that fast for that long has a cost the body eventually presents.
Then there is rest. When I can make an idea real about as fast as I have it, sleep starts to feel like an interruption. I have the timestamps. Thursday 2am commits, Friday 4am pushes, weekend marathons, and nothing forced me, I could not put it down. That is the seductive shape of this work. It exhausts you with your full enthusiastic cooperation, because the loop between idea and result got so tight and so rewarding that stepping out of it feels like loss. The old job protected me a little by being slow. This one removes the protection and replaces it with a thrill, and a thrill is not a substitute for sleep however convincing it is at 3am.
The scarce resource is now you
Put all of it together and the conclusion is uncomfortable. The scarce resource in modern software engineering used to be compute, or the supply of people who could type the code. Now it is my own attention, the amount of context I can hold at once before it goes blurry.
Picture it as a loom. The parallel threads of work you run at once are exactly that, threads, and a thread on its own is just a loose strand. Attention is the frame that holds the threads in tension and turns them into a fabric instead of a tangle. The weave is only ever as good as the loom, and a loom has a width. Run more threads than it can hold and they slacken and cross, and the pattern you were making comes apart in your hands. The machine can spin thread faster than anyone ever has, and it cannot widen my loom. That part is fixed, and everything I make is woven on it.
The machine took over the part that scaled with hours and handed back the part that scales with how fresh my mind is. So my mind is now the constraint on everything, and I have to manage it on purpose.
This changes what it means to be good at this job. Production is cheap, so being good is mostly about protecting and directing the one input that is scarce. The most productive thing I can do on a given day is often to leave the next stream closed and keep my head clear enough that the streams I already have get real judgment instead of a tired approximation of it. I would have found that sentence ridiculous a few years ago, when the obvious path to more output was more hours. Now the path runs through a rested mind, and a mind is finite in a way the old bottleneck never made me confront.
How you pay it down
So the discipline this era demands is the management of my own cognition as the scarce resource it has become, and most of it is unglamorous.
The first move is legibility. What overwhelms me is the system being illegible, too tangled to hold in my head, so that every decision costs more than it should because I have to reconstruct the whole shape before I can reason about a part of it. Size has less to do with it. The defense is to keep the system understandable on purpose, to spend real effort making the complex thing simple enough to reason about, which is the larger idea underneath everything I build, the practice of making a complex system legible enough to live inside. A legible system is cheap to think about. The illegible one taxes every move I make, and the tax compounds.
The second move is restraint, which I already called the new craft. Not every project that can be run should be run, and not every refactor the agent offers should be taken. The capacity to do more is not a reason to do more. The engineers who burn out fastest in this era will be the ones who could keep up and did not know where to stop. Saying no to my own capability is now part of the job.
The third move is to treat rest as part of the work. The old job built recovery into the day and I could afford to be careless about it. This one does not, so I put it back deliberately and defend it against the thrill that says the loop is too good to leave. Sleep is the maintenance of the only instrument the work now depends on. I came to this the hard way, and it is the same antifragile instinct I try to apply everywhere, that a little structure and a little protection on the downside is what lets a system, or a person, gain from intensity instead of being broken by it.
The last move is to know my own limit, the number of live streams past which coherence frays, and to stop short of it on purpose. That number is real and it is lower than my ambition wants it to be. Respecting it is the difference between using this capability for a long time and using it brilliantly for a while and then crashing.
There is a practical version of all of this that I had to learn by hand. I protect blocks of single-threaded attention, one stream, the loom holding a single clean pattern instead of a dozen fraying ones. The instinct of the era is to parallelize everything, because we can, and some of the most valuable work I do now is the refusal to, the hour given over to one hard problem with my whole head. The machine made breadth cheap and depth stayed expensive, and depth is still where the hard decisions get made well.
The work got more human, not less
There is a fear that AI hollows out engineering and turns it into prompting. My experience is close to the opposite, and the cost is the proof. The machine took the typing and the translation, the mechanical parts that were never really me. What it left behind is the parts that are nothing but me. The taste to know what is worth building, the judgment to know when something that looks right is wrong, the clarity to hold a complex thing in my head, the restraint to stop. Those parts are expensive because they are human, they cannot be delegated, and there is nowhere left to hide from them inside an afternoon of comfortable typing.
That is why the work is more tiring even as it is more productive. I am spending the whole day in the part of myself that costs the most to spend. The bargain is good, and it is a bargain, and pretending it is free is how people get hurt by it. Name the cost and protect the mind and I think I can do this for a long time and love it. Ignore it because the productivity numbers are intoxicating and the resource the whole thing depends on, which is me, runs out quietly, at the exact moment I am most convinced I am invincible.
If you want the method I run inside all of this, it is the book-length version in AgentSpek, free here, and the rest of how I build this way lives at AI-Assisted Development. The day-to-day shape of the bargain, where the hours actually go from the senior seat, is in How I Use AI as a Senior Engineer. The most important tool is outside all of them, the discipline of guarding the one resource that does not scale, which no machine is going to take off my hands the way it took the typing.
Related reading: Germane Friction and AgentSpek, chapter 14: The Weight of Creation.