Am I using LLMs wrong for coding?

[u/rozita123456]

I would like to preface this by saying that I am genuinely curious about how other teams work and whether we are not efficient enough.

A few of my good friends are also developers. They often tell me that Claude codes most of the features for them, it also does their reviews and they rely on prompting their coding standards on CLAUDE.md for instance.

The thing is that often, when I rely heavily on Claude to generate code for small features, it quite often makes crazy mistakes. Some examples:

- We use ORMs and QueryDSL to write type safe queries: if a query joins more than 2,3 tables and has complex logic, it almost always does it wrong

- It quite often makes small performance mistakes, like iterating the same multiple times, generating a lot of garbage methods which dont handle data efficiently etc

Do you think my team and I are using it wrong or the hype just .. a hype?

[u/RevolutionaryElk7446]

We're a large enterprise that has been running metrics on LLM use over the last 5 years with employees in US, Canada, and UK.

We rolled back and instead hired 75 more people (not necessarily large for our scale) and it produced far more results than LLMs.

We find they could... do boilerplate.. poorly. Templates did better and if you went beyond solo programming at the basic level and instead hit intermediate or high level programming, the LLMs failed badly. They are linguistic models, not designed for coding. They perform at just below Junior levels.

It's a lot of hype, and you'll have a lot of people experiencing programming for the first time, or that it does things they couldn't do before. I'm sure it can for them, but in the field where we need experience and application, students learning poor programming skills from LLMs is definitely not it.

I say this as someone who has been in the AI field since the 2000s and carry various certifications including Gen AI.

[u/Saltynole → u/RevolutionaryElk7446]

I agree with everything said here and can corroborate most of these points, yet all I see from where I sit is more companies/teams pushing to use more AI despite the dubious benefits. Are they doing something I’m not that makes their AI workflows less prone to errors or are they just content with the new reality of checking AI generated work as the bulk of the work we do now? Is it all a bunch of hot air or am I missing something? Im so unmotivated by this trend: AI that is being pushed on us and they insist is the future, that makes mistakes we would be reprimanded for if they were human generated

[u/RevolutionaryElk7446 → u/Saltynole]

It's currently subsidized, so everyone is trying to take advantage of what they felt was 'free labor'. Others are jumping in because they hear the hype. Business owners and CEOs are basically entirely about hype today, even the valuations. Our company did similar, but the customer feedback this last year has been horrendous due to so many issues that were RCA'd back to the LLM integration.

However, at the subsidized costs a lot of companies are finding out it still costs more than labor and often to achieve lesser results than with just regular labor.

We're at the point that they are pulling the subsidization and the costs are only going to increase, and the LLM product is going to narrow in focus. We've basically hit the high point for LLMs currently as we've thrown more money it than any other singular thing in the last few years and achieved almost nothing in return.

[u/DauntingPear → u/RevolutionaryElk7446]

I mean I can rack up $40+ in a day of “cost” from my $20/mo Claude subscription. No clue how that works but that’s what the usage page reports.
It would be insanely easy to let Opus free and rack up hundreds to thousands of dollars in a day.

[u/Stunning-Way-7527 → u/RevolutionaryElk7446]

Big corporations don’t lead revolutions. They industrialize them.

Their competitive advantage is scaling what already works, not discovering what works. That’s why “every Fortune 500 company is doing it” has never been strong evidence of product-market fit. More often, it simply means the hype cycle has reached the enterprise.

Meanwhile, millions of small development teams and solo developers are moving extraordinarily fast. There is far too much attention on the dinosaurs.

I normally distrust anecdotal evidence, but our own very small team has used LLMs to build things for clients that were previously unavailable at any price—and far beyond what we thought possible only a few years ago.

Sometimes size matters less than speed, judgment, and deep expertise in a specific domain.

Aircraft carriers may simply not be the ideal use case for LLMs.

[u/rozita123456 → u/Saltynole]

im wondering the same thing

[u/ghandimauler → u/Saltynole]

