Agent Mode Changes the Shape of Thought

The speed story is the easy one to tell and the least interesting. What actually changes when I build software in agent mode is the unit I think in. The number of things I can hold at once goes up with it, and the hard part of the work moves somewhere it never used to live.

When people describe agent mode they almost always reach for speed. It writes the code faster and does in an afternoon what used to take a month of evenings. That is true, I have said it myself, and it is the shallow version because it measures a new thing with the old ruler.

The deeper change is harder to see because it happens inside my head and not on the screen. What I keep noticing is that I think differently. The unit I reason in moved up a level and the number of things I can hold in flight went up with it, and the part of the job that is actually hard relocated to a place it never used to live.

First, the plain definition

If you have not used it, here is the short version, and I wrote a longer one separately. Agent mode is when I stop typing code and start directing an AI that reads the codebase, makes the change across as many files as the task needs, runs the tests and reports back. I describe the outcome, it does the work and checks itself, and I review it, correct it and send it again.

The old loop was write, compile, test. This one is specify, generate, verify, specify. I say what I want clearly enough that an agent can act on it, it produces the change, and I confirm the result is right or catch that it is wrong, then correct course and go again.

The hours in that loop go into the first step and the third, being precise about what I want and checking that I got it, and everything that follows comes out of that.

The unit of thought moves up

For most of the history of programming the unit of thought was small. I held a function in my head, the line I was typing, the variable I was tracking, the bug three calls down the stack. Even with good autocomplete the unit did not really change, because autocomplete finishes the line I am already writing and I am still the one holding the whole task in my head, typing it out one suggestion at a time. The machine is a faster keyboard at the same altitude.

Agent mode moves the altitude. I am no longer working at the level of the keystroke, or even the function. I am working at the level of the task, and increasingly at the level of the system. I do not think "write a loop that does this." I think "this endpoint needs rate limiting and the tests need to cover the new failure case," and that sentence is the work. The agent reads the relevant files, writes the change, runs the suite, and comes back with a diff. I was never in the editor. I was holding the intent.

That shift sounds small and it is not. When the unit of thought is a function, the day is a thousand tiny acts of translation, turning what I want into the exact syntax that produces it. When the unit of thought is a task that translation layer mostly disappears, and what is left is the thinking it used to bury. I spend my attention deciding what should exist and whether what came back is correct. The idea becomes the bottleneck instead of the grammar, which is where it belongs.

I noticed this most clearly the first time I described an outcome instead of a procedure, a private bucket behind CloudFront with a password at the edge, which I walk through in What Is Agent Mode?. I described the end state and never touched the order of the arguments. Deciding the design and checking the result was all that was left of the job.

The bottleneck moves off your hands

The hype never mentions that working in agent mode is more of the engineering that matters and less of the typing that does not.

For years the limiting factor on what one person could build was production. There were only so many hours, and the hours went into making the thing. Agent mode takes the cost of making the thing and drives it toward zero. What is left was always the real job and was always crowded out by the typing, knowing what to build and knowing when something that looks right is actually wrong.

So the bottleneck moved from my hands, from how fast and how long I could produce, to two places upstream of any code. The first is the clarity of my intent. Vague intent produces a polished version of the wrong thing, fast, so being precise about what I want stopped being a preface to the work and became the work. The second is the rigor of the verification. AI-generated code can pass every test I wrote and still be wrong, because it can satisfy the letter of a specification while missing the thing I actually meant. So checking is half the job rather than a formality at the end, and it does not get easier as the production gets faster. If anything it gets harder, because there is more output arriving and less of it passed through my own hands on the way.

When I rebuilt this site in agent mode and moved it off shared hosting onto AWS, that is exactly where my attention went. Instead of writing the components or the deploy configuration I was deciding what the site should be, reading the diffs, catching the architectural choices that would cost me later, and saying yes or no. The thing that did not drop, that became more important than before, was judgment.

Scaling cognition, not output

What still surprises me is what happens with several agents at once.

With one agent I am a person directing a fast collaborator. With several I become something closer to a conductor. One agent is refactoring a module while another drafts a migration while a third checks a result, and I am holding more in flight than I could hold working alone, and the holding is the skill. The bottleneck moves off my hands entirely and onto keeping several streams coherent at once, knowing which one needs me now and feeling when one is confidently heading the wrong direction while the whole shape stays in my head and the pieces move.

I did not expect this, and it changed how I think as much as how I type. I am scaling my own cognition. The limit is how much clear intent I can hold at one time, not how fast my hands move or how many hours I have, and that can be trained in a way typing speed never really could.

The closest image I have is the Iron Man suit, which never replaced the man inside it and never made him type faster. Without the man the suit is an empty shell, and without the suit the man is just very smart in a cave. The pairing widened the radius of what one person can affect, and the radius is set by the clarity of the person at the center.

I dreamt of this for a long time before it arrived. Not the specifics, the feeling that the distance between having an idea and having the thing could collapse. It is here now, and it is more than I let myself expect. This is the most exciting time of my life to be making things, and the reason is what the tools do to the gap between a person and what that person can build.

The proof is the range

