[flagged]
> We still require a code review for any change and it's becoming a bottleneck - for sure
> I fought for years trying to convince my colleagues to write good commit messages. Now Claude is writing great commit messages but since *I'm no longer looking at code* - I never see them. I don't think Claude uses them either.
(emphasis added)
I have almost certainty by now that half of the web is just bots steering the narrative of humans, because I’ve never seen so much non sense being normalized in my life. Dish soap drinking level I mean.
In a way, obvious injected opinions benefit culture, by making formerly-unaware readers skeptical.
Pretty sus, bot or otherwise.
Lots of tech companies are doing just fine with purely AI written code at this point.
Saying that the quality is getting worse in some immeasurable way (while incidents remain the same) is literally unfalsifiable.
What we do see publicly is OSS projects overrun with poor submissions, for example.
It is like saying "no one can produce a viable CPU because I can't tape one out in my garage."
If there are so many, surely you or one of the other AI supporters have a public example?
I’m aware of two examples, although they’re (mostly routine) translation with existing test infrastructure, so easier for an LLM:
- Bun’s rewrite, although we haven’t seen the effects on further development
- Ladybird’s rewrite, which seems to be continuing fine
I don't know what the Bay Area note is supposed to mean in the context of the whole post - unless you want to reinforce that it surely means that it's a sane take... In which case, I'm not certain the non-Bay readers would agree that it comes from an unbiased culture.
1) Since vibe coding GitHub has frequent outages and isn't able to load a large number of comments.
2) The slop translation of Bun resulted in immediate bugs (https://github.com/oven-sh/bun/issues/30719) that the hyped Mythos apparently did not find.
3) AI features and (likely, though not proven) AI code resulted in a 0-day in Google code:
https://projectzero.google/2026/01/pixel-0-click-part-1.html
The house of cards is beginning to collapse.
A common one: "I have stopped writing code, the world is going to end"
Another: "I will code by hand, I don't care"
Another: "I use it as a tool, but the hype bothers me so much that I have to bitch and moan from morning to night"
This one is: "I have stopped writing code, it wasn't the end of the world."
Which is the pathological take?
It’s irrelevant and unrelated.
vividfrier claims they haven’t written a line of code (implying other employees are similar), and their big company is operating normally. Bun is a big project and the rewrite is entirely LLM-generated. If its development continues normally, it reinforces the claim’s plausibility and proves someone made a large change (rewrite) entirely using AI. If not, it provides strong doubt: either vividfrier’s company is doing something different that avoids Bun’s problems (maybe other employees are still writing code manually), or they’re misleading or lying.
People write code differently, AI models write code differently, AI systems write code differently, companies create systems that write AI-written code differently, etc.
The system that wrote Bun bears no relationship to the system that writes OP's code.
Making such absolute statements about AI-written code is as dumb as making absolute statements about human-written code on the basis that it's "human-written".
It's plausible that OP's company is succeeding with 100% AI-generated code, even if Bun fails, but it's also plausibly false. Anyone can claim anything on the internet, what separates BS from reality is evidence.
I didn't write that Bun's rewrite absolutely proves or disproves OP's claim, I wrote that it provides evidence; it does, much more than OP's word.
It's also plausible that OP's claim is true, but only because despite being in a "big tech" company, they've been working on small self-contained repos, throwaway scripts, etc. The implications of this would be much different than what their comment suggests, which is another reason evidence matters: it forces them to narrow their claim, because anyone can make an overzealous claim from a small example.
That’s very different than converting a massive codebase one-off to an entire different language, while depending on tests to keep it contained.
Scale and process is dramatically different than the Bun case.
Imagine old school machinists saying to a CNC machinist “Ha! See, maybe you don’t jog the axes manually, but you still have to be involved in placing the stock material, and you have to do the CAD/CAM work - so did it really machine the part for you? No!”
AI is a tool like any other. It has its limitations. It has classes of problems that it is suited to handle, and others it isn’t. If it’s true that they haven’t written (as in “typed out by hand”) a single line of code, why can’t they say that without you making that statement into more than it is?
I haven’t written a single line of code in 6 months, and that’s simply fact. It is also true that I put in a lot of other work to make that feasible, but that work isn’t in the form of writing code.
“it’s mature and the next step of engineering”
Tautologically, it’s mature enough for what it is mature enough for, and it certainly is the next step in the same way that CNC was the next step for machining — if you’re not using it as a machinist, you’re going to produce less compared to those who are.
Same thing with garden hoses. Yes, you can go fetch water from a lake and splash it on your lawn, or, you know, you could just use a sprinkler connected to your garden hose. Doesn’t replace buckets. Buckets just have a narrower scope in a world where garden hoses exist.
A garden hose vs a bucket is also the same situation. You can accomplish the same thing with either, but one might be more labor intensive.
AI is nothing like either of those. It would be like instead of a bucket you get a garden hose that points in a different direction every time you try to use it. Or instead of a 5 axis mill that rigorously executes the g-code it just randomly reinterprets tool paths each time it cuts a part. Both of these things would be worse than useless in their respective applications.
AI is different because it plays to the pliability of the software domain. Even fairly shitty, irreproducible results can be good enough for software development, if you don't look at it too closely. Make analogies to the physical world at your peril!
And also adds a multiplier to your water bill
The same with AI you still have to hold it and point in direction to be useful.
It also had a logical stopping point in automation tech.
Ai is trying to do everything and wont stop
Because it's a solution looking for a problem. All the AI companies lean in to coding because it actually helps with that to some degree but the amount that it helps doesn't justify their valuations. It needs to be good at everything to justify their target IPO price.
The one you respond to is an obvious bot, new account only posting comments saying how great AI is for example.
No need to look further.
And to me, AI should best be used to add rocket fuel to existing practices. Better tests, better observability, more atomic changes instead of big changes, automatic rollback etc.
The more your codebase follows best practices and consistent patterns, the better AI will do and the faster you can move.
Same as humans really, just even faster. I'm also excited that people are finally writing docs and without even any flogging! They're calling the docs "skills" but hey whatever works
Yes, this is indeed a pungent smell. AI code assistants allow whole projects to be refactored and even rewritten in entirely different programming languages and software stacks in a few minutes, sometimes even with one-shot prompts. Most assistants even support creating and maintaining test suites with first-class support. Whatever you prompt, they do it.
And here we are, expected to believe that these tools can't or don't follow best practices?
You keep hearing people saying AI coding assistants and coding agents can easily output working code. With enough work they can easily output that follows your own coding style and restrictions.
If you prompt a coding agent to write code following your personal choices and recommendations and it outputs less than amazing code... What does it tell you?
> Personally I have not seen this amazing code.
You get out of it exactly what you put into it. Garbage in, garbage out. I mean, one of the prompt styles they support is literally "implement this following the style used in this component". And people complain the code generated from your prompts and with your own code as a reference turns out to be crap? Strange. Moreover, code assistants excel at refactoring work.
The model is trained on a ginormous corpus of code. The problem is, most code is shitty. My code isn't.
Using a model means constantly fighting mediocrity, to the point where the trying to prompt it into shape often becomes more work than just writing the goddamn thing myself.
Yes, I can prompt. But I can't prompt understanding into the pattern matching machine. It will always revert to the undesirable mean.
No, I meant what I wrote. I keep hearing people say how LLMs write amazing code now.
Switching to AI development on several of our projects exposed a lot of code that either never worked or didn't work the way that we thought it did.
That's an odd statement to make, particularly with today's models. They can easily pinpoint concurrency problems and memory management issues. But here you are, complaining they write buggy code. What kind of prompting are you throwing at it?
He answered:
> Well, yeah, who cares?
> This is where we need to differentiate between what truly needs to be clean (critical APIs) and where some random guy coding a product in a week will wipe the floor with a team of engineers with a clean architecture and no product after three months.
> What's more, this "vibe coder" is on the right side of history… Who's to say AI won't be able to just rewrite the code cleanly while keeping the core idea within 6, 12, or 18 months?
> This is also the question that drives business... and in business, "good enough" has almost always trumped "perfect." Except when you're making an ultra-luxury product like a Ferrari or something. Which software almost never is (if ever).
So when head of companies don’t care about quality, they’ll push hard no matter what to have speed.
Well lets say it's 18 months from now and AI writes lovely, ideal code. At that moment, the AI would have eliminated the need for AI, right? If the code is good, you can just read it and edit it.
The selling point of AI is that you will embrace that idea that you code is a mile-high stinking garbage heap, so that any human would be overwhelmed by the stench. Only so long as the best strategy for engineering is to pile the garbage as high as possible as fast as possible will the best tool for engineering be AI.
So my counter argument is: just wait 18 months and you can completely skip adopting AI.
This is especially true when the people who suffer the consequences of bad software are far removed from the company making it. You'll be forced to spend hours fighting with customer service over errors made by people using that bad software, but it won't impact the CEO of the company who vibe coded it. I hate that we're moving to a world where everything around is getting worse and less reliable while marketing companies try to convince us all that this is somehow progress.
> And here we are, expected to believe that these tools can't or don't follow best practices?
Uh they don't really. The contradiction you're seeing is actually fictional because that premise is wrong.
That just goes to show how far your experience goes. I have projects in my workspace to support the idea, and your baseless assertion rejecting the whole idea? What's more credible?
> The contradiction you're seeing is actually fictional because that premise is wrong.
Doubling down on baseless assertions means nothing.
Exclusively bad-faith/bait.
___
Edit:
Come to think of it, given the name, it might _actually_ be just an agentic LLM tasked with trolling HN.
That would be kinda fun ngl
I don’t think AI actually changes that we should always be questioning everything, including how much we question at a time.
Have you measured the impact of that on your ability to create good code? From my experience, relying on AI tends to degrade that ability.
Also, you seem to be able to do all of what you say and benefit from AI tools because you seem to understand the overall bigger picture well enough to be able to drive the AI agents to do their work properly. In other words, you operate in a familiar territory where you do not need to learn much new things.
But what about the junior people with little experience? Will they be able to manage such AI workflow? And more importantly, if junior people are given such AI tools, how will they learn?
These are all questions which may not matter in the short term and one might ignore them if they just want to see the profits and efficiency gains during the next cycle. But what about the long term?
Maybe I’m pushing it a bit, I know, but a couple of decades ago you could’ve been asking this instead.
It also sort of feels like "you don't know what you don't know", i.e. would you have considered an alternative better solution if you thought about it yourself, went to the documentation, found a tutorial on the web?
Of course, production is arguably a lot faster but it feels like there's starting to become a trade-off where the models feel so capable that we stop trying to find the solution to the problem ourselves and thus perhaps degrading our personal reasoning capabilities. I say this as something I'm afraid is happening, not something I'm certain of.
This is a false equivalence.
A compiler is a predictable, testable, deterministic piece of software.
An LLM is not.
Sure, all abstractions leak; so, at some point in time, for some reason, you may need to check its compiled code ( cough cough gcc 2.96 ). But, if today your code compiles properly, it will properly compile tomorrow as well.
But I think, in the analogy compiler ~ LLM, the issue is more of a trust than determinism. It took decades to assembler programmers to trust compilers enough not to write code in assembler. The similar will happen with AI - some will embrace it sooner than others.
> compilers can be quite undeterministic - you get a new version of compiler, or change compiler options (turn on optimizations)
That’s a whole other level pf bad faith argument right here. Flags and options are input too.
> It took decades to assembler programmers to trust compilers enough not to write code in assembler.
You do realize that Cobol, Algol, and Lisp are very old, and they were not assembly. And that Unix were written in C shortly after the language was created.
Not sure where you see the bad faith argument. (Btw I mean "same output", not "same input", it was a typo.)
Take for example JVM. It used to be horribly bad and unpredictable, performance wise, in the 90s. Sun tried to base a desktop environment on it - it didn't work.
> You do realize that Cobol, Algol, and Lisp are very old, and they were not assembly.
Of course! But people have been hand-writing assembler until late 2000s, because compilers were simply not that good.
The same will happen with LLMs - some people will not trust it and won't use it for decades, possibly. Some have already embraced it.
You proof for your argument that a compiler is undeterministic is to change the whole compiler to another version and saying it won’t produce the same output as the old one.
> But people have been hand-writing assembler until late 2000s, because compilers were simply not that good.
And we have software like Unix, enacs, ksh, awk… that’s all written in C. I strongly believe that those people who were writing assembly was optimizing stuff or dealing with constraints (like the 640kb of DOS). Just like today, you may still have to write assembly for microcontrollers or video codecs. Compilers were expensive, but people were paying for them.
Fair enough. What I meant though was that compilation as a process is not deterministic, because often when you recompile couple years later, you're using a different compiler. (In modern world it can be much shorter time, actually.)
> And we have software like Unix, enacs, ksh, awk… that’s all written in C.
So? IIRC, first compiler was FORTRAN, invented in 1958. OpenAI Codex, first coding LLM, came out August 2021. So we are like in a year 1963. For this comparison, we have ten more years to produce (using a coding LLM) a compiler and operating system just from the textual specification, without an intermediate formal programming language. Funny - we have actually already done that (Claude C Compiler, VibexOS).
Nope, the timeframe would have been three years
In 1961, the MCP was the first OS written exclusively in a high-level language (HLL).[0]
How is that relevant to the topic of this discussion?
Compilation from higher order languages to the machine code is deterministic. It is sufficient to review and well-test the tool which does the translation. Given the same input, the output will always be the same.
Transformation of a natural language prompt to code by an AI tool is non-deterministic. The outputs will vary between runs. Therefore, it is always necessary to verify them.
That is the difference.
With LLMs, we are trading away the determinism of the program output as well, in exchange for even more easier programming. Is it a good or bad thing? There are ways to mitigate the problem, just like there are with compilers.
You could argue the determinism of the program output was never really there, because the specification at the high enough level was always unclear. So we are not really losing that much, just accepting more messy reality.
Then the only question remains, can these computer programs (LLMs) do a better job (and where) than a SW developer, who is supposed to translate unclear specifications into a formal language (source code). It happened with compilers - eventually they got better than all of assembler programmers. Same happened to chess players.
Does JIT compiles some other program code instead of the one being run? Does it produce bytecodes for a differenr VM? Does it tries to compile parts of the program that have not been executed or aren’t going to be?
Does GC destroy objects being in use? Does it ignores instances and memory that has been properly released?
JITs and GC are deterministic algorithms, you can predict its behavior by just reading their code. LLM tooling involves an actual random generator for its output.
Sure, but the same is true for LLMs - the lead models no longer make trivial mistakes like answering "What is the capital of France?" wrong.
> JITs and GC are deterministic algorithms, you can predict its behavior by just reading their code.
On large enough systems, you can't, just like it's difficult to predict weather. Determinism has little to do with it. At work, I have just witnessed a bug in JIT (it seems to have been fixed in OpenJDK 25). It inlined a wrong method. We weren't able to reproduce the error conditions without a private customer dataset.
And the fact is, historically, there have been many bugs in compilers, or they have been bad at their job, writing performant programs. The output (resulting program) of a good compiler is difficult to understand (because it is written to be efficient). LLMs (for the programming use case) are different quantitatively, not qualitatively.
No one is saying that a compiler can’t have bugs. What we have been saying is that if we take the compiler has a blackbox, we’re reasonably certain given we know the input, what the outputs will be. And the output will stay the same if you keep the input the same.
But you can send the LLM the same prompt, and it will gives you a different answer each time. And it’s not even about the verbiage used.
But I am not sure why the insistence on the relevance of (non)determinism, rather than on the chaotic relation of the output to the input (which is true for both compilers and LLMs). In practice, inputs to the LLM, as well as to the compiler, change. And the fact is, the output can change radically due to that.
I think nobody really sends the same prompt twice to the LLM, so nobody cares about it being deterministic. I think what you're looking for is something different, some form of stability (as opposed to chaotic behavior). Although it's hard to define exactly, because in case of LLMs theory lacks behind praxis. (And as I said - we already gave up on stability with respect to performance by using compilers. We resolve that issue by doing performance testing.)
(I asked AI what's the opposite of "chaotic", I use "stable", but it seems that people use "deterministic" or "predictable" also in that meaning. So if you're using "deterministic" in that meaning, then you don't really care about sampling and temperature, i.e. determinism in the philosophical sense, but rather whether the output is consistent, albeit expressed differently.)
I posit a different argument. When you install a compiler on your computer, that compiler is "yours" for as long as you have the binary. You are able to completely forget about assembly because of 1. reliable _enough_ compiler 2. reliable access to said compiler.
Let's rewind decades back and pretend that the very first assembly compiler was behind a monthly subscription*. Do you think we'd be in the same place now?
Now the natural follow up to this "but the open models are close to SotA now". Well why aren't we using them? Do we really think we'd have a GNU moment for """open""" models? And are we willing to bet our industry on that?
But my point is, _these are not the same things_ and positing them as such is frankly insulting. How good are you at writing assembly when your compiler is inevitably taken away?
* I'm not a historian so I wouldn't be surprised some version of them were
We are though? It just depends on the task and the costs.
> Do we really think we'd have a GNU moment for """open""" models? And are we willing to bet our industry on that?
Yes and yes. We're in the mainframe era. But history this time around is passing us by at a ridiculously fast clip. Local models become "good enough" for new tasks by the day, after which they continue to shrink for a given performance level.
I'm not going to bet against either moore's law or relentless increases in model efficiency any time soon.
Basically it boils down to geopolitics, the US economy is currently being propped up by a small subset of companies, and a lot of that is based on proprietary models and speculation in the market around them. China is going to continue to dump better and better free models out to complete. Thus pulling the rug out on all that speculation.
Helping neutralize their biggest rival.
I’m not here to say that’s good or fun.
I have friends at other companies with similar projects, they say the same thing.
It's like we're living in different worlds.
Still, LLMs are nice for well defined small projects, microservices, tools and research.
We're guessing it comes from organizational behavior (culture, governance, management, etc.), we work in diverse teams / regions / companies.
Would you say the project is well architected? Clear boundaries? Or ball of mud?
How large is large?
Are there AGENT.md files giving good information that helps LLMs get context when looking at a certain area of the code?
Is it all in one repo? multiple repos?
Are there good tests?
I feel like these are some of the many variables that can make a difference.
I work on a pretty large project/code base, written mostly in Go, and I have pretty positive experience with LLMs. I take on fairly small chunks, I review and understand the changes. I also use LLMs to explore options and prototype quickly. They're also very good at fixing bugs, failing tests etc.
Yes, with generous budgets.
> They're also very good at fixing bugs,
Seeing opposite here too, they are like eager juniors 'oh the issue is here and here's a 5 page report why', and it's wrong... then you add more info and it goes to a different spot... repeat until you get tired and solve it yourseld, it is useful as a rubber ducky i guess.
> I work on a pretty large project/code base, written mostly in Go, and I have pretty positive experience with LLMs. I take on fairly small chunks, I review and understand the changes.
Great that it's working for you, I'm just pointing out there's a massive disconnect.
I would assume your work can be done by a junior engineer without any prior knowledge (except LLM md files) with same quality but less speed?
If yes, then great, perhaps that's where the disconnect is, complexity.
Also, if yes, which would be cheaper?, junior engineer or LLM?
x200 the speed of a junior.
It's interesting how far our experiences differ. I have heard from people working on C/C++ code bases that it's more challenging and I haven't tried the LLMs in these domains.
I do see people getting results even internally. Sometimes it's about getting to learn the tool. It's really interesting how we have this mix of "this is garbage" and "this is really useful". From my end I don't think I'm making stuff up or looking through some rosy glasses and I've been coding for 30+ years.
EDIT: I should add that when I use AI I already have a "shape" in my head of what I'm trying to get done. It's not like I tell AI something vague (like a user level issue) and expect it to fully understand a huge code base (though sometimes that also works). If I have a race I might have a Go race detector goroutine dump. If I'm refactoring I know where the work needs to happen. If I have a test failure I know what test failed and I usually have some idea of where to start.
I'll also add the resulting AI assisted code is good. I review it as it is being written and if there are issues (either functional or stylistic) make adjustments. All our code gets reviewed and all has quite extensive tests. Again this is at above junior level.
It's really amazing how different people have completely different experiences. I work on a massive code base and I thought AI would not be able to fix anything in at least a few years since the application is very complex and does not use well known frameworks. I was very wrong. In my experience, it fixes bugs better than I could, at least given a short time budget (which is always the case, if we spend too much time on each bug we just fix bugs slower than they get reported and we'd enter a death spiral).
I have worked on this code base for more than 10 years, touched every part of it, and I wrote large chunks of most systems, despite around 20 people working on it right now. Still, when I need to figure out something, now, I often ask AI as it is absolutely wonderful in understanding and explaining code, no matter how big the code base is. My team consists of 20 very senior developers, and I am their technical lead, so I think I know what I am talking about.
A junior would require at least 6 months of guidance to become productive in our code base, unfortunately, just because it's so big and it integrates with all sorts of external services, databases etc. I do understand that saying this is not really a flex, I would've actually preferred that my code base was so good even a junior developer could be immediately productive in it, but that's sadly just not the case. But perhaps, with the help of a AI tutor, that's actually possible now?!
If you think AI is at the level of a junior developer right now, I'm afraid you're kidding yourself.
In case you're wondering: we use Claude Code.
This is something I don't understand.
- If you have a bug, you need to fix it well as well as proper root cause.
- That way the bug never surfaces again and safeguards are added for that class of bugs.
- if done well over time it builds discipline and bugs only surface from new features or integrations.
I've never had an experience of a 'death spiral' that you mention.
> Still, when I need to figure out something, now, I often ask AI as it is absolutely wonderful in understanding and explaining code, no matter how big the code base is.
Sure, but you still dig into the code afterwards I assume, you don't blindly trust what the AI summarization tells you.
> If you think AI is at the level of a junior developer right now, I'm afraid you're kidding yourself.
It depends, small projects with well defined scope, yeah, it knocks them out of the park, what I'm working on, it's a bit disappointing, not for lack of trying.
Still, one other thing I'm noticing now... if my account were not anonymous I would likely need to think of possible repercussions for my 'lack of faith' and would probably post comments very similar to yours or not at all.
So I'll stop here.
Can you spend 3 months fixing a bug and doing nothing else? You always have a time budget, whether you know it or not, even for your hobby projects. Do you not have users reporting bugs regularly? Any large product will have bugs, I see the biggest companies with the best engineers maintaining open source repositories with thousands of bugs, and the list just keeps growing. Internal products are even worse. All you need for your bug list to keep growing is one bug taking longer to fix than the rate at which bugs are reported.
> if done well over time it builds discipline and bugs only surface from new features or integrations.
Yes, and we have a whole lot of features coming out every release. We have a very large product. That's why we keep adding "bugs"! Not because we're fixing bugs that had already been badly fixed previously, if that's what you're thinking.
You've never seen a bug spiral? I must assume you're new to this industry. Bug spirals have killed many companies. It's very common to have code that's so bad no one can touch it without introducing lots of bugs. Fix one bug, 2 new bugs are introduced.
Luckily, where I work we have a lot of tests so it's rare that we have regressions, so the main cause of bugs is the new features, especially big ones as it's humanly impossible to properly review thoroughly enough that there's no bugs. That's where I think AI will help a lot - but we're still trying to figure out exactly how. Simply letting the AI review everything is not enough. And as I said before, humans just can't spot bugs to save their lives, me included.
> if my account were not anonymous I would likely need to think of possible repercussions for my 'lack of faith'
That's weird to hear, HN is about 50% AI enthusiasts, 50% AI skeptics, at least that's my impression.
I was a skeptical until recently, but in the last few months of using Claude Code (and Copilot, but Copilot consistently performs worse), the LLM has become better than most humans IMO. I still write a bit of code by hand, though, simply because I can't help it and sometimes I know I can do things very fast anyway so why burn LLM tokens on the thing. But sometimes I try to "correct" AI code just to learn later the AI was right (normally tests pick that up - we instruct the AI to write comprehensive tests, and it does it well... I normally review mostly the test code and less so the implementation). I am almost at a level where I believe not using LLMs to write code professionally is akin to not using static type systems: you're refusing to let the computer help you for no reason. It's not about faith, it's about using the tools that make our jobs easier and our output better. I know not everyone is there yet, but I definitely feel like I am.
In what world would that be needed or accepted.
It generally takes 1-2 days to fix harder issues lile race conditions/memory corruptions. Regular bugs are much faster. All fixed correctly without AI.
AI just goes on a random path every time and in general fails to find the root cause unless you tell it explicitly what it is...
> I was a skeptical until recently, but in the last few months of using Claude Code (and Copilot, but Copilot consistently performs worse), the LLM has become better than most humans IMO
great that it's working on your end
I’m also in a big tech company and a lot of the team hasn’t written any lines of code by hand for awhile and it’s causing a whole lot of tech debt and frustrations are beginning to boil.
I’m not sure it’s possible to force someone to read every line of AI generated code and understand it. People generate code faster than they take time to read it.
Pressure from C-suite to AI AI AI AI AI MORE AI AI AI AI doesn’t help.
That should be my line. My new employer does not use LLMs at all. Software development, marketing, hardware development, nothing. Maybe too little, but whatever.
The problems the company is facing are entirely unrelated to "throughput".
Is it possible to have any means of private communication with you where you would share the information who this employer is?
As implied, my employer's product is not software, but rather hardware. This hardware does of course run firmware and software and needs to interface with other systems. It's entirely B2B. All this combined makes work relatively relaxed.
> Now Claude is writing great commit messages but since I'm no longer looking at code - I never see them.
Let it be a learning opportunity for us, folks. This is why you shouldnt take comments on the internet too seriously. People (or bots) will say anything just to get attention.
p.s. Offtopic, but this is why I believe the ability to hide post history was the tipping point of Reddit's downfall.
It's causing problems in all parts of the business and leadership's answer is that we must use AI to make fixing incidents faster and automated rather than assess whether we should be shipping enormous amounts of buggy code every day...
If you can't answer these questions credibly, I'm afraid I'll have to treat your answer as LLM influencer propaganda.
Most of our time is spent doing spec work, planning, and injecting the proper context into LLMs. Like the OP, our metrics have drastically improved the time for delivery of new features, slightly improved bug resolution times, and now we're bottlenecked by needing more code review and manual QA to handle the workload.
When you work on just a new mobile app, this is where I find AI is making the biggest difference.
On mobile you don't need specs and you don't need to understand every detail of the implementation. You can QA test the app on a real device. It gives me more confidence than just having written the code myself, and it's much faster. You can implement multiple major features in a single day.
This kind of e2e testing is just not possible with backend services.
And how many lines of Markdown have you written? Pointless metric. I think I type more now because I don't get any helpful autocomplete for... English.
It’s a tool and the good old sh* in sh* out principle applies.
People might take Mitchell’s comment as some kind of anti-AI stance, but it’s not he uses it regularly and makes a point in the X comments: “use AI, but think”
That comment sums it up best, because right now it’s hard to talk to either side, which separates at the comma.
What programming language are you using? It seems like some programming languages are more mature in LLMs, e.g., Python, Java, C#, maybe Golang. (Oh yeah, and definitely JavaScript/TypeScript.) Rust, Zig, C++: I have a harder time believing you can manage a large project using only an LLM to write code.
This is why this feels foreign. Most people don't take this approach (I'd argue it's the correct, rational way to use AI).
Not because I agree with my sibling comments, but because I strongly agree with the parent, making me think my org and I are much earlier than I thought. :)
If you still hold code review to the same standard and just make the agent do incremental changes rather than vibing the results are pretty good.
And to answer your question: No. I am yet to see a product made by AI or a product that used to require a dozen engineer and a few years being made by a single engineer in a month. Anything demoed is always a UI/functionality clone of the same thing LLMs regurgitates.
Our experience is very similar except we didn't really have a review process before, and now LLMs find bugs before PRs get merged in main.
We had 5x-100x speedups in some legacy but important pipelines, with no regressions (validated after extensively by humans). It's not that the code was actively bad. It's just only 1-5% people in the local SWE market would be able to write code that runs so fast and efficient and benchmark it correctly.
We found a subtle correctness bug that was in production for half of the decade (both GPT-5 and Claude Opus were able to find it), confirmed by human after.
And we keep finding subtle bugs that have been introduced by humans before (despite the human reviews, the particular domain is just difficult no matter how many docs and comments and tests one writes)
Machines, OTOH, are very good at it. I am currently trying to make the code review experience better for humans by not just having the AI review the code, but interact with the human, pointing out potential problems, bad patterns, perhaps hiding some code (e.g. renamings, formatting changes).
Developers still want to review the code, despite provably being bad at spotting bugs, because they want to actually keep knowledge of what's being modified in the code base, so I think this is the best approach.
I've addressed why in a response to a similar claim here: https://news.ycombinator.com/item?id=48157898
In my world, that is far too slow, and you will be seen as a low performer who just can't keep up with the tech.
What's the difference? I don't think anybody get paid by how efficiently they type on a keyboard. If you to use a die or raise a crow to get your next keypress I honestly don't think your PM cares as long as the actual output you contribute to the project is something you are responsible for.
I'm not saying it has no implications on how you think or no costs socially, ecologically, politically, solely that nobody cares HOW you get the code, only in your ability to keep on making it increasingly work better, closer to the evolving needs of the project.
Other programmers are painters. Their job is to start with a blank canvas and create something that others will value. When AI tries to paint, it tends to produce slop: a facsimile of everything it's ever seen.
AI is much faster at taking an idea and creating a working proof of concept than any human I've seen.
Not saying it's good engineering, but leave that to the gardeners.
Without any human code to grab on to, AI has a habit of writing code that is pervasively low quality and rife with misunderstandings such that it always needs to be thrown out.
And yes with considerable prompting effort you can improve this picture. But it's easier, faster and cheaper to just write the code yourself. Code is the best specification language we have.
Are other bots upvoting this?