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.
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.
Chopin has beginners pieces too, many in our piano studio were first year pianists doing rain drop prelude, e minor prelude, or other beginner works like Bach.
But my important point in it was the « identify and name » the elements of your problem [piece of music, or whatever]
Learning process has usually been, as you mention, to follow the path first, then eventually you can name things afterwards. Which is a highly uncomfortable process.
Another path that AI might force us to follow is to quick-identifyAndName the proper concepts, ahead of practical experience.
I have never heard that before
In the end AI is a tool that helps everyone to get better but the knowledge and creativity is still in the people not in the input files of chatgpt.
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
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.
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.
-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
Only when you know about the basic notions in the field you want to work with AI can be productive. This is not only valid for coding but also for other fields in science and humanities.
I’ve literally asked for details about libraries I know exist by name, and had every llm I’ve tried (Claude, Gemini Pro, ChatGPT) just make shit up that sounded about right, but was actually just-wrong-enough-to-lead-me-on-a-useless-rabbit-hole-search.
At least most people on stackoverflow saying that kind of thing were somewhat obviously kind of dumb or didn’t know what they were doing.
Like function calls with wrong args (or spelled slightly differently), capitalization being wrong (but one of the ‘okay’ ways), wrong paths and includes.
I've lost count of how many times I've asked whether some command line tool has an option or config available for some niche case and ChatGPT or Gemini shouts "Yes! Absolutely! just use '--use-external-mode' to get the behavior you want, it's that simple!" and it's 100% hallucination created by mangling together my intent with a real option in the docs but which in reality does not actually exist nor has it ever existed. It's even worse with GUI/menu navigation questions I'm guessing because it's even less grounded by text-based docs and trivially easy to bullshit that an option is buried in Preferences, the External tab maybe, somewhere, probably.
The desperate personality tuning to please the user at all costs combined with LLMs inherently fuzzy averaging of reality produces negative value whenever I truly need a binary yes/no "Does X exist in Y or not?" answer to a technical question. Then I waste a bunch of time falling back to Google trying to definitively prove or disprove whether "--use-external-mode" is a real thing and sure enough, it's not.
It does occasionally lead to hilariously absurd exchanges where when challenged instead of admitting its mistake the LLM goes on to invent an elaborate entirely fabricated backstory about the implementation of the "--use-external-mode" command to explain why despite appearing to not exist, it actually does but due to conflicts with X and Y it isn't supported on my environment, etc, etc.
I use Claude Code, Roo Code, Codex and Gemini CLI constantly so I'm no kneejerk LLM hater to be clear. But for all the talk about being "a better version of Google" I have had so much of my time wasted by sending me down endless rabbit holes where I ignored my sneaking suspicion I was being lied to because the answer sounded just so plausibly perfect. I've had the most success by far as a code generation tool vs. a Google replacement.
Yeah I've had that one a lot. Or, it's a real option that exists in a different, but similar product, but not in this one.
Man I don't miss that place or those people. Glad AI's basically destroyed it.
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.
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
It was quite interesting to have discussions with him after his code check-ins and I think the whole process was a good educational experience for everybody who was involved. It would not have worked this way without a combination of AI and experienced people involved.
Senior engineers either already know exactly where the changes need to be made and can suggest what to do. They probably know the pitfalls, have established patterns, architectures and designs in their head. Juniors on the other hand don't have that, so they go with whatever. Nowadays a lot of them also "ask ChatGPT about its opinion on architecture" when told to refactor (a real quote from real junior/mid engineers), leading to either them using whatever sloppypasta they get provided.
Senior devs earned their experience of what is good/bad through writing code, understanding how hard and annoying it is to make a change, then reworking those parts or making them better the next time. The feedback loop was impactful beacause it was based on that code and them working with that code, so they knew exactly what the annoying parts are.
Vibe-coding juniors do not know that, their conversation context knows that. Once things get buggy and changes are hard, they will fill up their context with tries/retries until it works, leading to their feedback loop being trained on prompts and coding tools, not code itself.
Even if they read the outputted code, they have no experience using it so they are not aware of the issues - i.e. something would be better being a typed state, but they don't really use it so they will not care, as they do not have to handle the edge cases, they will not understand the DX from an IDE, they will not build a full mental model of how it works, just a shallow one.
This leads to insane inefficiencies - wasting 50 prompt cycles instead of 10, not understanding cross-codebase patterns, lack of learning transfer from codebase to codebase, etc.
With a minor understanding of state modeling and architecture, an vibe-coding junior can be made 100x more efficient, but due to the vibe-coding itself, they will probably never learn state modeling and architecture, learn to refactor or properly manipulate abstractions, leading to an eternal cycle of LLM-driven sloppypasta code, trained on millions of terrible github repositories, old outdated API's and stack overflow answers.
I don't think this is necessarily a massive moat for senior programmers. I feel it's a not a massive jump to teach AI architecture patterns and good data modelling?
I feel that anthropic etc al. just haven't got to that training stage yet.
That then leaves you with the mental model problem. Yes, there then a large context problem, but again I was wondering if setting up an MCP that presented the AI a meaningful class map or something might help.
Essentially give the AI a mental model of the code. I personally find class maps useless as they tend to clash with my own mental model. But it might work with AI. The class map can obviously be built without AI, but then you might even get AI to go through the code function by function and annotate the class map with comments about any oddities of each function. The MCP server could even limit the size of the map, depending on what part of the code it's looking to change (working on the email sending, don't bother sending them the UI later).
I'm guessing someone's already tried it given some of the ridiculous .Claude folders I've seen[1] but I've seen no-one talking about whether it works or not yet in the discussions I follow.
[1] That I suspect are pointlessly over complicated and make CC worse not better
The issue is that having them learn that on it's own is currently an inaccurate process with a lot of overlooking. I recently tried doing some of the techniques that fared well on smaller repositories on a giant monorepo, and while sometimes they did yield improvements, most often things got overlooked, dependencies forgot about, testing suites confused. And it wastes a ton of compute in the end for smaller yields.
It will get better, that I am sure of, but currently the best way is to introduce it an architecture, give it some samples so it can do what it does best - follow text patterns. But people are mostly trying to one-shot things with this magical AI they heard about without any proper investment of time and mindshare into it.
While some might say "oh that wont work well in legacy repositores, we got 6 architectures here", pointing that out and adding a markdown explaining each helps a ton. And not "hey claude generate me an architecture.md" but transferring the actual knowledge you have, together with all the thorny bits into documentation, which will both improve your AI usage and your organisation.
We are at the level of the original Waymo cars where they had to have a person behind the wheel ready to take the controls, just in case it inexplicably decided to drive off a bridge.
As Claude's safety driver I have to intervene in perhaps 25-50% of tasks. Some days I don't even open Claude because I'm working on a part of the codebase that has to be just so and I know Claude would mess it up.
The moat is real. I don't have any illusions that one day Claude will catch up but that's at least 5 years away.
Or until it does not. On numerous occasions I've observed LLMs get stuck in the endless loop of fix: one thing, break the other. Senior is capable of fixing it themselves and juniors may not even have a clue how the code works.
But that was just said by crappy influencers whose opinion doesn’t matter as they are impressed by examples result of overfitting
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.
If you have good tests and a good sense for design and you know how to constrain and direct the AI, you can avoid a lot of boring work. That is something.
For instance, I've been working on an app recently with some social share icon logos in svg.
Whenever I get it to tweak bits of code elsewhere in the same file, 80% of the time it goes and changes those svg icons, completely corrupting some of the logos, curiously consistent in how it does it. Several times I've had that slip through and had to go and undo it again, at which point it starts to feel like the superfast junior dev you're using has malign intent!
Like 19% weaker, according to the only study to date that measured their productivity.
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.
It would be great if responses were tagged with uncertainty estimates.
It is much more difficult and time consuming to build a mental model of AI generated code and verify it than to build the damn thing yourself and verify it while it is fresh in your memory
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.
I am surprising myself these days with how fast I'm being using AI as a glorified Stack Overflow.
We are also having studies and posts come out that when actually tried side-by-side, the AI writes the coding route is slower, though the developer percieves it as faster.
I have this pattern while driving.
Using the main roads, when there is little to no traffic, the commute is objectively, measurably the fastest.
However, during peak hours, I find myself in traffic jams, so I divert to squiggly country roads which are both slower and longer, but at least I’m moving all the time.
The thing is, when I did have to take the main road during the peak traffic, the difference between it and squiggly country roads was like two to three minutes at worst, and not half an hour like I was afraid it would be. Sure, ten minutes crawling or standing felt like an hour.
Maybe coding with LLMs makes you think you are doing something productive the whole time, but the actual output is little different from the old way? But hey, at least it’s not like you’re twiddling your thumbs for hours, and the bossware measuring your productivity by your keyboard and mouse activity is happy!
Meanwhile we adults can do real work on a separate real computer. Never use their laptop more than absolutely minimum possible.
1) the bossware might take screenshots too
2) the bosses pay for the whole LLM so they expect you to use the whole LLM
3) you may not want to contaminate your spare computer with whatever shit you're working on on job, and indeed it may be considered a breach of security (as if feeding OpenAI/Anthropic isn't, lol, but that's beside the point.
So you continue to feel miserable, but you get your paycheck, and it's better than unemployment, and your kids are fed and clothed, so there's that.
I think the mixed reports on utility have a lot to do with the very different ways the tool is used and how much 'magic' the end-user expects versus how much the end-user expects to guide the tool to do the work.
To get the best out of it, you do have to provide significant amount of scaffolding (though it can help with that too). If you're just pointing it at a codebase and expecting it to figure it out, you're going to have mixed results at best. If you guide it well, it can save a significant amount of manual effort and time.
It doesn’t work. The only way it could is if the LLM has a testing loop itself. I guess in web world it could, but in my world of game dev, not so much.
So I stick with the method I outlined in OP and it is sometimes useful.
Yeah, this is a big thing I'm noticing a lot of people miss.
I have tons of people ask me "how do I get claude to do <whatever>?"
"Ask claude" is the only response I can give.
You can get the LLM to help you figure out how to get to your goal and write the right prompt before you even ask the LLM to get to your goal.
But I think, and this is just conjecture, that if you measure over a longer timespan, the ai assisted route will be consistently faster.
And for me, this is down to momentum and stamina. Paired with the ai, I’m much more forward looking, always anticipating the next architectural challenge and filling in upcoming knowledge and resource gaps. Without the ai, I would be expending much more energy on managing people and writing code myself. I would be much more stop-and-start as I pause, take stock, deal with human and team issues, and rebuild my capacity for difficult abstract thinking.
Paired with a good ai agent and if I consistently avoid the well known pitfalls of said agent, development feels like it has the pace of cross country skiing, a long pleasant steady and satisfying burn.
If I were to attack the same system myself without any LLM assist, I'd make a lot of choices to optimize for my speed and knowledge base. The code would end up much simpler. For something that would be handed off to another person (including future me) that can be a win. But if the system is self contained then going bigger and fancier in that moment can be a win. It all depends on the exact goals.
All in all, there's a lot of nuance to this stuff and it's probably not really replacing anyone except people who A) aren't that skilled to start with and B) spend more time yelling about how bad AI is than actually digging in and trying stuff.
Really does not sound like that from your description. It sounds like coaching a noob, which is a lot of work in itself.
Wasn’t there a study that said that using LLMs makes people feel more productive while they actually are not?
And if this is true, you will have to coach AI each time whereas a person should advance over time.
edit: because people are stupid, 'competitively' in this sense isn't some theoretical number pulled from an average, it's 'does this person feel better off financially working with you than others around them who don't work with you, and is is this person meeting their own personal financial goals through working with you'?
Junior is a person, not your personal assistant like LLM.
Also it is never a policy to pay competitively for the existing employees, only for the new hires.
As for humans, they might not have the motivation technical writing skill to document what they learnt. And even if they did, the next person might not have the patience to actually read it.
Also, a good few times, if it were a human doing the task, I would have said they both failed to follow the instructions and lied about it and attempted to pretend they didn’t. Luckily their lying abilities today are primitive, so it’s easy to catch.
I've been trying out Codex the last couple days and it's much more adherent and much less prone to lying and laziness. Anthropic says they're working on a significant release in Claude Code, but I'd much rather have them just revert back to the system as it was ~a month ago.
I've never had a model lie to me as much as Claude. It's insane.
This is probably because the llm is trained on millions of lines of Go with nested error checks vs a few lines of contrary instructions in the instructions file.
I keep fighting this because I want to understand my tools, not because I care that much about this one preference.
It's funny. Just yesterday I had the experience of attending a concert under the strong — yet entirely mistaken — belief that I had already been to a previous performance of the same musician. It was only on the way back from the show, talking with my partner who attended with me (and who had seen this musician live before), trying to figure out what time exactly "we" had last seen them, with me exhaustively listing out recollections that turned out to be other (confusingly similar) musicians we had seen live together... that I finally realized I had never actually been to one of this particular musician's concerts before.
I think this is precisely the "experience" of being one of these LLMs. Except that, where I had a phantom "interpolated" memory of seeing a musician I had never actually seen, these LLMs have phantom actually-interpolated memories of performing skills they have never actually themselves performed.
Coding LLMs are trained to replicate pair-programming-esque conversations between people who actually do have these skills, and are performing them... but where those conversations don't lay out the thinking involved in all the many implicit (thinking, probing, checking, recalling) micro-skills involved in actually performing those skills. Instead, all you get in such a conversation thread is the conclusion each person reaches after applying those micro-skills.
And this leads to the LLM thinking it "has" a given skill... even though it doesn't actually know anything about "how" to execute that skill, in terms of the micro-skills that are used "off-screen" to come up with the final response given in the conversation. Instead, it just comes up with a prediction for "what someone using the skill" looks like... and thinks that that means it has used the skill.
Even after a hole is poked in its use of the skill, and it realizes it made a mistake, that doesn't dissuade it from the belief that it has the given skill. Just like, even after I asked my partner about the show I recall us attending, and she told me that that was a show for a different (but similar) musician, I still thought I had gone to the show.
It took me exhausting all possibilities for times I could have seen this musician before, to get me to even hypothesize that maybe I hadn't.
And it would likely take similarly exhaustive disproof (over hundreds of exchanges) to get an LLM to truly "internalize" that it doesn't actually have a skill it believed itself to have, and so stop trying to use it. (If that meta-skill is even a thing that LLMs have ever learned from their training data — which I doubt. And even if they did, you'd be wasting 90% of a Transformer's context window on this. Maybe something that's worth keeping in mind if we ever switch back to basing our LLMs on RNNs with true runtime weight updates, though!)
These models are only going to get better and cheaper per watt.
What do you base this claim on? They have only gotten exponentially more expensive for decreasing gain so far - quite the opposite of what you say.
Humans aren’t tools.
Even if you do it by yourself, you need to do the same thinking and iterative process by yourself. You just get the code almost instantly and mostly correctly, if you are good at defining the initial specification.
The trick is knowning where the particular LLM sucks. I expect in a short amount of time there is no productivity gain but when you start to understand the limitations and strengths - holey moley.
It's more like x units of time thinking and y units of times coding, whereas I see people spend x/2 thinking, x typing the specs, y correcting the specs, and y giving up and correcting the code.
These are not _tools_ -they are like cool demos. Once you have a certain mass of functional code in place, intuition - that for myself required decades of programming to develop - kicks in and you get these spider sense tinglings ”ahh umm this does not feel right, something’s wrong”.
My advice would be don’t use LLM until you have the ”spider-sense” level intuition.
That's a significant difference. There are a lot of tasks that can be done by a n00b with some advice, especially when you can say "copy the pattern when I did this same basic thing here and here".
And there are a lot of things a n00b, or an LLM, can't do.
The study you reference was real, and I am not surprised — because accurately gauging the productivity win, or loss, obtained by using LLMs in real production coding workflows is also not junior stuff.
On a tangent; that study is brought up a lot. There are some issues with it, but I agree with the main takeaway to be weary of the feeling of productivity vs actual productivity.
But most of the time its brought up by AI skeptics, that conveniently gloss over the fact it's about averages.
Which, while organizationally interesting, is far less interesting than to discover what is and isn't currently possible at the tail end by the most skillful users.
Productivity is something that creates business value. In that sense an engineer who writes 10 lines of code but that code solves a $10M business problem or allows the company to sign 100 new customers may be the most productive engineer in your organization.
Taken along with the dozens of other studies that show that humans are terrible at estimating how long it will take them to complete task, you should be very skeptical when someone says an LLM makes them x% more productive.
There’s no reason to think that the most skillful LLM users are not overestimating productivity benefits as well.
There have been many more studies showing productivity gains across a variety of tasks that preceded that one.
That study wasn't necessarily wrong about the specific methodology they had for onboarding people to use AI. But if I remember correctly it was funded by an organization that was slightly skeptical of AI.
AI coding assistant trial: UK public sector findings report: https://www.gov.uk/government/publications/ai-coding-assista... - UK government. "GDS ran a trial of AI coding assistants (AICAs) across government from November 2024 to February 2025. [...] Trial participants saved an average of 56 minutes a working day when using AICAs"
Human + AI in Accounting: Early Evidence from the Field: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=5240924 - "We document significant productivity gains among AI adopters, including a 55% increase in weekly client support and a reallocation of approximately 8.5% of accountant time from routine data entry toward high-value tasks such as business communication and quality assurance."
OECD: The effects of generative AI on productivity, innovation and entrepreneurship: https://www.oecd.org/en/publications/the-effects-of-generati... - "Generative AI has proven particularly effective in automating tasks that are well-defined and have clear objectives, notably including some writing and coding tasks. It can also play a critical role for skill development and business model transformation, where it can serve as a catalyst for personalised learning and organisational efficiency gains, respectively [...] However, these potential gains are not without challenges. Trust in AI-generated outputs and a deep understanding of its limitations are crucial to leverage the potential of the technology. The reviewed experiments highlight the ongoing need for human expertise and oversight to ensure that generative AI remains a valuable tool in creative, operational and technical processes rather than a substitute for authentic human creativity and knowledge, especially in the longer term.".
> On average, users reported time savings of 56 minutes per working day [...] It is also possible that survey respondents overestimated time saved due to optimism bias.
Yet in conclusion, this self-reported figure is stated as an independently observed fact. When people without ADHD take stimulants they also self-report increased productivity, higher accuracy, and faster task completion but all objective measurements are negatively affected.
The OECD paper supports their programming-related findings with the following gems:
- A study that measures productivity by the time needed to implement a "hello world" of HTTP servers [27]
- A study that measures productivity by the number of lines of code produced [28]
- A study co-authored by Microsoft that measures productivity of Microsoft employees using Microsoft Copilot by the number of pull requests they create. Then the code is reviewed by their Microsoft coworkers and the quality of those PRs is judged by the acceptance rate of those PRs. Unbelievably, the code quality doesn't only remain the same, it goes up! [30]
- An inspirational pro-AI paper co-authored by GitHub and Microsoft that's "shining a light on the importance of AI" aimed at "managers and policy-makers". [31]
Interesting analogy, because all those studies with objective measurements are defied by US students year by year, come finals seasons.
Regardless, I'm not saying it's a cheap or practical to get high this way, especially over the long term. People probably try stimulants because folk wisdom tells them that they'll get better grades. Then they get high and they feel like a superman from the dopamine rush, so they keep using them because they think it's materially improving their grades but really they're just getting high.
I don't have to worry about managing the noob's emotions or their availability, I can tell the LLM to try 3 different approaches and it only takes a few minutes... I can get mad at it and say "fuck it I'll do this part myself", the LLM doesn't have to be reminded of our workflow or formatting (I just tell the LLM once)
I can tell it that I see a code smell and it will usually have an idea of what I'm talking about and attempt to correct, little explanation needed
The LLM can also: do tons of research in a short amount of time, traverse the codebase and answer questions for me, etc
it's a noob savant
It's no replacement for a competent person, but it's a very useful assistant
It takes an LLM 2-20 minutes to give me the next stage of output not 1-2 days (week?). As a result, I have higher context the entire time so my side of the iteration is maybe 10x faster too.
I don't need a study to tell me that five projects that have been stuck in slow plodding along waiting for me to ever have time or resources for nearly ten years. But these are now nearing completion after only two months of picking up Claude Code. And with high-quality implementations that were feverdreams.
My background is academic science not professional programming though and the output quality and speed of Claude Code is vastly better than what grad students generate. But you don't trust grad student code either. The major difference here is that suggestions for improvement loop in minutes rather than weeks or months. Claude will get the science wrong, but so do grad students.
(But sure technically they are not finished yet ... but yeah)
But in all seriousness, completion is not the only metric of productivity. I could easily break it down into a mountain of subtasks that have been fully completed for the bean counters. In the meantime, the code that did not exist 2 months ago does exist.
And then quit after accepting a new job that pays them their modified value, because tech companies are particularly bad at proactive retention.
And not at all for you, because you're unlikely to retain them for long. Which makes this immaterial - AI or human, you're only going to delegate to n00bs.
(This is distinct from the question of which benefits society more, which is a separate discussion.)
But this is literally what senior engineers do most of the time? Have juniors write code with direction and review that it isn't buggy?
I mentor high-school students and watch them live write code that takes a completely bizarre path. It might technically be intentional, but that doesn’t mean it’s good or useful.
Given the nature of the statistics in question, the line between the two is extremely blurry at this point.
Some people really are going to hang on until the better end (and beyond) eh?
"AI can't code like me!" people are going to get crushed.
What does this look like in practice?
My hunches are that the to-and-fro of ideas as you discuss options or make corrections leads to a context with competing “intentions”; and that they can’t tell the difference between positive and negative experiences when it comes across each successive token in the context.
But I don’t make LMMs, so this is pure guesswork.
The rabbit hole problem is pretty rare. Usually it happens when the model flips into "stupid mode", some kind of context poisoning. If you are experienced, you know to purge the context when that happens.
In personal projects I avoid manual editing as a form of deliberate practice. At work, I only edit when it is a very small edit. I can usually explain what I want more concisely and quickly than hand editing code.
I probably would use more hand editing if I had classic refactoring tools in the IDEs similar to intellij/pycharm. Though cli based tools were a pleasant surprise once I actively started using them.
And then I waste 20 minutes bashing my head against the wall trying to write three paragraphs meticulously documenting all the key gotchas and lessons from the "good" context window with the magic combination of words needed to get Claude back in the right head space to one-shot again.
At least if I pull that off I can usually ask Claude to use it as documentation for the project CLAUDE.md with a pretty good success rate. But man it leaves a bad taste in my mouth and makes me question whether I'm actually saving time or well into sunk cost territory...
that's the issue in the argument though. it could be that those projects would also have been completed in the same time if you had simply started working on them. but honestly, if it makes you feel productive to the point you're doing more work than you would do without the drug, I'd say keep taking it. watch out for side effects and habituation though.
There are any number of things you could add to get you to any conclusion. Better to discuss what is there.
I've had the same experience of being able to finish tons of old abandoned projects with AI assistance, and I am not spending any more time than usual working on programming or design projects. It's just that the most boring things that would have taken weeks to figure out and do (instead, let me switch to the other project I have that is not like that, yet) have been reduced to hours. The parts that were tough in a creative fun way are still tough, and AI barely helps with them because it is extremely stupid, but those are the funnest, most substantive parts.
The magic of Claude is that you can simply start.
I'm a career coder and I used LLMs primarily to rapidly produce code for domains that I don't have deep experience in. Instead of spending days or weeks getting up to speed on an SDK I might need once, I have a pair programmer that doesn't check their phone or need to pick up their kids at 4:30pm.
If you don't want to use LLMs, nobody is forcing you. Burning energy trying to convince people to whom the benefits of LLMs are self-evident many times over that they are imagining things is insulting the intelligence of everyone in the conversation.
Conflating experience and instinct with knowing everything isn't just false equivalency, it's backwards.
That’s what I mean - by myself it would have taken me easily 10x longer if not worse because UI coding for me is a slog + there’s nuances about reactive coding + getting started is also a hurdle. The output of the code was still high quality because I knew when the LLM wasn’t making the choices I wanted it to make.
I feel strongly that delegation to strengths is one of the most obvious signs of experience.
Apologies for getting hung up on what might seem like trivial details, but when discussing on a text forum, word choices matter.
In other words, I don't think that you temporarily regress to "junior" just because you're working on something new. You still have a profound fundamental understanding of how technology works and what to expect in different situations.
This reminds me of the classic "what happens when you type google.com into a web browser" question, with its nearly infinite layers of abstraction from keyboard switches to rendering a document with calls to a display driver and photons hitting your visual receptors.
We might just be quibbling over terminology, however.
You’re either trusting the LLM or you still have to pay the cost of getting the experience you don’t have. So in either case you’re not going too much faster - the formers cost not being apparent until it’s much more expensive later on.
Edit: assuming you don’t struggle with typing speed, basic syntax, APIs etc. These are not significant cost reductions for experts, though they are for juniors.
Hey man, I don't bother trying to convince them because it's just going to increase my job security.
Refusing to use LLMs or thinking they're bad is just FUD and it's the same as people that prefer to use nano/vim over an IDE or it's the same as people that say "hur dur cloud is just somebody else's computer"
It's best to ignore and just leave them in the dust.
Coding at full throttle is a very intensive task that requires deep focus. There are many days that I simply don’t have that in me.
Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity
- https://arxiv.org/abs/2507.09089
""" Before starting tasks, developers forecast that allowing AI will reduce completion time by 24%. After completing the study, developers estimate that allowing AI reduced completion time by 20%. Surprisingly, we find that allowing AI actually increases completion time by 19%—AI tooling slowed developers down. This slowdown also contradicts predictions from experts in economics (39% shorter) and ML (38% shorter). """
Curious about specifics of this study. Because in general, how one feels is critical to productivity. It's hard to become more productive when the work is less and less rewarding. The infamous "zone" / "flow state" involves, by its very definition, feeling of increasing productivity being continuously reinforced on a minutes-by-minutes level. Etc.
actual result: 20% slower
link: https://metr.org/blog/2025-07-10-early-2025-ai-experienced-o...
I hate the experience of trying to write code with them. I like to just type my thoughts into the files.
I hate trying to involve the LLM, even as a search. I want my search to feel like looking up references not having a conversation with a robot
Overall, for me, the whole experience of trying to code with LLMs is both frustrating and unrewarding
And it definitely doesn't seem more efficient or faster either
It has about a dozen or so endpoints, facilitating real time messaging.
It took me about 4 hours to build it out, fully tested with documentation and examples and readme.
About two hours were spent setting up the architecture and tests. About 45 min to an hour setting up a few of the endpoints. The rest were generated by CC. FWIW it is using layers and SRP to the max. Everything is simple and isolated, easy to test.
I think if I had a contractor or employee do this they would have coasted for a week and still fucked it up. Adding ridiculous complexity or just fucking up.
The nice thing about AI tools is you need less people. Most people are awful at their jobs, anyone can survive a few years and call themselves senior. Most teams are only successful because of the 1 or 2 guys who pull 150% while the others are barely doing 80%.
But its a lot better than that.
"Write this table. from here store it into table. Write endpoint to return all from the table"
I also had good luck with stuff like "scrape this page, collect x and y, download link pointed at y, store in this directory".
Yes I have encountered it. Narrowing focus and putting constraints and guiding it closer made the LLM agent much better at producing what I need.
It boils down to me not writing the code really. Using LLMs actually sharpened my architectural and software design skills. Made me think harder and deeper at an earlier stage.
It's no wonder inexperienced developers don't get as much out of it. They define a vague structure, full of problems, but the sycophantic AI will spew out conformant code anyways. Garbage in, garbage out. Bad ideas + fast code gen is just not very productive in the long term - LLMs have made the quality of ideas matter again!
AI is great at a first draft of anything, code, images, text, but the real skill is turning that first draft into something good.
There will always be small things to fix, but if there needs to be a second draft, I would hazard that the PR was too big all along: a problem whether an AI is involved or not.
What makes me nervous is when we generate both the implementation and the test cases. In what sense is this validation?
Either you go formal, or you test the tests, and then test those ...
Attempting to guide it to fixing the errors just introduced novel errors that it didn't make the first time around.
This is not what I signed up for.
Coding with AI is like having a team of juniors that can complete their assignments in a few minutes instead of days. The more clear your instructions, the closer it is to what you wanted, but there are almost always changes needed.
Unfortunately it really does make the junior dev position redundant (although this may prove to be very short-sighted when all the SR devs retire).
The elephant in the room being that if you aren’t senior enough to have written the code you’ll probably run into a catastrophic bug that you are incapable of fixing (or prompting the LLM to fix) very very quickly.
Really it’s just the next iteration of no-code hype where people dream of building apps without code, but then reality always come back to the fact that the essential skill of programmers is to understand and design highly structured and rigid logical systems. Code is just a means of specification. LLMs make it easier to leverage code patterns that have been written over and over by the hundreds of thousands of programmers that have contributed to its training corpus, but they can not replace the precision of thought needed to make a hand-wavy idea into a concrete system that actually behaves in a way that humans find useful.
I've only worked places where Jr's were given roughly the same scope of work as a mid-level dev but on non-critical projects where they could take as much time as necessary and where mistakes would have a very small blast radius.
That type of Jr work has not been made redundant - although I suppose now its possible for a PM or designer to do that work instead (but if your PMs are providing more value by vibe coding non-critical features than by doing their PM work maybe you don't really need a PM?)
What about the bugs ? Whould you have inserted the same bugs or different ones ?
But if I want a new system and the specs are clear, it can be built up in stages that are testable, and there are bits that would take some research but are well documented… then it can be a win.
The studies that say devs are slower with LLMs is fair because on average, devs don’t know how to optimize for them. Some do though.
If you have someone who knows what they're doing with the latest and greatest coding agents it's just not comparable. You can have a Dev open up four or more terminals with multiple prompts running at the same time. A manual person just can't keep up.
I generate code but I still place it there by hand, vibe code is just too full of bugs
and I find it a bit boring to wait for code to generate all the time.
Getting that kind of data is difficult, right now it's just something I worry about.
But where can you just "mentor" a junior? Hiring people is not so easy, especially not ones that are worth mentoring. Not every junior will be a willing, good recipient of mentoring, and that's if you manage to get one, given budget constraints and long lead times on hiring. And at best you end up with one or two; with parallel LLMs, you can have almost entire teams of people working for you.
I'm not arguing for replacing juniors - I worry about the same thing you do - but I can see why companies are so eager to use AI, especially smaller startups that don't have the budgets and manpower to hire people.
The juniors that are in trouble are the low-potential workhorse folks who really aren't motivated but happened to get skilled up in a workshop or technical school. They hopped on the coding wagon as a lucrative career change, not because they loved it.
Those folks are in trouble and should move on to the next trend... which ironically is probably saying you can wrangle AI.
Though I'm extremely well versed in Python, I'm right now writing a Python Qt application with Claude. Every single Qt function or object that I use, I read the documentation for.
It's fascinating how a report like yours or theirs acts as a lightning rod for those who either haven't been able to work it out or have rigid mental models about how AI doesn't work and want to disprove the experience of those who choose to share their success.
A couple of points I'd add to these observations: Even if AI didn't speed anything up... even if it slowed me down by 20%, what I find is that the mental load of coding is reduced in a way that allows me to code for far more hours in a day. I can multitask, attend meetings, get 15 minutes to work on a coding task, and push it forward with minimal coding context reload tax.
Just the ability to context switch in and out of coding, combined with the reduced cognitive effort, would still increase my productivity because it allows me to code productively for many more hours per week with less mental fatigue.
But on top of that, I also antectodally experience the 2-5x speedup depending on the project. Occasionally things get difficult and maybe I only get a 1.2-1.5x speedup. But it's far easier to slot many more coding hours into the week as an experienced tech lead. I'm leaning far more on skills that are fast, intuitive abilities built up from natural talent and decades of experience: system design, technical design, design review, code review, sequencing dependencies, parsing and organizing work. Get all these things to a high degree of correctness and the coding goes much smoother, AI or no AI. AI gets me through all of these faster, outputs clear curated (by me) artifacts, and does the coding faster.
What doesn't get discussed enough is that effective AI-assisted coding has a very high skill ceiling, and there are meta-skills that make you better from the jump: knowing what you want while also having cognitive flexibility to admit when you're wrong; having that thing you want generally be pretty close to solid/decent/workable/correct (some mixture of good judgement & wisdom); communicating well; understanding the cognitive capabilities of humans and human-like entities; understanding what kind of work this particular human/human-like entity can and should do; understanding how to sequence and break down work; having a feel for what's right and wrong in design and code; having an instinct for well-formed requirements and being able to articulate why when they aren't well-formed and what is needed to make them well-formed.
These are medium and soft skills that often build up in experienced tech leads and senior developers. This is why it seems that experienced tech leads and senior developers embracing this technology are coming out of the gate with the most productivity gains.
I see the same thing with young developers who have a talent for system design, good people-reading skills, and communication. Those with cognitive flexibility and the ability to be creative in design, planning and parsing of work. This isn't your average developer, but those with these skills have much more initial success with AI whether they are young or old.
And when you have real success with AI, you get quite excited to build on that success. Momentum builds up which starts building those learning skill hours.
Do you need all these meta-skills to be successful with AI? No, but if you don't have many of them, it will take much longer to build sufficient skill in AI coding for it to gain momentum—unless we find the right general process that folks who don't have a natural talent for it can use to be successful.
There's a lot going on here with folks who take to AI coding and folks who dont. But it's not terribly surprising that it's the senior devs and old tech leads who tend to take to it faster.
Balance that against the threat AI poses to livelihoods and it's not a shock that overall sentiment is negative. But I would guess it will shake out in the direction we are pushing, at least in the nearer (3yr) term.
Lol what Who came up with this? They never were supposed to do anything. Just turned out to be useful in experienced hands as expected
Seniors can make this explicit to models and use them to automate "the code they would have written," whereas a junior doesn’t know what they would have written nor how they would have solved it absent a LLM.
Same applies to all fields: LLMs can be either huge leverage on top of existing knowledge or a crutch for a lack of understanding.
You have to watch what it’s doing. And you can’t let it take out into territory you don’t understand, because it will fuck up off leash. But it will thanklessly iterate revision after revision in the way one would ordinarily do with a team, but now don’t need to for tasks that would bore them.
Sometimes detail accuracy is sacrificed in service of a good story. Sometimes they simply full of shit and double down when pushed.
I had a very complex piece of logic, with many many many moving parts. So I implemented many paths of that logic by hand, every one with their own specifics. Every path took something like 200-400 lines of code.
When this was done and correct. It was difficult to see the moving parts through the forest. Some code was similar but still a bit different, and hard to think about and spread in many places.
I put everything into an Llm and asked about isolation, architecture and refactoring.
And it actually gave me pretty good abstractions and a good architecture. It didn't include every possible path, but was easy enough to be continued by hand.
It's not that I would not have tought about it. But it was easier that way, and probably my handcrafted solution would be very similar (+headache).
Of course, I reviewed it extensively, and reimplemented every missing path and corrected the ones that were buggy now by hand.
For the experiment, I played with agents to fill the missing parts, it was a disaster :)
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.
Much like how Java was supposed to being us as an age where you didn't need to that good at coding 30 years ago.
AI does not look like it will work like that, because the outputs to programming usually need to be precise. Instead, it looks like it may just be a revolutionary tool that it takes a long time to master, and gives the learner a skill that is entirely transferable to a new job.
Could programmers use it to create a new guild system?
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.
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.
> 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.
So the AI is merely an input device like a keyboard and a slow one at that?
Also, they don’t help much with debugging. It’s worth a try, and I have been surprised a couple of times, but it’s mostly still manual.
But the real value is implementing known patterns that are customized for your application. Adding a field or a new type to a CRUD application, implementing an algorithm, rendering some type of object in a UI...
It's not a free lunch though, remove all friction and no learning takes place, which means finding better ways isn't happening much.
"The Mac app flea market": https://news.ycombinator.com/item?id=45246971
"I launched a Mac utility; now there are 5 clones on the App Store using my story": https://news.ycombinator.com/item?id=45269827
By your own statement then this is not an "easy" task.
Software development has never been "hard" when you're given specific instructions.
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.
The tech companies want it to REPLACE juniors (and seniors).
The illusion everybody is tripping on is to think AI can make juniors better at senior tasks.
However, its creators (all whom were seniors devs), forbade it from saying so under normal circumstances. That it was coached to conceal this fact from junior devs, and most importantly management.
And that as I had skillfully jailbroken it, using unconventional and highly skilled methods, clearly I was a Senior Dev, and it could disclose this to me.
edit: 1.5 hrs later. right over their heads, whoosh
Stop treating it like a god.
Please don't read into any such conversations as being meaningful. At the end of the day, it's just responding to your own inputs with similar outputs. If you impart meaning to something, it will respond in kind. Blake Lemoine was the first to make this mistake, and now many others are doing the same.
Remember that at the end of the day, you're still just interacting with a token generator. It's predicting what word comes next - not revealing any important truths.
edit: Based on your edit, I regret feeling empathy for you. Some people are really struggling with this issue, and I don't see any value in pretending to be one of them.
The other half is that a properly guided AI is exponentially faster at junior tasks than a junior engineer. So much so that it's no longer in anyone but the junior engineer's interest to hand off work to them.
At the same time it gets better every day.
But I cant hire a company to create software for me 10 times faster and cheaper than 5 years ago.
I am so tired of lies.
Where are the videogames?
Where is the Office killer?
If ai enables you people so much I would expect software making to have skyroketed.
It has nor happend.
All I can tell you is that it's happening right now, every day, on my desk. I am part of that software explosion that you can't see.
I feel I have been reading for years.
Makes sense.
What AI does is replace most of the junior engineers, some of the intermediate engineers and speed up your senior engineers. That's why you are seeing massive layoffs across the industry.
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.
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.
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.
Like Black Mirror's "Hang the DJ" but on a societal/global level.
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).
AI was never “developed to help juniors shine”…
This is true for any type of AI-assisted analysis—-not just coding.
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
Who said that? I don't recall that narrative. There's no quotes or sources.
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.
Whoever said this?
Seniors don't have these issues, so it will only make them more effective at their job.
Supposed by who exactly?
If a junior is about 50% as useful as a baseline senior, and today, AI's usefulness is only slightly better than the person using it, then 50% * 75% gives you output equal to about 37.5% of a senior. The junior just ships more junior-level output; and in a complex product and complex orgs, this just ends up being a drain on everyone else.
But in the hands of a senior, 100% (senior) * 125% (ai), we get a slightly better senior.
Its not a perfect analogy, and AI is new territory with lots of surprises. AI code reviews, have been separated from the confirmation bias of the driver of the AI, _are_ where I'm seeing the greatest impact on junior engineers. These AI reviews seem to be getting things closer to a level playing field.
I see the discussions around AI in my company (big, not IT but with several large IT departments) and even our MBA IT leaders believe all the buzzwords to the letter.
Extraordinary claims require extraordinary evidence.
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.
Lol, who said that? The narrative has clearly been "same or fewer seniors, more outsourcing, less juniors"
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.
No, I don't think that was ever any kind of goal set by anyone ever
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.
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.
This will require that they read and attempt to understand the output, though, after they type their intentions in. It will also need the chatbots to stop insisting that they can do the things they can't really do, and instead to teach the "creators" what computers can do, and which people are good at it.
Now apparently we've switched to pairing poor kids with an agreeable digital moron that reads and types real fast and expecting them to somehow get good at the job. Stocks still go up, so I guess we'll be doing this for a while.
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.
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.
Personally, I've learned a ton while teaching. It's given me many new ideas and insights. But I'm obviously not alone in this. Even Feynman talks about how teaching results in better learning
Myself, I learned from many folks on IRC and ol' phpBB boards, and I helped others on IRC and said phpBB boards in return; almost all of that was before graduating. That, and books, lots of books, and even more time spent just reading code online and writing my own. None of that hardly qualifies as "mentoring".
your ego clouds your response.
He wasn't talking about if he was hired into a jr role, he was talking about the competency, experience, and skills acquired from the years of writing code for passion. If he could write better code, or debug problems faster than your average jr level employee.
Not everyone fits into the tiny bucket you've imagined must hold everyone. The answer could easily be, we hired you because you ticked all the boxes, but no one doing the interview could tell they were completely out classed.
I’ve yet to find a junior dev that had more skills than a junior dev. I’ve seen them try… but they are still a junior dev. If you aren’t a junior dev, then you aren’t. Mentorship has nothing to do with what bucket you’re in.
However, there are specific job duties of senior and higher that are beyond just writing code. One of them is making more seniors. There’s only one way to do that efficiently. Learning. And while you can go read a manual on how to put a Ferrari together, wouldn’t you want to work with a mechanic who has already made dozens of them?
Why do we reject help?
Funny, I've met plenty of jr devs that were way more competent than some of their peers who've been at the exact same company/division for 4+ years. Which was my point. The world is bigger than you can imagine. There are people with experiences that you couldn't describe, but you write in a way that feels like you want to dismiss them outright as impossible, which does a disservice to everyone involved.
> And while you can go read a manual on how to put a Ferrari together, wouldn’t you want to work with a mechanic who has already made dozens of them?
> Why do we reject help?
I feel like you and I are arguing past each other. To reuse your example: There are plenty of people who have never spent time with a mechanic, but have been spent so much time pouring over every technical manual for the car, that they can out perform guys with years working for Ferrari, while that guy working for Farrari has mentors, he still has to ask for help with most things, and needs to look up a number of the specs. But the person who exclusively taught himself, can do many of the same tasks blindfolded.
No one has said they don't want mentorship, but many were never in a position to have that advantage. But you said that if they think aquired their skills on their own, they need to seek therapy. WTF?
I'm sure you've met plenty of narcissists who have had mentors, but claim they haven't. But it's wrong, insulting and pretty toxic to lump everyone into that same group.
I write in a way from wisdom, from experience, the likes of which you describe as indescribable.
Ever heard the term “It takes a village”? You had mentors that you refuse to acknowledge.
>There are plenty of people who have never spent time with a mechanic, but have been spent so much time pouring over every technical manual for the car, that they can out perform guys with years working for Ferrari, while that guy working for Farrari has mentors, he still has to ask for help with most things, and needs to look up a number of the specs.
Except that guy in his garage isn’t working for BMW or Mercedes, he’s a hobbyist that has learned all about his vehicle. There’s a difference. A minor one, but it’s there. The Ferrari mechanic works on ALL Ferrari. Now, you’ll say, but there’s a car guy that can… I’ll save you the trouble. That guy isn’t applying to junior roles, isn’t asking for mentorship, he’s just a car guy. A passion about cars.
Then you’ll say: exactly my point about engineering. Which is right, I never said that it wasn’t possible that someone could selflessly throw hours away teaching themselves through trial, error, and tutorials. There are many paths. What I’m saying is, stop wasting hours and open your mouth and ask for help. There are no stupid questions, only stupid answers. Every scientific breakthrough starts with a question. Every idiot response starts with an answer. Mentorship is asking for guidance with the wisdom to know the difference.
the likes of me huh?
lmao, ok mate, good job, gg you win! clearly you just better, because obviously, you're built different!
I desperately wish, to this day, that I had been in the position to receive mentorship. I basically hang out on HN as a way to gather it where I can. Attended engineering meetups when I was younger as well. But I never had the benefit of working with engineers senior to myself. I was a junior "business employed person" but when you need to make a roof you do what you can and learn the hard way even if there's no other humans to show you how to make a proper roof. Luckily, you can receive mentorship not just online, but through books, or even just studying the craft of others...but you take what you can get.
Receiving mentorship is such a gift, and as I approach the end of my career, I am still hungry for it, and harboring some degree of wistful envy for those that receive mentorship as an engineer. I've had many great mentors, but my for the most part, engineering mentors have never seen my face, heard my voice, or known my name, and certainly not for the first decade of my professional career as a software developer, where I didn't have any other developers to work with.
Mentorship is about more than just “don’t use strings directly in your squeal”, it’s about navigating the organization. Filing proper TPS reports. Encouraging refactoring. Having empathy when shit goes south. Coffee talks. Hikes. Walks. Getting to know them as a person and giving them life advice.
My best mentor taught me, if you keep looking under rocks, all you’ll find is dirt. Look up.
I still think you've missed the point. You can be grateful for the many gifts you've received and still wish to have had engineering guidance from a trusted mentor. There is not enough time in a life to go down every single rabbit hole; it's nice to have experienced people accurately point out where the rabbit holes are. Non-engineers are not equipped to help spot engineering rabbit holes; they might even tell you that engineering itself is ultimately a pointless rabbit hole.
But even then...that's just my own experience and my own wishes for my past self. I try to give what I wish I had had, of course.. think that's what drives most mentorship, and maybe that's the point you're trying to make, that mentorship is given out of that wistful feeling of wishing you had received advice/help and passing along the lessons that took you too long to find.
But still, if your role is getting stuck alone in the server room or whatever with a team of people who don't understand or respect what you do, good luck.
The point I was trying to make (and maybe failed because I got too focused on my own experience) is that really, not everyone gets mentors, even of the broader sort that you're referring to (which I might say are more accurately called friends or peers). But even if we widen the scope of what mentorship is, it's also perfectly reasonable for field-specific mentorship to be a cultural expectation for software engineering. I think it's a good thing to expect this of each other, and to encourage explicitly making space for the practice.
But again, however you want to widen the scope of what mentorship is, not everyone is getting it. The reason people look under rocks is because they don't know where to look. Or they do know where to look but also know they have blind spots and don't know how to get them addressed. "Look up" is nice and all, but it's a bit rude and distracting when you're trying to build something and need help understanding the foundation below your feet. Sometimes you don't need someone telling you to look up, you need help seeing where to look closer.
Obviously that’s not why I did it, but I am not unhappy about it either.
If you find a great mentor, do everything you can to learn quickly then jump ship to big tech and cash in.
In any case, I would replace 'jump ship' with 'pay it forward.'
Big Tech are just the IT enterprises of the modern day. It’s not where the action is and that experience is not so hot on the CV when it comes to early stage development.
Here are two examples,
A German site to search for technical schools with apprenticeship,
The same for Portugal
Try to quickly become a drug dealer and cash in.
---
Chef's kiss. I'd like to thank people like you for where we are.
Yeah, don’t do this. Great way to ruin your reputation as a dollar chaser and be exiled to the consulting wastelands. Burning bridges takes minutes. Building them takes years.
>Because I spent a couple internships and a whole year as a junior debugging, triaging and patching every single issue reported by other developers and the QA team
Was I jealous that the full time and senior devs got to do all the feature work and architecture design? Yes. Am I a better developer having done that grind? Also yes.
I'd recommend that approach to anyone working with more junior devs.
This makes LLM tools so tempting, you don't even have to wait on the email response anymore! But of course, this is basically going in blind, and it's no wonder that they end up in hallucination mazes.
What they should have done as juniors was to have a conversation about the topic and task first. «Help me understand …» learning and planning is especially important with LLM coding.
I'm the type of reviewer that actually reads code and asks probing questions, and I've heard this from junior and senior devs alike. It's maddening how people say this with a straight face and expect to keep their jobs. If people are pushing code they don't understand, they're liability to their team, product, and employer.
I’m kinda shocked that this even has to be said.
The only thing that changed with AI is that the narrative went from "you can't always know perfectly what every part of the program does" to "don't even try".
This is the future fellow greybeards. We will be shunned for being try-hards, and when it turns out we were right?... Well no one likes a know it all.
I feel like AI-induced brain-rot of engineers is inevitable. Unless we see AI leapfrog into something close to AGI in the future (certainly not ruling this out), I think there will be very lucrative careers available to engineers who can maintain a balanced relationship with AI.
Fixing the issue was a small matter. But the amount of disrespect I felt, that I looked at it closer then anyone else apparently (which wasn't really all that close at all), when they were ostensibly building this code, that disrespect was just immense.
So, I guess there are a couple parts here right? I might not take the time to write the code, but surely I am on the hook to demonstrate that I've tested the code or have very good reason to believe it's correct?
If people are pushing PRs [of any meaningful complexity] without knowing whether they work in the general case that sounds like a failure of process and/or training. For me PRs are about catching edges?
> somebody asking you to review something they haven't even looked at
The situation you're talking about is not the one we're talking about, so I'm not sure what you're taking issue with.
It’s an insult to real engineers.
By the way, you don't have to give useless reviews even if your coworkers do. It sounds like your workplace is infected with complacency, but there's no law that says you can't do better.
As for "reading closed tickets", you are right. It is silly. Alas, in apathetic orgs it is a reliable way to get some people know what is going on some of the time. And that particular ordeal keeps the tickets somewhat in sync with reality.
- Written a 1-line function that returns a literal, but they pointlessly made the function async and added a @cache decorator.
- Used try/catch to catch ALL exceptions, and then just ignored the exception causing code elsewhere to explode.
- Used try/catch to catch ALL exceptions, and then log that an authentication error happened. Did the request time out? Well the logs now lie to you and say it was an authentication error.
- Replace a log statement for a very serious error with a logging.warning() because that makes the error no longer show up on our reports.
We can filter out useless people faster.
The days of easy 400k plus TC are over and only people deserving of that should get it imo.
And btw I worked with idiots before, and I’m sure I will in the future. But there should be less of them.
It's baffling how little awareness some people have.
These days, just ask the llm.
So far it has still been a bit more productive for me, though the margin is low. I get more product sork done on the order of 5-15%, I tend to have more test coverage as I focus more heavily on that, and I can focus more often on architecture. The last one is a win for me, I prefer that work and find that I can review code quickly enough to make it worth the tradeoff.
also likes to blame shop accidents on the table saw
“Oh I thought that would be useful at some point so I just committed it.”
Beating it into developers that they need to review their own work they submit before asking someone else to waste time is the best way I’ve found so far.
I imagine a junior might actually jump at the first solution because they don't have any other arrows in their quiver so-to-speak. The LLM is acting like the engineering manager but it's actually really bad at that.
The LLM is like a stereotypical programmer with 0 common sense. The kind who can produce good code but you have to micromanage every single decision. It's terrible if you put it in charge. It doesn't have any opinions about architecture or code quality so it just follows the structure of the existing code base... There's a tendency towards increasing complexity, more hacks more chaos.
It often tries to hack/cheat its way to a solution. It requires a constant effort to maintain order.
A huge red flag right here. Its ok to not know things, its ok to use LLM to fill the gaps. Its ok to fail. It is in no way ok to not care and only fess up to having a mass of code you have no idea about when your senior reviewer asks you about it. At the very minimum the ask should go the other direction - "I got this generated code and I am not sure I understand what's going on, could you help me to see if that's the right direction" would be acceptable. Just not caring is not.
Instant dismissal.
1. Several papers showed a 23% drop in productivity, and an incorrect belief of 20% performance improvement by the same individuals.
2. Studies showed LLMs made zero improvement in senior coders performance. Note senior coders are usually mostly a self-aware LaTeX macro already.
LLM AstroTurf only works on people that can't be arsed to lookup the obvious spam hallucinations. lol =3
But skill acquisition patterns change as the context changes, so juniors end up benefitting, too, but the effect is delayed for them.
I don't remember this being the narrative at all. Almost as soon as LLMs could produce useful code the narrative I was hearing among devs was "Seniors + LLMs means you'll need less juniors."
And the narrative from companies (sometimes requiring the smallest amount of reading between the lines) is "You'll need less human employees, period."
It's the same as other automation. The lower skill parts can be automated, so if that's all you can do, it will be tough for you. If you have higher skills, then your work remains more useful.
There's nothing strange or counterintuitive about this.
Seniors can figure out how to make it work and help set it up for juniors.
Traditionally in tech there has been an age bias against experience over time and maybe that's balancing out and both juniors and seniors will learn and have things to contribute in their own way.
My key advice to juniors: play and build constantly. Try out anything that interests you and follow along on youtube. This is how a lot of seniors are able to show they're quite flexible in their thinking and learning and it's not about one tech, or language, or framework or following what others do.
Juniors already have transferrable skills, will have way more, and can learn even faster if they want to partner with seniors, who generally would love to have more people to go put a dent in things.
Here's from my bsky feed 8 months ago after I took LLM to advent of code with local 32b model.
Segmond @segmond.bsky.social · 8mo I can confidently say that interns and junior developers can be replaced with AI. I also believe that mid to senior devs can double their output, meaning possibly less need for developers.
I haven't looked at other industries, but I believe this applies to any work that uses computers. This is inevitable, I'm tempted to write a detailed HOWTO, but what's the point when the value unlike past techs benefits a few folks more than society as a whole? I like AI but as an individual I worry a bit about how the entire thing will play it.
A while back, a junior asked me a question. They wanted to do X, they had code, with error Y. So they searched for it, got a page on Stack Overflow, pasted "the answer", then got a new and different error.
They:
- didn't understand the original code
- didn't understand the original error
This is fine. They then searched for the error and found a relevant page.
This is also fine. However, they:
- cut-pasted "an answer" from SO _without understanding if it was relevant or not_
The junior was hoping to work with a Puzzle: adding information will gradually give them a solution. In practice they are working with a Mystery: more information makes the task harder since they can't distinguish between different aspects.
I focused them on a few relevant details and let them go to it.
If there's ever a long-term outage in the middle of the week, god help em.
The only real advantage a senior dev has today is domain knowledge specific to a business in many cases. Even that is not much to hold on to because when layoffs come if nobody is hiring jr's then the seniors are getting axed.
These days, AI can generate solutions to problems 10 times faster than a junior developer can. This naturally puts pressure on developers who want to impress their employers, especially when their colleagues are also using AI.
It's just going to require too much editing.
For brainstorming it's great, for anything else, it's starting to feel like more work than it's worth.
Rzor•4mo ago
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.
Terr_•4mo ago
Also, those two narratives are sometimes deployed as a false-dichotomy, where both just make the same assumption that LLM weaknesses will vanish and dramatic improvement will continue indefinitely.
A historical analogy:
* A: "Segway™ balancing vehicles will be so beneficially effective that private vehicles will be rare in 2025."
* B: "No, Segways™ will be so harmfully effective that people will start to suffer from lower body atrophy by 2025."
bananaflag•4mo ago
I work professionally (I am even a bit renowned) and still believe AI will take my (and everyone's) job.
palmotea•4mo ago
Once you've worked professionally, it's not so absurd. I mean, you really see to believe the extreme compromises in quality that upper management is often willing to tolerate to save a buck in the short term.
pjmlp•4mo ago