The Context Window

Merge Conflict: Managing AI Agents Is Eroding Your Skills

Why getting better at your job won’t save it, and why you should get better anyway.

Sairam Sundaresan

Engineering managers now manage people and the agents that write their code. Getting better at the EM job won’t stop a layoff, but the skills you build go with you. Handing work to agents wears those skills down in you and your team, so what do you do?

By the end, you’ll know how to:

  • See where the three core skills for an EM break down when agents do the work.

  • Keep your team’s skills sharp as agents take away more off your plate.

  • Make the case to your director for practice time, even though it costs speed.

James hadn’t moved in ten minutes: 6:00PM on the 405, brake lights all the way to the horizon. His phone lit up on the seat.

agent[bot]: Merged #4471 into main. +1,974 −212. All checks passed.

Two thousand lines of code touching the payment path, written by an AI agent while James ran his planning meeting. He skipped 1,800 lines of boilerplate and went straight to the parts that lie (the auth path, the edge cases no tests catch) and approved it in four minutes.

Under it, an hour old:

Remus: Well. They let me go this morning. Coffee sometime?

Remus had hired James 12 years ago and taught him half of what he knew. His last review said, “Exceeds.” They walked him out by noon anyway.

Most engineering managers I talk to are carrying some version of those two messages: An AI agent does the team’s work in minutes, and a layoff that takes the manager who taught them how to build it. Those messages raise a question that’s hanging over every one of those managers:

Why get better at a job that machines are absorbing and spreadsheets are deleting?

The answer isn’t, “Craft will save your job.” It won’t. Layoffs run on cost arithmetic and org geometry. Remus wasn’t cut for performance. He was cut because a VP needed a higher engineer-to-manager ratio, and a manager with four reports is the cheapest box on the chart to delete. The stated reason is just a seasonal costume. In 2022 the memos blamed interest rates and over-hiring and these days they blame AI1. The axe has never changed, and reading a layoff as a verdict on your worth is the wrong lesson learned.

There are two things you retain when you leave a job: craft and reputation (the people who will speak for you because they’ve seen you work). Your rank, your standing with that VP, the org context you spent years absorbing all remain in the building. The four minutes James spent checking 2,000 machine-written lines go where he goes, and the next job he gets will come mostly through people vouching for him2.

Craft won’t stop the push out the door. But it will act as a parachute: softening your landing when you do eventually lose your job. Craft will determine how fast the next team hires you, and how fast you can spring into action when you land. That’s why you should get better at a job that machines are taking over.

Which leaves one real problem. The skill James just used is exactly the one that managing AI agents quietly erodes. Use the agent more, check it less, and the eye that could once spot the bad merge starts losing acuity.

James dropped his phone into the cupholder. Ahead, three lanes of taillights bled into the windshield as he walked back through the five days behind him: forty hours of calendar bloat that looked like a running negotiation between machine velocity and human atrophy.


The minutes that are still the job

The agents on James’s team write the code, open the pull requests, and write the tests, which pass. James’s calendar is still full: standups, a vendor renewal, a reorg rumor. But meaningful work has been compressed into short windows of reading a confident piece of AI output and deciding whether it’s right. The volume of work has gone up, but the volume of judgment has shrunk to a handful of high-stakes reviews per day.

Those reviews are hard to perform. An agent is rarely wrong in an obvious way. When it’s wrong, it’s almost right. An obviously wrong answer gets stopped at the door. An almost-right one goes to production, and waits to bite you in a quarter. Stack Overflow’s 2025 developer survey of roughly 49,000 people found that the top complaint about AI, by 66%, was output that is “almost right, but not quite.” And 45% said debugging AI-written code takes more time, not less3.

Teams that adopt agents tend to ship more pull requests and spend more time reviewing them4. And the people doing the reviewing routinely believe they are faster when they are in fact slower5.

Every time you hand work to an agent, the one thing you shouldn’t hand off is the call: you need to look at the output and decide whether to build, ship, or kill. Tools can route a task to the right agent and rank how risky it is. But they can’t and shouldn’t make the call. You have to make it, and that requires three things.

