Because juniors don't know when they're being taken down a rabbit hole. So they'll let the LLM go too deep in its hallucinations.

I have a Jr that was supposed to deploy a terraform module I built. This task has been hanging out for a while so I went to check in on them. They told me the problem they're having and asked me to take a look.

Their repo is a disaster, it's very obvious claude took them down a rabbit hole just from looking. When I asked, "Hey, why is all this python in here? The module has it self contained" and they respond with "I don't know, claude did that" affirming my assumptions.

They lack the experience and they're overly reliant on the LLM tools. Not just in the design and implementation phases but also for troubleshooting. And if you're troubleshooting with something that's hallucinating and you don't know enough to know it's hallucinating you're in for a long ride.

Meanwhile the LLM tools have taken away a lot of the type of work I hated doing. I can quickly tell when the LLM is going down a rabbit hole (in most cases at least) and prevent it from continuing. It's kinda re-lit my passion for coding and building software. So that's ended up in me producing more and giving better results.

The best code I've written with an LLM has been where I architect it, I guide the LLM through the scaffolding and initial proofs of different components, and then I guide it through adding features. Along the way it makes mistakes and I guide it through fixing them. Then when it is slow, I profile and guide it through optimizations.

So in the end, it's code that I know very, very well. I could have written it but it would have taken me about 3x longer when all is said and done. Maybe longer. There are usually parts that have difficult functions but the inputs and outputs of those functions are testable so it doesn't matter so much that you know every detail of the implementation, as long as it is validated.

This is just not junior stuff.

If you search back HN history to the beginnings of AI coding in 2021 you will find people observing that AI is bad for juniors because they can't distinguish between good and bad completions. There is no surprise, it's always been this way.

Edit interesting thread: https://news.ycombinator.com/item?id=27678424

Edit: an example of the kind of comment I was talking about: https://news.ycombinator.com/item?id=27677690

The article says that more juniors + AI was the early narrative, but where does that come from?

Everything I’ve read has been the opposite. I thought people from the beginning saw that AI would amplify a senior’s skills and leave less opportunities for juniors.

I think it’s an expectation issue. AI does make juniors better _at junior tasks_. They now have a pair programmer who can explain difficult concepts, co-ideate and brainstorm, help sift through documentation faster and identify problems more easily.

The illusion everybody is tripping on is to think AI can make juniors better at senior tasks.

I read, ages ago, this apocryphal quote by William Gibson: “The most important skill of the 21st century is to figure out which proper keywords to type in the Google search bar, to display the proper answers.”

To me, that has never been more true.

Most junior dev ask GeminiPiTi to write the JavaScript code for them, whereas I ask it for explanation on the underlying model of async/await and the execution model of a JavaScript engine.

There is a similar issue when you learn piano. Your immediate wish is to play Chopin, whereas the true path is to identify,name and study all the tricks there are in his pieces of art.

I like the call-out for wrong learning.

Learning is why we usually don't make the same mistake twice in a row, but it isn't wisdom. You can as easily learn something wrong as something right if you're just applying basic heuristics like "all pain is bad", which might lead one to learn that exercise is bad.

Philosophy is the theory-building phase where learning becomes wisdom, and in any time period junior engineers are still going to be developing their philosophy. It's just that now they will hear a cacophony of voices saying dross like, "Let AI do the work for you," or, "Get on the bandwagon or get left behind," when really they should be reading things like The Mythical Man-Month or The Grug-brained Developer or Programming as Theory Building, which would help them understand the nature of software development and the unbendable scaling laws that govern its creation.

Steve Yegge if you're out there, I dog dare you to sit down for a debate with me

AI is filling "narrow" gaps. In the case of seniors these are:

-techs they understand but still not master. AI aids with implementation details only experts knowb about

- No time for long coding tasks. It aids with fast implementations and automatic tests.

- No time for learning techs that adress well understood problems. Ai helps with quick intros, fast demos and solver of learners' misunderstandings

In essence, in seniors it impacts productivity

In the case of juniors AI fills the gaps too. But these are different from seniors' and AI does not excell in them because gaps are wider and broader

- Understand the problems of the business domain. AI helps but not that much.

- Understand how the organization works. AI is not very helpful here.

- Learn the techs to be used. AI helps but it doesn't know how to guide a junior in a specific organisational context and specific business domain.

In essence it helps, but not that much because the gaps are wider and more difficult to fill

Statistically, senior engineers are less likely to accept AI suggestions compared to juniors. This is just a tidbit of supporting evidence for the suggestion that juniors are not properly reading and criticizing the ai output.

