If the keyboard work is increasingly done by agents, seniority can no longer mean "writes a lot of good code fast." It means something older and harder to automate: knowing what to build and what good looks like.
TL;DR
- Raw coding speed matters less when agents handle much of the implementation.
- Judgment, architecture, and taste become the differentiators.
- Verification and review become core senior skills.
- The role is more about deciding and directing than typing.
What stopped being the differentiator
For a long time, senior meant: writes more code, writes it faster, knows more APIs, debugs quicker. Agents erode each of those edges — they generate fast, recall every API, and produce volume. If your seniority was built on typing throughput, that ground is shifting under you.
What remains is the part agents do not do well: knowing what to build, why, and whether the result is actually good.
What seniority becomes
Judgment
The defining senior skill. Which problems are worth solving? Which trade-offs are acceptable? When is the agent's confident output actually wrong? Judgment is the accumulated, hard-won sense of what matters — and it is exactly what a model, however capable, does not have about your business and your users.
Architecture
Agents implement within a design; they rarely originate a good one. Deciding how systems fit together, where the boundaries go, and how to keep a codebase coherent as agents pour code into it — that is more valuable, not less. Someone has to ensure the whole still makes sense.
Taste
The hardest to name and the most senior of all: the sense of what good looks like. Clean over clever. Simple over flexible-for-no-reason. The instinct that something is off before you can fully articulate why. Agents produce plausible; taste is what distinguishes plausible from right.
Verification
As covered in the verification tax and reviewing agent code, the ability to rigorously check correctness is now core senior work — often the highest-leverage thing you do all day.
The senior engineer's output was never really the code. It was the decisions the code embodied. Agents make that truer, not less true.
What this means for growing engineers
A real tension: if agents do the entry-level implementation, how do juniors build the experience that becomes judgment? Teams have to be intentional — give people real problems, real review responsibility, and real exposure to consequences, rather than letting agents absorb the work that used to teach. Judgment is earned through reps; someone has to ensure the reps still happen.
The takeaway
The role did not shrink — it moved up the stack. Less time on the mechanical act of producing code, more on deciding what is worth producing, designing how it fits, judging whether it is good, and verifying that it works. Those were always the senior parts of the job. The agent era just stripped away enough of the busywork to make it obvious.