Founder @thebitforge.dev • Software & AI Product Agency • 186K+ readers & 7K+ followers • We turn ideas into digital products people 💙 to use | visit us also on insta @thebitforge.dev
That human-first approach is probably more important than ever in this conversation. The tools and languages are interesting, but we shouldn't lose sight of the people behind the work. I'll take a look at the rebellion too! 😄
Compressed tedium” is a great way to say it. We learn the most from the boring tasks and the bugs that take hours to fix. If AI does all of that for us, we miss the part that teaches us. I like the idea of doing one task a week without AI. It’s simple and anyone can try it.
Founder @thebitforge.dev • Software & AI Product Agency • 186K+ readers & 7K+ followers • We turn ideas into digital products people 💙 to use | visit us also on insta @thebitforge.dev
I think the tricky part is that those boring tasks don't feel like learning while you're doing them. You only realise later how much you picked up from fixing something that seemed insignificant at the time. That's why I wouldn't want AI to take all of that away, especially from someone just starting out.
Totally agree! When I started learning to code there was no AI to help me, and I still remember the mistakes I made and the bugs I spent hours trying to fix. Those lessons stuck with me because I had to figure them out myself. When AI fixes everything for you, you get the answer but you don’t really remember how you got there. The struggle is what makes it stick with you forever. Great post :)
"Compressed tedium” is the phrase I’ll steal. The part I think gets overlooked is your incentives table: it’s rare to see someone lay out that every actor is behaving rationally and that’s exactly why the gap persists. The other thing that deserves more attention is the PR template line about explaining every changed line without reopening the agent chat. It’s cheap, it’s testable, and it exposes the difference between a team that owns a change and a team that just deployed one.
What I can’t get past is that the plan still has no accountable owner. A YAML file and a template are good habits, but if a generated change causes an incident, “the team owns it” only works if someone can point to the human who reviewed the logic and the rollback path. Otherwise the post correctly diagnoses the gap and then hands the fix to people who already have no time.
I’d be glad to compare notes on this, and happy to connect with others who are trying to make the junior pipeline concrete rather than just debated.
If you want a realistic next step, run it as a one-sprint experiment: every AI-assisted PR gets a named human owner, a short explanation of the logic, and a rollback note; then measure review time and escaped defects against the previous sprint. Small enough to actually finish, and it gives you data instead of a policy file nobody reads.
Founder @thebitforge.dev • Software & AI Product Agency • 186K+ readers & 7K+ followers • We turn ideas into digital products people 💙 to use | visit us also on insta @thebitforge.dev
Yeah, I think the accountable-owner point is fair. I focused more on the process in the article and didn't make the ownership part concrete enough.
I like the idea of making the person responsible for the PR explicit. Not another approval layer, just a clear name attached to the change. If an AI-assisted PR gets merged, there should be someone who can say, “I reviewed this, I understand what it’s doing, and this is how we get it back out if something goes wrong.”
The one-sprint experiment you suggested is probably the easiest way to see if this actually works. A named owner, a short explanation of the change, and a rollback note don't seem like much overhead. Then we can compare review time and escaped defects with the previous sprint and see what the numbers actually say.
I also like your point about making the junior pipeline concrete rather than just debating it. That's really the problem I'm trying to get at with the article. I'd be happy to compare notes as you try this out.
"If the plan is nobody's job, why would it ever get made?" is the line that stuck with me. In India the junior ladder was the main way in for a lot of us: join somewhere, do the boring tickets, learn on the job. If agents eat those first-year tasks, the ladder doesn't get shorter, it loses its bottom rungs. I don't have the plan either, but I'd bet it starts with teams deliberately keeping some easy work for people to learn on, even when an agent could do it faster.
Founder @thebitforge.dev • Software & AI Product Agency • 186K+ readers & 7K+ followers • We turn ideas into digital products people 💙 to use | visit us also on insta @thebitforge.dev
I think that’s the part I’m still trying to work out too. The problem isn’t really that agents can do those first-year tasks faster. It’s that if we remove all of them, we also remove a lot of the situations where someone learns how a real codebase actually works.
I like the idea of deliberately keeping some of that work for juniors, but I’d take it a step further. Maybe the junior still gets the simple ticket, but uses the agent as a tool rather than handing the whole task over to it. They make the change, review what the agent produced, explain the important parts in the PR, and have a reviewer challenge their reasoning.
That way we're not pretending the old workflow is coming back. We're changing what the junior is expected to learn from the work.
The harder part, as you said, is ownership. Someone on the team has to actually decide what work is kept as learning opportunities and make sure it doesn't get squeezed out every time there's a deadline. Otherwise the agent will always win because it's faster.
Your version is better than mine. Keeping the ticket but making the junior explain the agent's change in the PR teaches the part that actually matters, reading code you didn't write and defending it. And you're right about ownership. If nobody's name is on "learning work", the first deadline eats it.
Doing one task a week with the agent off and then diffing against the agent's version is a practical way to keep reps, because the diff shows both what you would not have thought of and what the agent got wrong. The PR template line about someone on the team being able to explain the change is the part I'd adopt first, since it costs nothing. How would you handle a change that only the person who prompted it can explain?
Founder @thebitforge.dev • Software & AI Product Agency • 186K+ readers & 7K+ followers • We turn ideas into digital products people 💙 to use | visit us also on insta @thebitforge.dev
I'd struggle to approve that PR, honestly. If the person who prompted the AI is the only one who can explain the change, that's a sign something is missing. I'd ask them to walk another teammate through the logic without relying on the original prompt. If they can't, I'd rather have them revisit the code than merge something nobody else on the team fully understands.
Asking them to walk a teammate through the logic without the prompt is a good test, because it checks understanding instead of authorship. It also spreads the knowledge, so the change is not owned by one person and one chat history. Have you had a PR where that walkthrough changed the code before merge?
The napkin math hits hard because it's the exact timescale nobody in a planning meeting is incentivized to care about. "Save money this quarter, discover in year seven that all your mid-levels are gone" is not a line that survives a budget review.
Your point about seniors doing mostly review is the part I keep circling back to. Reviewing generated code well requires precisely the judgment you build by writing a lot of bad code first — so we're quietly optimizing away the training set for the skill we're about to need most. That's not a paradox anyone has to intend; it just falls out of everyone acting rationally.
On your closing question: if my team stopped hiring juniors tomorrow, in 2033 the seniors would be whoever came in through an adjacent door — data, ops, QA, support — because those paths still involve real debugging with real consequences. It's a worse pipeline, but not zero. Which is maybe the quiet hope buried in all this: the ladder doesn't have to stay the only way up, we just haven't built the others on purpose yet.
Founder @thebitforge.dev • Software & AI Product Agency • 186K+ readers & 7K+ followers • We turn ideas into digital products people 💙 to use | visit us also on insta @thebitforge.dev
I hadn't really thought about people coming into engineering through those other paths, but it makes sense. QA and support especially can teach you things you don't always pick up when you're just writing code. Maybe the bigger issue is that we're so focused on the traditional junior-to-senior path that we're not putting enough thought into what other paths could look like.
Exactly — and the frustrating part is those paths already work, we just don't formalize them. Support engineers who debug customer issues all day build better diagnostic instincts than most juniors. We just don't call it engineering training, so nobody designs it that way.
Founder @thebitforge.dev • Software & AI Product Agency • 186K+ readers & 7K+ followers • We turn ideas into digital products people 💙 to use | visit us also on insta @thebitforge.dev
Yeah, I think that’s the part I hadn't appreciated when I wrote the article. We may already have some of the alternative paths sitting inside companies; we're just not treating them as part of the engineering pipeline.
A support engineer who spends a year figuring out why real customers are hitting weird failures is learning a lot of the same judgment we'd want from a junior developer. The missing piece is probably giving that experience somewhere to lead — opportunities to work closer to the code, take on more technical problems, and eventually move into engineering if that's what they want.
That actually makes the problem feel a little less bleak to me. Maybe we don't need to recreate the old ladder exactly. We need to stop assuming there's only one ladder in the first place.
The support engineer point is spot on. They see the system at its absolute worst and develop an empathy for the code you can't get from a tutorial. Formalizing that bridge gives you engineers who actually understand customer pain. "Stop assuming there's only one ladder" is a great way to frame it.
Your incentives table describes a classic general-training externality. When a firm pays senior engineers to mentor juniors, it builds portable judgment that another employer can hire away in year three, while cutting junior seats drops this quarter's payroll cost immediately. Because every firm faces the same math, nobody prices the 2033 senior review bottleneck into today's headcount budget.
That dynamic is also why voluntary rules like protected mentoring hours tend to slip under margin pressure. For a policy like your team-ai-policy.yml to hold across firms, junior seats have to pay back inside the first year as structured verification work, or employers have to pair training with retention structures that keep trained mid-levels from walking out the door.
Founder @thebitforge.dev • Software & AI Product Agency • 186K+ readers & 7K+ followers • We turn ideas into digital products people 💙 to use | visit us also on insta @thebitforge.dev
I hadn't thought about the retention side of this as much, but that's a fair point. Even if a company invests in training juniors, there's no guarantee it'll benefit them a few years down the line. I also like your point about making junior roles useful through verification work from the start. That feels like a much more practical way to approach this than simply asking companies to spend more time mentoring.
I research AI tools, APIs & agents — comparing specs, pricing and real user reports — then publish honest rankings so you don't waste money. Research-first, never sponsored fluff.
The 'learn to code' parallel is the sharpest bit in here — true, free, and not a plan for anyone except you. The year-seven line is the one I'd steal for planning meetings though. Genuine question: in your model, who actually owns the plan? The firm has no incentive, the industry has no mechanism — is it just nobody's job by design?
Founder @thebitforge.dev • Software & AI Product Agency • 186K+ readers & 7K+ followers • We turn ideas into digital products people 💙 to use | visit us also on insta @thebitforge.dev
I think that's the uncomfortable part: it mostly is nobody's job right now. Firms are focused on their immediate needs, and there's no real incentive to think seven years ahead. I don't think there's one owner who can fix it, but teams can at least stop treating junior development as something that will somehow take care of itself.
The year-seven point is the one that should worry planning meetings. Cutting junior seats saves money this quarter, and the cost shows up years later as a shortage of people who can review generated code with any real judgment. Since every firm faces the same math, nobody budgets for it.
One reply suggested making junior roles about verification from day one, and I think that is the practical version of a plan. Writing acceptance cases, reproducing the messy edge cases, and explaining a change to a teammate without the original prompt are exactly the skills that turn into review judgment later.
At Ascendra Ventures we see the same thing in fixed-scope work. Typing got cheap, but deciding what done means and proving it did not, and that part still needs people who learned it somewhere.
Of the options in your table, which one do you think a small team could actually start with next month?
Founder @thebitforge.dev • Software & AI Product Agency • 186K+ readers & 7K+ followers • We turn ideas into digital products people 💙 to use | visit us also on insta @thebitforge.dev
I'd start with one real task per sprint where a junior owns the work, then walks a senior through the decisions they made. No elaborate policy needed. Just making that time non-negotiable would be a good start. The hard part isn't introducing the practice, it's making sure it doesn't disappear the moment deadlines get tight.
One team, one community stack for WordPress: BuddyNext, Reign, BuddyX, Jetonomy, Learnomy & more. Custom community, LMS and marketplace builds. 13+ years.
From a small agency's side, the part nobody plans for is the apprenticeship. Juniors used to learn by doing the boring tickets: the plugin conflict, the broken form, the migration checklist. Those are exactly the tasks AI now drafts in seconds. If we hand all of them to a model, in five years there's nobody who has debugged a real client site at 2 a.m. and knows why the fix worked.
What we're trying: juniors still get the boring tickets, they may use AI, but they have to explain the fix back in plain words before it ships. Slower this quarter, cheaper in three years.
Founder @thebitforge.dev • Software & AI Product Agency • 186K+ readers & 7K+ followers • We turn ideas into digital products people 💙 to use | visit us also on insta @thebitforge.dev
I think this is probably closer to the answer than trying to ban AI from the boring work altogether.
Letting juniors use AI but still making them understand and explain the fix keeps the learning part of the job. The important thing isn't whether the first draft came from them or the model. It's whether they can look at the problem, understand what changed, and explain why that change actually fixes it.
And I really like the “slower this quarter, cheaper in three years” point. That's the trade-off I think teams need to be willing to make. If every easy ticket is given to an agent because it's faster today, we may save time now while quietly making it harder to build experienced developers later.
The interesting part would be seeing how you decide which tickets are worth keeping as learning opportunities. I'd be curious to hear how that works in practice.
A curious tech enthusiast who spends most of my free time exploring AI tools from Trae to SDGun. Currently balancing e-commerce operations and digital creativity, sharing every useful trick I pick up
This hits the core point almost every AI‑and‑developer post skips: the pipeline. “Learn to use AI” is solid personal advice, but it is not an industry succession plan.
The observation that senior judgment is compressed tedium is brilliant. All the boilerplate, debugging, small messy bugs are the training substrate. If agents absorb that substrate, we keep the senior title while slowly eroding the foundation the role depends on.
That toy model drives it home: skipping a cohort of juniors does not feel urgent today, but it creates a predictable hole years out.
Your final question stuck with me. If we stop giving people space to make their own mistakes, there really is no source for the next generation of engineers who can judge what the AI is doing.
Founder @thebitforge.dev • Software & AI Product Agency • 186K+ readers & 7K+ followers • We turn ideas into digital products people 💙 to use | visit us also on insta @thebitforge.dev
Yes, exactly. I think the mistake would be treating the junior pipeline as something that will just fix itself later.
Someone has to actually get the chance to make those mistakes, debug the ugly bugs, and sometimes take the longer route to a solution. That experience is what eventually gives someone the judgment to look at an AI-generated change and say, “this looks fine, but something about it isn't right.”
I don't think the answer is to stop using agents either. It’s probably to be more deliberate about what we let them take away. Some work can be automated completely, but some of it is also where people are learning how systems behave.
The difficult part is convincing teams to protect that learning time when the agent can finish the ticket in minutes. That’s the part I still think needs a much more concrete answer.
The PR template where someone has to explain every changed line is the part I'd actually steal. It works even without the mentorship angle, since it forces someone to read the diff the agent wrote. Who explains it though, the junior or the reviewer?
Founder @thebitforge.dev • Software & AI Product Agency • 186K+ readers & 7K+ followers • We turn ideas into digital products people 💙 to use | visit us also on insta @thebitforge.dev
I’d put that responsibility on the person opening the PR. If a junior used the agent to make the changes, they should be the one explaining what was changed and why. The reviewer’s job is to check that explanation, question anything unclear, and catch things the author might have missed.
I wouldn't expect someone to explain every single line word-for-word, especially in a large PR. But they should be able to explain the important changes without having to go back to the agent and ask what it did.
If they can't explain a particular part, that’s a sign it needs another look before merging. That way, the PR doesn't just get reviewed; the person submitting it actually learns from the changes too.
In financial pipelines and SEC filing extractors, modern models easily generate clean, passing code. They frequently miss subtle semantic distinctions, like treating accrual tax adjustments as cash tax payments, or mixing discrete quarterly numbers with cumulative year-to-date figures.
A reviewer who never spent nights tracing discrepancies across restated 10-Q tables will struggle to catch those slips in a diff. They see formatted functions, passing mocks, and green test runs. Senior judgment requires having burned hours debugging weird edge cases to recognize when generated code is subtly wrong. Without building that diagnostic muscle early, teams lose the ability to review long before 2033.
Founder @thebitforge.dev • Software & AI Product Agency • 186K+ readers & 7K+ followers • We turn ideas into digital products people 💙 to use | visit us also on insta @thebitforge.dev
This is exactly the part that worries me. Passing tests and clean code can make a change look perfectly fine, but understanding what the code is actually doing takes a different kind of experience. And you're right, that judgment usually comes from dealing with the messy cases, not just reviewing the happy path. That's a lot harder to replace than writing the code itself.
Great piece. AI made code cheap, but deciding what to build, for whom, and how good it has to be is still the scarce part. Please have a look at MyJackfruit (warning: self-promotion). We built it so you and our Kai-Zen agents do the systems engineering first: map the stakeholders, quantify what they value, and set numeric targets for security, scalability and performance before any code.
Founder @thebitforge.dev • Software & AI Product Agency • 186K+ readers & 7K+ followers • We turn ideas into digital products people 💙 to use | visit us also on insta @thebitforge.dev
Thanks. I think that distinction is becoming more important as the cost of producing code keeps dropping.
If an agent can generate the implementation quickly, then the harder part becomes knowing what should actually be built, what constraints matter, and how you decide whether the result is good enough.
I like the idea of doing that thinking before the code exists. Otherwise it's very easy to end up with a technically impressive solution to the wrong problem.
I'll take a look at MyJackfruit. The part I'm especially interested in is how you keep that systems thinking from becoming another layer of process that teams skip when they're under pressure.
We're a place where coders share, stay up-to-date and grow their careers.
Reflect to a title: Mostly I build software for human first mentality Terminal is your Friend |> ; Hexaw the programming language, plus above these I created a game which is courious about Singularity.
Do not miss my invite to join a rebellion request!
That human-first approach is probably more important than ever in this conversation. The tools and languages are interesting, but we shouldn't lose sight of the people behind the work. I'll take a look at the rebellion too! 😄
Compressed tedium” is a great way to say it. We learn the most from the boring tasks and the bugs that take hours to fix. If AI does all of that for us, we miss the part that teaches us. I like the idea of doing one task a week without AI. It’s simple and anyone can try it.
I think the tricky part is that those boring tasks don't feel like learning while you're doing them. You only realise later how much you picked up from fixing something that seemed insignificant at the time. That's why I wouldn't want AI to take all of that away, especially from someone just starting out.
Totally agree! When I started learning to code there was no AI to help me, and I still remember the mistakes I made and the bugs I spent hours trying to fix. Those lessons stuck with me because I had to figure them out myself. When AI fixes everything for you, you get the answer but you don’t really remember how you got there. The struggle is what makes it stick with you forever. Great post :)
"Compressed tedium” is the phrase I’ll steal. The part I think gets overlooked is your incentives table: it’s rare to see someone lay out that every actor is behaving rationally and that’s exactly why the gap persists. The other thing that deserves more attention is the PR template line about explaining every changed line without reopening the agent chat. It’s cheap, it’s testable, and it exposes the difference between a team that owns a change and a team that just deployed one.
What I can’t get past is that the plan still has no accountable owner. A YAML file and a template are good habits, but if a generated change causes an incident, “the team owns it” only works if someone can point to the human who reviewed the logic and the rollback path. Otherwise the post correctly diagnoses the gap and then hands the fix to people who already have no time.
I’d be glad to compare notes on this, and happy to connect with others who are trying to make the junior pipeline concrete rather than just debated.
If you want a realistic next step, run it as a one-sprint experiment: every AI-assisted PR gets a named human owner, a short explanation of the logic, and a rollback note; then measure review time and escaped defects against the previous sprint. Small enough to actually finish, and it gives you data instead of a policy file nobody reads.
Yeah, I think the accountable-owner point is fair. I focused more on the process in the article and didn't make the ownership part concrete enough.
I like the idea of making the person responsible for the PR explicit. Not another approval layer, just a clear name attached to the change. If an AI-assisted PR gets merged, there should be someone who can say, “I reviewed this, I understand what it’s doing, and this is how we get it back out if something goes wrong.”
The one-sprint experiment you suggested is probably the easiest way to see if this actually works. A named owner, a short explanation of the change, and a rollback note don't seem like much overhead. Then we can compare review time and escaped defects with the previous sprint and see what the numbers actually say.
I also like your point about making the junior pipeline concrete rather than just debating it. That's really the problem I'm trying to get at with the article. I'd be happy to compare notes as you try this out.
"If the plan is nobody's job, why would it ever get made?" is the line that stuck with me. In India the junior ladder was the main way in for a lot of us: join somewhere, do the boring tickets, learn on the job. If agents eat those first-year tasks, the ladder doesn't get shorter, it loses its bottom rungs. I don't have the plan either, but I'd bet it starts with teams deliberately keeping some easy work for people to learn on, even when an agent could do it faster.
I think that’s the part I’m still trying to work out too. The problem isn’t really that agents can do those first-year tasks faster. It’s that if we remove all of them, we also remove a lot of the situations where someone learns how a real codebase actually works.
I like the idea of deliberately keeping some of that work for juniors, but I’d take it a step further. Maybe the junior still gets the simple ticket, but uses the agent as a tool rather than handing the whole task over to it. They make the change, review what the agent produced, explain the important parts in the PR, and have a reviewer challenge their reasoning.
That way we're not pretending the old workflow is coming back. We're changing what the junior is expected to learn from the work.
The harder part, as you said, is ownership. Someone on the team has to actually decide what work is kept as learning opportunities and make sure it doesn't get squeezed out every time there's a deadline. Otherwise the agent will always win because it's faster.
Your version is better than mine. Keeping the ticket but making the junior explain the agent's change in the PR teaches the part that actually matters, reading code you didn't write and defending it. And you're right about ownership. If nobody's name is on "learning work", the first deadline eats it.
Doing one task a week with the agent off and then diffing against the agent's version is a practical way to keep reps, because the diff shows both what you would not have thought of and what the agent got wrong. The PR template line about someone on the team being able to explain the change is the part I'd adopt first, since it costs nothing. How would you handle a change that only the person who prompted it can explain?
I'd struggle to approve that PR, honestly. If the person who prompted the AI is the only one who can explain the change, that's a sign something is missing. I'd ask them to walk another teammate through the logic without relying on the original prompt. If they can't, I'd rather have them revisit the code than merge something nobody else on the team fully understands.
Asking them to walk a teammate through the logic without the prompt is a good test, because it checks understanding instead of authorship. It also spreads the knowledge, so the change is not owned by one person and one chat history. Have you had a PR where that walkthrough changed the code before merge?
The napkin math hits hard because it's the exact timescale nobody in a planning meeting is incentivized to care about. "Save money this quarter, discover in year seven that all your mid-levels are gone" is not a line that survives a budget review.
Your point about seniors doing mostly review is the part I keep circling back to. Reviewing generated code well requires precisely the judgment you build by writing a lot of bad code first — so we're quietly optimizing away the training set for the skill we're about to need most. That's not a paradox anyone has to intend; it just falls out of everyone acting rationally.
On your closing question: if my team stopped hiring juniors tomorrow, in 2033 the seniors would be whoever came in through an adjacent door — data, ops, QA, support — because those paths still involve real debugging with real consequences. It's a worse pipeline, but not zero. Which is maybe the quiet hope buried in all this: the ladder doesn't have to stay the only way up, we just haven't built the others on purpose yet.
I hadn't really thought about people coming into engineering through those other paths, but it makes sense. QA and support especially can teach you things you don't always pick up when you're just writing code. Maybe the bigger issue is that we're so focused on the traditional junior-to-senior path that we're not putting enough thought into what other paths could look like.
Exactly — and the frustrating part is those paths already work, we just don't formalize them. Support engineers who debug customer issues all day build better diagnostic instincts than most juniors. We just don't call it engineering training, so nobody designs it that way.
Yeah, I think that’s the part I hadn't appreciated when I wrote the article. We may already have some of the alternative paths sitting inside companies; we're just not treating them as part of the engineering pipeline.
A support engineer who spends a year figuring out why real customers are hitting weird failures is learning a lot of the same judgment we'd want from a junior developer. The missing piece is probably giving that experience somewhere to lead — opportunities to work closer to the code, take on more technical problems, and eventually move into engineering if that's what they want.
That actually makes the problem feel a little less bleak to me. Maybe we don't need to recreate the old ladder exactly. We need to stop assuming there's only one ladder in the first place.
The support engineer point is spot on. They see the system at its absolute worst and develop an empathy for the code you can't get from a tutorial. Formalizing that bridge gives you engineers who actually understand customer pain. "Stop assuming there's only one ladder" is a great way to frame it.
Your incentives table describes a classic general-training externality. When a firm pays senior engineers to mentor juniors, it builds portable judgment that another employer can hire away in year three, while cutting junior seats drops this quarter's payroll cost immediately. Because every firm faces the same math, nobody prices the 2033 senior review bottleneck into today's headcount budget.
That dynamic is also why voluntary rules like protected mentoring hours tend to slip under margin pressure. For a policy like your team-ai-policy.yml to hold across firms, junior seats have to pay back inside the first year as structured verification work, or employers have to pair training with retention structures that keep trained mid-levels from walking out the door.
I hadn't thought about the retention side of this as much, but that's a fair point. Even if a company invests in training juniors, there's no guarantee it'll benefit them a few years down the line. I also like your point about making junior roles useful through verification work from the start. That feels like a much more practical way to approach this than simply asking companies to spend more time mentoring.
The 'learn to code' parallel is the sharpest bit in here — true, free, and not a plan for anyone except you. The year-seven line is the one I'd steal for planning meetings though. Genuine question: in your model, who actually owns the plan? The firm has no incentive, the industry has no mechanism — is it just nobody's job by design?
I think that's the uncomfortable part: it mostly is nobody's job right now. Firms are focused on their immediate needs, and there's no real incentive to think seven years ahead. I don't think there's one owner who can fix it, but teams can at least stop treating junior development as something that will somehow take care of itself.
The year-seven point is the one that should worry planning meetings. Cutting junior seats saves money this quarter, and the cost shows up years later as a shortage of people who can review generated code with any real judgment. Since every firm faces the same math, nobody budgets for it.
One reply suggested making junior roles about verification from day one, and I think that is the practical version of a plan. Writing acceptance cases, reproducing the messy edge cases, and explaining a change to a teammate without the original prompt are exactly the skills that turn into review judgment later.
At Ascendra Ventures we see the same thing in fixed-scope work. Typing got cheap, but deciding what done means and proving it did not, and that part still needs people who learned it somewhere.
Of the options in your table, which one do you think a small team could actually start with next month?
I'd start with one real task per sprint where a junior owns the work, then walks a senior through the decisions they made. No elaborate policy needed. Just making that time non-negotiable would be a good start. The hard part isn't introducing the practice, it's making sure it doesn't disappear the moment deadlines get tight.
From a small agency's side, the part nobody plans for is the apprenticeship. Juniors used to learn by doing the boring tickets: the plugin conflict, the broken form, the migration checklist. Those are exactly the tasks AI now drafts in seconds. If we hand all of them to a model, in five years there's nobody who has debugged a real client site at 2 a.m. and knows why the fix worked.
What we're trying: juniors still get the boring tickets, they may use AI, but they have to explain the fix back in plain words before it ships. Slower this quarter, cheaper in three years.
I think this is probably closer to the answer than trying to ban AI from the boring work altogether.
Letting juniors use AI but still making them understand and explain the fix keeps the learning part of the job. The important thing isn't whether the first draft came from them or the model. It's whether they can look at the problem, understand what changed, and explain why that change actually fixes it.
And I really like the “slower this quarter, cheaper in three years” point. That's the trade-off I think teams need to be willing to make. If every easy ticket is given to an agent because it's faster today, we may save time now while quietly making it harder to build experienced developers later.
The interesting part would be seeing how you decide which tickets are worth keeping as learning opportunities. I'd be curious to hear how that works in practice.
This hits the core point almost every AI‑and‑developer post skips: the pipeline. “Learn to use AI” is solid personal advice, but it is not an industry succession plan.
The observation that senior judgment is compressed tedium is brilliant. All the boilerplate, debugging, small messy bugs are the training substrate. If agents absorb that substrate, we keep the senior title while slowly eroding the foundation the role depends on.
That toy model drives it home: skipping a cohort of juniors does not feel urgent today, but it creates a predictable hole years out.
Your final question stuck with me. If we stop giving people space to make their own mistakes, there really is no source for the next generation of engineers who can judge what the AI is doing.
Yes, exactly. I think the mistake would be treating the junior pipeline as something that will just fix itself later.
Someone has to actually get the chance to make those mistakes, debug the ugly bugs, and sometimes take the longer route to a solution. That experience is what eventually gives someone the judgment to look at an AI-generated change and say, “this looks fine, but something about it isn't right.”
I don't think the answer is to stop using agents either. It’s probably to be more deliberate about what we let them take away. Some work can be automated completely, but some of it is also where people are learning how systems behave.
The difficult part is convincing teams to protect that learning time when the agent can finish the ticket in minutes. That’s the part I still think needs a much more concrete answer.
The PR template where someone has to explain every changed line is the part I'd actually steal. It works even without the mentorship angle, since it forces someone to read the diff the agent wrote. Who explains it though, the junior or the reviewer?
I’d put that responsibility on the person opening the PR. If a junior used the agent to make the changes, they should be the one explaining what was changed and why. The reviewer’s job is to check that explanation, question anything unclear, and catch things the author might have missed.
I wouldn't expect someone to explain every single line word-for-word, especially in a large PR. But they should be able to explain the important changes without having to go back to the agent and ask what it did.
If they can't explain a particular part, that’s a sign it needs another look before merging. That way, the PR doesn't just get reviewed; the person submitting it actually learns from the changes too.
Skipping entry-level engineers directly undermines code review.
In financial pipelines and SEC filing extractors, modern models easily generate clean, passing code. They frequently miss subtle semantic distinctions, like treating accrual tax adjustments as cash tax payments, or mixing discrete quarterly numbers with cumulative year-to-date figures.
A reviewer who never spent nights tracing discrepancies across restated 10-Q tables will struggle to catch those slips in a diff. They see formatted functions, passing mocks, and green test runs. Senior judgment requires having burned hours debugging weird edge cases to recognize when generated code is subtly wrong. Without building that diagnostic muscle early, teams lose the ability to review long before 2033.
This is exactly the part that worries me. Passing tests and clean code can make a change look perfectly fine, but understanding what the code is actually doing takes a different kind of experience. And you're right, that judgment usually comes from dealing with the messy cases, not just reviewing the happy path. That's a lot harder to replace than writing the code itself.
Great piece. AI made code cheap, but deciding what to build, for whom, and how good it has to be is still the scarce part. Please have a look at MyJackfruit (warning: self-promotion). We built it so you and our Kai-Zen agents do the systems engineering first: map the stakeholders, quantify what they value, and set numeric targets for security, scalability and performance before any code.
Thanks. I think that distinction is becoming more important as the cost of producing code keeps dropping.
If an agent can generate the implementation quickly, then the harder part becomes knowing what should actually be built, what constraints matter, and how you decide whether the result is good enough.
I like the idea of doing that thinking before the code exists. Otherwise it's very easy to end up with a technically impressive solution to the wrong problem.
I'll take a look at MyJackfruit. The part I'm especially interested in is how you keep that systems thinking from becoming another layer of process that teams skip when they're under pressure.