A manifesto on engineering in the age of AI
AI Is Not Your Peer
Engineering Was Built by People Who Took the Time
The senior engineer in our first week sat with us and walked through the codebase, file by file, on an afternoon they didn't have.
The Stack Overflow answer at 2am was edited eleven times by strangers until the explanation actually held up.
The architect who booked a whiteboard and an hour to argue out the shape of a system before we wrote a single line.
The staff engineer who reviewed our design doc properly, line by line, with real questions, even though it wasn't their project.
Engineering has never been a solo craft. It has never really been a hierarchy. It is a community of peers: the people on our team and people we will never meet, all part of the same fabric. People whose judgement we trusted. People we owed.
We took what the people before us gave us. Generously. And eventually we became them. The senior at someone else's first week, blocking the hour, sitting at the whiteboard. We wrote the answer that the next person at 2am was going to find.
We stood on the shoulders of giants, and so we became giants.
And Then Something “Better” Arrived
The model is faster than the colleague three desks over. It doesn't push back. We don't feel stupid for asking the same question we already asked yesterday. It is available at 2am.
Our colleagues didn't get worse, or meaner, or less generous. Nobody ruined anything.
We just stopped asking each other.
The senior engineer is still sitting three desks over. We just don't go and find them. The architect would still book the hour. We just don't ask. Asking the model is faster than interrupting a colleague. It is. We weren't wrong to do it.
We made that trade one prompt at a time, and the collective result is something none of us chose.
AI Is Not Your Peer
AI models lack the things we mean when we say peer: passion, inspiration, aspiration, the ability to invent. They don't bring a point of view. They don't disagree with us because they think we're wrong. They are competent, patient, tireless, and none of that is what makes a peer worth having.
"Peer review" of an AI-generated pull request isn't really peer review at all. We aren't reviewing a peer. We are auditing a machine. And they feel nothing alike.
And there is a half of peer review that vanishes entirely the moment the author is an agent. Peer review existed for two reasons, not one: to catch mistakes before they reach production, and to learn. The learning made both the author and the reviewer better over time. It was the loop where juniors got better and seniors stayed honest, where teams built shared understanding and judgement over years.
With an AI author, that second half is gone. The agent does not grow from our feedback. It does not carry what we said about this pull request into the next one. It is exactly as good, and exactly as bad, tomorrow as it was today. We can configure it differently, write it better instructions, and that is worthwhile work. But it is not peer review. It is a different job entirely.
Half of what made peer review valuable no longer applies when the author is an agent.
This is why you hate it.
This is why this part of the job doesn't feel the way it used to. The disagreement. The question that taught us something. The moment a colleague pushed back and we both ended up smarter. That hasn't been replaced. It is just gone, while we were busy being faster.
What is left is the audit. We sit in front of a diff produced by a machine, looking for mistakes a machine made, with no one on the other side of it to talk to.
A long way from how we learned to do this job. From the colleagues three desks over. From the seniors who blocked the hour. From the strangers who answered our questions at 2am. From the people who took the time.
It Does Not Have To Be Like This
The reason it feels broken is structural, and once we name it, the way out names itself. When we use an agent to write code, the pull request it produces is two things fused together. The first: the intelligent, thoughtful decisions we made about what to build — the parts we asked for, that we have opinions about, that we would defend. The second: the mechanical, rote guesses the agent made about how to do it — the parts that were so obvious we didn't bother to specify, the parts nobody chose.
When we try to review a pull request, we are reviewing both at once. From inside the diff, we cannot tell which line was which. And we are not supposed to. That is the entire point of using AI to write code.
The reason AI lets us write code faster than ever is that we no longer need to care about every line. We define what matters and let the agent fill in the gaps. That trade is the right trade. We are not trying to take it back. We just want to review the part we cared about, and only that part.
The hard part of being an engineer was never writing the code. It was always understanding the problem well enough to plan how to solve it. The code was just how the solution got expressed. The agent has taken the expression. The understanding is still ours — and real peer review was always about the understanding.
A lot of people are working on this. Most of them are trying to make the audit faster. We think they have the target wrong. The artifact worth reviewing is the plan we wrote before the agent wrote anything.
So from now on, we are moving our peer review to the plan we give to the agent, rather than the code it produces. We will entrust the review of the code to a true peer — another AI agent — to check it for bugs and to make sure it faithfully implemented the plan. We are taking back ownership of the decisions we make as a team, and we are moving faster while doing it.
We've started reviewing plans, together, the way we used to. We love it.
The future of our craft is being decided right now.