84% of developers use AI tools. 29% trust them. The gap between those two numbers turned into a job description.
It is 4 p.m. on a Tuesday. The pull request queue says fourteen open. You have been reviewing for two hours. The diff in front of you looks fine. The last one looked fine too. The one before that, also fine. Somewhere in your head a small voice asks whether your standard for “fine” has been quietly drifting down all afternoon, and you tell the voice to be quiet because there are still nine PRs to go and one of them is from the new hire who cannot be left waiting any longer.
The trick AI played on senior engineers was subtle. It did not replace them. It amplified them, and the amplification is what hurts. The juniors got faster. Whole features land in a morning. The seniors got tired. Same week, same codebase, two different paradoxes pointed at the same role.
The diff that always looks fine
There is a specific kind of bad pull request that only shows up after AI tooling lands on a team. It compiles. It passes lint. It picks reasonable variable names. It even has a sensible commit message. And somewhere in the middle of it, in line 47 of file three, Cursor’s autocomplete decided that the way to handle a missing record was to silently return an empty object, because in the training data that is what most code does. Your codebase, however, has spent three years building a contract that says you throw on missing records loudly enough to break a CI pipeline. Nobody told Cursor. Nobody could have, because nobody wrote it down.
The diff looks fine. The diff is not fine. Welcome to the new review modality.
Stack Overflow’s 2025 Developer Survey put real numbers on this feeling. AI usage among developers sits at 84%. Trust in the accuracy of what the AI produces sits at 29%. That gap of 55 points is not a contradiction. It is the description of your inbox. The AI writes; somebody human signs the form; in 2026 the somebody is almost always senior. The same survey found that 45% of developers say their single biggest frustration with AI coding tools is “code that is almost right, but not quite.” That frustration has a job title now, and the job title is yours.
Your sense of speed is broken
This part is unkind. You probably feel faster than you used to. You might also be slower.
METR ran a randomized controlled trial on sixteen experienced open-source developers working in their own repos with Cursor Pro and frontier Claude models. Going in, they expected AI tools to make them 24% faster. Coming out, they reported feeling 20% faster. Measured, they were 19% slower. The gap between perception and reality was 39 points wide, and the developers who fell into it were not interns. They were the kind of people who maintain the projects you depend on every day.
The time did not vanish. It moved. The hours that used to go to typing now go to prompting, waiting, reading output, deciding whether the output is correct, deciding whether it is safe, deciding whether it matches an architectural decision the codebase made in 2022 that nobody documented, fixing the parts that miss, and prompting again. The bottleneck used to be your fingers. The bottleneck is now your attention. Your fingers are well-rested and your attention is fried, which is why the diff in front of you at 4 p.m. on a Tuesday looks “fine.”
The shape of your day
Imagine a small team. Six engineers, two of them senior. Adoption of AI coding tools is high. Pull request volume nearly doubles. Pull request size grows by half. Pull request review time, according to a Faros AI study summarized in CIO, goes up 91%. Notice where the work landed.
The two seniors did not get more output. They got a queue. The juniors did not slow down. They sped up, because AI is genuinely good at the parts juniors used to ask for help on, so the juniors-to-seniors hand-off rate quietly climbed. The seniors now spend most of their day in a feed of AI-generated diffs that look fine but cannot be trusted, while the work that actually requires senior judgment — the design decision, the migration plan, the difficult conversation with the platform team — gets pushed to evenings and the long weekend before vacation.
Harvard Business Review put a name on the feeling: AI brain fry. The research describes the kind of mental fatigue specific to high-volume AI oversight, and the specific words people use when asked what it feels like are fog and buzzing. You probably know both already.
When the junior pastes the rebuttal
Here is a paradox the surveys do not capture, because it shows up in Slack and not in pull requests.
Picture a senior engineer responding to a design doc from a junior. The objection is good: the design conflates two abstraction layers, takes ownership of state it does not need to own, and adds a queue to solve a problem that a single mutex would solve in five lines. Two years ago that comment ends the thread. The junior reads it, the design changes, everyone moves on by lunch.
In 2026 the junior pastes the objection into Claude, gets a four-paragraph counter-argument back, and posts it. The “Certainly! Here are three considerations to weigh against the proposed alternative” artifact at the top is still visible. The senior reads it and decides not to point it out. The thread starts to grow. They have been here before. Instead of typing another paragraph, they paste five lines:
cache.mu.Lock()
defer cache.mu.Unlock()
if cache.IsStale() {
cache.Refresh()
}
The thread dies. The next morning the junior DMs to say they had not realized the queue was a layering choice and not a performance one, and asks if they can pair on the next iteration. That is what senior leverage looks like in 2026. Not more prose. The right artifact in the right medium.
A bad idea used to lose because nobody could articulate the alternative. Now bad ideas come pre-articulated. The Pragmatic Engineer noticed this dynamic in early 2026. Saying a clear no still works. It just costs more, and the cost is paid in afternoons unless you can change the medium of the argument.
The 2 a.m. version of all this
The harder version of the same paradox is the on-call rotation. At 2 a.m. on a Sunday the page comes in. You scroll back through the deploy log. The commit that broke production has a message that reads, in full, “refactor for clarity.” The diff is two hundred lines long. There is no human author on the PR. There is no linked ticket. The agent that wrote it is asleep in a way that means it does not exist, and there is nobody to ping. You are the only person on this call, and you have ninety seconds to decide whether the rollback is safe. This is the part of 2026 that does not show up in productivity studies, and it is the part that decides whether senior engineers stay senior.
What the senior-engineer job actually is now
Three things shift if you actually want to push back on this.
Tests become the spec, not the safety net. When an agent writes the code, the only artifact that survives every refactor and every model upgrade is the test suite. The seniors who used to roll their eyes at TDD are quietly picking it back up, because tests are the cheapest way to tell a model what your codebase actually wants. A failing test is the fastest possible code review. It does not need a Slack thread. It does not get into a four-paragraph counter-argument with you.
Type signatures are the new prompt. Pydantic V2 was not rewritten in Rust for aesthetic reasons. TypeScript did not eat the JavaScript world for fun. The static-by-default new languages exist because a type signature is the cheapest and most reliable way to bound what an agent can produce. Types compile in milliseconds. Reviewers do not.
Architectural docs become executable context. The CLAUDE.md, the AGENTS.md, the README that explains *why* the codebase does the strange thing all used to be optional. They are not optional anymore. The senior engineer who finally writes down “we never block inside this handler, and here is why” reduces subtly wrong PRs for the rest of the year, by their own team and by every agent that reads the doc. That paragraph you keep meaning to write is doing more work than your last six code reviews combined.
Tuesday at 4 p.m., revisited
Your queue still has fourteen PRs. AI tools are not going away. Adoption is going to keep climbing while trust keeps stalling, because that is the deal: the AI writes, somebody human signs, the somebody is you. The job is not to type more code. The job is not even to review more code. The job is to keep saying a clear no, longer, with the leverage that tests, types, and a few good docs give you.
A few things to walk into Wednesday with:
- The 39-point perception gap is real; your gut is not a reliable productivity meter.
- “Almost right” is the dominant failure mode; tests, types, and one good architecture doc are the cheapest defenses.
- Review time on high-adoption teams went up 91%; protect the review queue like a production resource.
- Bad ideas now arrive with citations; the senior-engineer job is to keep articulating the right answer longer, not faster.
- AI brain fry is real; step away from the screen before approving something at 4 p.m. that you would have rejected at 10 a.m.
What to watch next: how teams formalize the new role. Anthropic’s code review tool, GitHub’s review-the-AI workflows, and the eval frameworks shipping monthly all point at the same place. The senior engineer is now on-call for AI mistakes, the migration-plan reviewer of last resort, the one who actually reads the autogenerated CHANGELOG before it ships.
That is the new job description, even if HR has not updated yours yet