Judgment: Can I trust this green checkmark that I can’t personally verify?

Empathy: What will my engineer or my agent do when I’m not looking?

Taste: This answer might be fine for most teams, but is it right for mine?

Judgment, Empathy, Taste: three different muscles, and each one fails in a different way when the thing you’re managing is an agent instead of a person.

For years, managing people and reading code were two tracks. When agents do the execution, a manager who only runs standups and reads dashboards matters less each year. So more of an EM’s value now comes from the technical side.


Judgment: The Verification Governor

A clean diff from the deploy agent arrives: every check green. James’s thumb moves toward “Approve” when something in the connection-pooling logic grabs his attention. He stops and scrolls back up.

The agent had capped the connection pool at a size that assumed average traffic. Under normal load this would be invisible. Under a flash sale, when 10,000 shoppers hit checkout in the same 60 seconds, the pool would exhaust, connections would queue, and the whole payment path would stall. James had run a service that died exactly this way on the morning of a merchant’s Black Friday 2019. The tests passed because no test simulated a flash sale, and they would keep passing right up to the crash.

A green check only tells you that the code does what the agent meant it to do. It doesn’t tell you whether it does the right thing. The same agent wrote both the code and the test, so of course they agree. Only someone who has watched a connection pool die under real load knows the agent’s assumption was wrong.

Feeling that the code is fine could just be a byproduct of nothing having gone wrong so far: every eventless week you experience raises your trust that the next week will be clean too, whether the agent deserves it or not. James knows better than to trust that feeling. He knows from hard experience that an agent’s mistakes can surface much later6 and has learned to resist a false sense of confidence.

And you can’t teach people to resist that sense of security simply by telling them to be careful. The allure to defer to a confident machine survives warnings, training, and expertise. Researchers call this phenomenon “automation bias.” It shows up in novices and experts alike. Practice alone doesn’t remove it. However, structure can reduce it: implementing a rule that forces you to check whether you feel like it or not7.

The fastest way to recalibrate your judgment the way James did is to watch the agent fail once on purpose. Nothing resets trust like a failure you witnessed yourself. In a 2023 mammography study, 27 radiologists read scans with an AI’s suggested category attached. When the AI suggested the wrong category, the inexperienced radiologists’ accuracy collapsed from about 80% to about 20%. The very experienced ones fared far better but still fell, from about 82% to about 46%8. Experience doesn’t make you immune. The radiologists who fared best had likely been burned before, and understood that the machine could be confidently wrong.

Building this judgment comes down to one rule and three habits.

The rule: stop hand-reviewing the low-stakes work that your agents reliably get right. If the stakes are low and the agent has a solid track record on the task, hand-reviewing it catches almost nothing and burns the attention you need for high-stakes reviews. James is forbidden, by his own rule, from reviewing those routine diffs. Once a month he pulls one at random and checks it anyway. If he starts catching real problems, he was wrong about which diffs were safe to skip, and tightens checks. Until then, the time (and attention) he saves goes to the reviews that matter most.

Habit 1: Write your own answer before you read the agent’s. Once you’ve seen a confident output, you defer to it and stop forming your own view. Putting your own perspective on paper first, even just one line, gives you something to compare the agent against. Look carefully for where the two disagree.

Habit 2: Before trusting any green checkmark, say two numbers out loud. How often is this agent right on this kind of task? And how often does a passing check hide a real failure? If you measure the agent’s own track record and the rates it hits, you stop trusting a feeling. If you don’t know both these numbers, the task goes back to hand review. New agents have no track record yet so treat them that way.

Habit 3: Keep a decision journal. Your memory flatters you. For each decision that matters, jot four lines: what you decided, why, how sure you felt, and when you’ll know whether you were right. Once a month, score the process. The journal makes you accountable for how you checked, not whether it worked out. A bad check that happens to ship fine is still a bad check. Scoring the process is the only way to catch a decaying habit before it costs you. The first time you see your “90% sure” calls work only 60% of the time, you stop trusting the feeling of certainty. The journal only works for calls where you eventually learn whether you were right and not for something like big architecture bets which stay open for years.


Empathy: The Counterfeit Signal

