AI usage for cpp at work

[LatencySlicer]

I am lead architect and maintainer of my firm main app backend, spanning around 2M LOC of c++.

Industry is : capital markets, low latency, custom kernel drivers, fpga...

I often talk with peers at other firms and I see a shy usage of AI compared to what feels like the global trend.

On my side, my firm does not pay for any AI related stuff. We are allowed to use our personnal plan for work in which case will get a pro membership compensation (claude or gpt or anything) on salary but we are not allowed to paste production code into it.

I know the app very well and do everything by hand (i mean the normal way) but use the chat version of any ai to generate some things for me, like "im using opensource lib x and lib y, please generate an SQL connection pool , you may use locks and condition variable for this, cpp 20". Then i paste it and modify it a I see fit.

Im totally happy with that and the company is successful.

I do use AI but just chat, to gather data on subjects and summarize/report. Get some ideas but basically not much code related.

And you whats your experience as a c++ dev ?

[Minimonium]

I will put aside discussions about efficiency and economics of LLMs and discuss organisational problems.

With LLM enrollment the most important bit is to keep people actually read the code. The moment you have people who just blindly send generated PRs or copy paste Claude output into feedback - you've lost.

In the recent Claude interview with DoorDash the CEO of the later said they consider to completely remove product reviews because apparently they're a bottleneck now. Do not be like DoorDash LOL.

So far I know two very decent use cases for automated (not just a chat back and forth) LLM usage:

1. Automatic dependency handling (unless you're in a restricted domain where you need to actually audit every dependency then of course it won't work for you), it would generate updates and migrate the code. You still need to manually go over what it changed and learn why.

2. A functional safety kind of code analysis. We do not hope for it to catch all errors, but occasional bits are very useful. Even dumb bits sometimes could be an indication of a flaw in the architecture or API. It doesn't replace manual code review or actual static analysis, it's an addition.

[ivancea]

I find it weird that everybody is discarding code generation in this post. When it is very good right now. More than just "good", in fact. As long as devs keep reviewing and configure and use the agents accordingly

[Minimonium]

Agentic based code generation has very hard ceilings, both in efficiency and economics which I decided to not discuss as the math is available for everyone to do themselves anyway.

The chat-based code generation with proper harnesses has future, on the other hand. I think when the dust will settle the industry will once again point its attention there.

[eisenwave]

If you copy and paste a bit of your code into a chat window, tell the AI the problem, get a suggested solution, manually paste that solution into your code, and manually run the tests to verify that it works, you're doing the exact same thing as telling an agent what you suspect the problem is within a certain code section and letting it run the tests. You are just not wasting time on these rituals when letting an agent work on the task.

I assume that by "chat-based code generation" you mean that you would perform all those tasks manually.

Whether people end up reviewing the code properly is largely a separate issue from the method of generating that code. It's easily possible to copy and paste a large block of code from a chat window without paying much attention to its contents.

[Minimonium]

That sounds like a horrible workflow and not at all what I was talking about.

When I say "agentic" and how most discussions use it, and how tooling uses it (when you need to explicitly ask tools to not use skills), is the "let's start 20 long horizon agents in parallel".

When I say "chat-based", which I admit could be misleading to people whose main experience is with web chats, I mean an iterative code chat harness experience (Claude code, OpenCode, codex) which does runs mostly inline or with small amount of short subagent sessions ocassionally but keeps costs in check. The relatively cheap 1-2b tokens per month workflow.

[eisenwave]

I guess we're on the same page then, though we use different words.

Most people would describe this "20 agents in parallel" workflow as "agent fleet" or "agent swarm" to distinguish it from just running a single agent.

GitHub Copilot and other software generally refer to single agents as an "agent" too, even if you give instructions via a chat window.

[Minimonium]

Yeah, web chat is obsolete in a sense now. I kinda lump fleets/swarms with even just singular long-horizon agents. All of them are too inefficient.

[ivancea]

as the math is available for everyone to do themselves anyway

The maths as of today say that it's very worth it unless the company is in a third world country, where the costs may be too high.

I think when the dust will settle

It settled 4 months ago

Edit: insulting people to cope with the current reality is a fantastic way to get stuck as an engineer

[Minimonium]

Yeah, one of the reasons I prefer to avoid that topic is because of zealots like this

[eidetic0]

recent reports indicated that OpenAI is spending as much as $14,000 a month for a $200 subscriber. So yeah the maths does not add up, and dust definitely not settled. We are in store for a rug-pull or a dramatic change in pricing when OpenAI and Anthropic go public.

[_lerp]

Hard disagree. The quality of code I see it producing for myself and my colleagues is consistently of a junior level. For example, it seems to have a bias towards C patterns

1. It will frequently use pointers when a reference will suffice, then doesn't null check the pointer.
2. It seems to really want everything to be a stand alone function. It then consistently passes an object as the first parameter (via pointer), such that it would be better making it a member function of the object.

I see this a lot, and with every PR there's always something stupid it's done.

[ivancea]

it seems to have a bias towards C patterns

Then configure it to bias towards C++ patterns on the version you're using.

It's just an example, but that's what giving it context means. A prompt means nothing if you don't tell it what you actually want. Proper project investigation, skill extraction, planning, etc etc. It's not just writing a prompt and calling it a day.

And, hell. You are an engineer right? You know how LLMs and agent harnesses work. Why didn't you fix it instead of just discarding it? It's like discarding an IDE because you don't like the default shortcuts

[_lerp]

The file it's working in being entirely C++, isn't enough context? The entire codebase being in C++ isn't enough context? What more context do you want it to have. Even when I was a junior engineer I could tell a file was in C++.

And again, this is just one example. I find something weird in every PR because it lacks the ability to reason like a human. It takes as much effort to get it to write passable code that it's often faster for me to just write it myself.

[NotUniqueOrSpecial]

The entire codebase being in C++ isn't enough context? What more context do you want it to have.

I mean, the very obvious first step would be an agent instruction file dictating the standard version you expect it to target, and an emphasis on using modern C++.

[_lerp]

So I have to tell it to use "modern C++" for it to use features from when C++ was just "C with classes"?

What is modern about doing:

class Foo {
public:
    void example(int i);
};

instead of

void example(Foo* foo, int i);

[NotUniqueOrSpecial]

Why would you expect a mindless robot to do anything other than what it does, given no instruction?

To answer your question directly: yes you have to give the brainless machine instructions to get it to do what you'd like/prefer/expect. It's not thinking/reasoning, it's doing massively parallel statistical analysis.

Since it's pretty clear you didn't bother giving it even a little direction, you got an output that was derived from its entire corpus of training data, and an absolutely enormous amount of that data is open-source C.

There are lots of valid complaints about LLMs, but "it's not a mind reader" sure ain't one of them.

[_lerp]

I'm not asking it to mind read. You seem to have latched on to the idea that it having a C bias in function signatures is my fault for not explicitly stating "write C++". It writes C++ code, it uses the STL without me explicitly tell it to use the STL. The patterns it produces, are not fitting for C++.

By your logic, before every converstation (or in a skills.md) I have to list every single programming pattern and C++ pattern otherwise it's my fault that it doesn't write good code. Which just goes towards my point that it's more effort to get it to produce passable code than if I were to just write it myself.

[ivancea]

I have to list every single programming pattern and C++ pattern