For the same reason that an amateur with a powertool ends up in the emergency room and a seasoned pro knows which way to point the business end. AI is in many ways a powertool, if you don't know what you are doing it will help you to do that much more efficiently. If you do know what you are doing it will do the same.

Because there is no budget nor culture for training juniors internally. The culture (top-down) is rewarding short-term capital efficiency without regard to longevity and succession.

This question shouldn’t even need to be asked.

Look at a decade of StackOverflow use.

Did YouTube turn medical interns into world class doctors?

AI is just the next generation search engine that isn’t as stupid as a plain keyword match.

In some sense, it’s just PageRank on steroids — applied to words instead of URLs.

If anything, AI was supposed -- still is -- to thin out the ranks of ever-expensive human employees. That's why it attracted such a huge pile of investment and universal cheerleading from the C levels. What we're seeing right now that there's not so much "I" in AI, and it still needs a guiding hand to keep its results relevant. Hence, the senior advantage. How much it's going to undermine regular generational enployee replacement (because "we don't need juniors anymore", right?) remains to be seen. Maybe we're in for different training paths, maybe a kind of population collapse.

Certainly not just coding. Senior designers and copywriters get much better results as well. It is not surprising, if context is one of the most important aspects of a prompt, then someone with domain experience is going to be able to construct better context.

Similarly, it takes experience to spot when the LLM is going in the wrong direction it making mistakes.

I think for supercharging a junior, it should be used more like a pair programmer, not for code generation. It can help you quickly gain knowledge and troubleshoot. But relying on a juniors prompts and guidance to get good code gen is going to be suboptimal.

> The early narrative was that companies would need fewer seniors, and juniors together with AI could produce quality code

I have never heard that before

Because there is no shortcut for things learned over a period of time through trial and error. Your brain learns and makes judgements over time through experience and, the strange thing, what I feel is that it can alter new decisions it is making right now based on older memories to do something and that is totally logical as well. Without understanding what I am writing, just copy-pasting, I guess is going to make new developers horribly lazy, maybe. But then again, there are always two sides of the same coin.

> Architecture: Without solid architecture, software quickly loses value. Today AI can’t truly design good architecture; it feels like it might, but this kind of reasoning still requires humans. Projects that start with weak architecture end up drowning in technical debt.

I strongly disagree about this in regards to AI. While AI might not yet be great at designing good architecture, it can help you reason about it, and then, once you've decided where you want to get to, AI makes it much easier than it ever was to reduce technical debt and move towards the architecture that you want. You set up a good scaffolding of e2e tests (possibly with the AIs help) and tell it to gradually refactor towards whatever architecture you want while keeping those tests green. I've had AI do refactorings for me in 2h that would have taken me a full sprint.

Strongly disagree with "AI Was Supposed to Help Juniors Shine". It was always understood that it would seriously push down demand for them.

Tasks usually come from the top down. Seniors design the architecture, mid-levels figure out ancillary tasks, and they generate "tedious" tasks that they hand off to juniors. With the aid of LLMs, many of those tasks don't make it to lower levels. So they run out of simple tasks for juniors, and end up giving them more advanced projects, making them de facto midrangers.

The "junior + AI" idea always felt like a manager's fantasy more than an engineering reality. If you don’t already know what “good” looks like, it's really hard to guide AI output into something safe, maintainable, and scalable

> The early narrative was that companies would need fewer seniors, and juniors together with AI could produce quality code.

Lol, who said that? The narrative has clearly been "same or fewer seniors, more outsourcing, less juniors"

These days, AI can do much more than "Cranking out boilerplate and scaffolding, Automating repetitive routines". That was last year. With the right instructions, Claude Sonnet 4 can easily write over 99% of most business applications. You need to be specific in your instructions, though. Like "implement this table, add these fields, look at this and this implementation for reference, don't forget to do this and consider that." Mention examples or name algorithms and design patterns it should use. And it still doesn't always do what you want on the first attempt, and you need to correct it (which is why I prefer Claude Code over Copilot, makes it easier). But AI can write pretty much all code for a developer who knows what the code should look like. And that's the point: junior developers typically don't know this, so they won't be able to get good results.

Most of the time, the only reason for typing code manually these days is that typing instructions for the LLM is sometimes more work than doing the change yourself.

If you're using them correctly, AI tools amplify your existing skills. Senior engineers have more skills to amplify.

> AI was supposed to help juniors shine

No, I don't think that was ever any kind of goal set by anyone ever