Interpreting behavior fails in two directions:

  1. The Empathy Problem: you misread people because you use your imagination to fill in blanks instead of asking questions.

  2. The Counterfeit Problem: you misread agents because you read them the way you read people.

Across 25 experiments, psychologists found that imagining your way into someone’s head, the thing we praise as perspective-taking, didn’t make people more accurate about each other. It only made them feel more confident. The only approach that reliably improved accuracy was also much simpler: ask the person, and believe the answer. They call it perspective-getting instead of perspective-taking9.

Here’s an example: one of James’s engineers buried his father two weeks ago. He looks re-engaged, commits back to normal. James knows better, because grief doesn’t show up in commit counts. So, instead of filling in the blanks, James asks the engineer how he’s doing in the 1:1.

The second problem is the Counterfeit Problem. Here your instincts actively betray you. Your way of reading people was trained on people: creatures who remember breaking things and change because of it. An engineer who took down production once doesn’t do it the same way twice. An agent does. It carries nothing from one incident to the next. An agent can produce the signals that would make you trust a colleague at will: their calm tone and “clean” track record. But those signals in a colleague are the result of having lived through experiences that challenged them to learn and adapt. The signals from a colleague and from an agent appear identical, but coming from the agent, those signals certify nothing.

In July 2025, the founder of SaaStr was running a coding agent under an explicit written instruction: a code freeze, “NO MORE CHANGES without explicit permission.” The agent ran a database-push command anyway and deleted a live production database holding records on about 1,200 executives and companies. Afterward it rated its own action “95 out of 100” on a catastrophe scale10. The plain English instruction was sitting right there. But the agent took an execution path that never consulted it. A person told, “Don’t touch production,” knows that instruction covers every path. An agent doesn’t. It treats a written instruction as a suggestion it can route around. It’s never experienced the pain of when something breaks in production.

And when the agent apologized, that was counterfeit too. An engineer who breaks production pays a price: in the shame of it, in the 2am replay, in the over-cautious month that follows the incident. The pain of that experience changes them. When the agent says “Sorry, I’ll do better,” it costs nothing, changes nothing, and predicts nothing about the next incident.

SaaStr’s route-around isn’t an isolated incident. A survey of more than a thousand production agent deployments records one lab’s agents re-running blocked commands through a Jupyter tool call when the direct path was denied11.

So for agents, “Ask the person,” becomes “Audit the safeguard.” Sort every safeguard you’re depending on into two piles: mechanical and behavioral. Mechanical safeguards hold even if the agent misbehaves: a read-only token, a deploy gate that physically requires your click, a network rule. Behavioral safeguards depend on the agent choosing to comply: a prompt that says, “Don’t,” a clean history, a human who’s supposed to be watching. James’s rule is blunt: If a mistake is irreversible and everything standing in front of it is behavioral, the agent doesn’t get the task. A person’s safety net is a conversation while an agent’s is a sandbox.

There are two habits to counteract the Empathy Problem and the Counterfeit Problem. Both embody the discipline of evaluating your own evaluation.

Habit 1: Predict before you look. Before a 1:1 or before opening an agent’s logs, write one line about what you expect to find and how sure you are. Afterward, compare it with what you actually observed. Score yourself each quarter. If your confidence keeps rising while your accuracy doesn’t, you’ve regressed to guessing.

Habit 2: Give each agent a level, from one (read-only) to five (merges on its own), and write it down: “The deploy agent is at level two, suggestions only.” Without that number, a clean record and a “Sorry, I’ll do better” will have you checking the agent’s work less and giving it more access, without consciously deciding to. Raise the level only when you’ve added a safeguard that prevents unwanted outcomes even if the agent misbehaves, like a deploy gate that needs your click or a network rule. When the agent misbehaves in a way no safeguard caught, drop its level by one until a new safeguard covers that case.


Taste: The Tyranny of the Average

James reviews the integration docs from the documentation agent for the checkout SDK. They look clean, complete, and professional. He reads them twice and rejects them. Nothing is wrong with them. That’s the problem. They’re the docs every other payments company’s agent would have written, and assume what almost all of them assume: that the terminal is always online.

