Reading code

Senior engineers are readers now

Agents made typing cheap, so most of the senior job is now reading code and judging it, and a promotion process that counts output is about to reward the wrong people.

Matt Kindy · · 6 min read

Typing is the cheapest thing in software right now. An agent will turn a ticket into a six-hundred-line pull request in less time than it took to write the ticket, and the tests it writes will pass.

That should worry anyone on a promotion committee, because a promotion packet is mostly a list of things that exist because of the candidate: features shipped, projects led, services with their name on the README. That was always a rough way to judge an engineer, but it mostly worked. You couldn’t produce that much code without understanding most of it along the way, so the code was evidence that the understanding was there.

Agents took that evidence away. With three agents and loose standards, someone can put together a packet that reads like a staff promotion in a couple of quarters, and nothing in the packet tells you whether they understand any of it.

The job that’s left

When agents do the typing, the senior job is the work around it. Most of that work is reading a diff you didn’t write and working out what it does when it runs. Some of it is judging whether the problem a change solves should be solved at all. That can mean saying no to a pull request that puts a cache in front of a service whose data model is wrong, and writing down the reason so nobody opens the same pull request in six months. It also includes deleting code, and being the person on call who can look at a graph in the middle of an incident, open the handler and say what the system is doing.

Almost all of that is reading. The senior engineers I’d promote read far more code than they write, and more of what they read was written by an agent that won’t be around to explain it.

Even so, your best people shouldn’t spend all day in the review queue. In an earlier post I argued that babysitting AI output line by line is a waste of senior engineers, and that their time is better spent turning what they know into checks that catch the problem for everyone. I still think that, and a reader who notices the same mistake twice and writes the lint rule is using judgment too.

Very little of this work shows up in a packet built around output. A migration you talked a team out of has no launch date, and the review where you caught a double charge before it shipped is a comment thread three replies long.

Who gets promoted when output is cheap

Consider two engineers at the end of a quarter.

One merged 140 pull requests across four services, most of them written by agents, and has a long packet with lots of links.

The other merged 12 and spent the rest of the quarter reviewing other people’s changes. Along the way they killed two migrations that would’ve lost data, ran the incident review for the billing outage, and rewrote the runbook so the next person on call wouldn’t need them.

Two promotion packets at the end of a quarter. Engineer A has a long packet with lots of links: 140 pull requests merged, most written by agents, across four services. Engineer B has a short packet: 12 pull requests merged, reviewed other people's changes, killed two migrations that would've lost data, ran the billing outage's incident review, and rewrote the runbook. Engineer A Long packet, lots of links 140 pull requests merged, most written by agents, across four services Engineer B Short packet 12 pull requests merged Reviewed other people's changes Killed two migrations that would've lost data Ran the billing outage's incident review Rewrote the runbook
Two packets at the end of a quarter, one much easier to evaluate than the other.

I’d expect most companies to promote the first engineer. Their packet is easy to evaluate, the second one is easy to undersell, and the second engineer is probably too busy to write theirs up well.

The gap between what a packet shows and what an engineer did was always there, and agents have widened it. Merging 140 changes used to mean somebody had read 140 changes, slowly, while writing them. Now it can mean somebody clicked Approve 140 times. A company that keeps promoting on that count will get more of it, along with senior engineers whose main skill is producing pull requests faster than anyone can review them.

Promote for judgment, and go find the evidence

Judgment’s harder to see than output, so you have to go looking. A few places I’d start:

  • The reviews. Ask for the five reviews they’re proudest of and what they caught in each one. Then go ask the authors.
  • The things they stopped. A “no” with a written reason is some of the most valuable work an engineer does. Count it like a launch.
  • Production. Have them walk you through the last incident they handled: what the system was doing, how they found out, what the code does on that path. Ask them to explain a service they own from the code and the dashboards, without using AI.
  • Deletions. Code that doesn’t exist anymore, and systems that got simpler.

Promotion processes have undercounted this kind of work for a long time. In her 2019 talk Being Glue, Tanya Reilly describes an engineer who onboards new people, gets two teams to agree on a design and unblocks a teammate so his project ships on time. When she goes up for promotion, she’s told she isn’t producing much code. With agents, I think work like hers, along with review and on-call, has become most of what a promotion process should look at, because once output is cheap, judgment is most of what distinguishes a senior engineer.

Juniors learn by reading too

That leaves the question of how juniors get good enough to be the reader, if agents do the typing they used to learn from. I think they learn mostly by reading.

Anthropic published a small study in January 2026 in which a group of mostly junior engineers learned an unfamiliar Python library, some with an AI assistant and some by hand. On a quiz right afterwards the AI group scored noticeably lower, averaging 50 percent against 67 for the hand-coding group, and the biggest gap was on debugging questions. The authors are careful to say the sample was small and the quiz came straight after the task. Still, among the AI users, the handful who only asked the assistant conceptual questions did well, and the handful who handed it the whole job scored poorly.

Most people who have mentored a junior engineer would agree that you learn a system by being made to explain it, so I’d make juniors explain things. Put them on the review rotation early, have them walk through an agent’s pull request out loud before anyone approves it, and put them on call next to someone senior. Keeping juniors away from review until they’re “ready” takes away the practice that gets them ready.

Stop counting what got cheap

A promotion system tells people what a company values more clearly than any values page does. If it rewards volume, people will produce volume, and agents make volume nearly free.

I’d promote the people who can tell you what the code does, who say no when it matters, and who you’d want on call when something breaks. They’re the ones doing the senior job now, and a promotion process that counts output will keep passing them over for whoever ran the most agents.

Get the next essay

Follow the RSS feed to see each new essay when it goes up.