Mostly agree with article, though what happens in few years when juniors will eventually become senior.

Personally seeing trend juniors are relying so much on AI that they can't even explain what they wrote even in interview or coding assignments or even PR. Its like blackbox to them.

I believe then we would see the higher impact or may be by then its solved problem already.

At the moment, AI isn't good enough yet. Juniors can't tell the difference between bad coding practices or unmaintainable code. If the output is completely broken, they probably also have a hard time fixing it.

Seniors don't have these issues, so it will only make them more effective at their job.

It does help juniors shine. For example, it's far easier for a new comer to understand an old code base with a capable LLM now. It's easier to get unstuck because an LLM can spot a junior's mistake faster than the junior can go ask a senior.

The problem is that seniors are even more powerful with LLMs. They can do even more, faster. So companies don't have to hire as many juniors to do the same amount of work. Add in ZIRP ending and tariff uncertainty, companies just don't invest in as many junior people as before.

Because it's too unpredictable so far. AI saves me time, but only because I could do everything it attempts to do myself.

It's wrong maybe 40-50% of the time, so I can't even imagine the disasters I'm averting by recognising when it's giving me completely bonkers suggestions.

It's obvious to me: the strongest use for AI seems to be to tie together larger projects which you orchestrate. It lets someone with a lot of experience overcome individual cases where they lack specific domain expertise. A novice might not know how things go together, and so cannot orchestrate the LLM.

So we fantasize now some claims into reality and then argue against them?

AI was never “developed to help juniors shine”…

learning typically follows a specific path.

1. Unconsciously incompetent

2. Consciously incompetent

3. Consciously competent

4. Unconsciously competent

The challenge with AI, it will give you “good enough” output, without feedback loops you never move to 2,3,4 and assume you are doing ok. Hence it stunts learning. So juniors or inexperienced stay inexperienced, without knowing what they don’t know.

You have to Use it as an expert thinking partner. Tell it to ask you questions & not give you the answer.

Assuming the LLM is more competent than the user, it will still require “absorptive capacity” for the user to meaningfully use the output.

Many discuss AI without considering that unless the LLM is going to take over the entire process, those interacting with it, must be sufficiently skilled to do the integration and management themselves.

This goes for organizations and industries as well. Which is why many companies struggle with merely digitalizing their products.

You can’t abdicate learning. A junior who doesn’t understand the problem is going to use AI to more efficiently arrive at the wrong solution.

This is true for any type of AI-assisted analysis—-not just coding.

Because managing a complexity is a senior skill.

If you're a junior and using AI to generate code, someone has to review it anyway, plus you're not learning on the job. So what's the point if the senior person can generate the code herself?

This is a good thing. That shift in expectations will hopefully prevent a total collapse of systems as inexperienced developers would have yeeted god knows what code into production.

The best part: all of the materials that were available to now-seniors are available to new juniors. The added advantage of having an LLM to explain or clarify things? Seniors didn't have that. We had to suffer.

Sorry, but the outcome is fair. Seniors had to suffer to learn and can now benefit from the speed up of AI. Juniors don't have to suffer to learn, but they do have to learn to leverage AI to help them catch up to the existing crop of seniors.

Not impossible. Not impractical. Just a different form of hard work, which, no matter how much anyone kicks and screams will always be the thing standing in the way of where you want to be.

It doesn’t make seniors shine. It makes some of them fucking delusional. Sure, once in a while a LLM does something impressive and you are left thinking “holy shit, the future is now!”. However, this does not make up for the mass of time that you spend going “what is this shit?”, and saying “that’s not what I intended, gentlemen robot, please correct x, y and z.” And then gentlemen robot will go ahead and FUCK IT UP WORSE THAN BEFORE. Never work with kids, animals or AI. This shit is the worst, who came up with this? I can code! I’m bloody good at it! If I wanted to deal with some useless no-hoper having a crack and constantly needing to have their head kicked to do anything useful, I would have gotten you to do it.

You're only show as your typing speed and working memory. I noticed that LLM quickly spits out the code and thus I can iterate faster while typing myself I have focus on course and thus lose a lot of design context. Overall I haven't found any benefit of LLM. For me, it's just a probabilistic text generator that guesses my intent.

AI produces code that often looks really good, at a pace quicker than you can read it.

It can be really, really hard to tell when what it's producing is a bag of ** and it's leading you down the garden path. I've been a dev for 20 years (which isn't to imply I'm any good at it yet) and it's not uncommon I'll find myself leaning on the AI a bit too hard and then you realise you've lost a day to a pattern that wasn't right, or an API it hallucinated, in the first place.