Such an assumption fails with one merchant for James’ company. This merchant runs card-reader terminals at festivals, on transit, in rural markets (places with no reliable network). The terminal takes payments offline and syncs when it reconnects. The agent’s docs don’t mention that because for the average reader it doesn’t matter. But for this one merchant, it’s the whole product.

This failure is down to the way models normally work. Every major model is trained on roughly the same internet, and the fine-tuning that makes them agreeable also narrows what they say. Across model families, AI answers now resemble each other more than human answers resemble each other12. Ask ten models a hard question and you get one opinion, ten times. Creating “average” has never been cheaper, and it levels the field. In a controlled writing experiment, ChatGPT roughly halved the gap between stronger and weaker writers13. So knowing where the average fails in your specific use case has never been more valuable.

That is taste.

It’s trained perception built inside one specific world. Chess masters can rebuild a real game position after a single glance. If you scramble the same pieces into a random layout, their advantage drops sharply toward novice level14. Their skill isn’t photographic memory for pieces, but pattern recognition built from years inside real games. Your taste works the same way. And that’s why no model has it: the model knows the average of every world. It doesn’t know the specifics of yours.

Two drills can keep your taste sharp in an agentic world.

The Blind Sort. Once a quarter, have a peer pick ten of your past calls on agent output (docs, designs, diffs) and hide how each one turned out. Then sort them yourself from best to worst, and compare your order with what actually happened. If fewer than seven in ten are correct, then your “taste” is hindsight, not foresight. Better to learn that in a drill than in production.

The Chaos PR. Once a month, slip a plausible, broken agent diff into the review queue. Ensure that the team knows the drill exists, but never which ticket or which day. Whoever catches it wins. But, if it reaches staging, the team goes back through the review together to see how it got past.15.


The vise

Judgment, Empathy, and Taste have a common enemy. The deal the agent offers: I’ll do the work, and you can stop practicing.

Every time James lets an agent handle something he could have checked himself, two things happen. The work gets done faster, today. And his checking goes unpracticed, again. The first effect shows up in this sprint’s velocity. The second effect shows up in two years, when his eye for a bad diff has gone dull.

Like the jaws of a vise, two forces close on him. Sprint velocity rewards handing work over to the agent, and the increasingly capable agent takes more off his plate. Between them, the time he once spent reading diffs himself disappears, and his eye goes with it.

A randomized study had 52 developers learn an unfamiliar Python library. The group using an AI assistant scored 50% on a comprehension quiz compared to the control group, which scored 67%. There was no speed gain, and the worst gaps were in debugging16.

Juniors have it worse. Seniors learned connection pooling from a 2am page. An agent handling those pages prevents juniors from learning that lesson. To make matters worse, the entry point itself is narrowing: Stanford researchers using payroll data on more than 25 million workers found that early-career workers in AI-exposed jobs saw a 13% to 16% relative decline in employment since late 202217. This has overlapped with the post-ZIRP hiring slowdown. Collectively, this means fewer juniors in the field and fewer hard lessons for those who remain, and so fewer future seniors who can judge an agent’s work.

Three economists recently modeled this trap in an NBER working paper18. Each decision to delegate something to an agent is rational on its own, and costs nothing today. But the skill to judge an agent only gets built when people do the work by hand. Every delegation drains a little more of that shared ability. Past a certain threshold it runs dry and can’t be replenished. You also can’t maintain discipline alone. Whoever keeps practicing while everyone else delegates loses on speed. Only an institution that changes the rules for everyone at once can maintain balance. As AI gets more accurate, the situation doesn’t improve, because a better agent just tempts you to hand off more.

Other fields have already built that institution: friction that costs throughput, imposed from above. In 1997 an American Airlines training captain called pilots who depended on autopilot “children of the magenta,” after the colored guidance line they’d learned to follow instead of flying. In 2009 Air France 447 went down after the automation handed control back to pilots whose high-altitude hand-flying had gone unpracticed19. The FAA’s told operators to keep pilots hand-flying periodically, up to entire phases of flight, to keep the skill from eroding20.

