The senior engineer’s instinct didn’t come from going to class. It came from having shipped enough bad code to recognize the smell. Everyone knows college doesn’t prepare you for the work itself. It gives you fundamentals and a vocabulary. The judgment that makes someone senior is built somewhere else, in the years between graduation and competence, doing the mundane work that no one teaches because no one can.
The senior analyst’s judgment didn’t come from a training program. It came from cleaning up enough data to know what messiness actually looks like. The senior lawyer didn’t get there by reading case law. They got there by drafting the documents nobody else wanted to draft, watching what got marked up, and slowly absorbing why.
The mundane work was never the point. The mundane work was the training ground.
AI now does that work. The training ground is gone. And we’re starting to see the gap.
The Diagnostic
What’s actually breaking. Three failure modes anyone running an organization through the AI transition has seen at least once. I have seen all three.
Juniors who produce plausible output but can’t recognize when it’s wrong. They generate a function, a memo, a brief, a model, and the surface looks right. The variables are named well. The logic flows. The references are formatted correctly. What’s missing is the instinct that something is off. The AI handed them a confident-looking answer and they had no internal alarm to question it. They’ve never produced enough bad versions to know what bad looks like, because the bad versions were the ones AI now writes for them.
This is the failure mode that scares senior leaders the most, and it’s the one juniors don’t see in themselves. Confidence without judgment looks identical to confidence with judgment, until something breaks.
Mid-level practitioners who can lead a feature but freeze at the edges. They are competent inside the playbook. They can run the standard work cleanly, manage the standard meetings, deliver against the standard sprint. What they cannot do is operate where the playbook ends. The edge cases, the novel customer problem, the system behavior nobody documented, the situation that requires inventing a new rule of thumb. These used to be the moments that made someone senior, because the mid-level engineer had to figure them out and the figuring-out built the judgment. AI now handles the routine cases so well that the edge cases are the only cases left. And the mid-level person trained on AI-assisted routine work never built the muscle to handle them.
Senior promotion candidates who can articulate the right answer but can’t explain why. This is the most subtle and the most consequential. They’ve absorbed the pattern language from their seniors and from the AI tooling. They can describe a microservices boundary correctly. They can name the right design pattern. They can articulate the principle. What they cannot do, when pressed, is explain why this case calls for that pattern and not another. The vocabulary outran the understanding. They learned the words for judgment without earning the judgment underneath.
You see this most clearly in a promotion panel. The candidate gives the textbook answer fluently, and a senior in the room asks the second question. Why this approach over the alternative? And there’s a pause that should not be there.
What these three failure modes share is not a deficit of intelligence or motivation. The juniors are sharp. The mid-levels are diligent. The promotion candidates have done the work that was asked of them. What they share is a missing layer of experience that previous generations got by accident, by having to do enough of the wrong-looking, frustrating, low-leverage work to develop the pattern recognition that judgment is made of.
Removing that layer was not a decision anyone made. It happened because AI made the work it produced more valuable to ship than to use as training. Every leader optimizing for delivery velocity in the last three years has accelerated this, including me. The output quality has gone up. The development of the next generation has slowed down. Both are true.
The question is not whether this is happening. It is. The question is what to do about it.
Three Operating Moves
These are not philosophical. They are operational, they cost time and attention, and they work if a leader commits to them. The leaders who design these into their organizations now will produce seniors in three to four years. The leaders who don’t will buy senior talent at compounding cost forever.
Move one: Train the critic, not the producer.
When AI does the first draft, the junior’s job changes. They are no longer the producer of the work. They are the critic of work that has already been produced. That is a higher-leverage role and a harder one, and almost no organization is training for it deliberately.
The mistake is assuming the critic role is easier. It is not. Producing a function and reviewing a function require different muscles. The producer builds judgment by being wrong and getting corrected. The critic builds judgment by recognizing what could go wrong before anyone is corrected. Recognition is harder than production, and it does not develop on its own just because someone is now reviewing AI output instead of writing it.
What this looks like in practice:
Code review becomes a teaching instrument, not a gate. The junior writes the critique aloud, on paper, in the PR, before the merge. What could go wrong here. What edge case is not handled. What load profile breaks this. What assumption is buried in this function that won’t survive contact with production. Most code review today is a check-in by a senior, with the junior receiving comments. Reverse it. The junior writes the critique. The senior reads the critique and responds to the critique, not the code.
Pair programming where the AI is the third participant and the junior narrates the critique out loud. The senior is in the room not to write code, but to listen to the junior reason through what’s wrong with what the AI just produced. The thinking out loud is the training. The artifact is incidental.
Failure post-mortems where the junior does the analysis, not the writeup. Most post-mortems treat juniors as scribes. That is backwards. The junior should be the one tracing the failure, building the timeline, identifying the contributing causes, and writing the recommendations. The senior is there to ask the next question when the junior stops too early.
The principle: produce the deliberate practice that the work used to produce by accident. Mistakes were the training device of the old model. Recognition of mistakes is the training device of the new one. It only works if leaders engineer it on purpose.
Move two: Make the implicit explicit.
Senior judgment used to transfer by osmosis. You watched a staff engineer reject your PR with a one-line comment, and you absorbed something. You saw a senior partner mark up a memo without saying why, and over time you started to see what they saw. The transmission was silent because the volume of contact was high. You had hundreds of those moments a year.
That model is breaking on both ends. Seniors are spread thinner across more AI-generated reviews, so each contact is shorter and shallower. Juniors are exposed to fewer of those moments because more of the work flows through AI tooling that doesn’t carry a senior’s judgment in its comments. Osmosis worked when contact was dense. Contact is no longer dense.
The fix is to make the reasoning explicit in places it used to be implicit.
Code review comments that explain the principle, not just the change. Instead of “rename this variable,” write “rename this variable because three engineers will read this in six months and the current name forces them to read the function body to understand what it holds.” That comment is twice as long and teaches the principle once. The one-line comment teaches nothing.
Architectural decision records that document the reasoning, not the decision. Most ADRs name the choice and the alternatives. Few ADRs explain why the choice survived contact with the team’s actual constraints. The judgment is in the why. Write it down.
Office hours where seniors think out loud about decisions they’re working through, not just decisions they’ve already made. The most useful thing a junior can watch is a senior in mid-reasoning, hedging, weighing, revising. The least useful thing is a senior delivering a finished answer from a podium. Schedule the reasoning, not the announcement.
This costs senior time. There is no version of this move that doesn’t. The companies that pay that cost now will compress the senior development curve from ten years to four. The companies that don’t will pay the cost later, in the form of senior seats they can’t fill.
Move three: Engineer the surface area that AI removed.
The work AI eliminated was not just routine. It was the work that put juniors in front of enough situations to build pattern recognition. Reading other people’s bad code. Tracing a bug through three layers of legacy systems. Sitting on a customer call where the customer describes a problem the team has never seen. Running an incident at 2 AM. Refactoring a module nobody documented because the person who wrote it left two years ago.
These experiences were not the point of the work. The point of the work was to ship the feature, fix the bug, satisfy the customer. The experiences were the byproduct. AI now does enough of the work that the byproducts disappear. The shipped feature still happens. The pattern recognition does not.
The move is to engineer the byproducts deliberately, because they will not happen by accident.
Rotation through ops, even for engineers who will never work in ops. The goal is not to train ops engineers. The goal is to put juniors in front of production systems failing in ways no playbook covers. A week of incident response shadowing builds more judgment than a month of feature work.
Legacy refactor sprints where juniors lead the analysis. Pick a module nobody understands. Make a junior responsible for documenting what it does, why it was built that way, what would break if it changed, and what should replace it. Then have a senior read the analysis and ask the next question. The refactor itself may or may not happen. The development of the junior will.
Customer-facing rotations for engineering juniors. Not because juniors should do support. Because hearing a customer describe a broken workflow in their own words, watching the customer try to use the product, sitting through the silence when the customer cannot figure out the obvious flow, teaches something no internal review can teach.
The principle: the surface area that produced senior judgment was a feature of the old work, not a bug. AI removed the surface area as a side effect of efficiency. Leaders have to put it back deliberately, in the form of rotations and stretch assignments that have no immediate business justification but produce the seniors of 2030.
The Close
The conversation about AI and entry-level work has been mostly philosophical. Will AI take the jobs. Will the bottom rung of the ladder disappear. Will the next generation be unemployed or unemployable. These are not the right questions. The jobs are not disappearing. They are changing into something harder, the role of a thoughtful critic instead of a busy producer. The bottom rung of the ladder is not gone. It is no longer made of mundane work. The next generation is neither unemployed nor unemployable. They are arriving with degrees that prepare them for fundamentals, into a workforce that no longer offers the apprenticeship that used to turn fundamentals into judgment.
The career ladder didn’t disappear. The rungs that built seniors got replaced, and we have not yet built the new ones.
This is an operational problem, not a philosophical one. It belongs to the leaders running engineering organizations, law firms, consultancies, hospitals, agencies, and every other domain where the development model assumed years of apprenticeship producing the judgment that classroom learning could not. The leaders who design the new rungs deliberately will have organizations that scale themselves, that produce the seniors they need from the juniors they already have. The leaders who wait for the problem to surface will find themselves five years from now buying senior talent at compounding cost, and competing with everyone else who waited.
The mundane work was the training ground. AI took the work. The training is now our job to design.