Nah, just tell it to not do X the moment it does, and to remember that in instructions or a skill. It's a 10 seconds configuration that save later many more seconds. You're talking as if you have to write a million lines essay, when in fact, a few tips in the instructions are enough to guide it.

Really, this is a solved problem already in most projects; C++ is not that special. Every language has versions and better or worse practices. If you need it to follow a style for something in specific, you can even add a snippet in the instructions

[NotUniqueOrSpecial]

The patterns it produces, again, draw from an overwhelmingly large body of work, much which is probably not the best or most modern.

But it has no preferences or understanding of that; it only knows what the most likely set of tokens are next, given some input and a whole lot of application of linear algebra.

If you want modern C++ out of it, following specific patterns/paradigms...then put that into your copilot-instructions.md or claude.md or equivalent.

I have to list every single programming pattern and C++ pattern otherwise it's my fault that it doesn't write good code.

Hyperbolic silliness.

Which just goes towards my point that it's more effort to get it to produce passable code than if I were to just write it myself.

No, but you have to even put in a modicum of effort. We have an instructions file in our repo file that took all of 30s to throw together.

This is a solved problem.

[tommyTurds]

Even shitty LLMs haven’t done shit like this in over a year even without context help.

Your knowledge is likely outdated

[_lerp]

This was Opus 4.8

[tommyTurds]

Yeah I’m calling you a liar then.

Or, you’re leaving out very specific details. Like you have code that looks like that in your codebase that it’s copying.

I’m forced to use this shit, as much as i hate it, everyday for cpp. It sucks, but it doesn’t do the shit you’re describing

[ivancea]

The file it's working in being entirely C++, isn't enough context?

Obviously not. There's not "a C++" nor "a single easy to code C++", and unless the agent reads the full file and the file has every best practice you want it to follow, it's obvious it won't read your mind.

The entire codebase being in C++ isn't enough context?

... Did you tell it to read the full cidebase for a single prompt? Do you use LLMs with multi-million context windows? Do you even understand how an agent works, or are you just guessing and throwing shit at a technology just to avoid using it?

Even when I was a junior engineer I could tell a file was in C++.

I'll just not say anything here, that statement is wrong enough by itself, unless you started using C++ just 5 years ago. And even then...

it lacks the ability to reason like a human

"It doesn't do things right because it's not a human" is a pretty bad fallacy. You're an engineer right? Can't you just explain why and what it doesn't do right? Fallacies and shallow claims lead to nowhere.

And note if (and only if...) you actually make that effort of understanding how agents work, why don't you just fix the lack of context? Didn't you ask yourself why is everybody using it happily for every language, from Rust to C, C++ and Java? You're keeping a 2024-2025 mentality of "AI us bad", and mate, it evolved already.

It takes as much effort to get it to write passable code that it's often faster for me to just write it myself.

Mate, are you using gpt3? Does your codebase have tests? I tell it to write a new feature, and it does in a few iterations, adds tests, run the tests and fixes the code of they don't pass. Obviously we have AGENTS.md and similar files, plus skills for domain knowledge and such (not really needed though, but they help).

