To comment on the post you linked:
I agree that people can be thought. But on the other hand, I also had juniors that reached their limit pretty fast, which can also be frustrating. The best way to "teach" LLM's is the context, but I agree it has limits and is not really teaching anything, just steering them in the right direction every time (like a checklist).
Your comment basically states that running LLM's is a gamble, but according to my experience, most of the time it delivers what I ask. Maybe in a different way that how I would do it, but I want results, and am not interested in micro-managing.
Are you working on a project that requires high quality code? Or is it your preference to work in such a codebase? For me, I was always ok with "good enough" code. And sometimes "good enough" needs to be good, and other times you can get away with some really bad code.
i meant "working with" as i explained in the linked comment. the feedback and response i get from juniors is very different. and yes, sure every junior dev is different from the others, but i simply enjoy working with people and i can't stand working with machines in the same way.
what bothers me about LLMs is that they are not deterministic. that just drives me nuts. i do enjoy learning the ins and outs of a language or compiler to figure out how to write the code to get the results i need. but LLMs just don't work like that. the same instruction that produced good working code today could produce nonsense tomorrow.
this is not about quality. this is about trust. i can't trust LLMs and that makes it very uncomfortable for me to work with them.
That's because you try to look at LLM's as tools, and not as an intern.
LLM's are not deterministic, they can make mistakes, etc. You refuse to work with LLM's like you would work with interns, and then somehow you're frustrated that they don't work like a compiler?
Maybe shifting your expectations would solve a lot of your frustrations.
Look, every developer writes bugs. Me, you, everyone. There is no perfect developer that can churn out 100% quality code. That means you always have to take this into account. You are correct that I don't take compiler bugs into account, because they are very rare. But when working with LLM's, just take into account that it can go wrong, just like any human developer.
Basically, you have very fast and cheap interns at your disposal, with a huge amount of knowledge. Can you trust an intern? Of course not!
There's nothing wrong with that. Many of us do (or did) like programming and the problem-solving itch it scratched for us. But getting work done for pay is more than what we like. If an LLM can reliably solve a problem for me in a day that would have taken a project, a team of several people, and close to a month of work to build out manually, then I go with the tool that works.
And that "if" is the reality I live in. About a decade ago, I wrote a program to do analysis of config files for a product our team uses. It took me weeks of side-work to implement the idea of passing boolean python functions as checks for the configuration. Such an elegant way of creating new checks on our system! It was company work, and when I left to a new place, I didn't have that code, just the idea. Fast forward five years and I want to write the same thing at a new place. I asked an LLM to do the same task, and it wrote exactly my solution immediately. It just worked. It shocked me. In the last few months, I've had it write analysis tools against this product that would have taken me days or weeks. I am admittedly not a comp-sci level programmer.
There is no denying that LLMs are powerful coding tools. That can be true at the same time that we lament the end of manual-coding-for-pay, the death of programming education as we know it, and the worries about employment and society.
No, but when a junior puts up a PR I do. They aren’t trustworthy enough yet.
One of the biggest parts of being senior is ownership of your code and knowing you’re putting your trustworthiness behind every PR you make. If you’re making bad PRs, you can’t say it’s Claude’s fault because you didn’t think a certain area was worth reviewing.
> That's just impossible.
Somewhat, but this is directionally bad advice. There’s huge payoffs for taking time to thoroughly understand areas you’re working in. It greatly amplifies your ability to prompt and overall execute in a codebase.
That's why I say: every session is a new intern. That's how I look at it.
> The claim is that if I'm any good, I should know how to squeeze consistent quality results from LLMs.
Claude Opus 5.5 can write decent code, better than most juniors I came across, and definitely codes faster than me.
But is that quality high enough for your standards? It sounds like no. So then the next question is, does your project really require your high standards?
Sure, LLM's are unreliable. So are juniors.
Sure, LLM's code quality is not always great. Well, so is the juniors code.
The benefit of LLM's is that they can work super fast and have a vast amount of knowledge. The benefit of juniors is that they actually learn from their mistakes and get better over time. LLM's stay at intern/junior level, even with the correct context.
So for me, I see each LLM session as a new intern coming in. You hand them the right context, give them the correct instruction, and off they go. Then they come back, and you will have to judge how detailed you want to review what they produced. Or in other words, can you get away with some bad code? And for the next session, it's a new intern that starts from 0.
But it is also highly dependent on the project you are working on. If it's a big complex codebase, LLM's will struggle, and they can only do simple tasks (however, they can help with testing a lot!)
So the teachable thing is unfortunately experience:
- Know where quality matters, and where it doesn't
- Know what kind of mistakes could be made and should be checked for
- Know which things can be duck-taped together, because they live at the edge, and which things need a proper foundation, because the rest builts on it.
So in the end, I think it all comes down to making the right trade-offs and the right decisions (which LLM's are terrible at, by the way). And unfortunately that is gained by the slow process of experience.
I think it's very tough for junior developers right now, because they either go fast by letting the LLM's do the work, but then they learn nothing. Or they go slow by asking the LLM's what's going on, and then do learn.
A senior developer never understood the full code-base, and never reviewed every line of code. That's just impossible. And now every developer needs to be a senior developer that is able to steer these new "interns".
And just like with juniors and interns, you have to put a lot of effort into it, and it's not always clear in the end if you gained or lost something :D.