It's right there on the label. If you didn't mean "vibe coded" then don't vibe write "vibecoded", and instead read what you wrote, then look up the meaning and spelling of the terms you are using, and do not neglect to correct yourself because it's not what you meant.
I have to correct typos like that all the time when I write them by hand. But making typos and having to correct them and having to look up the meaning and spelling of words does not make me complain about all human generated code and text just because it requires me to proofread what I wrote.
Reading what you wrote or what ai generated and looking up terms is all part of the process, because people and llms make mistakes. Vibe coding is not giving a shit about that, thinking it doesn't apply to you, and hitting "Accept All" without reading the code, by definition.
And if you can't accept that, then don't write or generate code or text, and don't complain about how you have to read what you and llms generate and correct it, and understand what words mean.
>I had to literally vibecode a separate linter for this
Why would you "literally vibecode" a linter and use it to review other llm generated code without reading the linter's code itself? That is "literally" vibe coding eating its own tail.
I take your emphatic use of the word "literally" to mean that you are "literally" using the well know definition of vibe coding as it was coined by Andrej Karpathy of OpenAI, which is "iterally" (and I quote):
>I "Accept All" always, I don't read the diffs anymore.
Am I misunderstanding you, or are you vibe writing the wrong term without reviewing the meaning of your own words?
Here is the full literal quote so there is no room for confusion or claims of missing context:
https://x.com/karpathy/status/1886192184808149383
>Andrej Karpathy @karpathy:\nThere's a new kind of coding I call "vibe coding", where you fully give in to the vibes, embrace exponentials, and forget that the code even exists. It's possible because the LLMs (e.g. Cursor Composer w Sonnet) are getting too good. Also I just talk to Composer with SuperWhisper so I barely even touch the keyboard. I ask for the dumbest things like "decrease the padding on the sidebar by half" because I'm too lazy to find it. I "Accept All" always, I don't read the diffs anymore. When I get error messages I just copy paste them in with no comment, usually that fixes it. The code grows beyond my usual comprehension, I'd have to really read through it for a while. Sometimes the LLMs can't fix a bug so I just work around it or ask for random changes until it goes away. It's not too bad for throwaway weekend projects, but still quite amusing. I'm building a project or webapp, but it's not really coding - I just see stuff, say stuff, run stuff, and copy paste stuff, and it mostly works.
That is the "literal" widely understood and well defined meaning of what you wrote, but misspelled "vibecoding", according to the well known AI expert from OpenAI who originally defined and championed the term. Its meaning has not suddenly changed.
Only a vibe coder would vibe code a linter to vibe lint vibe coded code for them, without looking at ANY of that code themselves, by just hitting "Accept All" always. Because vibe coders by definition don't want to bother reading what they generated, don't care what it means, and still expect it to come out perfect.
Don't be a vibe coder, or a vibe writer, or a human stochastic parrot: read what you write and know the definitions of the words you use.
And if you're not a vibe coder, then don't claim to "vibecode": that's "not engineering" just "magical and wishful thinking", as you like to say.
>"I always have to correct its hallucinations during the day. Why would I ever let it run unsupervised overnight?"
And the answer to your question is: because you are using git, so you can look at the diffs before merging and deploying into production. You are using git and looking at the diffs, aren't you? Have you heard of PRs and code reviews? Or is that too much to ask of a "vibecoder"?","offTopic":false},{"id":"9b511d1f-b306-4a27-bdc1-2e3ccca25dbe","excerpt":" — Also, as someone who has developed an ever growing suite of bespoke tools for my personal workflows using Codex/Gemini CLI over the last year, something I don’t see mentioned as often is the “mental overhead” of self-designed apps.
Even if the coding process itself is “effortless” and the agent just churns aw","url":"https://news.ycombinator.com/item?id=48137785","role":"demand","weight":1.1005764,"occurredAt":"2026-05-14T16:38:32.000Z","sourceKey":"hackernews","sourceName":"Hacker News","credibility":0.7,"venue":"news","intent":"alternative_search","painScore":0.58166665,"sentiment":-0.6666667,"confidence":0.6958333,"matchedPatterns":["alternative_to","missing_feature"],"statement":"I’ve had moments where I’m relieved to discover a popular open source tool that works out-of-the-box as an alternative to my own so I can offload that organizational overhead and decision fatigue to someone else.","title":null,"body":"Also, as someone who has developed an ever growing suite of bespoke tools for my personal workflows using Codex/Gemini CLI over the last year, something I don’t see mentioned as often is the “mental overhead” of self-designed apps.
Even if the coding process itself is “effortless” and the agent just churns away to implement whatever I ask for on a dime, it can become exhausting thinking through all my needs/wants, tradeoffs, API shape etc. Despite not needing to write a line of code myself or read more than excerpts in the chat it can turn into a slog after the honeymoon period passes and it starts to feel like unpaid work.
I’ve had moments where I’m relieved to discover a popular open source tool that works out-of-the-box as an alternative to my own so I can offload that organizational overhead and decision fatigue to someone else. While benefiting from all their features/enhancements I didn’t have to design or maintain myself over time.
As an example, I had been building a TUI/web app to download and organize ebooks from various sources like Project Gutenberg or Anna’s Archive with a central meta search, and manage my personal library. It solved the immediate problem at the time but I kept needing to add missing features, plug holes in the various search integrations, UI refinements, etc and it never quite worked exactly as I wanted so kept having to work on it and became less and less fun as time went on.
Then I discovered Calibre Web Automated + Shelfmark on GitHub that did 99% of what I needed plus a lot more and overall had a level of polish and reliability my tool never reached. Now I just pull a Docker container every so often for updates and made a few tweaks to syncing but overall spend vastly more time on actually reading/organizing/growing my library vs. increasingly tedious vibe coding sessions and it feels so much more enjoyable.
I still have plenty of self-designed tools and continue making new ones but now tend to reach for an existing, off-the-shelf option first whenever possible for anything more complex than a one-off script. That way I can benefit from a community collectively contributing to improve and maintain the project over time without needing to become an unpaid Product Manager, Lead Designer, Senior Developer and QA Manager for everything I use.
I hope the current period of exuberance around LLM development doesn’t lead to everyone becoming stuck in individual silos duplicating work that in the past could have been directed to an OSS project where that time investment could be shared with everyone else and benefit from way more eyes catching bugs and smoothing off rough edges.","offTopic":false},{"id":"4f8eb451-e2a6-4add-b137-bc22184ccce1","excerpt":"LLM’s can’t do graphics programming — I have generally been tracking LLM progress and attempting to integrate LLM’s into my workflow. My two cents: LLM’s are not currently capable of high-level autonomous graphics programming.\n\nHere are some anecdotes I’ve collected over a series of experiments and production tests tha","url":"https://www.reddit.com/r/GraphicsProgramming/comments/1twjk6b/llms_cant_do_graphics_programming/","role":"request","weight":1.1503334,"occurredAt":"2026-06-04T10:23:21.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"GraphicsProgramming","intent":"feature_request","painScore":0.36,"sentiment":0.26923078,"confidence":0.84583336,"matchedPatterns":["missing_feature","manual_process"],"statement":"**Conclusion** The discussion of the failures of LLM programming often centers around: - lack of notable productivity increases in companies that have heavily adopted LLM coding - challenges with code maintainability - flawed unit economic…","title":"LLM’s can’t do graphics programming","body":"I have generally been tracking LLM progress and attempting to integrate LLM’s into my workflow. My two cents: LLM’s are not currently capable of high-level autonomous graphics programming.\n\nHere are some anecdotes I’ve collected over a series of experiments and production tests that I hope will add some color to the current discussion being had in posts on this sub/elsewhere.\n\n**Shader Obfuscator**\n\n2 months ago, I tested Claude code (using Opus 4.6) on some tasks for a custom HLSL obfuscation pipeline I built in rust. It parses a simple AST from HLSL and then runs various AST transforms on it to make it unreadable to the average programmer.\n\nClaude was able to successfully implement very simple features and refactors. It was also able to quickly stamp out plausible boilerplate given high level descriptions. This was awesome because there’s a lot of these sorts of tasks involved in writing a compiler front end, and using an LLM made the process more enjoyable.\n\nThat said, it was not able to handle anything of intermediate complexity, even with a pretty good description of exactly what should be done and a lot of hand-holding. It would often make subtle mistakes that I would catch in tedious fine-grained reviews.\n\nContrary to what others have said: it could not produce meaningful unit tests on its own. The tests it wrote looked extensive at first glance, but they were just verbose and repetitive. They typically missed critical edge cases present in real shader files.\n\nI think this is an interesting case because this project was favorable to the LLM (heavily unit-tested, CLI interface, small number of lines of code, few external dependencies), but also algorithmically complex enough to evaluate its problem solving skills. On the latter, it performed worse than I expected.\n\n**Volume Renderer**\n\n~1 month ago, I used Claude Opus 4.7 to vibe code a real-time volume renderer from scratch with Web GPU and Rust.\n\nMy goal with this experiment was to evaluate both the degree to which a non-expert could have success in this matter, and failing that, the effectiveness of LLM’s at translating a very high level implementation request from an expert into a working solution. \n\nI understand that this is not the most effective way to use an LLM; a tight spec where you describe exactly what you want in detail is best. *But*, the capability to do this kind of hands-off work is what is being advertised and hyped, so I think it’s important to circumscribe the boundaries of what is possible.\n\nI was actually stunned when after ~10 mins of churning, it produced a working prototype that imported an open VDB file to a 3D texture, set up a simple camera + viewport, and successfully ray marched the volume.\n\nThat is more or less where the successes ended though.\n\nI tried to get it to optimize the ray-marching loop—starting with deliberately vague non-expert requests to just “make it faster” and then progressing to targeted algorithmic suggestions. It had quite a hard time with the open-ended nature of these requests; often it would undo work it had previously done when I provided new suggestions, and ultimately it failed to implement anything meaningful.\n\nI also attempted to get it to iterate on the lighting techniques by providing screenshots. No luck here: it could not translate visual critiques to solutions, even with progressively specific algorithmic guidance.\n\nFinally, I asked for a trivial adjustment to the camera controller to make it more intuitive to fly around. I expected it to be able to do this, but it failed.\n\nWhen I read the code, it was a bizarre combination of clean and messy; highly documented but overly verbose, with tons of unused functions. It only got messier as I asked for more modifications.\n\nFinal thoughts on this one: someone without experience would likely not push past the initial result to discover that LLM’s can’t currently vibe out unique graphics functionality. This may explain some of the conflict in discourse on the topic.\n\nThe structure of the successes/failures makes me slightly more confident that as of 2026 LLM’s continue to associatively interpolate the latent space of all code they’ve been trained on (including hand-tuned “reasoning paths”), despite recent claims to a more structural understanding of reasoning.\n\n**Unreal Plugin Integration**\n\nI’m working on a plugin for Unreal engine and, in the last 2 weeks, I’ve been looking for clever ways to inject my plugin’s data structures into the Unreal render passes without modifying Unreal’s source.\n\nUsing Claude code to scrape the UE source, which is largely undocumented, has been great for surfacing API’s and common usage patterns. This has sped up my work immensely. \n\nHowever, it would often tell me there was no way to do something without modifying source, when in truth it was actually possible with some creative thinking.\n\nHad I relied on Claude entirely here, I would have been forced to conclude I cannot ship my project as a plugin, which is wrong and would have significant business model consequences for our product.\n\n**Open VDB Transforms**\n\nFinal relevant example: about 2 weeks ago, I was dealing with a non-trivial bug with Open VDB frame transforms.\n\nI threw Claude Opus 4.7 at it and, despite having access to all the open VDB source, it hallucinated a bunch of stuff that didn’t work. I managed to figure it out in ~an hour.\n\nOf course I’ve had Claude successfully spot bugs for me as well. But I’ve found the more complex the issue the less likely it is to figure it out; perhaps an obvious statement.\n\n**Conclusion**\n\nThe discussion of the failures of LLM programming often centers around:\n- lack of notable productivity increases in companies that have heavily adopted LLM coding\n- challenges with code maintainability\n- flawed unit economics of token costs\n\nThese are all valid critiques, but a more fundamental issue is the simple fact that LLM’s cannot do effective graphics programming autonomously, i.e. without close guidance, and thus the productivity improvements appear to me to be (currently) overstated.\n\nExpert-level graphics skill is still required, both for boundary-pushing work and for run-of-the-mill tasks of intermediate complexity. How long that remains true is a mystery to us all, but given the current state of things I do not think we should assume we are within striking distance.\n\n**EDIT:** wow this has gotten more traction than expected. I started writing this as a comment on another post but I’m glad I decided to post it for real instead.\n\nFew things I wanted to address from the comments.\n\nAll of the above experiments were using agentic tools (claude code’s $20/mo tier in particular).\n\nThe stories I shared cover a somewhat wide range of usage patterns. The volume renderer experiment was more about seeing what a naive non-expert could build with LLM’s. On the other hand, the Open VDB bug was something I encountered in my day to day usage of the tools.\n\nAs written above: I agree that LLM’s can successfully complete “bite sized” tasks given the appropriate specs and an accurate description of the desired solution. I agree you could probably build an awesome renderer this way, maybe quite a bit faster than “by hand”. **I do not consider this “LLM’s doing graphics programming”**, at least in the way I meant it in the post title, because the expert graphics programmer is the one doing 90% of the substantive work.\n\nLastly: I use LLM’s to great benefit all the time. I am not anti-LLM coding. But I think we all ought to evaluate these systems honestly, with a high bar for correctness, and ask “when is it worth it to outsource work to a paid subscription service; what productivity improvement is required?“.\n\nThank you all for an interesting discussion!\n\n**EDIT #2**: edited original post’s language for clarity and intent.","offTopic":true},{"id":"37f2e3af-4781-4ee2-aeff-4f80591c585e","excerpt":" — > Thinking more deeply about your words, is it that you enjoy figuring out the instructions to use to solve a problem? In other words, figuring out the algorithm and writing the code out to create something? Would you feel if you just tell the LLM what you want to create and it does it, you've lost the enjoy","url":"https://news.ycombinator.com/item?id=48089739","role":"request","weight":1.0923611,"occurredAt":"2026-05-11T00:40:09.000Z","sourceKey":"hackernews","sourceName":"Hacker News","credibility":0.7,"venue":"news","intent":"problem_report","painScore":0.34444445,"sentiment":-0.11111111,"confidence":0.8125,"matchedPatterns":["i_need","missing_feature","manual_process"],"statement":"Even if I'm specific on the details of the algorithm it uses, it subtly fills in the blanks and the missing pieces that I haven't cemented in my brain yet thus making me miss out of the opportunity to do so.","title":null,"body":"> Thinking more deeply about your words, is it that you enjoy figuring out the instructions to use to solve a problem? In other words, figuring out the algorithm and writing the code out to create something? Would you feel if you just tell the LLM what you want to create and it does it, you've lost the enjoyment?
So there's a lot of nuance to the "is it that you enjoy figuring out the instructions to use to solve a problem".
At the surface I don't enjoy typing, I don't enjoy fighting syntax checkers, rust's borrow checker, or manual memory management in my personal C projects, typing out the HDL for nand2tetris problems, etc...
However, there have been studies done decades before this LLM boom about the psychological concept called the Generation Effect. While everyone is different and it's not completely black and white, the studies have found that people learn more by actual practice (the act of doing) than just by reading material. That's 100% the case for me.
I can read blogs and resources till the cows come home and I'll have a very surface understanding of a concept. Then I'll go to write the code to implement it and it rarely works right away because there are demonstrable gaps in my understanding. I'll debug it and iterate on it until it works, and that is what actually solidifies the mental model of what I was trying to learn in my mind. Not only can I say for sure that I remember it better, that seems to form connections in my brain that allows me to apply it in other use cases, or build fascinating technical tangents.
I not only get my high from that initial "Aha!" moment when I really feel like I understand a concept enough to actually apply it in other scenarios, but I also get my high from tangents that spawn off of that concept.
In many cases, I can map a direct line of my personal projects to a set of root projects that spawned them off because of ideas I came up with while actually implementing the projects. Since I tried real hard to optimize a C# game engine for an embedded platform, I realized where limitations were and it solidified my knowledge of how old game consoles worked.
This led me down to the interest of creating a GPU out of embedded device that I can pair with I/O constrained embedded devices. This taught me soooo much about the embedded space, and while I heavily improved my C writing abilities it also made me wish I could write C# on embedded.
Since I had learned C for the embedded project (and I knew MSIL from previous deep dives), I realized I can just translate MSIL into C and that would allow me to run C# anywhere (got C# working on an SNES, the linux kernel, and on an ESP32S3).
By implementing that by hand and coming face to face with many small decisions I had to make, that solidified a bunch of concepts in my head around intermediate representations and why they are a massive benefit. Those aha moments (among others) then led me down the path to implementing a just-in-time compilation engine for NES games and the C64 OS into the .net runtime.
The learnings from that have already spawned some other ideas in my mind, which is why I'm now learning Verilog and FPGA development.
None of these projects solved any useful problem (as in nothing was created that I or anyone else would use). The satisfaction and the high I got from them was having the curiosities of a problem, ideas of a solution, and persevering (partially due to being stubborn) through it and actually accomplishing it. The satisfaction that I actually understand the concepts at a foundational level, which actually ends up breeding excitement for a whole other tangent/problem.
These learnings have indirectly helped me in my day job as well. While I'm not working on anything that sophisticated or cool, all of these actual implementations I've learned have given me direct learnings I have been able to successfully use to create better software in other domains.
So it's not the actual typing I enjoy, but the whole picture of what comes out of the end through that typing. LLMs take most of that away. It lets me ideate on a vague solution and then it goes ahead and implements it for me. Even if I'm specific on the details of the algorithm it uses, it subtly fills in the blanks and the missing pieces that I haven't cemented in my brain yet thus making me miss out of the opportunity to do so.
And it steals the accomplishment of the final thing existing. I don't feel an accomplishment by typing in google "I need a C# to C transpiler" and just downloading it. That's what LLMs feel like, even if I'm trying to steer them at a lower architectural level. I don't have the aha moments, I don't have the learnings, and I'm disconnected from the code.
Thus it feels like it's stealing all the intrinsic rewards from me, only leaving the extrinsic ones. And those are not rewards I am particularly motivated by.","offTopic":true},{"id":"14cc34b6-4564-4896-8b67-e84658c15151","excerpt":" — Let me give a concrete example. I had a tool I built ten years ago on Rails 5.2. It's decent, mildly complex for a 1-man project, and I wanted to refresh it. Current Rails is 8. I've done upgrades before and it's...rough going more than one version up. It's _such_ a pain to get it right.
I poin","url":"https://news.ycombinator.com/item?id=46702924","role":"pain","weight":1.0778828,"occurredAt":"2026-01-21T08:58:12.000Z","sourceKey":"hackernews","sourceName":"Hacker News","credibility":0.7,"venue":"news","intent":"purchase_intent","painScore":0.4765517,"sentiment":-0.2413793,"confidence":0.73,"matchedPatterns":["i_hate","would_pay","manual_process","product:claude"],"statement":"I pay for Claude Code, but I regularly test local coding models on my ML server in my homelab.","title":null,"body":"Let me give a concrete example. I had a tool I built ten years ago on Rails 5.2. It's decent, mildly complex for a 1-man project, and I wanted to refresh it. Current Rails is 8. I've done upgrades before and it's...rough going more than one version up. It's _such_ a pain to get it right.
I pointed Claude Code at it, and a few hours later, it had done all of the hard work.
I babysat it, but I was doing other things while it worked. I didn't verify all the code changes (although I did skim the resultant PR, especially for security concerns) but it worked. It rewrote my extensive hand-rolled Coffeescript into modern JavaScript, which was also nice; it did it perfectly. The tests passed, and it even uncovered some issues that I had it fix afterwards. (Places where my security settings weren't as good as they should have been, or edge cases I hadn't thought of ten years ago.)
Now could I have done this? Yes, of course. I've done it before with other projects. But it *SUCKS* to do manually. Some folks suggest that you should only use these tools for tasks you COULD do, but would be annoyed to do. I kind of like that metric, but I bet my bar for annoyance will go down over time.
My experience with these systems is that they aren't significantly faster, ultimately, but I hate the sucky parts of my job VASTLY less. And there are a lot of sucky parts to even the code-creation side of programming. I *love* my career and have been doing it for 36 years, but like anything that you're very experienced in, you know the parts that suck.
Like some others, it helps that my most recent role was Staff Software Engineer, and so I was delegating and looking over the results of other folks work more than hand-rolling code. So the 'suggest and review' pattern is one that I'm very comfortable with, along with clearly separate small-scale plan and execute steps.
Ultimately I find these tools reduce cognitive load, which makes me happier when I'm building systems, so I don't care as much if I'm strictly faster. If at the end of the day I made progress and am not exhausted, that's a win. And the LLM coding tools deliver that for me, at least.
One of the things I've also had to come to terms with _in large companies_ is that the code is __never__ high quality. If you drill into almost any part of a huge codebase, you're going to start questioning your sanity (obligatory 'Programming Sucks' reference). Whether it's a single complex 750 line C++ function at the heart of a billion dollar payment system, or 2,000 lines in a single authentication function in a major CRM tool, or a microservice with complex deployment rules that just exists to unwrap a JWT, or 13 not-quite-identical date time picker libraries in one codebase, the code in any major system is not universally high quality. But it works. And there are always *very good reasons* why it was built that way. Those are the forces that were on the development team when it was built, and you don't usually know them, and you mustn't be a jerk about it. Many folks new to a team don't get that, and create a lot of friction, only to learn Chesterton's Fence all over again.
Coming to terms with this over the course of my career has also made coming to terms with the output of LLMs being functional, but not high quality, easier. I'm sure some folks will call this 'accepting mediocrity' and that's okay. I'd rather ship working code. (_And to be clear, this is excepting security vulnerabilities and things that will lose data. You always review for those kinds of errors, but even for those, reviews are made somewhat easier with LLMs._)
N.b. I pay for Claude Code, but I regularly test local coding models on my ML server in my homelab. The local models and tooling is getting surprisingly good...but not there yet.","offTopic":false},{"id":"3d8e0048-e44b-4535-8435-191c8667b226","excerpt":" — > I've worked with enough people with fine coding skills and terrible English
What about people with fine English and terrible coding skills?
What about people with both terrible English and terrible coding skills?
> Now, I often find Claude's idea of idiomatic prose to be a bit load-bearingly ","url":"https://news.ycombinator.com/item?id=49359702","role":"pain","weight":1.0219077,"occurredAt":"2026-08-19T10:46:07.000Z","sourceKey":"hackernews","sourceName":"Hacker News","credibility":0.7,"venue":"news","intent":"feature_request","painScore":0.69846153,"sentiment":-0.84615386,"confidence":0.6016667,"matchedPatterns":["missing_feature"],"statement":"In other words, if a person wants to limit themselves to avoiding LLM code over fears of it being bad, they would also have to avoid any any all code written by people that essentially produced the problematic training dataset, as well as…","title":null,"body":"> I've worked with enough people with fine coding skills and terrible English
What about people with fine English and terrible coding skills?
What about people with both terrible English and terrible coding skills?
> Now, I often find Claude's idea of idiomatic prose to be a bit load-bearingly seam-hitting as it lands not this point, but THAT one, but it is probably better than something hacked out by a person who confuses tenses, cases, pronouns and when they can enverb a noun. So I tend towards giving people the benefit of the doubt on this.
Personally, I find AI writing as insufferable as anyone else (though Anthropic's is particularly bad, maybe just due to my familiarity with it), but I wouldn't judge individuals for using it to make communication more readable, rephrase what they mean etc. If anything, any difficulty in reading my prose would support that.
> Lastly, if you think LLM-written software is full of security vulnerabilities and bugs, I have terrible news for you about the state of human-written code. The fact that what we do is often better than nothing at all, is no big recommendation.
I guess a lot depends on how you use the LLMs (I bet horrible coding skills coincide with horribly lazy and problematic usage of LLMs for development too), but I wonder how humans actually stack up to the slop-machine when it comes to how good or bad the code they produce is on average, since I'm sure that SOTA model code by now tends towards the upper end of that.
In other words, if a person wants to limit themselves to avoiding LLM code over fears of it being bad, they would also have to avoid any any all code written by people that essentially produced the problematic training dataset, as well as any programmers with the same capabilities (or lack thereof). You'd basically have to avoid using a lot/most of the software out there if that's your quality standard.","offTopic":true},{"id":"ad6b9ce3-feb9-4669-9f6f-9ffc28266b23","excerpt":"Am I the only one who finds auditing AI-generated Rust way more exhausting than just writing it? — Hey everyone,\n\nI know this isn't a direct question about Rust syntax or a new crate release, but I wanted to get the perspective of the low-level and systems engineers in this community, since the way we have to reason ab","url":"https://www.reddit.com/r/rust/comments/1v1biob/am_i_the_only_one_who_finds_auditing_aigenerated/","role":"pain","weight":0.889,"occurredAt":"2026-07-20T04:37:28.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"rust","intent":"other","painScore":0.4,"sentiment":-1,"confidence":0.635,"matchedPatterns":[],"statement":"Am I the only one who finds auditing AI-generated Rust way more exhausting than just writing it?.","title":"Am I the only one who finds auditing AI-generated Rust way more exhausting than just writing it?","body":"Hey everyone,\n\nI know this isn't a direct question about Rust syntax or a new crate release, but I wanted to get the perspective of the low-level and systems engineers in this community, since the way we have to reason about memory and safety is a bit unique.\n\nWith Linus Torvalds recently defending and leaning into AI tools for Linux kernel development, I’ve been trying to force myself to use LLMs more in my daily workflow. On one hand, if the systems world is adopting it to find bugs and speed up boilerplate, it feels like a tool worth leveraging.\n\nBut on the other hand, in practice? It feels like a massive cognitive trap.\n\nEvery time I ask an LLM to draft a custom allocator, some async socket-handling logic, or complex threading code, I end up spending the next hour auditing 100 lines of plausible-looking code. I'm stuck trying to reverse-engineer its \"intent\" just to make sure it doesn't subtly violate safety invariants, introduce a silent data race, or hide a memory leak.\n\nThe thing is, if I just write the code myself from scratch, I have absolute control over the execution path. Because I have to fight the borrow checker and map out lifetimes line by line, I build the mental model natively in my head. My own code is fundamentally way more understandable to me because I actually know *why* every single line is there.\n\nWhen we write low-level code, we feel architectural friction immediately when a design is bad. AI feels no pain, it will happily vomit out structurally messy code that technically compiles but is a total nightmare under the hood. I feel like I'm trading the active, rewarding problem-solving of *writing* code for the mind-numbing task of code-reviewing a junior dev who doesn't exist.\n\nHow are the rest of you systems/low-level devs actually using these tools without losing your sanity, your control, or your deep understanding of your codebase? Or are you just ignoring the hype cycle and sticking to the editor?","offTopic":false},{"id":"95ecc390-facb-4314-bed5-3df69f0187d8","excerpt":" — > MVP
I guess a lot of folks are having better luck than I am, in getting ship-quality results from LLMs.
In my case, I find that the first iteration is almost never suitable for shipping. In fact, the more intricate the functionality, the more likely it is, to contain some real showstopper bugs","url":"https://news.ycombinator.com/item?id=48918951","role":"request","weight":0.94633335,"occurredAt":"2026-07-15T10:56:01.000Z","sourceKey":"hackernews","sourceName":"Hacker News","credibility":0.7,"venue":"news","intent":"feature_request","painScore":0.36,"sentiment":0,"confidence":0.6958333,"matchedPatterns":["missing_feature","manual_process"],"statement":"That lack of trust in my output is something I haven’t had, in decades.","title":null,"body":"> MVP
I guess a lot of folks are having better luck than I am, in getting ship-quality results from LLMs.
In my case, I find that the first iteration is almost never suitable for shipping. In fact, the more intricate the functionality, the more likely it is, to contain some real showstopper bugs.
In my experience, iteration really requires that I know my shit. I have to know what to look for, and how to form effective prompts. Testing is absolutely vital. I can’t ever “just assume” that the code is fundamentally sound; even for extremely basic stuff.
That lack of trust in my output is something I haven’t had, in decades. It can be a bit stressful.
For example, I write a lot of mobile software, so resource usage is a big deal. I had gotten used to not testing for battery usage, leaks, or out-of-control allocations, over the years of using Swift. I am now back to routinely running Instruments.
In a couple of instances, I was just unable to get anything useful from the LLM, had to toss all its output, and rewrite by hand.
That’s why I can’t even imagine directly shipping anything the LLM gives me.
That said, I have generally had extremely positive experiences with LLMs. It’s now a basic component of my workflow.","offTopic":false},{"id":"8e203dd8-ce39-4681-b596-356b12f8bc12","excerpt":" — Direct feedback:
You have to give up on style. "not how I'd write things" is not a blocker. Defiance of instructions is normal, you just have to steer it and correct. There's no substitute for diligence yet.
80/20 - this means your scope was too large, split the scope or tell the agent t","url":"https://news.ycombinator.com/item?id=49324857","role":"request","weight":0.9130327,"occurredAt":"2026-08-16T23:28:25.000Z","sourceKey":"hackernews","sourceName":"Hacker News","credibility":0.7,"venue":"news","intent":"problem_report","painScore":0.31214285,"sentiment":-0.14285715,"confidence":0.6958333,"matchedPatterns":["terrible","praise"],"statement":"If you get into the loop on changes it'll feel awful and like no time savings.","title":null,"body":"Direct feedback:
You have to give up on style. "not how I'd write things" is not a blocker. Defiance of instructions is normal, you just have to steer it and correct. There's no substitute for diligence yet.
80/20 - this means your scope was too large, split the scope or tell the agent to revert, split the scope, and try again.
RE and assembler: it's really good at this stuff. It can patch almost any binary with the right tools
Swift: you have to give it tool usage in whatever result you're wanting. If it's a macos app, you have to let the LLM pilot it to get feedback, or build an extensive end to end test suite that it can drive autonomously. If you get into the loop on changes it'll feel awful and like no time savings. Review at the level of using the app and looking at the code, not in process or reviewing every tool call or diff.
applescript: works great, I have a bunch of automation set up this way, what problems are you seeing?
elisp: tough language, llms kinda hate parentheses unless you're really tight on the linting, and elisp is enough of its own animal that the training for e.g. common lisp isn't great.
python: will suck unless you enable all the typechecking, make it use bdd, and have a linter/formatter run precommit and yell at the robot for you.
Web vs cli: you should use the cli 100% because it lets you change the environment, if you're getting better results on web, you haven't set your local environment up very well. My personal preference is to run my own dev server on aws but that's spendy.","offTopic":true},{"id":"df61bb25-1504-4259-ae23-b15f0c684883","excerpt":" — I believe that "functional core / imperative shell" (FCIS) is the future of programming:
https://medium.com/ssense-tech/a-look-at-th","url":"https://news.ycombinator.com/item?id=46903283","role":"pain","weight":0.90598214,"occurredAt":"2026-02-05T18:47:52.000Z","sourceKey":"hackernews","sourceName":"Hacker News","credibility":0.7,"venue":"news","intent":"problem_report","painScore":0.5642857,"sentiment":-0.2857143,"confidence":0.57916665,"matchedPatterns":["waste_of_time"],"statement":"Which has bloated nearly all software by perhaps 10-100 times in terms of lines of code, conceptual complexity and even execution speed, making perhaps 90-99% of the work we do a waste of time or at least custodial.","title":null,"body":"I believe that "functional core / imperative shell" (FCIS) is the future of programming: https://medium.com/ssense-tech/a-look-at-the-functional-core... The idea being that business logic gets written in synchronous blocking functional logic equivalent to Lisp, which is conceptually no different than a spreadsheet. Then real-world side effects get handled by imperative code similar to Smalltalk, which is conceptually similar to a batch file or macro. A bit like pure functional executables that only have access to STDIN/STDOUT (and optionally STDERR and/or network/file streams) being run by a shell. I think of these like backend vs frontend, or nouns vs verbs, or massless waves like photons vs massive particles like nucleons. Basically that there is no notion of time in functional programming, just state transitions where input is transformed into output (the code can be understood as a static graph). While imperative programming deals with state transformation where statically analyzing code is as expensive as just running it (the code must be traced to be understood as a graph). In other words, functional code can be easily optimized and parallelized, while imperative code generally can't be. So in model-view-controller (MVC) programming, the model and view could/should be functional, while the controller (event handler) could/should be imperative. I believe that there may be no way to make functional code handle side effects via patterns like monads without forcing us to reason about it imperatively. Which means that impure functional languages like Haskell and Scala probably don't offer a free lunch, but are still worth learning. Why this matters is that we've collectively decided to use imperative code for almost everything, relegating functional code to the road not taken. Which has bloated nearly all software by perhaps 10-100 times in terms of lines of code, conceptual complexity and even execution speed, making perhaps 90-99% of the work we do a waste of time or at least custodial. It's also colored our perception of what programming is. "Real work" deals with values, while premature optimization deals with references and pointers. PHP (which was inspired by the shell) originally had value-passing semantics for arrays (and even subprocess fork/join orchestration) via copy-on-write, which freed developers from having to worry about efficiency or side effects. Unfortunately it was corrupted through design by committee when PHP 5 decided to bolt-on classes as references rather than unifying arrays and objects by making the "[]" and "." operators largely equivalent like JavaScript did. Alternative implementations like Hack could have fixed the fundamentals, but ended up offering little more than syntactic sugar and the mental load of having to consider an additional standard. To my knowledge there has never been a mainstream FCIS language. ClojureScript is maybe the closest IMHO, or F#. Because of that, I mostly use declarative programming in my own work (where the spec is effectively the behavior) so that the internals can be treated as merely implementation details. Unfortunately that introduces some overhead because technical debt usually must be paid as I go, rather than left for future me. Meaning that it really only works well for waterfall, not agile. I had always hoped to win the internet lottery so that I could build and test some of these alternative languages/frameworks/runtimes and other roads not taken by tech. The industry's failure to do that has left us with effectively single-threaded computers which run around 100,000 times slower today (at 100 times the cores per decade) than they would have if we hadn't abandoned true multicore superscalar processing and very large scale integration (VLSI) in the early 2000s when most R&D was outsourced or cancelled after the Dot Bomb and the mobile/embedded space began prioritizing lower cost and power usage. GPUs kept going though, which is great for SIMD, but doesn't help us as far as getting real work done. AI is here and can recruit them, which is great too, but I fear that they'll make all code look like its been pair-programmed and over-engineered, where the cognitive load grows beyond the ability of mere humans to understand it. They may paint over the rot without renovating it basically. I hope that there's still time to emulate a true multiple instruction multiple data (MIMD) runtime on SIMD hardware to run fully-parallelized FCIS code potentially millions of times faster than anything we have now for the same price. I have various approaches in mind for that, but making rent always comes first, especially in inflationary times. It took me over 30 years to really understand this stuff at a level where I could distill it down to these (inadequate) metaphors. So maybe this is TMI, but I'll leave it here nonetheless in the hopes that it helps someone manifest the dream of personal supercomputing someday.","offTopic":true},{"id":"fcae00c1-a67a-47f0-b96b-1f8f594f268a","excerpt":" — Pretty much every software problem we work on breaks down into steps that are solved in prior art. Even if it weren't, if you're capable of explaining the context and constraints of your problem, then a modern LLM with effort=high will generally come up with a solution that's worth starting with bec","url":"https://news.ycombinator.com/item?id=49352623","role":"pricing","weight":0.8904667,"occurredAt":"2026-08-18T20:59:21.000Z","sourceKey":"hackernews","sourceName":"Hacker News","credibility":0.7,"venue":"news","intent":"pricing_complaint","painScore":0.48,"sentiment":1,"confidence":0.6016667,"matchedPatterns":["too_expensive"],"statement":"Moreover, you can start with the solution and then course-correct based on future information because refactoring is trivial with an LLM, yet human projects often ratchet into a local optimum because refactoring is too expensive.","title":null,"body":"Pretty much every software problem we work on breaks down into steps that are solved in prior art. Even if it weren't, if you're capable of explaining the context and constraints of your problem, then a modern LLM with effort=high will generally come up with a solution that's worth starting with because it's well-reasoned. Moreover, you can start with the solution and then course-correct based on future information because refactoring is trivial with an LLM, yet human projects often ratchet into a local optimum because refactoring is too expensive. I don't think "it's been built before" does as much work as it seems. I didn't fork a project. The LLMs reasoned about how to build the project from scratch using trade-offs that made sense for my needs, and they made reasoned, unsolicited deviations from kitty, xterm, and co, not just blindly doing what some ref impl did. Btw, it was still a lot of work because my project isn't just "kitty but swift". Then the models went on to drive a well-reasoned incremental implementation of a system that lets me use the terminal running on my Macbook from my iPhone over tailscale with a decent scheme it came up with itself. The point is that I don't really have to know how things work to build good software with modern models. LLMs can do things like read Linux source code and adversarially refine ideas such that the final idea is a good one. And my biggest influences on the project can be automated through the use of reusable markdown files. Now, I'm at risk of downplaying all my years in software here, but I see the writing on the wall. It was only one year ago that I only trusted AI to do autocomplete.","offTopic":true},{"id":"ade8be4b-01fd-4e1b-a6ed-b47ea6e61bd6","excerpt":" — I've taken the approach of writing and even directly reviewing almost no code for this, otherwise I'd simply not have time for it as another side project. It's also interesting to see how far I can push this "vibe engineering" approach, and although it's not perfect, the answer is much ","url":"https://news.ycombinator.com/item?id=48082631","role":"pain","weight":0.87454164,"occurredAt":"2026-05-10T10:24:32.000Z","sourceKey":"hackernews","sourceName":"Hacker News","credibility":0.7,"venue":"news","intent":"problem_report","painScore":0.51,"sentiment":0.8333333,"confidence":0.57916665,"matchedPatterns":["terrible"],"statement":"It's instructed to maintain test coverage and treat quality very seriously - as a result there are over 5000 tests (some I suspect are useless...) and it's pretty rare to get a regression.","title":null,"body":"I've taken the approach of writing and even directly reviewing almost no code for this, otherwise I'd simply not have time for it as another side project. It's also interesting to see how far I can push this "vibe engineering" approach, and although it's not perfect, the answer is much further than I'd have expected going in. I've managed to get OpenCode setup such that I can have a productive discussion about the design or an issue / change then leave the LLM iterating for long periods while I do other work. It's instructed to maintain test coverage and treat quality very seriously - as a result there are over 5000 tests (some I suspect are useless...) and it's pretty rare to get a regression. I'm pretty sure there are plenty of significant bugs and gaps, but also that once found it seems like all of them will be fixed pretty quickly by the LLM. I just have to avoid looking at the code...","offTopic":true},{"id":"2324700e-67ab-426c-b981-8bbb09f24f37","excerpt":" — It is never really for "One". If it is open source and published, It may be use by others... not to mention coding AI ML (Machine Learing), then for many. I have written so much software for one... I cannot recall everything. I use some of it daily: - I have my custom elf(glibc)/linux distro - I","url":"https://news.ycombinator.com/item?id=49133358","role":"request","weight":0.8628333,"occurredAt":"2026-08-01T11:13:35.000Z","sourceKey":"hackernews","sourceName":"Hacker News","credibility":0.7,"venue":"news","intent":"feature_request","painScore":0.24,"sentiment":0.05882353,"confidence":0.6958333,"matchedPatterns":["wish","free_tier"],"statement":"But I wish for RISC-V to be a success, namely as a modern, very often hitting the 'sweet spot' in technical design compromises, NON-IP-LOCKED ISA.","title":null,"body":"It is never really for "One". If it is open source and published, It may be use by others... not to mention coding AI ML (Machine Learing), then for many. I have written so much software for one... I cannot recall everything. I use some of it daily: - I have my custom elf(glibc)/linux distro - I use my own ffmpeg based x11 media player (will have an update for wayland). - Since the "geniuses" at gogol blocked all accounts not using whatwg cartel web engines and blocked all self-hosted SMTP servers (I do not pay the DNS mob, then IP literals, which is stronger than SPF) to exchange with gmail.com users (now prisoners), I have my very own simple noscript/basic HTML servers (messaging, file transfer, openstreetmap browsing, etc). Unfortunately, most are C written from linux instead of assembly (at least, I removed most of the time the libc dependency with direct syscall programming). IPv6 is making everything internet software muuuuuuch easier to implement: I am lurking at an IPv6 only, super idiotic and real time voice/video/text/file transfer protocol, probably based on SIP (the main issue are randomly generated IPv6 addresses from mobile internet, which may require a mini-server for IPv6 address exchange, BAAAAAAAD!). - Ofc, I still have my own minimal SMTP server (and a SMTP client to send emails), because there are still honnest people on internet. mutt forever. - I am trying to build a RCS for linux, aka a Reduced Command Set with near direct hardwiring to linux syscalls. I lose comfort, but knowing that I removed giga tons of bloat feels so much satisfying it is worth it by light years. I will have to code my own command shell one day. I still have C code since I currently need portability on IP-LOCKED ISAs (arm and x86-64). But I wish for RISC-V to be a success, namely as a modern, very often hitting the 'sweet spot' in technical design compromises, NON-IP-LOCKED ISA. I am writting much software in RISC-V assembly now... which I run on x86-64 with a small interpreter (written in x86-64 assembly)... trying to fix the bloat and kludge from corpo-like open source software (including the SDK). Right now, I am writting my own wayland compositor using that framework. I was not expecting window management to be a bazillion of little things to do everywhere. And even if a wayland compositor is several orders of magnitude smaller and leaner than a x11 server, it ain't that a small project (ofc, I implemented myself the wayland wire protocol, no external libs here). In my 'trying to fix the bloat and kludge' from corpo-like open source, I force myself to use my own exe/dynamic lib format for modern hardware (so lean, a simple RFC will be enough, and no more loader bloat/kludge). But I am scared at the abominations which are all the requirements of classic computer languages to run: I would like a mesa vulkan driver, but there is still c++ (super BAD) in there which makes porting to an alternative dynamic lib format a living hell, non trivial C won't be that easy neither (for instance the abomination of the ISO __thread keyword, amazing bright minds there). Taking perspective from that, I wonder why anybody sane would add on top of that a big runtime requirement?? And what people doing that have to keep in mind: IRL can put a violent stop to all of this.","offTopic":true},{"id":"a0a77c18-c9ed-4f1b-afdc-eb86ef44fbcb","excerpt":" — > Quite a lot of changing the code is just useless busywork: re-wiring old functions, moving imports around, searching for locations that benefit from extracting a common piece of code. If other people are dissatisfied with LLM output quality while it seems to work fine for you, you might want to consider that ","url":"https://news.ycombinator.com/item?id=49051077","role":"pain","weight":0.852286,"occurredAt":"2026-07-25T20:13:25.000Z","sourceKey":"hackernews","sourceName":"Hacker News","credibility":0.7,"venue":"news","intent":"problem_report","painScore":0.53105265,"sentiment":-0.05263158,"confidence":0.5566667,"matchedPatterns":["terrible"],"statement":"Quite a lot of changing the code is just useless busywork: re-wiring old functions, moving imports around, searching for locations that benefit from extracting a common piece of code.","title":null,"body":"> Quite a lot of changing the code is just useless busywork: re-wiring old functions, moving imports around, searching for locations that benefit from extracting a common piece of code. If other people are dissatisfied with LLM output quality while it seems to work fine for you, you might want to consider that the quality of code you produce is closer to the quality of code the LLM produces than what those other people are producing. What you posted there, for example, about most of changing code being busy work is a pretty big red flag for a codebase. One of those "large structure" things that you're supposed to be paying attention to is the architecture of the code. There's always the chance that some change you need to do goes against the grain of the solution you architected, and you need to make changes all across your codebase to fit it in, but in general the point of modularity and good architecture is that when you make a change you just have to make that one change, ideally just changing the logic of the one responsible function with only minor changes required anywhere else in the codebase. If you're consistently having to hunt throughout the code for related functions that you need to rewire that's a sign that your architecture does not fit with the direction your codebase is evolving, or alternatively that you don't have much of an architecture to begin with and your code is highly interconnected. Actually one habit you mention at the end of that quote can worsen this issue: "searching for locations that benefit from extracting a common piece of code". Tautologically this is a good thing as you define it as only working on locations that will benefit, but given the frequent need for rewiring of functions I would hazard to guess that you've "deduplicated" code a bit overzealously. Just because two functions share some common code does not necessarily mean it is appropriate to pull that out into a function. Deduplicating is good if conceptually the code is a single thing that you would always want to keep in sync, as it means that when you need to make a change to it you don't have to hunt down all the places it's used. On the other hand, if you find yourself frequently needing to delve in to these functions to rework them because you need to make a change to how it's used by just one caller, your "deduplication" has added to your workload, and probably created some overcomplicated code in the function that is in reality handling multiple distinct needs. I hope this doesn't come across as too condescending, and if I've just wasted your time explaining principles you already understand I apologize. I don't know you or the code you're working on so I can't exactly confidently judge your work solely on a few paragraphs. It's just that your mention of how your experience of coding has been different from what others have described, and specifically that, for you, writing has been the bottleneck rather than understanding, combined with the specific issues you describe facing, imply to me that you may not realize that the approach you are taking to producing code yourself may be significantly different from how other Software Engineers are producing code, and that may account for some of the differences you note in your personal experiences programming.","offTopic":false},{"id":"f1b307d9-0b78-43b3-a913-d9bc44676a11","excerpt":" — Yeah I have a lot of experience writing software. My code is written mainly in Golang, but I had models write different code in Javascript, Rust, Python, Shell and other languages already. I used a variety of frontier models over the last years, always the best available model at the time. I prompt LLMs by writing","url":"https://news.ycombinator.com/item?id=49133227","role":"request","weight":0.8284667,"occurredAt":"2026-08-01T10:59:08.000Z","sourceKey":"hackernews","sourceName":"Hacker News","credibility":0.7,"venue":"news","intent":"problem_report","painScore":0.36,"sentiment":0.53846157,"confidence":0.6091667,"matchedPatterns":["manual_process"],"statement":"Especially juniors or people without programming background don't care about how the code looks that the AI wrote, I only see these issues because I have 10+ years of experience working by hand in large codebases and I have developed…","title":null,"body":"Yeah I have a lot of experience writing software. My code is written mainly in Golang, but I had models write different code in Javascript, Rust, Python, Shell and other languages already. I used a variety of frontier models over the last years, always the best available model at the time. I prompt LLMs by writing design specs and iterate on them first, then let it implement them step by step, checking the results after each step. That works fine for simpler changes where I use the LLM to write code that I have mostly worked out in my head, it always goes wrong once I try to do that with larger features. I have tried a lot of different things like writing extensive RFCs and design docs for the whole codebase, building harnesses and evaluation loops to ensure we stick to specific paradigms in the codebases but the LLMs still deviate from that in sublte ways and spuriously introduce duplication, wrong abstractions or simple hacks. That said my codebases are quite complex, it's not run of the mill CRUD software, I suspect these LLMs would do much better on these. That's probably why other people report large success using AI based development, 90 % of apps out there are just plain RoR or Django backends, React or Next.js frontend or Android apps, and they are already built following strict cookie cutter recipes, LLMs have no trouble following these. My work is e.g. on novel parser generators, graph data persistence layers, format-preserving pseudonymization and personal information detection in unstructured data so there's really nothing that you can base the software design on apart from general principles, I suppose that is why the models struggle so much. There was a discussion here explaining the attention mechanism of the larger models and why they are not good at using their full context length, that was quite enlightening to me as it explained a lot of the behavior I saw on more complex changes, so I think one mistake I made was to have too long conversations with too much context (even though "on paper" the context length was fine and well within limits of the given model), I guess I need more careful conversation management and in general reduce the level of abstraction I'm working at with an LLM. For me at least they're not yet good enough to work at the business or concept level of abstraction, but they are capable of speeding up delivery of finished architectural designs. Maybe it's also a perception problem. A lot of people will just look at their AI generated software and check that it does what it's supposed to do on the happy path and they will be fine with that, calling it a day (and to be honest I did that too for projects with tight deadlines, though it feels irresponsible). Especially juniors or people without programming background don't care about how the code looks that the AI wrote, I only see these issues because I have 10+ years of experience working by hand in large codebases and I have developed a "taste" for what good code is supposed to look like for me. That might explain why people are feeling so radically different about LLMs, if you don't have all of that intrinsic baggage that senior level developers have amassed over their careers then AI generated code will always look good to you. And maybe they are right, could be that in 10 years no one looks at any code anymore and we just care about tests and making sure the behaviour is correct. To be honest I never looked at Assembly code in the last 10 years and I don't care how my compiler unrolls my loops (mostly) as it's a solved problem for me, maybe it will be similar with the higher level code, we just move the abstraction that we work at to a higher level. But I still feel that we don't have the right tools for working at this higher level yet.","offTopic":true},{"id":"6bd523f3-2d03-4d26-9ba2-7e21af0f4238","excerpt":" — >That won't actually work though, it'll just go off and do nonsense, I've tried that. I've tried it too. It worked. >If you want it to be something maintainable, no you can't do that. If you try, you'll get parallel interfaces, half baked APIs, a bunch of special cases that ar","url":"https://news.ycombinator.com/item?id=49339454","role":"pain","weight":0.82076186,"occurredAt":"2026-08-18T00:09:27.000Z","sourceKey":"hackernews","sourceName":"Hacker News","credibility":0.7,"venue":"news","intent":"feature_request","painScore":0.41714287,"sentiment":-0.14285715,"confidence":0.57916665,"matchedPatterns":["missing_feature"],"statement":"Your statement lacks any real world data and it's just wishful thinking.","title":null,"body":">That won't actually work though, it'll just go off and do nonsense, I've tried that. I've tried it too. It worked. >If you want it to be something maintainable, no you can't do that. If you try, you'll get parallel interfaces, half baked APIs, a bunch of special cases that are incompatible and brittle, and eventually it'll have to be refactored and good luck with that -- the agents have a special failure mode there that is quite fun (building a artifact verification cathedral and then spending all its time verifying that instead of working on code). You're just saying this. You haven't actually tried having an LLM write all the code and have the LLM do the maintenance. Your statement lacks any real world data and it's just wishful thinking. The answer here is actually quite complex because we have people like you who complain about it and say they "know" it won't work because they've seen it with their own eyes while people like me have seen it totally work and be totally doable as well. So who's reality is true? Only time will tell. But I find it unlikely you've tried to have an LLM try to maintain an active project in prod. I have. >This is why languages are designed. This process won't produce anything but mush. Typescript is the result of years of iteration on a tiny language called javascript. >Okay but have you though? Have you actually tried building a language this way? How long did you maintain it for? Can we see it? Nope. haven't done it. But I have done things more complex then language design. And I can't show you because my employer owns it. But FYI language implementation follows very common patterns and this makes it very very easy for LLMS to create one. A beta of a language can be done in about a week.","offTopic":false},{"id":"cb553daf-7c11-4971-adc7-ebd72874378c","excerpt":" — Interesting point about "letting go". I hear that quite a lot, which I find surprising. In IT, when new technologies like cloud computing emerge people always need to adapt their workflows, and for some that is challenging e.g. going from manually maintained servers to virtual machines or containers that a","url":"https://news.ycombinator.com/item?id=49133911","role":"request","weight":0.7876667,"occurredAt":"2026-08-01T12:37:16.000Z","sourceKey":"hackernews","sourceName":"Hacker News","credibility":0.7,"venue":"news","intent":"problem_report","painScore":0.36,"sentiment":0.13043478,"confidence":0.57916665,"matchedPatterns":["manual_process"],"statement":"going from manually maintained servers to virtual machines or containers that are just spun up and down on demand.","title":null,"body":"Interesting point about "letting go". I hear that quite a lot, which I find surprising. In IT, when new technologies like cloud computing emerge people always need to adapt their workflows, and for some that is challenging e.g. going from manually maintained servers to virtual machines or containers that are just spun up and down on demand. Maybe it is similar with AI, we gain new capabilities along one dimension like speed of development and we lose some capabilities along the way e.g. manual control of quality. And of course there are large financial incentives here as well, maybe they are larger than we have ever seen before and the change also happens faster. Cloud computing took probably multiple decades to be fully adopted (I think AWS became available in 2006 and we still see large corporations migrating to the cloud from their on premise setups today, though the adoption curve is flattening), LLMs have significantly higher adoption after only around 2-3 years of them becoming "production-ready". So naturally people struggle with how to adopt them and we need to figure out where they make sense and where not. That said it's precisely an engineers' job to figure that out, people that just see the upsides of this technology seem quite naive to me. I can see this struggle it in my organization as well, in the last year there was a big push to adopt AI everywhere and tons of initiatives to automate processes and produce code and text and other artefacts with LLMs. Now it seems the pendulum is swinging back a little as people see that all of the LLM generated stuff shows all of these subtle quality degradations, and people get tired of managing it as they are suddenly confronted with tons of additional information they need to manage. Given that models are still evolving and becoming better at a rapid pace I think that we will solve most of these issues in the near future, but for now I don't think the age of hand crafted code is over yet. I have been thinking about that machine code analogy before as well, I don't think it really holds. Machine code is written in an automated way but following mostly deterministic rules that have been crafted through decades of manual optimizations and testing. AI generated code has nowhere near this level of scrutiny, testing and optimization behind itself. The fault rate of compilers and optimizers is incredibly small (I can't find any numbers but it must be on the order of ppm or ppb), AI generated code has fault rates that are even in the best case on the order of 99-99.99 % maybe (i.e. between one error per hundred lines and one error per ten thousand lines in the best case), try building anything complex using such a fault rate without manual correction and review. It's impossible. I have done it, I dabbled with writing a compiler, a database and even a simple web framework from first principles. I didn't get far, even though I had good mental models of these things and I carefully wrote RFCs and documents for the LLM, specified test cases etc... If you're lucky it will regurgitate some existing code or follow documented guidelines, but when you're on new territory these models won't be able to produce anything good. I would really like to see a single example of someone vibe coding a high quality library or tool with LLMs, I haven't found anything and no one can point me to a complex codebase (say 10,000 lines or more) that was generated using high level prompts that looks decent and doesn't have multiple glaring issues that appear when looking at it in detail.","offTopic":true},{"id":"2f1a1ab7-5346-417c-b7b2-cb1c173fb630","excerpt":" — So the biggest change is the day to day workflow change of just pumping out little powershell scripts for whatever I need and not building those scripting skills or performing the manual rote admin work. Rather than manually expand a disk in the hypervisor and then sshing in and expanding the partition and filesyste","url":"https://news.ycombinator.com/item?id=48000062","role":"request","weight":0.7876667,"occurredAt":"2026-05-03T18:45:44.000Z","sourceKey":"hackernews","sourceName":"Hacker News","credibility":0.7,"venue":"news","intent":"problem_report","painScore":0.36,"sentiment":0.6666667,"confidence":0.57916665,"matchedPatterns":["manual_process"],"statement":"Rather than manually expand a disk in the hypervisor and then sshing in and expanding the partition and filesystem Claude spits out a one liner and I run it.","title":null,"body":"So the biggest change is the day to day workflow change of just pumping out little powershell scripts for whatever I need and not building those scripting skills or performing the manual rote admin work. Rather than manually expand a disk in the hypervisor and then sshing in and expanding the partition and filesystem Claude spits out a one liner and I run it. While not challenging or particularly rewarding those trivial tasks are a soothing part of the constant flow of work that i didn’t dislike. Solid things in which i understood every aspect becomes a black box that does it for me and i have to reinterrogate or accept it, and in which it’ll never be worth the time to learn myself. As for the deeper work, the most recent example I have is deploying an observability stack for our lab cluster. In the past i would have done way more upfront work on understanding the alternatives and the deployment. I would have known every line of config before pressing deploy including the ones I chose not to set. The why and how of everything. Now the most efficient way is just to tell Claude to stand up a monitoring stack in the manner that apps are already deployed on the cluster and iterate with Claude once it’s up and running. Why bother diving deep when you can be running a proof of concept in five minutes and then just see if it falls over. Another part of it is that i really dislike learning through a prompt. I don’t like summaries, i like man pages. I don’t want to interrogate a result i want to provide a complete solution. Part of it too is I’m fairly new to all this professionally. I’ve only been at it 5 years, though hobby much longer. Basically i can feel myself growing and getting better and now suddenly there’s this genius moron in my pocket that so much better than I ever dreamed I could be while simultaneously having huge shortfalls. It’s a just an instant paradigm shift and after the first week of glee it’s not been a positive feeling. It’s not that my existing knowledge isn’t relevant at all, there’s still a huge base of networking and systems knowledge that’s necessary. It’s routinely surprised me in my career when i speak with a greybeard developer who is a an absolute wizard to me but dns/tcp etc are just a black box to them. Or when I talk to a friend new into the selfhosting hobby and i try to explain something to them that think is simple and i realize there’s 10 years of accumulated knowledge underneath that simple concept in order to actually grok it. I don’t know if that answered your question, just an unstructured ramble. I think the heart of it is that googling and research and things being concrete and complete understandings of workings and interactions and variables and secrets and configs etc are giving way to a black box pumping out systems and it mostly working out of the box and often that is simply good enough for now and it’s on to the next thing.","offTopic":true},{"id":"a36d6888-ad85-4a80-b815-ac68a51bc092","excerpt":" — I realized that I was typing the comment above in the middle of the night; finally, brain fatigue hit and I wrapped it too soon (thus some typos, sorry). That all was some "poetry." Now let me give you some concrete example cases. 1. You're typing a message to your colleague, and you're ","url":"https://news.ycombinator.com/item?id=48875695","role":"pain","weight":0.77933335,"occurredAt":"2026-07-11T20:47:01.000Z","sourceKey":"hackernews","sourceName":"Hacker News","credibility":0.7,"venue":"news","intent":"problem_report","painScore":0.4,"sentiment":-0.1,"confidence":0.5566667,"matchedPatterns":["manual_process"],"statement":"Do liberate your text from the tyranny of complex GUIs, do get annoyed when you have to manually retrieve any piece of whatever.","title":null,"body":"I realized that I was typing the comment above in the middle of the night; finally, brain fatigue hit and I wrapped it too soon (thus some typos, sorry). That all was some "poetry." Now let me give you some concrete example cases. 1. You're typing a message to your colleague, and you're doing it in Slack, Teams, etc. Why? Why not use your trusted editor where you probably already have smart completions, quick spellchecking, thesaurus, definition and etymology lookup, translation and dictionaries, LLM integration and more. Years ago I realized that and stopped typing anything longer than three words in anything else but my editor. But that forced me to copy-n-paste a lot, so I automated the process. I'd press a key in the middle of typing - regardless of what the current app is, the script simulates pressing Cmd/Ctrl+a Cmd/Ctrl+c; opens the editor buffer; inserts the text; I'll do editing; press a key - it goes back to the app; pastes the text. Stupidly simple, deviously efficient. Suddenly, my entire OS is my editor and my tool is "invisible" - like the article describes. 2. You're typing a message to your colleague. Now you're doing it in your editor, you want to share the url to the thing opened in your browser. What do you do? Normally, you'd switch to the browser, press another key to focus on the navbar, copy the link, switch back, paste the link. Goddammit, the url is cryptic. You, being a good teammate, want to add a description, now you have to go back to the browser to copy it. Then you have to make it into a markdown link format. Darn it. Was it parens and square brackets, or the other way around? We don't even realize how often we do this, because this simple action has become a routine. What's the point of arguing if mouse or vim or shortcuts is faster if the action is fundamentally flawed? For me, inserting a link in the middle of typing, from any tab in my browser is within a keystroke. It intelligently and properly formats it while retrieving the document.title. 3. Your colleague sends you a message: "Hey Jon, what about FOOBAR-41234?..." You know it's a Jira ticket number. But between FOOBAR-41345 and -41234 and a bunch of other recent ones you have no mental recollection of what that number is about. You go to your browser, navigate to the Jira instance, darn thing says you have to re-login, now you're going through 2FA - it won't even let you-in unless you find your phone and confirm it. All that effort just to look at the title. We all recognize this familiar flow, don't we? Why even deal with this BS at all? Jira, Asana, Trello, etc. - all have CLI tools, you should leverage that. In my editor, whenever the cursor stumbles on a pattern like above, it immediately fetches the ticket description and shows it in a popup. I can quickly convert the plain "FOOBAR-41234" into a markdown, org-mode, whatever link format that has a description. 4. You're looking at FOOBAR-41234, you even see the description (because your editor is smart now), but how do you answer questions like: "what are the PRs related to this ticket?", "find slack threads that mention it", etc.? That stuff should be quick and easy. Do get annoyed whenever it takes longer than two seconds to answer any of these or similar questions. 5. You are pair-programming over Zoom. Alice (your colleague) is sharing the screen, you are reviewing some big unit of work. She's scrolling through the code changes, occasionally opening documentation, navigating to different sites, etc. You just can't bear constantly interrupting her with "slow down, I'm taking notes", "please, share this link", etc. After the session you frantically try to recall, but most of it is gone now, your notes are whacky, containing a bunch of broken urls and half-typed nonsense. Three weeks later it is a complete and utter garbage. Then you spend years debating of note-taking strategies trying to figure out what "works" and what doesn't. That should annoy you. Darn it, if I can see it on the screen, why can't the computer "see" it too? It irked me, so I hooked up Flameshot, Tesseract, and Emacs and now I can select any area of my screen and the text gets OCRed and pops in a buffer. It's not always accurate, but it is quick and I don't even have to tell Alice to slow down anymore. --- These are just a handful of examples, and I haven't even touched anything code related. Hopefully you can already see what I meant in my post above. Do liberate your text from the tyranny of complex GUIs, do get annoyed when you have to manually retrieve any piece of whatever. You're a damn programmer, computers and computer programs should obey your command, never forget that.","offTopic":true}],"breakdown":[{"sourceKey":"hackernews","sourceName":"Hacker News","count":17},{"sourceKey":"reddit","sourceName":"Reddit","count":2}],"total":19}}