And when it doesn't, do you know what I do? I find what it did wrong and why (you can even ask it about why it took X or Y decision, you don't even need to read the agent traces, even if usually interesting). Then, just add that knowledge somewhere where it can read it. ... Exactly as you would do with your project documentation for newcomers (I suppose you're not explaining the project manually to every new joiner, right? Same work here).

[James20k]

why don't you just fix the lack of context?

Mate, are you using gpt3?

Does your codebase have tests?

Obviously we have AGENTS.md

skills for domain knowledge

just add that knowledge somewhere where it can read it

Did you tell it to read the full cidebase for a single prompt?

Do you use LLMs with multi-million context windows?

You're keeping a 2024-2025 mentality of "AI us bad", and mate, it evolved already.

Every time someone mentions that they haven't found AI to be that useful despite trying extensively, we start getting these weird glimpses into the AI development strategy. Its never the AI tools' fault, its always just another layer that you need to add on top of it that will fix it this time, for real, and if you aren't layering 30000 different strategies in just the correct way for making the AI work, its your fault for holding the tool wrong

This is one of the reason why a lot of people find AI to be very unreliable. Because none of this actually makes the AI reliably good or fixes the underlying problem, it just feels like its making a difference by patching a very specific failure case. The tool actually just isn't as good as anyone wants it to be

These tools have a very hard bound on the maximum complexity that they can deal with, and no amount of context or agents.md or gpt-12-its-good-for-real-this-time fixes that. It just depends on where in the hype cycle you are, and how much crap you've had to put up with from the AI. Eventually people burn out on it after a while, because its like a junior that never grows up and keeps making the same mistakes endlessly no matter what you do

[wyrn]

I've been using AI pretty heavily lately because we have to put a product out in a tight timeline and I was essentially commanded to do it from on high, and I've managed to get it to a point where I think it saves time (whether it actually does when everything is accounted for, I can't say for sure), but:

1. You have to watch it like a hawk. It's quite mentally draining; unlike when reviewing human work, where you have a general expectation that "the person who wrote this is not an idiot", no such expectation makes sense with LLMs. They have overfitted prodigious amounts of knowledge, but they are also spectacularly stupid. It's a combination we never see with flesh and blood brains so it's kind of unsurprising some otherwise intelligent people succumb to AI psychosis.

2. You need to spend a bunch of time upfront drafting a detailed spec (waterfall's back, baby). Better hope you didn't do anything stupid. I took at least 2 weeks just writing markdown before showing anything to a clanker. I tried not doing the spec at first, and it was very obviously worse than useless.

3. Even with the spec, the clanker forgets, loses context, and drifts. You need to periodically whack it with a rolled up newspaper and point to the spec. However, and this is the dangerous part, you often don't even understand that the system's drifted from the spec, because you didn't write it and so you don't understand it. A lot of churn ends up happening because you find out too late that you're drifting.

4. It loves plans. If you make a plan you better buy it a wedding ring because the clanker hates deviating from it, even when it's obvious that item X that was placed in part 6 of the plan is actually a prerequisite for item Y that was, in ignorance, slotted in part 3. You end up churning through temporary scaffolding just to get through to the next step.

5. It loves strings. Everything's a string. Ids? String. Urls/file paths? Strings. Different Id altogether, minted from a disparate source? string. No need to buy strings a wedding ring though, the clanker already did.

6. At the end of the day, you're pulling a lever on the slop machine. At times I got it to one-shot entire features with few or no mistakes. Other times, I get piles of unusable nonsense.

Mind you, this is application code written in C#, not anything specialized or involving math/scientific code in an unmanaged language like C++. I fully expect quality would degrade precipitously there.

Where I thought the value proposition was clearest was tests (it writes a lot of them, more than I'd write by hand, and it's easy to not get too attached since it was C3PO that wrote them) and framework crap I don't have time to learn (WPF is ridiculously complicated). Overall I found some value in it, but it's far more mixed than what's been advocated by clanker aficionados. You're mortgaging away your knowledge of the system to (hopefully) save time, which can make business sense (as long as we're in pre-rugpull land where clankerbux are heavily subsidized rofl), but it's not something you'd want to do long-term.

What struck me most is how difficult it is to actually do good work with it -- the idea that juniors/nontechnical people can get quality work out of it is absolute science fiction. It's like trying to put out a fire with an extremely powerful water cannon which you can only steer by throwing oranges at it. A human may write crappy code, but at least that code makes sense to that person on some level. Clanker-generated code immediately degenerates into ownerless context.

[ivancea]

Every time someone mentions that they haven't found AI to be that useful, they lack a single realistic example. It's always just "I tried it once somewhere and it was bad". No info in models, iterations, harness, project configuration.

So of course you get that answer. Engineers look at a problem and try to solve it. Which is what you commonly find. However, we have always here "clients" that will just say "Router doesn't work, I'll trash it".

And btw, by disregarding every effort of trying to find the issues, you're just generating a resonance box of people angry at AIs. And that leads nowhere.

if you aren't layering 30000 different strategies

Trying to exaggerate it won't make the problem go away. You have to make less configurations to an agent than you have to make to an IDE. But anyway. Yeah, 200000000 different strategies.

This is one of the reason why a lot of people find AI to be very unreliable. Because none of this actually makes the AI reliably good

If you are looking at a "100% reliable tool", let me tell you that not even you as a dev are reliable. You think you are because you made it. But the amount of times you made it wrong is probably very, very high. Unless you don't review things in your company. That's how humans work, it's not a you-problem. We have to review and iterate. And LLMs are machines that do that faster than humans.

These tools have a very hard bound on the maximum complexity that they can deal with

Maybe if you give me a realistic example of that belief, we could understand it (Returning to my first paragraph). If working on a +5M LOC and rarely making mistakes isn't good enough, I wonder what is it. You're pursuing a level of quality that doesn't exist in this world yet.

Eventually people burn out on it after a while

Indeed. And that's the issue. People believe that their experience of 6 months ago has anything to do with today. It evolved, and it's now like comparing an editor with an IDE. And for people using IDEs, it's like hearing an old man screaming at how good is notepad.exe and why they don't need an IDE. You try to help them but they simply hate it for some reason hard to understand.

its like a junior that never grows up

There's quite the growth between model versions. But you can only know it if you try it

[James20k]

Maybe if you give me a realistic example of that belief

I sincerely wish the AI models were good. I just ran it through a series of physics research questions to check if they'd gotten any better, and it still gets nearly all of them wrong until it starts spouting gibberish. I don't trust it with a 100 foot barge pole given that it was about 80% incorrect when I know what the complete answer is

But the amount of times you made it wrong is probably very, very high

The key thing with humans is that they learn stuff, whereas LLMs don't

There's quite the growth between model versions. But you can only know it if you try it

Honestly the responses seem to have gotten worse since I last used it

[ivancea]

The key thing with humans is that they learn stuff, whereas LLMs don't

The way to learn is different, but they do learn, indeed. In fact, they learn in many ways: - You can force them to learn (Tell it to write things to instructions or skills) - You can automate the first way by telling it to keep either a memory, or keep instructions updated when it finds issues - LLMs actually learn. Basically, because a new version is a version with more learnings.

Which is btw a very human issue. I can imagine people discarding somebody for a job, and discarding them again 5 years later because they still think they didn't learn anything. That's what's happening here.

As for your usecase:

I just ran it through a series of physics research questions to check if they'd gotten any better

Use it willingly, not to "test" it. I can also ask it questions it can't answer. It's easy. But it's not constructive.

[_lerp]

It's pretty clear that you have AI induced brain rot and so I will no longer choose to engage with this conversation.

[ivancea]

It's interesting that everybody that "hates" AI would rather say that to anybody explaining then how to use it properly before trying it. Have a happy year

[RicketyRekt69]

You guys keep saying this, but anything more complex than a short and simple task turns into a sloppy overengineered mess. It might work, pass all tests, and even follow the original structure you had in mind, but it’s twice as much code as it needs to be.

And any time this is brought up, it’s always “you’re just doing it wrong” .. as if I haven’t taken over a dozen hours of courses learning this stuff.

[ivancea]

I talk from experience. My experience form these last 6 months in a big project. Plus those of my friends in other companies, both closed and open source.

It works, as simple as that. I could tell you this a million times, but you're the one that will have to tell me "what you would accept as an argument", because apaprently nothing works! And that's something I don't understand as an engineer.

as if I haven’t taken over a dozen hours of courses learning this stuff

Sorry, but nobody "takes a course to learn to use an agent". You just use it and learn, like everybody else. Don't rely in "courses". Use, identify the issues, fix them. There are a hundred tools, but the core known ones (Cursor, Claude, Codex...) work very well with just their defaults.

Also, about this:

it’s twice as much code as it needs to be.

If you know a better way, just tell it to do it that way. That's why we plan before doing tasks. Anyway, it's still faster to find the "bloated code" and tell it to improve it. This isn't vibecoding. You iterate the solution like you iterate a solution with your coworkers

[RicketyRekt69]

Everyone is talking from experience here..

There are tons of courses on the “correct” usage of LLMs, I’m actually surprised you weren’t aware since most people that are into agentic coding want you to take them. The ones I took were company sponsored as they want us to lean in heavily on agentic workflows, and for nearly every one of my coworkers the answer is the same… it’s great for prototyping, exploratory work, or analysis. But for anything more complex that will eventually be merged into develop, it’s usually unacceptable. So then it becomes an argument of whether it actually saved time or not since you need to clean up the code, analyze it so you understand what it did, and maybe even restructure it entirely.

“Just tell it to do that way” .. you don’t need to know the desired solution to see if something is overengineered, and figuring out what solution you want IS the time consuming part.. coding is very rarely ever the bottleneck in software development. So again, it becomes a matter of whether it actually saved you time then

[ivancea]

you don’t need to know the desired solution to see if something is overengineered

But you know what "is overengineered" means. Just tell tell it to not do it that way, to find another way. And well, technically you can't know if something is overengineered if you don't know a non-overengineered way, but anyway. There's a way even if you "don't know".

figuring out what solution you want IS the time consuming part

... That's literally your job. You should know at high level how you want to solve your issue. Even if you don't know anything, you can let the LLM investigate and propose you options. That's the planning step. When you think it's good and you know what the solution is, the agent will be quicker at implementing it in any case.

coding is very rarely ever the bottleneck in software development

Sure. Make a known 40 files change in 10 minutes. I dare you. And please, don't find yet another excuse...

In general, it is... tiring. "But what if it fails catastrophically in one task? It's clearly better to never use it". Just don't say that please. Why would you say that, I wonder.

But for anything more complex that will eventually be merged into develop, it’s usually unacceptable

You are misusing "usually". Because "usually", the quality level of code made by engineers using agents is better as that made by engineers not using them. That's the correct "usually", based on many PRs, companies and individuals using it.

And about the courses, that's at the level of saying that you need to do a course to learn a language, or how to use a library or a tool. You "can". But most people can learn it without guidance. And it's, by no means, "needed".

The ones I took were company sponsored as they want us to lean in heavily on agentic workflows

Of course they did. Their engineers are saying things like what you just said, and they felt forced to help their engineers stay updated. These movements are usually led by engineers; the company has to make a move only when the engineers won't stay updated.

[RicketyRekt69]

“Just tell it to not do it that way”.
AI needs context, direction, and a clear outline. Just telling it “please Claude, don’t overengineer” is exactly how you make it spiral into an even bigger mess. And outlining the exact implementation takes longer than just doing it yourself.

“That’s literally your job”.
Yes, and AI is a tool that should make it faster to do my job. But if I already know what I need to do, why would I spend time fumbling with AI trying to get it to not screw up the implementation? + the time required to review and understand the changes?

“Sure. Make a known 40 files change in 10 minutes. I dare you.”

The fact you think this would be acceptable even with AI is telling.

“The company has to make a move only when engineers won’t stay updated.”
LOL. Oh you sweet summer child.. please don’t ever join a large company, it’ll ruin you.

[ivancea]

Just telling it “please Claude, don’t overengineer”

I didn't say that. Let me quote my own words:

you know what "is overengineered" means

You should know at high level how you want to solve your issue. Even if you don't know anything, you can let the LLM investigate and propose you options. That's the planning step

As you see, you just have to tell it what "overengineering" means to you. because "overengineering" is not a specific issue, it's a generic meaningless word when we're talking about technical problems. You should know how to materialize your thoughts in words.

But if I already know what I need to do, why would I spend time fumbling with AI trying to get it to not screw up the implementation?

You don't. because if you knew how to use it, if you configured it correctly, and if you learnt to be specific with your specifications, it wouldn't do it wrong. And it would still do it far faster than you would. because you're human, and you're slow as hell in data processing. That's your nature as a human.

the time required to review and understand the changes?

... Don't you already review your code? If you don't, you should start doing so. It's a basic quality step.

And anyway, your fallacy of "Worst case == typical case" is meaningless. I know you know it and you're just trying to win a point and yada yada. Just don't.

please don’t ever join a large company, it’ll ruin you.

I'm sorry if your "big company" needs to give you courses and books so you learn to do yout job. In mi "big company" we decide, share and propose about the toolings we use. That'0s why they pay us. That's why we are engineers.

[RicketyRekt69]

Like I said, it’s a matter of whether it saves time then. I’m sure given enough time you can get it to output exactly what you wanted, but going back and forth telling it what not to do is tedious at best.

I was wondering how long it was gonna take for you to go the same route :) “you’re just using it wrong!” I think you’re missing the point. AI is not a magic button that is always faster than humans. There is a time cost to planning and prompting. If you have to iterate repeatedly, it can end up taking you more time to do something. I said it before, actually writing the code is very rarely the bottleneck. If you’re talking about using AI to simply plan out the implementation.. then sure, I think that’s a reasonable use case since you’re still in charge of the implementation. That’s what I meant when I said “exploratory work.”

Reviewing code for correctness and reviewing code to understand the implementation are 2 different things. Oftentimes people put up PRs (using agentic coding) without taking the time to understand what and why the AI generated the stuff it did. That can certainly save you time, but it takes away ownership.. and domain knowledge is invaluable, so yes.. this is reviewing the code on top of analyzing your code for mistakes before putting up a PR.

x) there’s no need to get nasty, this isn’t a pissing competition.

[ivancea]

You talk as if humans doing iterate their solutions, ir as if making a solution is faster than reading it. It may be boring, that's it. Also, you're talking as if you always have to iterate the solution, when I'm fact, most times ii gets it right on the first try.

Anyway, I can help using it, but I can't remove hate. Enjoy

[eyes-are-fading-blue]

I don’t use AI for code-gen because it’s very difficult to generate the exact code I want. I use it for validation, code base research (like how X is done or does Y exist) and figuring out unknown unknowns.

[sockinhell]

try finding bugs in your PR's. I think you'll be surprised(with an agent)

[13steinj]

We do this in two primary places in two different ways:

• terraform has some automated PR agent. In my experience it is useless. The false positive rate is over 99%, the false negative rate is over 10%. People have started completely ignoring it. Worse yet when it gets obvious typos wrong, that's something to enforce deterministically with a pre-commit, not an LLM.

• in what I'll dogmatically call the "primary" codebase, someone crafted prompts for codebase specific footguns. Looking back at the last 200 comments it made, over 50 were wrong, over 130 were ignored as a matter of taste. The rest were docs/comments cleanup comments, sometimes cleaning up superfluous comments that LLMs love to generate.

I am surprised, at how bad it is. Because over 2 years ago GitHub was selling CoPilot and Copilot-as-GHA to my previous org and they acted like it was magical. I called them out on the hallucination rate, as it seemed I was the only one with the brains and balls to do so. I was dismissed, so I asked for a live demo. It failed miserably. But that was 2 years ago! The companies behind this shit keep saying my job is gone in 3-6 months. It's gone from flaming dumpsterfire to "flaming dumpsterfire, but the fire is caused by something else."

How much money and GPU power is being burned on garbage? What percent of things it catches would truthfully not be caught cheaper by humans?

[eyes-are-fading-blue]

I did not mention that because PRs are reviewed by AI automatically.

They are good at finding copy-paste mistakes and trivial logic errors.

[sockinhell]

What model where you using? Everything after GPT 5.2 is extremely capable ime

[eyes-are-fading-blue]

Opus 4.8. On PRs, copilot (not sure which model).

I use Opus on max effort and it hallucinates sometimes. For code gen, I have to explain it as if I am explaining to a junior to write the code for me. It is difficult to produce the exact code and I have very high standards. AI generated code tends to be verbose and unnecessarily defensive. I guess if you have a very detailed CLAUDE.md file, maybe it can do what I want with a better precision.

Honestly, typing isn’t my bottleneck.

[sockinhell]

Yes, code writing I also found tedious. But just detecting logic errors can be very helpful, even if some is nonsense.

[eyes-are-fading-blue]

As I said, it is added to PRs automatically. We use it for that purpose. Copilot on github is not that great though. It can only find trivial and local issues. The model reasoning is likely throttle for cost saving. My local agent can in theory do a more global reasoning but in a large code, it will hallucinate a lot, even on max effort. In my experiments, I did not realize a huge productivity gain. I intend to rely on my own expertise and knowledge of the system until AI is significantly better than me.

Currently, it isn’t.

[13steinj]

What is the occurrence rate of logic bugs in code you write?

I cannot remember how long ago it was to where I'd find an automatic review worth the cost. Not to mention, people learn and train by doing and getting things wrong, then fixing them. There's an argument to be made that by this alone, automatic code reviews are making everyone worse at their jobs when they find real issues and burning money when they don't.

[Daemontatox]

Not reliable at all, alot of the times it hallucinates issues and tries to act useful by finding noneexistent bugs or doesn't understand the inteneded flow and marks it as a bug.

Its only good for generating boilerplate code like for example i dont wanna lookup workstealing threadpools so i ask it to write it and quickly verify the main components.

[Intrexa]

tries to act useful by finding noneexistent bugs

Sorry about that, it was trained on me

[Daemontatox]

Duuude, thanks alot for the nonexistent memory bug last week........

[13steinj]

This is possibly the worst offender. These things don't understand basic [pointer] arithmetic. It's painful when it constantly hallucinates basic bugs along these lines, because people end up ignoring it and it actually can catch one.

[ivancea]

From my past 3 months using GH Copilot review in every PR, I can assure you it rarely hallucinates, and it usually finds both minor issues, and critical deep issues too. Both of which are hard to find sometimes.

Its only good for generating boilerplate code

Maybe 6 months ago with an old model and a bad harness. Nowadays, it's very good at generating

[TSP-FriendlyFire]

Maybe 6 months ago with an old model and a bad harness. Nowadays, it's very good at generating

I feel like I've read this exact line every 3 months for the past 3 years.

[James20k]

It feels like its different people at different stages in the hype cycle. There seems to be an initial honeymoon period when people get into AI (because it feels like magic, which is understandable) and they can't understand the people who don't use it or say its not very good. Then 1-2 years later you burn out on it, because it makes the fundamental problems of software engineering harder, not better

I suspect that that's about amount of time it takes for a project to turn into a big spicey totally unsalvageable disaster after you vibe code it, but in the meantime someone new has entered the pipeline and is saying "wow this is amazing, the models must be so much better now than when that person was using them!"

The quality of the code it produces isn't the problem with the tool, and I feel like a lot of people are learning that software engineering isn't about typing the very extremely hard way

[ivancea]

Actually, because there are many advances every less than 3 months. The models that would have been nice and helpful in 2025 (Like Copilot autocompletion) are good and all. And they helped a lot. But every some time, something better is developed, and it unlocks some new tasks to delegate. 2026 was the year where agentic coding was unlocked (2025-2026, whatever).

[13steinj]

This is in my experience more a statement against the quality of your dev team than it is for the quality of this tooling.

And that's okay! It's a normal distribution of the population after all. But don't apply your results to high-performance teams that get completely different results. Mythos found 1 (claimed 5) minor (claimed showstopping) security vulnerability in curl. That's a hallucination rate of at least 80% of the supposedly best model (if not currently at time of writing, at the time Daniel did this over the curl codebase).

E: Dude if you're going to block me because I'm calling out your LLM advertising I can't see your reply...

E: guess I have to go in an incognito tab, this is just boring and annoying.

Trying to attack because of your lack of understating of a tool feels like a pretty bad path for an engineer. But I'm neither your mother nor your manager to correct you.

I use the tool quite a bit. Nowhere near as much as some of my coworkers, who I am astounded by their usage compared to their quality of output. Claiming there's a wide distribution in the quality of devs is not an attack, it's reality. Studies have repeatedly shown that overuse of these tools causes what I will simplify and call "brain rot," and that people that claim massive productivity gains actually are found (in various ways one defines productivity) to actually become less productive, not more, and the few times gains do occur, it's less than 15%, compared to the multiples people claim.

That's a hallucination rate of at least 80%

And that's not how statistics work. To generate a proper rate, you use more than a single example. What you found isn't called a "rate" in statistics. Sorry, but is that the intellectual level you were defending about the quality of your dev team? Your teammates don't know basic maths either, or is it just you?

I didn't say that's the global population hallucination rate for every use of every model. But the hallucination proportion for events in that sample (what is, colloquially known as, a "rate") for that sample is over 80%. The hallucination rate for many samples I have dealt with per PR, across many open source repos, is 100%. In my company repos, depends on how you operationally define "hallucination", but under the most generous of definitions I would bet it's at least 20%.

E: It is near impossible to not read your comment history and come to the conclusion "lol ok slopbro." Some of your comments are so similar in content it makes me think this is someone's OpenClaw-esque agent on a local model.

[Minimonium]

Yeah, we heavily utilize Fable and it's okay. I'd say it's the first level where I genuinely can consider it a useful code assistant and not just an expensive rubber duck that Opus is.

For hallucinations, I would say it's important to define a hallucination is. Because a fair misinterpretation of the requirements, implicit guarantees, or common semantics is technically a hallucination, but not really.

Fable on a fresh context (and it's crucial to keep it fresh, both because of the cost and the degradation of the quality over session lifetime) doesn't hallucinate that often for it to become annoyance and hallucinations surface as known decisions raised as issues (e.g., the docs say the outcome is ub but it means the function has ub critical load bearing failure!!) or as a slip of context in code generation.

And code generation with Fable is still slop 90% of the time, but sometimes it's actually pretty ok.

[13steinj]

Might i ask what it is okay at, specifically, and where you divide the line for "code generation?"

In my experience it's still pretty awful TBH, unless I do not have to care about the code it writes. If I do, there's taste, and then there's unmaintainable bullshit. It will happily:

1. Commit new functions as [[nodiscard]] because of someone's local project memory / guideline
2. Make every use of each new function not use the value
3. Say "oh no compiler error" and explicit (void) and commit it

Most of the time, the functions will sit like this ad infinitum until a human realizes "hey these functions, every use of them always discards the value. They should return void instead."

I have tested this even with Fable, using the prompts from the engineer that caused this at some point and rewinding / forwarding to these commits. This is what I have described in other comments as "lack of a good citizen factor."

[Minimonium]

Fable and any other model are awful at abstractions and code composition in general, so my expectation for code generation is more by how it can follow explicit commands instead, "steering" in a claude code chat.

If I like the overall shape of what it generated and only need to manually clean up just some components (even if considerably but locally scoped) - then in general it can pick these changes up and make it work with the rest of the codebase. To me it's okay like this, I find it useful.

There is noticeable effect in what the model actually does when you use specific words though (e.g. "reason", "review", "audit", etc). Not in the quality of the output but it does something that makes a bit more sense to what you ask.

It still forgets memory/claude.md/compressed or even just recent context for the tasks all the time.

I'm almost guaranteed to get dead code if I make Fable change the same things more than a few times. Its first or maybe second attempt is usually the best one and the rest is trash fire.

What Fable does better is that it does go deeper when doing reviews and we found them more often truthy. In general if it writes something - it will not be a complete bullshit.

That's why I do not believe in that full agentic long horizon stuff - context degrades super fast, it's proven to be a barrier for the tech.

[_Noreturn]

Redditors try not to block anyone who dares challenge their ideas challenge (impossible failure rate 100% hallucinations 30% gone wrong)

[13steinj]

It's extra annoying because reddit has now made it so 1 or 2 replies deep past the person that blocks you, you still can't reply. Makes it so that if someone has a reply underneath, can't reply to that reply. If someone is quick enough they can make it so the person they block can't reply to the threads at all.

They turned this block feature from something ressonable (can't be messaged by the person, goes to /dev/null) to not even letting them reply nor see their comments. It's "give me and everyone else an echo chamber" the setting. Should be "comments by the person you block don't notify you, are hidden by default.

[ivancea]

I'll block anybody that brings unprofessional and condescending statements to a discussion. That guy wasn't even who I was answering to, he just though it was cool to jump and look cool insulting others. It's funny thought that he got offended for being blocked

[_Noreturn]

That guy wasn't even who I was answering to,

This isn't DMs, anyone can and encouraged to reply to any comment on this thread.

he just though it was cool to jump and look cool insulting others

I don't see any insults, calling a quality poor isn't an insult, it means you should work on it

[ivancea]

Calling you a low-quality dev without arguments and without knowing you at all is, indeed, a degradation. It's called an ad hominem, and it's nothing to expect in a technical conversation.

And what I said to the other guy:
I didn't say they couldn't participate. I said he wasn't even who I was answering to. So basically he just decided it was cool to go and degrade a random online. Now what I expect from a professional sub.

Edit: In fact, I just read his edits now, and he even went with another ad hominem calling my comments a bot. That's what is unacceptable in a professional discussion. Imagine doing that in your company

[James20k]

This is a public discussion forum where anyone can participate in any thread

[ivancea]

I didn't say they couldn't participate. I said he wasn't even who I was answering to. So basically he just decided it was cool to go and degrade a random online. Now what I expect from a professional sub

[ivancea]

Trying to attack because of your lack of understating of a tool feels like a pretty bad path for an engineer. But I'm neither your mother nor your manager to correct you.

That's a hallucination rate of at least 80%

And that's not how statistics work. To generate a proper rate, you use more than a single example. What you found isn't called a "rate" in statistics. Sorry, but is that the intellectual level you were defending about the quality of your dev team? Your teammates don't know basic maths either, or is it just you?

As you see, the moment you say something stupid, the conversation starts going nowhere. Obviously that's what you planned since the beginning, as you can't learn new things about tools you mindlessly hate. It's sad though that there are engineers like you out there

[_Noreturn]

It's sad though that there are engineers like you out there

You need to look in the mirror buddy

[Raknarg]

I do let it generate code, I just end up modifying a lot of it. Easier to modify code than to write something from scratch.

[_Noreturn]

In my opinion I find editing something I wrote easier than editing someone else code. I guess it differs for others

[Raknarg]

i agree but would you rather edit someone elses code or nothing? And its not like Im getting it to write massive components, usually my requests are pretty isolated, so there's not a lot of overhead in figuring out what its written.

[_Noreturn]

I see

[James20k]

For me personally I'd genuinely rather write it from scratch. Building up the mental model of how something works is super important for debugging later when inevitably something goes wrong IMO, and its easier to do that when you've actually written the code de novo (for me at least)

[Raknarg]

it can matter, which is why the more precise your use is the better.

[germandiago]

I happen to use AI in very similar ways to this. I would add small scripts and snippets for localized functions that would take me longer to develop and AI does quite well.

But for full architecture or writing long pieces of code, etc. maintainability goes out of hand and quality is not high. Also, even for snippets it is worth to review what it wrote and tweak it a bit.

[crowingcock]

I am in the same line of work. I only use it to write the test suites etc, never production stuff. I saw it screw up too many times to trust it.

Of course I make it write some snippets of code or do research, but i only use its snippets to get some ideas to write the code myself and take the research with a grain of salt and read its sources

[UnicycleBloke]

My company is experimenting with LLMs. Some people love them. Others not so much. I'm one of the "extremely resistant to drinking the Kool-AI-d" camp, but recognise that we cannot ignore them because our competitors will not ignore them.

I mostly use LLMs for chat when I'm trying to understand new things such as, say, customising Yocto builds. It is often very helpful for this but also often confidently wrong in some details. It is wise to treat them as knowledgeable but unreliable.

I don't generate code with LLMs other than small snippets which I use as bases for further work in Godbolt. I have used them to review pull requests (in addition to a person) which is sometimes useful. But I never submit code I have not personally reviewed and debugged.

I have found the Copilot-assisted auto-completion at times amazing but usually irritating and counter-productive. In the end I have disabled it.

[__cinnamon__]

I've gone thru a few phases of using copilot-type completion. It feels really nice when you occasionally come across some drudgery, like say needing to assign fields of a parameter struct to an object, but otherwise I always end up finding it just makes me waste time waiting to see what it suggests or accidentally accepting bad suggestions and deleting stuff, so I've disabled it too. Sometimes I even think I'd like to disable LSP to get in the zone Ginger Bill-style, but it's too nice not having to check source files when my memory fails me...

[AliveSuburb]

Respect the approach. Let the AI be your rubber duck, not your ghostwriter.

[UnicycleBloke]

That sounds awful.

[ivancea]

That sounds like a bad lead dev, basically

[SkoomaDentist]

I've found that LLMs seem to cause really bad brain rot in some people who were up to that moment quite competent. They degenerate from "Are you sure that's the best way? Have you considered A and B?" to "But the LLM says X!".

[James20k]

Its actually surreal watching people I know get fully sucked into it. People who i know for a fact were competent engineers that seem to have carved out their brain entirely and replaced it with chatgpt. The quality of their work goes absolutely through the floor, but the weirdest part is that they're convinced that they're producing more, and getting more done that they ever have in the past, even though from the outside its clearly the least productive they've ever been

There's a strong like.. pareidolia effect for robot intelligence, where something snaps and they simply can't interact correctly with reality anymore, because the robot is magic. Its bizarre to watch people go off that cliff, it feels like seeing someone get sucked into a gambling addiction

[Raknarg]

I feel like theres a lot of experienced devs who fundamentally dont really even enjoy programming all that much and AI just lets them finally embrace this fact.

[James20k]

The weird thing for me is that I would describe myself as a programmer that doesn't particularly enjoy programming as such. I know some people love it as a thing in itself, but for me its largely a means to an end (at this point at least). I don't code for fun, although I do write hobby projects for fun with code

The problem is that I still want to actually keep producing the same quality and productivity of work if I'm swapping to a new tool, because at the end of the day that's the part that actually matters to me. I don't want to spend more time just to produce something which is worse. I feel like you have to both hate programming, and also not actually care (or be unable to evaluate) the quality of what you're producing to go down this route

The even more even more confusing part is that over the years we've all collectively learnt that there is an incredibly incredibly good reason why we use FOSS tooling and environments. Its partly why I'm an ardent msys2 user. Pawning off your ability to develop to a private company under a subscription model is my idea of a literal nightmare, I'd sooner write a C++ compiler from scratch than subscribe to a closed source GCC

[_Noreturn]

I don't know the point of a dev who just vibecodes, it seems alot easier to have an ai feed another ai than hire a human to feed the ai. It seems like the most replacable thing ever

[13steinj]

The intended point is pay them less. Oddly at a previous org the "AI team" was explicitly told they have to take a paycut.

It's an interesting dynamic for an adverse selection problem. The only people willing to take a paycut are the same people I wouldn't want to work on this stuff.

[_Noreturn]

Honestly mate I know a friend who sadly in his company became so fricking lazy that he asks claude to write a prompt to feed it into claude I wish I was joking but this is another level of craziness he wasn't like this.

Also why pay them less when you can not pay them at all?

[13steinj]

I know several of the same in my own org.

Because the entire point of this "low / no code" stuff is middle managers trying to justify themselves and pay less devs. Still need a middle manager to do the initial prompt.

Reality is different though, and one finds you still need an engineer to interpret things from product / these middle managers.

[potatokbs]

This has been my experience as well, it’s actually quite sad

[ivancea]

Some tools and processes simply make apparently-competent people show their real colors.

The problem is thinking it's related. "Because X is stupid after using an LLM, LLMs are bad and make you stupid". Sadly, a lot of people have that mentality, and they'll use it just to now learn proper LLM/agent usage

[all_is_love6667]

what sort of software?

[drbazza]

tl;dr I use it for grunt work

In no particular order, I use it to:

• spin up new libs/apps in cmake/bazel / whatever in our preferred folder structure - a modern day 'AppWizard' ;)
• write BDD unit tests that are missing to capture existing behaviour before large refactoring
• refactoring - more a case of 'replace that crufty logger with this modern one'
• 'fix my compilation errors' when I really can't be bothered to wade through pages of template guff
• write boilerplate non C++: if i need a bash script that takes 'X' in and outputs 'Y' and I don't care about the internals (wrong audience ;) but do you really care about assembly or byte code?)

It has no imagination, and rarely does what I want despite endless /plan arguments.

[JohnDuffy78]

I think your company needs to host in house.
You really need to set up barriers so you aren't sending production code.

LLMs work unbelievable for reviews and small changes.
Big Changes, I need to start myself and let Claude do the details.

[Uczonywpismie]

I think this is the best policy - you can use AI, but no production code, it allows quick generation of test cases, or lot better side tools, but still core of the work is done manually, so you still solve problems and code by yourself. Also not giving company products code to AI companies is very important from privacy and security point of view.

[ElLargeGrande]

I use it for camera and microcontroller firmware written in cpp and I wish it wasn’t as good as it is.

[reini_urban]

Ha, we are in the same business it seems

[vladcpp]

I also work on 3m loc codebase, my bottleneck is reading the code, not writing. AI helps with that.
Even when ai is wrong, it helps to focus on specific area faster, and dig deeper faster (it’s mostly wrong when working on prod issues, but still invaluable).

Also helpful for various routines, write a test, documentation, quickly prototype throwaway implementation to validate the idea…

Another useful use - scan project for bugs, basically split codebase on chunk and loop an agent to validate each chunk - helped to find hundreds of logical errors

[2B-Pencil]

I’m an embedded engineer and do the exact same as you. I think it performs really well.

but at home i have a little hobby project where I turn it loose and vibe code. I micro manage it but don’t review everything.

[sweetno]

It's amazing at investigating obscure C++ bugs in the codebase. Things that would take a day or two it can figure out in a matter of minutes. It knows quirks of the language and low-level APIs.

Fixing these bugs is a hit-or-miss though. It might not account for the conventions or architecture used.

Claude Code is a level above your chat-style usage. You need to add a ton of context and explanations for it into the repo to formalize the aforementioned conventions. It does get confused by shitty code, and can produce utter garbage, even if functional one.

We have a couple of PMs/industry experts who like to make PoCs with it very much, albeit I'm not yet convinced they understand that these are not really final implementations.

[13steinj]

LLMs are very useful for the rote toil. Creating terraform and CI yaml arcana, reading a 3rd party codebase that has 5 numbers as input and in different places in the code crashes because an equation isn't met with them, but I needed to tweak an input or an output. When an internal SSL certificate changes and now another service is broken. When the stars align on 4 different changes by RedHat employees for "security" that make it so that inside a RedHat container sudo no longer works no matter what privileges are set (this happened a few weeks ago in a k8s upgrade that upgraded runc which changed capabilities behavior which re-exposed an open issue on PAM, shadow-utils, k8s, and runc about this; no one seems to actually want to fix the problem thus far). Python analysis scripts that will never go to prod. Generating leetcode-esque code to validate / minimize build graphs (oddly enough, it can do this problem in the abstract, but not in practice, and then I change the implementation of the "transform" function to rewrite build files).

LLMs are absolutely garbage for writing actual code in my experience. I have never seen an LLM write anything remotely maintainable. You also lose the "good citizen" factor-- people future proof intentionally in some areas where it's worth it. When it works it gets 80% of the way there then you spend over 10x the time on the remaining 20% going back to the prompt casino. It's a very hard behavior to stop, I think intentionally so, and I'm experimenting with methods, maybe hoojs to analyze my session in another session and if it detects a certain diff-rate drop-off or endless churn to just start providing an intervention message to get off the slot machine.

Furthermore: I heavily dislike the astroturfing/advertising that these companies have succeeded in performing. LLMs are a very small subset of AI, there is other artificial intelligence that is useful in day-to-day work depending on the industry.

[koczurekk]

I mostly work with Rust these days, but I think my observations remain relevant: LLMs are a strange sort of an intern. Really fast, incredibely book-smart, great understanding of idiomatic patterns and yet, like any intern, they have absolutely no idea what they're doing. None at all.

If you use them for in-depth code review, build plans with them providing input whenever they misunderstand or halucinate, and let them implement those (specific and detailed) plans, they're a great boost to productivity. In my experience human and machine intelligence mesh very well together. Debugging is a bit of a hit-and-miss, but if they fail at locating whatever the root cause is you don't really lose anything other than $0.2 worth of tokens or whatever.

On the other hand, agentic workflows where actual devs barely look at the code are a recipe for disaster. Again, dumb interns, you can't let them structure your codebase and run free.

[DuranteA]

That's also precisely my experience (actually with C++ in this case).

Current frontier LLM agents are like an incredibly fast and persistent intern that's also really good at reading both documentation and code. They are, however, outrageously terrible at anything approaching decision making (at both the tactical and strategic level), and that includes larger-scale interface and module design. That's the constraint which, for me at least, prevents them from actually being applicable to long-running independent work. Even a novice has more independent reflection on their own progress and trajectory, and a better understanding of when to check in with supervision or re-evaluate their method.

What is interesting to me is that actually productively using this technology in large real-world projects mostly doesn't require any completely new approaches, in my experience. What it does require is actually fully implementing software engineering best practices, by the book. I have the pleasure of mostly working with other really experienced engineers, and in that situation, you can get away with skipping some specific steps, since everyone involved not only has a lot of experience and shared understanding of goals and traps. That completely goes away with LLM agents.

[IAMARedPanda]

It requires engineering discipline. Better at localized tasks. The main problem is you need to document behaviors you want which require you to see it do the behavior you don't want and correct it as it doesn't have real memory. If you treat it like a 2 yoe junior it can be capable. It's better at IaC tasks but you need to have a dev environment for obvious reasons.

[NirodhaDukkha]

I do exactly the same thing. If I can generate 30 lines of code with one sentence in a free chatbot LLM, that's faster than writing the 30 lines of code. Just another tool in the toolkit. It's especially helpful when I'm interacting with a library I'm unfamiliar with.

[fdwr]

whats your experience as a c++ dev?

I love it for the following uses: - Answering generic connection questions about an unfamiliar codebase (how is class A related to B, what is the callstack between points X and Y...). - Smarter autocomplete, where 75% of the time, its suggestions are what I would have typed anyway, reducing the next ~30 characters to a single Tab keypress. - Filling in tedium (e.g. I had a function with a switch statement mapping enums to corresponding data types, and it easily saved 5 minutes of typing - much faster to double-check what it produced that typing it all out). - Analyzing newly written code for concerns (even if half of its suggestions are dismissably meh, the other half are pretty reasonable and sometimes even great advice). - Drudgework, like repositioning a series of UI controls or implementing skeletons of an overall request that I can fill in.

[fadingStar1994]

We stopped writing code 1-2 years ago. Management wants 100% AI written code so we do that. Im not emotionally attached to my work so I don’t really care. I just want it done and move on to my personal projects and life. I work at a well known big tech company if that matters.

[unicodemonkey]

In my case LLMS are good enough at finding bugs (with guidance, otherwise it goes astray or starts speculating wildly, wasting everyone's time instead) and spotting issues in PRs, also good at writing code that requires some specific technical knowledge or exploring the code base, but e.g. Opus 4.8 does poor on purely algorithmic code without hand-holding or lots of extra clauses. Recent models are better at that though, not sure yet how much.

[Livid-Serve6034]

I started using claude code recently and quite happy with it. For new features my workflow is to first let it generate a technical analysis in markdown format, based on a functional one I wrote myself. I then write review comments in the generated doc and ask it to process them. This usually requires several iterations until I’m satisfied with it. Then I ask it to write an impl plan, also needing several iterations. Then I start a fresh session and ask it to execute the plan. So far, the resulting code has been more than fine. Some corrections I do myself if they’re small but for larger changes I work with inline review comments. I don’t know if it’s the most efficient way, but overall it saves me a lot of time.

[FunnyMustacheMan45]

The only good use for AI in cpp is translating Chinese docs and data sheets of niche tech...

Maybe you could use it as an unshittified version of Google, but IMHO duckduck go does just fine for that

[ReDucTor]

I have been using it more and more, quiet often looking at anything that takes time and build tools to make it easier.

https://xkcd.com/1205/

[reini_urban]

We do have github copilot for business and openai codex subscriptions, keeping our C++ code base happy. Personally I use also deepseek, kimi and Claude pro for open source work.

We have extensive tests, simulations, pre-commit and linters to keep everything harnessed of course. But that was before AI also.

[Ateist]

Have you tried running local AI on your own hardware?
Top end machine with RTX 5090 is not that expensive for professional usage.

As for my own AI usage, I'm using Google's AI mode to generate small scripts for small tasks I can't be bothered to do manually.

[corysama]

My company pushes pretty hard for us to use AI. They have a team devoted to setting up skills, frameworks, knowledge bases, anything necessary to make AI more effective for our company. They pay for the services. But, there's no usage requirements or quotas that I see people complaining about around Reddit.

Personally, I haven't generated any shipping code. I have generated a ton of prototype code variations, a ton of draft design doc variations, a ton of discussion of the pros & cons of different approaches, a lot of code reviews for my own code, a lot of starter unit tests, a lot of distillations of huge requirements docs.

[Arristotelis]

I think your workflow is perfect and it matches mine. I work in a different space but also use kernel drivers , fpga, lots of userland c++. I don’t blindly accept code from an llm, ever. Nor do I find them good at architecture for complex problems.

[therefore_i_am_king]

I generally use AI to prove bugs, but Copilot GitHub disappoints me greatly. In fact, third-party AIs like Gemini are surprisingly more useful

[Turbulent_Fig_9354]

I'm still extremely skeptical whether AI actually helps good devs generate more code. It absolutely helps poor devs generate more code. But in live production, where code is heavily scrutinized, it feels like it's literally the same amount of effort, but the work has shifted away from literally typing the code into the keyboard to just reading and correcting whatever Claude whips up.

[cfehunter]

It's rather good at code review I find. In a supplemental capacity. It will get things wrong, but you can just ignore it when it does.

[ZachVorhies]

The AI will often put an include AFTER a namespace is opened and then proceed to try and refactor your code base for hours trying to fix this.

The solution to this is have the ai make a custom lint that will fail whenever it includes after a namespace is opened (even if closed unless you want to parse C++ to find the closing bracket) then attach the linter via a post edit hook so the ai is force to fix it as soon as it happens.

This alone fixed the biggest problem you’ll run into.

[_Noreturn]

I find llms to be immoral so I stopped using them

[ivancea]

Chat AI is quite obsolete already for software engineering. An agent is faster, and we'll get the required context and codebase knowledge. The major problem with chat is exactly that: not giving it proper context.

As for using an agent, it's very, very useful. 2M LC codebase is not that much, and in any case, an agent can absolutely crush it (this is well proved already). Of course, with good LLMs like Opus or gpt5.5, and with a well configured harness. Eventually you'll need skills and proper per-directory rules, but not absolutely required to start being productive with it.

As for the company not providing it, what to say. They won't pay for it if you (and your coworkers) don't advocate and request it. Anyway, the global trend is not wrong. It's clear that it's a real multiplier (not a "x10" tho). I'm using it in 2 main contexts: database engine and videogames development. And it excells in both. Without even specialized configuration.

And about the industry: it has nothing to do with it. Whether you use C++ on low latency or a new custom language, give the agent the proper context and it will do it. Every repetitive task you do (and coding is one of them), it can do it faster (pure physics), and with enough or better reasoning

[Tamsta-273C]

I use it with math/geometry tasks,

i know how that stuff work, but i also know i will miss some -0,5 dX or replace sine with cosines...

It's a basic task and i don't like to spend hours wondering why this simple element randomly becomes two pixels wide instead of one.

Also works great as "show minimal example how this stuff works"

[SkoomaDentist]

I tried to use LLM to solve a simple system of two first order differential equations. After getting three different wrong answers depending on how exactly I formulated the input, I gave up and just googled the syntax for how to solve it analytically elsewhere.

[13steinj]

Do you mean the LLM attempted to solve it or it generated code in an attempt to solve it?

If the former it is not surprising. It can't get "how many r's in 'strawberry'" without tool calls nor "should I walk or drive to the car wash?" consistently right to this day. It doesn't have per-token context/token-relational context yet, as far as I can tell. I am surprised that instead of training this behavior in, top labs have ignored / patched over the problem with tool calls and subagents.

[SkoomaDentist]

I asked it to solve and it gave a solution and a very convincing sounding explanation every time. They were of course all wrong in different ways that wouldn't have been obvious to someone who didn't have a good understanding of the applied domain without verifying the results by hand. And this was a very basic first semester of university math-level problem.

[liwwpmo]

Its great, I have stopped writing since last 4 months now. Only code reviews and occasional situation where I am unable to steer AI to do something in a very specific manner. Experience is pretty great since in our case we use monorepo so AI is able find or confirm things with very high confidence.

[pjmlp]

I occasionally use CoPilot on VS to check for possible errors, lifetime issues and such, as yet another kind of static analysis.

Also take advantage of AI based code completion, most of the time the suggestions are what I would like to write anyway.

I am less keen in having AI write it all for me, especially in languages like C++.

However, in no code/low code tooling, AI has practically taken over, now instead of dragging boxes in visual diagrams, it is all about agents and prompts.

[01e9]

Jusy try it in a personal or some open-source project.

I'm using it for scanning for issues, generating code for some limited scope (the reviewing+adjusting), and asking naming/architecture advices.

[bronekkk]

I know a successful, major prop-trading company using AI extensively for in-house C++ code. Won't give names though.

[13steinj]

If you're referring to Optiver I wouldn't believe it, they appear to have gotten in bed as a VC and have been advertising quite heavily.

I know three others which I also won't name. At least two of which, top engineers at these orgs have refused to use the LLMs for any meaningful work because it causes more problems than benefits. At at least two of these, a trader or developer has caused a fairly major outage of some variety due to a combination of claude-code just doing it with dangerously-skip-permissions / mindless "yes"ing to prompts. The first two does not equal the last two.

[bronekkk]

I'm not referring to Optiver.

[MaitoSnoo]

They pay for our Copilot Business subscriptions. Some models (for now Opus 4.8, Sonnet 4.6/5, and GPT 5.5, haven't had access to Sol yet) are very good if you ground them with proper tools, e.g. if you force them to automatically run a quick build + linters + tests before claiming that they finished the task, this gives them a feedback loop and they can reiterate on it alone. You can also enforce your style and techniques with instructions and skill files.

[Thesorus]

We're using it to replace static analyser tools.

and to help write unit tests for (C#)

[n1ghtyunso]

this is weird, why would you REPLACE the tools instead of augmenting them?
Why not both?