Everyone wants to know what the AI agent is. Is it a genie that grants wishes, three at a time, each one warping in a way you didn't foresee? Is it the thing that comes for your job in the night? The question feels enormous, and the enormousness is the problem, because it makes us reach for myth when what we actually need is a management handbook.
So let me offer a smaller, more useful picture. An AI agent is a junior developer.
Not a bad one. A brilliant one — the kind you're lucky to hire. It reads faster than you, it never gets bored, it has skimmed more documentation than any human could hold in a single skull, and it will produce a plausible first draft of almost anything before you've finished describing the problem. It is also green in the way only the very fast can be green: confidently wrong, occasionally, and wrong in a register that sounds exactly like right. It will hand you a function with the poise of a senior engineer and a bug buried three lines down that a senior engineer would never have made, because a senior engineer would have paused where the agent did not.
Anyone who has managed a talented new hire knows this animal precisely. You don't hand them the keys to production on day one. You don't reject their work either. You review it. You read what they wrote as if a stranger wrote it, because a stranger did, and you ask the questions the work can't answer for itself: Why this approach? What happens when the input is empty? Who owns this when it breaks at two in the morning?
This is why I think the defining skill of the next decade is not prompting. Prompting is how you assign the ticket, and assigning tickets was never the hard part of engineering. The hard part is judgment — knowing what good looks like well enough to catch the counterfeit. The person who can only generate is at the mercy of what gets generated. The person who can supervise — who can read a diff and feel the wrongness in it before they can name it — that person becomes more valuable as the generation gets cheaper, not less.
There's a quiet reversal hidden in here, and it's worth saying plainly. For years we told junior engineers that the way up was to type faster, ship more, learn the tools. The tools now type faster than all of us. What's left is the thing the tools can't do: take responsibility for the output. Stand behind it. Say I checked this, and it's right, and if it's wrong it's on me.
That is what a senior engineer has always been. Not the fastest hands in the room. The one whose signature on the review actually means something.
So the next time someone asks you whether the agent is going to replace us, you can give them the honest answer, which is also the reassuring one. It replaces the typing. It does not replace the person who reads the work and decides whether it's true. It just hired us, all of us, into the same job: senior, in the room, accountable.
The machine never sleeps. Good. Somebody still has to.