Here is the evidence, which is a range rather than a benchmark. Over the last year I shipped four open-source projects, each in a different domain. Pixel Vault, a library of small playable games. ChipForge, a music synthesis engine built from raw arrays of numbers. Napkin Films, an animation studio that runs from scripts. Velocidad, a language-learning system that is nothing but text files and prompts. Different fields and different skills, none of which I am formally trained in across the board, all built primarily in agent mode and all shipping things you can actually use today.

A few years ago that range would have been impossible for one person in a year. The individual pieces are within reach of a determined builder, but the cost of becoming fluent enough in four unfamiliar domains to produce finished work in each one was too high. The typing alone would have eaten the year. The agent did not know those domains for me. What collapsed the cost was the agent handling the translation in each one, the part where a clear intent turns into the specific incantation that a synthesizer or an animation pipeline or a spaced-repetition system wants. So my actual job in all four was the same job, deciding what should exist, setting the constraint and verifying the result.

That sameness is the tell. When the unit of thought is the keystroke, every new domain is a new language to learn before I can say anything in it. When the unit of thought is the intent the domains start to rhyme, because the thing I am doing, holding a clear specification and actually checking it, does not change when the subject does. The skill that scales is the discipline of clear intent rather than domain knowledge, and that discipline ports.

I do not think this means anyone can now do anything. Taste does not transfer for free, and a clear head in one domain is not automatically a clear head in another. But the friction that used to keep a single builder pinned to one specialty got much thinner, and what is left holding me is my own judgment, spread as wide as I can keep it coherent. The four projects, and the one philosophy underneath them, are written up together if you want the longer look.

Judgment becomes the whole job

The same thing that makes the suit powerful is exactly how you fly it into a mountain.

It does what I point it at, fast and confidently, and that is the danger. A vague intent gets a polished version of the wrong thing and a weak check lets a plausible mistake through at speed. The faster the system, the more my judgment is the only thing standing between me and a very efficient disaster. Power that does what I say is only as good as the clarity of what I say and the rigor of how I confirm what came back.

I learned this the direct way, the day an agent-written deploy script made the live site match a build that had failed halfway and deleted most of the images from production. The whole story, and the recovery, is in how I rebuilt this site in agent mode. The script was logical. The assumption underneath it, that a build is always complete, was the bug.

That is the loop working as intended. I trust it to do the work without trusting it to be right, and I keep a source of truth it cannot touch and the irreversible operations behind a gate. The agent did most of the typing for the original script, the recovery, and the hardening. The judgment about how it should fail was mine, and it had to be, because that is the kind of decision that does not survive being delegated.

What this asks of you

If the production stops being the constraint, the constraint becomes me, and not in a way I can fake.

I have to actually know what I want, and agent mode is brutal about this. When my intent is clear, the work pours out and most of it is right. When my intent is muddy, the work pours out just as fast and most of it is subtly wrong, and I have to throw it away and figure out what I was actually after, which I should have done first. The tool will not do that part. If the problem is still fuzzy in my own head no amount of delegation helps, because I cannot specify what I have not figured out. That part is still mine, and it is more exposed than it used to be because there is nowhere to hide it. I cannot disappear into an afternoon of typing and feel productive while I avoid the hard decision, because the typing is gone and the decision is all that is left.

So the discipline moved and concentrated instead of going away. I spend less effort making the thing and far more effort being sure I asked for the right thing and that the thing is correct. I think in failure modes now because the platform keeps teaching me to, assume the part will fail, name how, and build so that when it does I already know what happens next. I think in specifications, because a specification is just intent made precise enough to act on, and in verification, because speed without checking is just a faster way to be wrong. None of those are new ideas in engineering. What is new is that they are no longer the parts I get around to. They are the parts that are left.

There is a version of this that reads as loss, as if the craft got hollowed out, and I do not experience it that way at all. The craft was always the judgment, the taste, the decision about what is worth building and the eye for when something that looks right is wrong, never the typing. Agent mode removed everything around the craft and left me standing in front of the part that was always the point, with my whole attention free to spend there. This is the same instinct I bring to everything else I build, the discipline of making a complex system legible enough to live inside, whether the system is a cloud platform, a codebase, or a life.

Where it leaves you

The gap between having an idea and having the thing got small. A single builder with taste and a clear head can now reach a scale that used to require a team, and can keep the whole thing coherent because it is still one mind directing it. That is the part that feels new and a little vertiginous. The reach went up, and what sets the reach now is the clarity I can hold rather than my hands.

So the practical advice is almost philosophical. Get clear. Say what you want with enough precision that another intelligence can act on it without you hovering. Verify without flinching, especially when the output looks finished, and hold more than one thread without losing the shape of the whole. Those are the skills that scale now, and they are skills of thought.

If you want the method I run inside all of this, I wrote down an AI agent workflow that holds up, and the book-length version is AgentSpek, free to start reading here. If you want the feel of the work rather than the mechanics, it is not vibe coding. And the rest of how I build this way lives at AI-Assisted Development.

The suit is real and it fits. The strange, good catch is that it makes the human inside it matter more, because the one thing it cannot do, decide what is worth building and know when it is right, is suddenly the only thing left to do.