It basically feels like I'm being gaslit constantly, even though I've changed my tools to some that feel like they work better with AIs. I expect it's difficult for junior devs to cope with that and keep up with senior devs, who normally would have offloaded tasks to them instead of AI.

Some of the juniors I work with frequently point to AI output as a source without any verification. One crazy example was using it to do simple arithmetic, which they then took as correct (and it was wrong).

This is all a pretty well-trodden debate at this point though. AI works as a Copilot which you monitor and verify and task with specific things, it does not work as a pilot. It's not about junior or senior, it's about whether you want to use this thing to do your homework/write your essay/write your code for you or whether you use it as an assistant/tutor, and whether you are able to verify its output or not.

Because it basically needs an RFC to know what to do, it’s just programming at a higher language level. If you let it decide how to be a programmer you’re in for a bad time.

“Was supposed to” according to whom?

It doesn't make seniors stronger, it just make juniors weaker as they are using this magic thingy LLM instead of learning from the seniors. It is important to evaluate not only what you gain by using a tool, but also what you lose...

AI was supposed to get rid of juniors (and seniors, soon).

i think it is due to the reverse utility curve; most products have some sort of gaussian utilty fuction for utility vs. expertise level. a complete newb will have trouble using the camera and a professional photographer will be limited by it, but most people in-between will get a lot of use out of it.

with llm’s it is opposite; a complete newb can learn some stuff, and an expert will be able to detect when it is bullshitting, but most people will be at a point where they have more knowledge about the subject the llm is talking about than the newb, but not enough to detect the bs.

It's a code/text generator not a pair programmer - not that different from past code generators which were always designed by seniors who knew what the end results should look like, and used by juniors to make them more productive and less error prone. Sure a junior can vibe code... something... but do they know what they want at the outset or do they know when things are going off the rails and a step back is needed? It's easy to get lost way out in the weeds if you can't check your (experience) compass every now and then.

>> AI was supposed to help juniors shine.

Who said that? I don't recall that narrative. There's no quotes or sources.

Not my experience, I've found it to worsen senior out output. Not sure if its laziness or what but the seniors around me using AI are outputing worse code than those who aren't.

This surprises people? How?

Because it's a multiplier not an adder.

Seniors have a better theory, which is what LLMs lack.

Verification.

That’s the whole issue in a nutshell.

Can the output of a generative system be verified as accurate by a human (or ultimately verified by a human)

Experts who can look at an output and verify if it is valid are the people who can use this.

For anyone else it’s simply an act of faith, not skill.

I think LLMs are best as learning tools, explaining code and producing something that can be then iterated.

When did anyone say it was designed to make juniors shine?

The tech companies want it to REPLACE juniors (and seniors).

> The early narrative was that companies would need fewer seniors, and juniors together with AI could produce quality code

I'm not deep into it, but I have not a single time seen that direction argued before this post. Maybe it was _really_ early on?

The narratives I always saw were, firstly, "it will be as a good as a junior dev", then "it's like pairing with an overly enthusiastic junior dev", then finally arguments similar to those presented in this article.

Which, frankly, I'm still not so sure about. Productivity is incredibly hard to measure: we are still not completely, non-anecdotally sure AI makes folk broadly more productive. And even if it does, I am beginning to wonder how much ai is short term productivity with long term brain rot, and whether that trade off is really worth it.

Was it? I don't recall such claims.

"AI Was Supposed to Help Juniors Shine" is a false narrative. AI's end goal has always been to fundamentally eliminate more and more of human labor positions until the only job left is executive directorship.

The ai has terrible taste. Juniors also have terrible taste. Seniors can guide both, but the ai is faster, cheaper, probably better than most. I’m worried that in a few years we will struggle to find new seniors. Who is going to put in the time to learn when the ai is so easy? Who is going to pay them to develop good taste?

Was it? That is always one way it gets sold, in practice I see we (the industry) are trying to replace offshoring with AI.

AI is a tool, like any other. Imagine you invented a new machine gun that fires faster and has less recoil but james more often. Who will be able to put the new machine gun to better use -- new recruits or veteran soldiers? C'mon.

Because garbage in, garbage out

Ai amplifies intelligence/skill

Hard disagree. Senior engineers can be just as incompetent as juniors

Ai closes the knowledge gap but it doesn't close the skill gap.

> supposed to help juniors shine

Supposed by who exactly?

> AI was supposed to help juniors shine.

Was it? Says who? People who want to sell you something?