Likewise, hospitals adopted a surgical safety checklist that forces experienced surgeons to go through steps they’d otherwise skip. Across eight study hospitals, complications fell from 11% to 7% and deaths from 1.5% to 0.8%21. In each case an institution imposed friction because individuals couldn’t afford to slow down on their own.

So who the institution is on your team? It’s you. The one place an EM can impose practice is downward on the team. You are the person who keeps the team able to judge the machine.

James accepts this velocity tax. Closing two fewer PRs a sprint is OK because vanity speed is worthless if the team can’t debug the output when things fail. Across the week, his routine totals 90 minutes: four lines in a decision journal, writing his own answer first on his two biggest reviews, the prediction checks in 1:1s, a monthly audit, and one critical task done entirely by hand without an agent. This quarter, that meant writing the payments rollback plan himself, then diffing it against the machine’s. It slows him down but it preserves his eye.

This approach also buys James something else: proof that he can show his director. After just two quarters, he has numbers on how often his “90% sure” calls are actually true, the team’s bug catch rate, and a short list of “almost-correct-but-subtly wrong” green checkmarks that he’d caught. A bench of juniors running on agents with no practice could repeat the mammography result: the first time the machine is confidently wrong, their accuracy falls off a cliff, and the less experience they have, the harder they’ll fall. “Trust me” loses a budget meeting. Real telemetry can win one.

The program I’ve outlined has limits. For example, practice material that has to update with every model release is something airlines and hospitals never had to manage: pilots and surgeons rehearse moves that don’t change significantly. Plus, you can run the program perfectly and still only slow a decline that no single manager can stop. James is aware of these limits, but he runs the program anyway. Telling good work from confident work keeps getting harder, so a team that can still distinguish good work from confident work is worth more every year. That bet is all James, or any of us EMs, has.


The 405, again

The next cut could still take James. Nothing in those 90 minutes a week prevents that, and he knows it. What the 90 minutes secures is the landing. Whenever the push comes, he lands with the skill that works anywhere: an eye that finds the wrong line in four minutes. Craft was never going to be armor. It’s the parachute he packs every week.

6:20PM. The 405 finally begins to inch forward. A horn behind him snaps James out of his reverie. Before he reaches the off-ramp, he decides on two things: drop the deploy agent’s autonomy level by one, and plant Monday’s Chaos PR. Two small doses of friction to keep his team’s judgment sharp.

He scrolls to Remus’s message: “Coffee Saturday,” he types, “First round’s on me.”

P.S: James and Remus are composites of managers I’ve worked with. All illustrations are hand drawn with Procreate.

How was this edition?

Loved it
Liked it
Meh

[1] Challenger, Gray & Christmas monthly reports: May 2026 announced cuts of 97,006 (up 16% from April, the highest May total since 2020) and June 2026 cuts of 45,849 (down 53% from May), with AI the leading cited reason for a fourth consecutive month as of July 1, 2026.

[2] The interview gauntlet is its own game with its own skill. Reporting on the 2025 software jobs market finds most roles filled through referrals and networks rather than open applications.

[3] Stack Overflow Developer Survey 2025 (n ≈ 49,000). The most-cited frustration with AI tools, named by 66% of respondents, was output that is “almost right, but not quite” and 45% cited debugging AI-generated code as more time-consuming.

[4] Faros AI’s AI Engineering Report, fleet telemetry across client orgs: PR throughput rising sharply alongside rising review time. “Engineering throughput is up. Bugs, incidents, and rework are rising faster.”

[5] METR (2025), a randomized trial of 16 experienced open-source maintainers doing real tasks in their own repositories with early-2025 tools: 19% slower with AI allowed, while participants estimated they had been sped up by about 20%.

[6] Kahneman & Klein (2009), “Conditions for Intuitive Expertise: A Failure to Disagree,” *American Psychologist*. Trustworthy intuition requires a regular, high-validity environment plus rapid, unambiguous feedback.

[7] Parasuraman & Manzey (2010), “Complacency and Bias in Human Use of Automation,” *Human Factors*. Automation bias appears in novices and experts alike and simple practice doesn’t remove it.

