And below you repeat what all of Hacker News hypemen say about AI (“I have stopped writing code”, “it’s mature and the next step of engineering”)
Thank you for reinforcing the point of OP
EDIT: you're the same person that a month ago said your company feels git is outdated now that you have agentic coding, and you don't even need to write your own commit messages. This is next-level trolling, or a serious case of AI psychosis.
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.
No need to look further.
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.
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.
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.
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."
You can use agents for dev and reduce MTBF
Examples of hype right now in SV (could happen, but more evidence needed imo):
- RSI
- Dark factories
- Overnight swarms, full rewrite one-shots
- 1 person unicorn
- AI native services co
- UBI / UB compute
- "permanent underclass"
Usually they provide grandiose claims (like the top-level comment) without any evidence or just anecdotal evidence that is not verifiable.
HN is lousy with new accounts (created in the past year) that are overwhelmingly excited for the so-called AI revolution.
Oh look more useless arguing.
People who do things care about the doing more than how the sausage was made.
I do not care how software gets built. Only that it works. Results is the only thing that matters and I hope everyone in this thread internalizes that fact.
I mean, I agree on a very high level of abstraction. But my problem is that I need to understand how software gets built so that I can have confidence in my ability to maintain and evolve the project.
I need to understand whether a feature is easy to add or requires a wholesale rewrite of the entire codebase, which comes with risks. I need to understand how new features affect existing users.
I also need to understand the economics of the process and the economics of my industry. That means I have to care to some degree about how software gets made, not just whether some specific program works at the present moment.
If you give me a choice between an implementation that is 100 LOC I can understand and an implementation that is a million LOC that I can never understand, I'm going to chose the former, even if both implementations pass all tests.
this is not a thing. there hasn't been a single line of code written that a human can't understand.
Also, code quality matters for AI as well. Maintaining a million lines of code requires more tokens than maintaining 100 lines of code.
Then do it. Be successful. Be wonderful. Show us all the great results.
If you only care about results, then go do the things.
Why are you complaining? Whats wrong with differing views?
When people cannot accept other people critiquing AI; that is literally AI psychosis.
Heres a trick: what is AI bad at? Stop and ask yourself what it really sucks at.
Nothing come to mind?
You're living AI psychosis.
If you can't accept that anything it does is wrong or bad, that you are only successful when you use AI you are, flat out, gas lighting yourself.
Now go read the comments by recent new accounts about AI.
Yeah.
Either there are a lot of bots, or a lot of really really troubled people out there right now.
This account is my real name. I have nothing to hide. The metrics speak for themselves.
We just had a week with 7 major zero days announced for pretty much every major OS and architecture. Reality doesn't care about your opinion.
What metrics? Where are the amazing new projects and features you built? Where are the amazing products and features you built that are better than existing ones (run faster, consume fewer resources etc.)?
For a person who "has nothing to hide" somehow none of your comments ever mention what projects you work on, what you ship, or what metrics you employ.
New php extension https://github.com/hparadiz/ext-gnu-grep
A Demo showing how to stream webrtc to KDE Wayland overlay. https://github.com/hparadiz/camera-notif
A fun little tool that captures stdout/stderr on any running process. https://github.com/hparadiz/bpf_write_monitor
Then I upgraded my 10 year old hand written framework to a new version that supports sqlite and postgres on top of existing MySQL support https://github.com/Divergence/framework
But then I was like eh lemme benchmark every PHP orm that exists just to check my framework's orm....
https://github.com/hparadiz/the-php-bench
And published the results.... Here
https://the-php-bench.technex.us/
And then I decided to vibe code a simulation of the entire local steller group https://earth.technex.us
Followed by my simulation of the Artemis 3 landing sites at the lunar South pole https://artemis-iii.technex.us/?scale=1.000#South-Pole
And I left the best for last.....
https://github.com/hparadiz/evemon
A brand new task manager written in C for Linux that supports a plugin architecture with an event bus. It's literally the best gui Linux task manager ever. Still working on it.
I'm not even talking about my paid job. This is me just fucking around.
What I said was: what is AI bad at?
Let’s start the conversation there. Can you one shot a new Linux kernel with AI? Does “new project, are me GTA 8!” Work?
No.
That is hard reality, disconnected from any ridiculous hype BS people are living in.
You need to start the conversation with: I acknowledge, AI is not good at some things.
Now, if you can accept that baseline reality that you live in you can ask some hard questions like:
Are the things I’m doing things I could do without AI?
Am I actually more productive?
Is what I’m building actually working?
Are the things that other people are claiming to do, things that it can actually do?
Is it the right tool for the next thing I’m going to work on?
Maybe you don’t care; but, if you don’t like people asking those questions; why?
This is genuinely great tech. No one is denying that; it’s effective and productive to get certain stuff done.
What scares me is people who you cant even have this conversation with. What’s AI bad that?
Nothing!
Thats AI psychosis.
Take a look at your own opinions and why you take it personally (it seems) when someone calls out a case where AI did a bad job, or someone who failed because they relied too hard on AI.
Seriously man, if those things are upsetting you, because, literally, they have nothing to do with you, other than the tiny voice in your head telling you that “critiquing AI is critiquing me”… then have a good think about that.
It’s not a good place to be.
Build things. Be happy, be proud. Coming here and ranting like you’re doing? It’s not good. It’s realllly not good.
--- start quote ---
- Just what kind of evidence do you suppose they could have?
- Showing actual improved products and features. Showing actual code. etc.
--- end quote ---
Note how you provided neither. It's just claims.
> Anyway AI for sure increased project cadence by at least 2x.
As in: you claim this. Also, no one denies that you can ship a lot of code much faster with AI. However, somehow, very little actual evidence of grandiose claims (see farther up in the context) besides anecdotal "I'm so faster and features are being shipped left and right".
See also a sibling comment: https://news.ycombinator.com/item?id=48158565
I think it's a great example of using LLMs effectively. In the end becoming more productive is understanding where LLMs work great and where they fail miserably.
But it is a step similar to, say going from assembly to a higher-level programming language, not the silver bullet that AI astroturfers like you to believe (fire all the programmers to buy more tokens!)
I’m currently working on a rewrite of an app that originally took two years. It’s been about three months, and I’m probably about 70% done. It’s a total “from scratch” rewrite; both client and server (two versions of each, as I also have administrative code). It’s a pretty big system, for one guy. I couldn’t do it, without the LLM.
It’s not been a cakewalk. I’ve needed to toss out large swaths of LLM-generated code, and rewrite by hand, but, for the most part, it’s been a huge help.
But I’m also not doing it in a manner that eats tokens. I just use the standard $20/month subscription as a chat. I suspect my workflow is not one that Anthropic or OpenAI really wants out there.
But I also bet that many HN accounts are bots; although I think many may be ones run by enthusiasts, not some AI cabal.
Other than that, I am not boosting AI, and have absolutely zero interest in doing a bunch of work to satisfy some random Internet Guy, who can't be bothered to examine my pretty damn extensive open portfolio.
I was just talking about my personal experience.
> random Internet Guy, who can't be bothered to examine my pretty damn extensive open portfolio.
You cannot even be bothered to examine the comment you reply to, maybe get off your high horse.
And the main part of my comment was about something in the common realm, open source software, and hard performance/quality improvements. Not wishy-washy products and features, not yet another tone deaf cool story.
For instance, I checked out yours, and there's not much, except a whole bunch of challenging people here. I am wondering if you came here to "set us straight." I know that a lot of folks have low opinions of HN, and not all of them are wrong, but I find this place a fairly good place to hang out. Being challenged, is one of the draws, for me.
By the way, have you tried the new unhomogenized heavy cream? Good stuff!
Have a great day!
Not everyone is you. E.g. I don't expect he answer to "show your work" be no answer and "why didn't you check my profile".
My answer to "show your work" was "No." I am not going to go through my code, and show a bunch of supporting evidence for a casual comment, in which I have exactly zero investment. I really don't care that much what people think of me. I was just sharing my personal experience. If you guys want to write me off, then knock yourselves out.
"No" is a complete sentence. What part of "No" didn't he understand?
Have a great day!
An interesting answer to literally "Just what kind of evidence do you suppose they could have? - Showing actual improved products and features. Showing actual code. etc."
> "No" is a complete sentence. What part of "No" didn't he understand?
See above. After pointing this out you immediately started down the path of "why didn't you looko at my profile and followed the link to my github".
Not even close. The opposite even. Read more carefully.
> For 5 million comments like yours I haven't seen a single one with the old code vs. the new code. I understand that not all code is public that way, of course, and I don't mean to put you on the spot personally. But where are all the open source projects that now do the same with better error handling using less resources?
Same here :)
> not some AI cabal.
There are enough enthusiasts to make it feel like one. Also an unhealthy doze of marketers, people buying into hype, AI psychosis etc.
There's absolutely no question that AI is a real thing, and that there's going to be a lot of money made, so there's a bunch of folks with commercial interest in pushing it.
It's just different from crypto. This has actual real-world utility for just about everyone. I am increasingly hearing people say "Ask ChatGPT," where they used to say "Google It" (where they used to say "Look it Up at the Library").
But your anecdote is much more balanced and more in line with my personal findings. Not like all the AI astroturfing that happens here. I like to use LLMs as well, but in a very targeted way in places where LLMs shine.
Yes, LLMs can make you much more productive. But so could assembly -> C -> Python or Rust, or switching an IDE with code completion and support for refactoring. Each step makes you more productive.
Sure, LLMs can spit out greenfields projects. But on large projects with complex requirements, you still need senior engineers to guide them, carefully review the output, and as you say throw out code and write it from scratch in a better way.
I had some friends who ended up in bits of AI psychosis. They exclaim that a swarm of agents was writing all their code, but every time I ask them to show the end-result, all they have is a pile of code that they don't understand, nor doesn't really work either. At the same time, they stopped getting any actual work done.
At any rate, somebody had a great analogy on HN recently: think of it is a vector, LLMs can significantly increase the magnitude of the vector, but you still have to make sure that the orientation of the vector is correct.
Great analogy!
https://www.youtube.com/watch?v=AkKo1_RP_0c
The comment you’re replying to wasn’t uncivil. It wasn’t rude. It was a lament.
I’m not advocating for this rule to change (I’d appreciate if you didn’t straw man and mischaracterise what I said), but I am saying if a problem happens over and over and people notice it and talk about it, then you should maybe pay attention. The rule for new accounts came about from multiple comments and even submissions asking for it, not private emails. It came about from community conversation and outcry.
The load-bearing word in that claim is "undue", and it's not justified here. I'm not doing arcane rules-lawyering, I'm just saying people should avoid doing things the site guidelines quite specifically ask them not to do.
> I’m not advocating for this rule to change (I’d appreciate if you didn’t straw man and mischaracterise what I said),
I wasn't suggesting you did, I was suggesting the person I originally replied to might.
https://en.wikipedia.org/wiki/Generic_you
Does that mean I now repeat your parenthetical back to you? ;)
Which I agree with. And I’m just saying the rules aren’t absolute, can’t cover every situation, and could not predict the change of the world around them, thus occasional deviation from them is OK, especially when it serves the larger goal of protecting discourse on a website whose rules were written to protect it.
It’s the spirit of the law VS the letter of the law. Let’s say the rules ask you to not shove people but say nothing about peeing on others. If someone suddenly starts peeing on everyone without consent and refuses to stop, shoving them to get them away becomes an appropriate response despite being technically against the rules.
> I wasn't suggesting you did, I was suggesting the person I originally replied to might. (…) Does that mean I now repeat your parenthetical back to you?
By your own logic, I wasn’t suggesting you did it, I was asking for no one else to do it (also, it’d make no sense anyway, it’s not a straw man to incorrectly say someone is straw manning). It also means the person you originally replied to wasn’t accusing their parent comment, thus making your original comment invalid.
Also I provided the list of actual hype ha
Often such comments appear just before the submission is abandoned to wrap up the thing.
> 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)
In a way, obvious injected opinions benefit culture, by making formerly-unaware readers skeptical.
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.
Seriously, not a bot. Just a software engineer who feels gaslighted because I see AI used in one way at work and then I go to Hacker News and I feel like I am using a different technology compared to everyone else.
And don't get me wrong. I would like to be more skeptic about AI because I enjoy writing code, I enjoy a high salary with great benefits. But with the speed and direction we're seeing now (so I am not only looking at this specific point in time but rather also the direction and the fact that no one knows what they're doing) - I do worry about losing this. So I am definitely crossing my fingers that it is a bubble but I just don't see the evidence yet.
Above, you said:
> We still require a code review for any change
And:
> We don't really vibe though. At least I don't. I see it more as comment driven development. I need to understand the code and what I want to achieve where in the codebase
But in your previous comment, you said:
> since I'm no longer looking at code
And:
> Branches are now irrelevant
How can all of these things be true?
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.
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.
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."
Focus on that message, not the messenger.
HN was a tremendous resource built by its members and the moderators. In the last year or so a lot of that has been destroyed by people who have no sense of decency. They see deception as a virtue. They call it hustle or whatever. WTF?
Pretty sus, bot or otherwise.
Just like I need to keep in mind that not everyone work in a big tech(ish) company where tech stacks are standardised and many problems are solved centrally, I feel like people also need to keep in mind that not everyone has a horrible experience with AI.
And I also want to clarify that I hate AI. I loved writing code, I loved having a comfortable job with a good salary and good benefits. While the company I work for haven't done "AI layoffs" yet I feel like it's a matter of time because I'm not only looking at the state we are right now but also what the direction and speed is. It was only back in October I felt like AI was a bubble about to burst cause I wasn't getting enough value out of Claude Code. And then ofc Opus 4.5 happened and it changed my view completely. And we're a few months into using 4.5/4.6/4.7 (and I'm not an Anthropic shill, currently I am using Codex most of the time) but I was hoping this career would last me decades. But where will be 5 years from now? 15 years from now?
I just want to provide my perspective from a big tech company where I feel AI is doing more and more parts of my job. It's not perfect and it gets things wrong but I mean... humans do as well?
Which is the pathological take?
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
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.
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.
I've definitely thought about how I currently offer something to the company because I know these systems and can stop the agents from doing weird shit. But in a greenfield project I would probably (definitely) not get the same understanding.
I think as we figure out best practices - you'll start to see that you can rely less on humans. More tests, more acceptance tests of critical business logic, etc.
I think we might get to the point where I'm not really adding value anymore because I dont know the codebase well enough to stop the agent. But then again - the cost of code is getting cheaper and when you reach that state where agents can't reliably work in the codebase due to AI slop - maybe you just start over? Kick off a few agents over the weekend and come back on Monday to a new (hopefully leaner) codebase? Run it in shadow mode next to the production service - ask the agents to fix any discrepancies and iterate until you have a simpler service?
I dont know what will happen. But I dont think we'll go back
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
I don’t think AI actually changes that we should always be questioning everything, including how much we question at a time.
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.
No, I meant what I wrote. I keep hearing people say how LLMs write amazing code now.
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.
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.
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.
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?
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.
> 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 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.
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?
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
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.
We're guessing it comes from organizational behavior (culture, governance, management, etc.), we work in diverse teams / regions / companies.
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.
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.
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.
If you can't answer these questions credibly, I'm afraid I'll have to treat your answer as LLM influencer propaganda.
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.
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.
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.
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.
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.
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.
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
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.
Are other bots upvoting this?
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...
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.
Maybe next time write with more conviction instead of doing the "But it all feels... " shy 14 year old attitude in an attempt to be "neutral" and "mature" in your own confused words.
Shill AI less and either learn to code or fuck off cause I will personally poison your drink and every brown's drink who's sabotaging civilization by faking it """"till they make it"""""you'll never make it, you'll crash and burn like you did for millions of years since Pakistan & India and I'm telling you to stay away from us just like China & India have always been separated.
>We still require a code review , by whom, by which standard? By codemonkeys who don't understand the code and soon enough by AI judging other AI's code cause you're that lazy, incompetent and irresponsible to push blind guesswork into something beyond a hobby project, something as serious as fucking security and even vehicle AI.
> 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.
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.
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).
I'm in a big tech company where everything is standardised. All our microservices have the same tech stack. We're in a monorepo. Most microservices are... I wouldn't say tiny or micro but small enough.
And I haven't written a single line of code myself since what - February maybe?
We still haven't seen an increase in incidents, we ship more features at a higher quality. We address the tech debt we didn't have time for in the past.
We still require a code review for any change and it's becoming a bottleneck - for sure.
But it all feels... Mature and the next step of software engineering.
We don't really vibe though. At least I don't. I see it more as comment driven development. I need to understand the code and what I want to achieve where in the codebase but I'll leave godo comments explaining this before asking an agent to fill in the blanks.