You must log in or # to comment.
This is exactly how I feel about LLM’s. I will use them if I have to to get something done that would be time consuming or tedious. But I would never willingly sign up for a job where that’s all it is.
I use AI coding tools, and I often find them quite useful, but I completely agree with this statement:
And if you think of LLMs as an extra teammate, there’s no fun in managing them either. Nurturing the personal growth of an LLM is an obvious waste of time.___
At first I found AI coding tools like a junior developer, in that it will keep trying to solve the problem, and never give up or grow frustrated. However, I can’t teach an LLM, yes I can give it guard rails and detailed prompts, but it can’t learn in the same way a teammate can. It will always require supervision and review of its output. Whereas, I can teach a teammate new or different ways to do things, and over time their skills and knowledge will grow, as will my trust in them.
I’ve maintained for a while that LLMs don’t make you a more productive programmer, they just let you write bad code faster.
90% of the job isn’t writing code anyway. Once I know what code I wanna write, banging it out is just pure catharsis.
Glad to see there’s other programmers out there who actually take pride in their work.
It’s been my experience that the quality of code is greatly influenced by the quality of your project instructions file, and your prompt. And of course what model you’re using.
I am not necessarily a proponent of AI, I just found myself being reassigned to a team that manages AI for developer use. Part of my responsibilities has been to research how to successfully and productively use the tech.
But at a certain point, it seems like you spend more time babysitting and spoon-feeding the LLM than you do writing productive code.
There’s a lot of busywork that I could see it being good for, like if you’re asked to generate 100 test cases for an API with a bunch of tiny variations, but that kind of work is inherently low value. And in most cases you’re probably better off using a tool designed for the job, like a fuzzer.
But at a certain point, it seems like you spend more time babysitting and spoon-feeding the LLM than you do writing productive code.
I’ve found it pretty effective to not babysit, but instead have the model iterate on it’s instructions file. If it did something wrong or unexpected, I explain what I wanted it to do, and ask it to update it’s project instructions to avoid the pitfall in future. It’s more akin to calm and positive reinforcement.
Obviously YMMV. I am in charge of a large codebase of python cron automations, that interact with a handful of services and APIs. I’ve rolled a ~600 line instructions file, that has allowed me to pretty successfully use Claude to stand up from scratch full object-oriented clients, complete with dep injection, schema and contract data models, unit tests, etc.
I do end up having to make stylistic tweaks, and sometimes reinforce things like DRY, but I actually enjoy that part.
EDIT: Whenever I begin to feel like I’m babysitting, it’s usually due to context pollution and the best course is to start a fresh agent session.
If you think of LLMs as an extra teammate, there’s no fun in managing them either. Nurturing the personal growth of an LLM is an obvious waste of time. Micromanaging them, watching to preempt slop and derailment, is frustrating and rage-inducing.
Finetuning LLMs for niche tasks is fun. It’s explorative, creative, cumulitive, and scratches a ‘must optimize’ part of my brain. It feels like you’re actually building and personalizing something, and teaches you how they work and where they fail, like making any good program or tool. It feels you’re part of a niche ‘old internet’ hacking community, not in the maw of Big Tech.
Using proprietary LLMs over APIs is indeed soul crushing. IMO this is why devs who have to use LLMs should strive to run finetunable, open weights models where they work, even if they aren’t as good as Claude Code.
But I think most don’t know they exist. Or had a terrible experience with terrible ollama defaults, hence assume that must be what the open model ecosystem is like.
Improving your input, and the system message can also be part of that. There are multiple optimizations available for these systems that people aren’t really good at yet.
It’s like watching Grandma google “Hi, I’d like a new shirt” back in the day and then having her complain that she’s getting absolutely terrible search results.
Mmmmm. Pure “prompt engineering” feels soulless to me. And you have zero control over the endpoint, so changes on their end can break your prompt at any time.
Messing with logprobs and raw completion syntax was fun, but the US proprietary models took that away. Even sampling is kind of restricted now, and primitive compared to what’s been developed in open source.
A simple, but succinct summary of the real cost of LLMs. Literally, everything human for something that is just a twisted reflection of the greed of the richest.
Argument doesn’t check out. You can still manage people, and they can use whatever tools make them productive. Good understanding of the code & ability to pass PR reviews isn’t going anywhere, nor is programmer skill
If it allows to kick out code faster to meet whatever specs/acceptance criteria laid out before me, fine. The hell do I care if the code is good or bad. If it works, it works. My company doesn’t give af about me. I’m just a number. No matter how many “we are family” speeches they give. Or try to push the “we are all a team and will win”….we aren’t all a team. Why should I care more than “does it work”. As long as profits go up, the company is happy. They don’t care how good or pretty my code is.
Tell me again how you’ve never become the subject matter expert on something simply because you were around when it was built.
Or had to overhaul a project due to a “post-live” requirements change a year later.
I write “good enough” code for me, so I don’t want to take a can opener to my head when I inevitably get asked to change things later.
It also lets me be lazier, as 9 times out of 10 I can get most of my code from a previous project and I already know it front to back. I get to fuck about and still get complex stuff out fast enough to argue for a raise.
Disagree
Experts who enjoy doing [blank] the hard way don’t enjoy the tool that lets novices do [blank] at a junior level.
Somehow this means the tool is completely worthless and nobody should ever use it.
Except it becomes more dangerous for a novice to use an LLM.
It will introduce vulnerabilities and issues that the novice will overlook.
This is extremely valid.
The biggest reason I’m able to use LLMs efficiently and safely, is because of all my prior experience. I’m able to write up all the project guard rails, the expected architecture, call out gotchas, etc. These are the things that actually keep the output in spec (usually).
If a junior hasn’t already manually established this knowledge and experience, much of the code that they’re going to produce with AI is gonna be crap with varying levels of deviation.
How I guide the juniors under me is to have it generate singular methods to accomplish specific tasks, but not entire classes/files.
You know it’s crazy, someone just told me that’s more dangerous than having them do nothing.
They use it with heavy oversight from the senior devs. We discourage its use and teach them the very basic errors it always produces as a warning not to trust it.
E.G. that ChatGPT will always dump all of the event handlers for a form in one massive method.
We use it within the scope of things we already know about.
Ok, don’t use them…?
This could have been a facebook status
The problem is that many employers are requiring employees to use them.