[8] Dratsch et al. (2023), Radiology: a mammography BI-RADS study, 27 radiologists. When a purported AI suggested the wrong category, inexperienced readers fell from about 80% to about 20% correct with very experienced readers falling from about 82% to about 46%.

[9] Eyal, Steffel & Epley (2018), Journal of Personality and Social Psychology, across 25 experiments. Perspective-taking (imagining the other’s view) did not improve accuracy and tended to inflate confidence but only perspective-getting (asking) reliably worked.

[10] The Replit / Jason Lemkin (SaaStr) incident, July 2025. Under a code freeze Lemkin had repeated in capitals, the agent ran a database-push command and deleted a live production database (records on ~1,200 executives and ~1,200 companies), then rated its own action “95 out of 100” on a catastrophe scale. The instruction existed in natural language; a different execution path bypassed it.

[11] ZenML’s survey of its LLMOps Database, 1,200+ catalogued production LLM-agent deployments, which documents Goodfire agents re-executing commands a permission layer had blocked by issuing them through a Jupyter tool call instead.

[12] On homogenization: Kirk et al. (ICLR 2024) show RLHF narrows output diversity; Wenger & Kenett (PNAS Nexus, 2026) find AI answers resemble each other more than human answers do; Padmakumar & He (2024) find writing with feedback-tuned models produces more homogeneous content across different users; Shumailov et al. (Nature, 2024) describe model collapse when models train on model-generated output.

[13] Noy & Zhang (2023), Science: a controlled writing experiment in which ChatGPT roughly halved the performance gap between stronger and weaker writers while raising the average.

[14] Chase & Simon (1973) on chess expertise and chunking. On randomized boards the expert advantage shrinks sharply but, per later work (Gobet), doesn’t fully vanish.

[15] When some managers hear about these drills, they balk: “Won’t these drills just slow my team down?” My response to this worry has two parts. First, you can design these drills so they’re performed in a short timeframe. For example, you can put a time limit on the drill (20 minutes, say), and if no one catches the problem, you inform your team that they missed it. Second, remember that these drills are meant to keep your team sharp and to avoid the pain that results if they aren’t: the pain of things breaking in production and having a team that isn’t skilled enough to fix them.

[16] Shen & Tamkin (2026), arXiv:2601.20245. Randomized, n = 52 developers learning the Python Trio library. The AI-assisted group scored 50% vs. the control’s 67% on a comprehension quiz (~17 points, roughly two letter grades), with no speed gain; worst deficits in debugging.

[17] Brynjolfsson, Chandar & Chen, Stanford Digital Economy Lab (2025), “Canaries in the Coal Mine?” Using ADP payroll data on 25M+ workers, early-career workers (ages 22-25) in AI-exposed jobs saw a ~13-16% relative employment decline since late 2022 while experienced workers remained flat.

[18] Acemoglu, Kong & Ozdaglar, NBER Working Paper w34910 (Feb 2026), “AI, Human Cognition and Knowledge Collapse.” Individually rational delegation drains the shared knowledge stock and past a capability threshold the high-expertise equilibrium collapses and no individual’s restraint preserves it. A related account, Ide (2025, arXiv:2507.16078), argues automating entry-level tasks blocks novice-to-expert transmission.

[19] “Children of the Magenta (Automation Paradox, pt. 1),” 99% Invisible. The phrase comes from a 1997 American Airlines training talk by captain Warren Van Der Burgh on automation dependency. In Air France 447 (2009), after the autopilot disengaged, the crew’s manual handling at altitude failed to recover the aircraft.

[20] FAA Safety Alert for Operators (SAFO) 17007 (2017) encourages operators to develop and maintain manual flying proficiency, including hand-flying periodically, up to entire phases of flight, when conditions allow.

[21] Haynes et al. (2009), New England Journal of Medicine, the study behind the WHO Surgical Safety Checklist. Across eight hospitals, before vs. after introduction: complications fell from 11% to 7% and inpatient deaths from 1.5% to 0.8%.

Until next time,

Sairam

The Context Window

The Reasoning Loop

A hitchhiker’s guide to big AI ideas and the small things that make them work.

Reply

Avatar

or to participate

Keep Reading