13 years of coding on a range of projects for many companies (we helped out companies that needed help because they weren't good at development).

Back then, we saw:

• visual coding (seems a bit slicker and more useful, but still limiting)
  
• many middle managers weren't coders or designers and were good at dealing with finance and tracking where the project was at (roughly) and talking to higher ups, but that's about of what they could do (a good one would ask what you needed and get it for you to speed things up)
  
• coders assuming that SLOC (significant lines of code) was a good metric and pushed coders (which isn't the right answer - the best answer is understanding the the problems, the limitations, and what you can change, what you can't and what will give the best performance and UX experience).

I don't mean to be unkind to the people that have work using vscode and other such tools, but if they are really stuck, could they go deep into the libraries and understand them, let alone figure out how they could improve them? I don't think many could.

I worked on a cell phone network. The product was an integrated auditing, authorizations, authentications, and managing all the connects to the clients and had the whole framework that provided user management and device management and plan management and monitoring and support. We worked on customizations for varied companies like Sprint, AT&T Mobility, and Verizon. Also were asked to move their entire framework from SunOS to RHEL5 - hardware, software, and a lot of libraries. 18 sprints (3 week sprints) and when we dropped an early alpha, the client (in India) put 50,000 or so live customers onto their network - by accident. But we got very few complaints. When we finished and delivered, we wondered what had happened. We had less than a month of support because the whole 7 millions were running well including support. They just didn't need any more help.

The only reason we could do what we did so well was a group of experienced coders. I remember figuring out a problem that went right into the OS (after coming from the UX, through multiple servers, multiple tiers, and multiple languages...). It turned out that one of SunOS' features was that one of the handles and it was atomic. In RHEL, despite their man pages, it actually wasn't. But you had to have get through several languages and a lot of polymorphysm and a lot of network traffic to even get to the place where you could begin to discover the problem.

Also learned SNMP MIBs and how to set them up (adding new things to be monitoring) and I rewrote their support software (in Perl....) and the support folks were very appreciative because I actually took the time to map most of the actual failures and push them up to the support framework. Before that, most errors just blew up and nobody knew why or when.

Being in a rush and depending on one language (as enough) and an AI for your worker... not going to be a good approach in many places.

[u/rozita123456 → u/RevolutionaryElk7446]

no no .. im not talking students! im talking seniors and tech leads in startups or unicorn companies

[u/RevolutionaryElk7446 → u/rozita123456]

Yeah... to be honest we're talking about the same people.

[u/Sufficient-Pause9765 → u/RevolutionaryElk7446]

Bad harnesses and bad adherence to SDLC. The LLMs have limits, but with the right infra and eng management are more like a good senior.

[u/D0ntBotherMe2Day → u/RevolutionaryElk7446]

What cert do you have that you recommend

[u/4Dethklok]

If you one shot claude and get bugs. Apply the fix, then have claude analyze the issue and structure along with anything you can think of in a mark down file to reference at a later time. When you build a big enough context mark down file, claude starts making less mistakes. Whatever claude generates, you are the code owner of that code and is in charge of debugging, fixing, and documenting so claudes code output becomes more standardize with you or your organization's code structuring and formatting

[u/Al_Cioppino]

Agentic workflow (multiple agents working on parallel processes guided/guarded by a conductor and converging at the end of a sprint all on their own branch) and loops (the llm iteratively prompts itself against a high level goal) are efficiency multipliers. You still need to define the rails with spec driven development, test driven development and clear architecture.

All LLMs make mistakes, it's how you handle the recovery / fallback process. Most projects benefit from a corpus of skill files directly related to the operation of the project itself (ex. your query join idiosyncrasies).

[u/rozita123456 → u/Al_Cioppino]

but even after doing all these are u confident claude can review PRs on its own or that u donz need to fix any code it has generated?

[u/Al_Cioppino → u/rozita123456]

There are always some errors and I keep my eyes on outputs, but in the last 6 months the frontier models have become very very good and with proper guardrails and guidance are very productive. This idea that AI only produces slop code is outdated; the best engineers in the world are leaning on it to get stuff done.

[u/EfficiencyMurky7309]

I use Claude in my workflows for some very specific tasks that are administratively burdensome and I have no complaints. I also use Claude Code to vibe-code some simple things for personal use that I just don’t have the time to do otherwise. I’ll generally throw these up on GitHub so they can be refined if useful afterwards.

[u/Stunning-Way-7527]

I don’t think you’re using it wrong. “Claude wrote the feature” often means it generated the code while the developer handled architecture, constraints, validation, and review.

Complex joins, hidden business rules, and performance-sensitive code are exactly where models still fail. claude.md teaches conventions, not your full system.

The best results come from narrow tasks, explicit invariants, tests, query inspection, and human review.

Generating 80% of the code is not the same as completing 80% of the engineering work.
We use Fable 5 for reviewing the codebase and do not rely on it, but its a extremely fast start before humans waste their expensive time!

[u/Alternative_Win_6638]

Short answer: yes, the workflow is probably the issue — not the tool.

I use AI assistants daily and get solid results, including on complex queries and performance-sensitive code.

The problems you're describing — wrong joins, inefficient iterations, bloated methods — are almost always a context problem, not a Claude problem. The model is doing its best with what it was given.

What changed things for me: stopping the "prompt and paste" habit and building a proper workflow around the AI instead. That means giving it clear specifications before asking for code, scoping each session tightly to one feature, and always validating output against explicit acceptance criteria — not just "does it run." Without that structure, you're essentially hiring a brilliant contractor and handing them a napkin sketch. The mistakes you're seeing are predictable.

If you want to dig into what a structured AI-assisted dev workflow actually looks like in practice, happy to share more — or point you to this walkthrough that covers this in depth

[u/Sufficient-Pause9765]

Stack, testing, ci, harnesses all matter. A lot.

Claude code on its own with just skills is a junior developer. You are going to get code duplication, unnecesary helpers, inneficient code, etc.

With a testable stack, with proper work checks, and a harness system that keeps PRs small and enforces deterministic work checks, its a senior dev.

And senior devs, both human and AI still staff level supervision on architecture and complex stuff and human code reviews.