Because as far as I can tell the only thing it was supposed to do was to make its owners money.

Does it make seniors stronger?

Extraordinary claims require extraordinary evidence.

In my experience CC makes so many wrong decisions that if I don’t have 1) experience and 2) have my thinking cap on, the results would not be good (or it would take a lot longer. Juniors typically have neither.

> AI Was Supposed to Help Juniors Shine.

Whoever said this?

In my narrow field, at least, AI has been tremendously helpful to those of us who clearly understand how to use it, and specifically how to apply it to the job. I think Junior developers are still in that phase of throwing code until something works. They try to use AI, but they either don't understand how, or they don't fully understand the output. In my humble opinion, experience knows what's possible and what will work so the outcomes are better.

No one thought juniors would be more benefited than seniors. St some people some said everything would be automatic and seniors would disappear altogether with programming itself.

But that was just said by crappy influencers whose opinion doesn’t matter as they are impressed by examples result of overfitting

"AI" tools accomplish one thing: output code given natural language input. That's it.

Whether the generated code meets specific quality or security standards, or whether it accomplishes what the user wanted to begin with, depends on the quality of the tool itself, of course, but ultimately on the user and environment.

They're not guaranteed to make anyone "stronger". The amount of variables involved in this is simply too large to make a definitive claim, which is why we see so much debate about the value of these tools, and why benchmarks are pretty much worthless. Even when the same user uses the same model with the same prompts and settings, they can get wildly different results.

What these tools indirectly do is raise the minimum skill level required to produce software. People who never programmed before can find them empowering, not caring about the quality of the end result, as long as it does what they want. Junior programmers can benefit from being able to generate a lot of code quickly, but struggle to maintain the quality standards expected by their team and company. Experienced programmers can find them useful for certain tasks, but frustrating and a waste of time for anything sophisticated. All these viewpoints, and countless others, can be correct.

simple: power law.

>Of course, the junior + AI pairing was tempting. It looked cheaper and played into the fear that “AI will take our jobs.”

Those are two different narratives. One implies that everyone will be able to code and build: "English as a programming language", etc. The other is one of those headless-chicken, apocalyptic scenarios where AI has already made (or will very shortly make) human programmers obsolete.

"AI taking jobs" means everyone's job. I won't even comment on the absurdity of that idea; to me, it only comes from people who've never worked professionally.

At the end of the day, companies will take any vaguely reasonable excuse to cull juniors and save money. It's just business. LLMs are simply the latest excuse, though yes, they do improve productivity, to varying degrees depending on what exactly you work on.

When was ai supposed to help juniors?

AI was supposed to help juniors shine? I don't remember hearing that anywhere. AI was supposed to let CEOs fire expensive experts and replace them with whatever slop the computer extruded from the manager's prompt. There was never any significant hype about making juniors into experts.

no, AI is supposed to reduce the labor costs for companies. that is how the AI companies are marketing their AI services to corporate C teams. any other benefits that their marketing departments are pushing to the public are smoke screens.

Uh because an LLM is a transfer function. Specifically a transfer function where the input has to be carefully crafted. And specifically where the output has to be carefully reviewed. Inexperienced people are good at neither of those things.

>AI was as supposed to help juniors shine

Citation needed? LLMs have mostly been touted as the junior replacement, a way for seniors to oversee scalable teams of shortsighted bots instead of shortsighted people.

Actually studies show that it makes most Seniors weaker: https://metr.org/blog/2025-07-10-early-2025-ai-experienced-o...

Like 19% weaker, according to the only study to date that measured their productivity.

"AI" does not make anyone stronger. It destroys thought processes, curiosity and the ability to research on your own.

Seniors just use it to produce the daily LOC that resembles something useful. If mistakes are introduced, they have secured a new task for the next day.

There have always been seniors who exclusively worked on processes, continuous integration, hackish code-coverage that never works, "new" procedures and workflows just to avoid real work and dominate others.

The same people are now attracted to "AI" and backed by their equally incompetent management.

The reality is that non-corporate-forced open source contributions are falling and no serious existing project relies on "AI".

Generative "AI" is another grift brought to you by leaders who previously worked on telemedicine and hookup apps (with the exception of Musk who has worked on real things).

Step one would be to stop calling whatever this is “AI” because while it may be artificial, it is not at all intelligent.

It doesn't.

Ol

does it really? it lets seniors work more, but idk if its necessarily stronger.

i just soent some time cleaning up au code where it lied about the architecture so it wrote the wrong thing. the architecture is wonky, sure, but finding the wonks earlier would have been better