9 ms·
Vibe code is legacy code
- pyman 1y agoSomething interesting is happening. A false narrative is spreading online, pushed by people who know little about engineering, and others who should know better. They claim junior devs are now 10x more productive, and project managers are shipping code themselves. Now, close your eyes for five seconds and try to picture what that code looks like. It's 100% legacy, disposable code. The problem isn't AI, or PMs turning Figma into code, or junior devs prompting like mad. The real problem is the disconnect between expectations and outcomes. And that disconnect exists because people are mixing up terminology that took engineers years to define properly. - A lean prototype is not the same as a disposable prototype - An MVP is not the same as a lean prototype - And a product is not the same as an MVP A lean prototype is a starting point, a rough model used to test and refine an idea. If it works, it might evolve into an MVP. An MVP becomes a product once it proves the core assumptions and shows there's a real need in the market. And a disposable prototype is exactly that, something you throw away after initial use. Vibing tools are great for building disposable prototypes, and LLM-assisted IDEs are better for creating actual products. Right now, only engineers are able to create lean prototypes using LLM prompts outside the IDE. Everyone else is just building simple (and working?) software on top of disposable code.
- JohnMakin 1y agoEven thinking outside of product view point - speaking technically, I can't think of anything worse than junior dev's or PM's determining what they want technology-wise. At least once a week in my entire career I've had to shoot down awful ideas because they would be unnecessarily risky, won't possibly scale beyond minor use case, etc. I would hazard a guess it's going to be extremely profitable being a consultant in the next few years.
- bluefirebrand 1y ago> I would hazard a guess it's going to be extremely profitable being a consultant in the next few years. I hope so. This is something I'm hoping to get into. As long as companies are trying to push their internal teams to use AI tools, I think it makes sense to position myself to follow along after them and clear the mess
- JohnMakin 1y agosame
- sidewndr46 1y agoI've worked on projects where each feature had its own unique part of the technology stack. To the point that multiple databases were used for one application. I imagine 'vibe coded' applications to be similar to this but even worse.
- ryandv 1y ago> that disconnect exists because people are mixing up terminology that took engineers years to define properly. This is one of the larger trends I've observed in about 10 years of the software industry. A lot of these terms are really the crystallization of discussions at the water cooler, expositions in books or articles, or on technical fora like these, that span months if not years and thousands upon thousands of words. A veteran utters the word and immediately all the past conversations he's had regarding this topic come to mind. Newer cohorts come in, and, not having been privy to those discussions, latch on to the jargon in a mimetic attempt to stochastically parrot the experts, but don't have the substance underlying the word - they only have the word itself. Now it gets thrown around as an ill-defined, ill-specified buzzword that means multiple different things to multiple people, none of whom can clarify what exactly the definition of that word is, what it means to them, because they were never part of the discourse, the oral or written tradition, in the first place, and don't understand the meaning of that word in context, its usage. "Agile." "Technical debt." "DevOps." And now, "vibe coding." There was an article here on HN [0] [1] discussing semantic drift of the term "vibe coding" and how it now means something different from what was originally intended; I will merely point out that this is par for the course in software. For other, more technical, examples of linguistic sloppiness: see JavaScript's conflation of objects, JSON, dictionaries, and hashmaps; to the computer scientist, you have the compositional primitive from object-oriented programming, the JavaScript Object Notation for serialization, the abstract data type, and the concrete data structure, respectively. To the JavaScript programmer, you just have "objects," and the fidelity of your linguistic and conceptual space has been reduced to a single pixel instead of something with more resolution and nuance. [0] https://simonwillison.net/2025/Mar/19/vibe-coding/ https://simonwillison.net/2025/Mar/19/vibe-coding/ [1] https://news.ycombinator.com/item?id=43739037 https://news.ycombinator.com/item?id=43739037
- msgodel 1y agoPeople are focusing on the artifacts because they can't point to the theory in the physical world, but it's the theory and its correspondence to the artifacts that they actually want.
- hollowturtle 1y ago> Everyone else is just building simple (and working) software on top of disposable code. I'd argue we should better define working. Take for example a generated UI, they all look the same and are subtly wrong or broken in many ways. At a first sight it might seem "working" only to fail at the first user test. Also generated UIs already feel like obsolete, meaning they religiously follow the trend at the training moment, they spectacularly fail coming up with something new
- ravenstine 1y ago> And a product is not the same as an MVP Tell that to almost every company I've worked for! The whole "make it to the next financial quarter" attitude among directors and C-suite these days leads to the kind of crap where developers build an MVP and then are made to move on to the next thing. Like you said, it's not really about vibe coding at all. To a degree, they're right; the perception of feature richness leads to the bottom line irrespective of quality because few are truly comparing products, assuming it's feasible. Hell, are developers (which we now call engineers apparently) even empowered to prototype things these days? I'm sure it happens, but it doesn't seem all that common. Maybe it happens in the gaming industry and actual tech (not "big tech"). Most coding outfits don't provide much affordance for that. It's just MVPs all the way down. At best, vibe coding just accelerates that process while quality suffers.
- reactordev 1y agoOne would argue that perfectly crafted code is at odds with first to market. Every company I have ever worked for has just run with their MVP, bolted on more and more, until they find they own the market - then they split into these things called microservices that make engineering easy to understand at a service level but a nightmare to orchestrate into the same business processes leading to the inevitable disruption by the next… MVP.
- cookiengineer 1y agoIn the past I always talked about other devs in different mindsets. What we see is currently a developer fatigue of code that nobody understands anymore. Usually that was when an engineer chimed in, and made the broken part into something more useful and more maintainable. Then an architect looked at the codebase and tried to reduce its complexity. Now, post LLM, it seems we have 100x the code written by devs, and engineers and architects are completely left out. And that's what we are observing. If you figure out how to test this, whether or not with e.g. a TDD MCP server or a DDD MCP server (or whatever workflow and architecture you prefer) you have a potential for a trillion dollar startup. We need to scale the efficiency of code reviews, because currently that is utterly broken as a concept and doesn't scale well enough.
- Joel_Mckay 1y agoIn general, bad design patterns and team management are the primary drivers for sick projects. "[O]rganizations which design systems (in the broad sense used here) are constrained to produce designs which are copies of the communication structures of these organizations." (Melvin E. Conway) Keep in mind Conway's law also works in reverse, try running a private project wiki with documentation, and a ticket/task queue with small tasks. Setting pie-in-sky project goals is just as bad as ivory tower engineers. =3
- exasperaited 1y ago> And a product is not the same as an MVP Hahaha you're funny :-)
- calrain 1y agoHave you seen how enterprises write code for internal use? It's no different to vibe coding, except if you ask an LLM to harden your code base to pass a pen test, it will do something. Enterprises just don't give a sh!t.
- nyarlathotep_ 1y agoIn many cases some of the stuff at the big enterprises is shockingly, remarkably bad. I've seen multiple contracting firms leave things behind that wouldn't warrant a passing grade in an 'intro to programming' class. Most of the time it's not "don't give a sh!t"--it's they genuinely don't know any better, no actual stakeholders even see the codebase nor are in any position to pass judgement, etc. Most of the time folks that are "enterprise architects" or some such haven't written code in a decade and spend many hours a day on meetings.
- deleted 1y ago[deleted]
- 0x500x79 1y agoI had a PM at my company (with an engineering background) post AI generated slop in a ticket this week. It was very frustrating. We asked them: "Where is xyz code". It didn't exist, it was a hallucination. We asked them: "Did you validated abc use cases?" no they did not. So we had a PM push a narrative to executives that this feature was simple, that he could do it with AI generated code: and it didn't solve 5% of the use cases that would need to be solved in order to ship this feature. This is the state of things right now: all talk, little results, and other non-technical people being fed the same bullshit from multiple angles.
- AdieuToLogic 1y ago> I had a PM at my company (with an engineering background) post AI generated slop in a ticket this week. It was very frustrating. This is likely because LLM's solve for document creation which "best" match the prompt, via statistical consensus based on their training data-set. > We asked them: "Where is xyz code". It didn't exist, it was a hallucination. We asked them: "Did you validated abc use cases?" no they did not. So many people mistake the certainty implicit in commercial LLM responses as correctness, largely due to how people typically interpret similar content made by actual people when the latter's position supports the former's. It's a confluence of Argument from authority[0] and Subjective validation[1]. 0 - https://en.wikipedia.org/wiki/Argument_from_authority https://en.wikipedia.org/wiki/Argument_from_authority 1 - https://en.wikipedia.org/wiki/Subjective_validation https://en.wikipedia.org/wiki/Subjective_validation
- escapedmoose 1y agoI’ve recently had a couple people try to help me fix code issues by handing me the results of their AI prompting. 100% slop; it made absolutely no sense in the context of the problem. I figured the issue out the old-fashioned way, but it was a little annoying that I had to waste extra time deciphering the hallucinations, and then explaining why they were hallucinations.
- stevekrouse 1y agoAuthor here - very excited to chat with you all about this :)
- hibikir 1y agoI think you are not going far enough though: All code is legacy code. So vibe coding's ability to make writing more code faster isn't special because it's code nobody understands: Your hand-rolled code is also bad. Once you embrace the fact that all the code is legacy, then it's clear how writing more code, faster cannot be helpful from a maintenance POV: You are just creating more work for yourself. And no, libraries don't really solve the problem, but might make it a bit less so if they are well maintained, because hopefully then they are someone else's problem. Eventually it can be mostly trusted and be almost not legacy. But a library that changes too often, or has a bad interface, is just legacy code which you also cannot change easily for a double whammy. The more one writes code, the more one eventually realizes that the one way out of the problem is doing less: Not necessarily you, but just needing fewer things, in general. Because all complexity is ultimately a puzzle for someone that doesn't remember, and that's probably you a week later, or even in the way you typed it, as what you thought were the requirements might not really have been the requirements. And even if they were what a supposed expert told you they should be, that doesn't mean that whoever told you was right, and that's true even when you are the supposed expert.
- croes 1y agoMy hand rolled code isn’t legacy code for at least three months. After that I need my documentation to make changes. Vibe code is legacy from day one and with changing styles
- skydhash 1y agoIf you have good documentation and you're on stable platform, you can go for years without changes (Common in the Common Lisp world). Which is what we called finished software. Just light maintenance here and then.
- mrits 1y agoAll code is a liability but all code is not legacy. I'm not OP but I agree Vibe is legacy simply because there is no longer anyone around that is qualified to maintain it or know the reasoning behind it (there never was)
- simonw 1y agoThis is really clear and well argued. I particularly enjoyed this line: > If you don't understand the code, your only recourse is to ask AI to fix it for you, which is like paying off credit card debt with another credit card.
- stevekrouse 1y agoThanks Simon!!
- pyman 1y agoI'm now following your advice and just telling LLMs, "Do better." Although I have to admit, the other day I lost it and said, "Fix it goddammit or I'll delete you!" LLMs really know how to bring out the worst in intelligent, hard-working, respectable developers. I can't even imagine what PMs are saying to them, but I'd happily pay another $30 a month just to read those messages :)
- ay 1y agoThis is a super apt analogy. Every time I decided to let LLMs “vibe-fix” non-obvious things for the sake of experiment, it spiraled into an unspeakable fubar territory, which needed to be reverted - a very similar situation to this financial collapse. Invariably, after using the brain, the real fix was usually quite simple - but, also invariably - was hidden behind 2-3 levels of indirection in reasoning. On the other hand, I had rather pleasant results when “pair-debugging”, my demanding to explain why or just correcting it in the places when it was about to go astray certainly had effect - in return I got some really nice spotting of “obvious” but small things I might have missed otherwise. That said, definition of “going astray” varies - from innocently jumping into what looked like unsupported conclusions to blatantly telling me something was equal to true right after ingesting the log with the printout showing the opposite.
- MrGilbert 1y agoAnd what you will get in return is professional software developers looking at vibe-coded modules that already went into production, stating that "we will never ever touch this", as they don’t want to be responsible for something they would have never put into production in the first place. Now, they see themselves challenged to defend against the non-technical departments, because all they see are some elitist developers, that deem something as "not good enough", which, from a user standpoint, "is working quite well". However - it's unmaintainable. That whole situation is a mess, and it's becoming bigger and bigger.
- NitpickLawyer 1y agoAsking someone to maintain a "vibecoded" project isn't vibecoding anymore, by definition. I feel this whole thing is going the "AGI" way. Everyone is shouting above everyone else, using different definitions and biases, and there is 0 productive discussion going on. Vibe coding - you don't care about the code. You don't look at the code. You just ask, test that what you received works, and go on with your life. LLM-assisted coding - you care about the code. You will maintain that code. You take responsibility and treat it as any other software development job, with everything that's required. Same same, but different.
- sshine 1y agoIt’s a spectrum. I care when it doesn’t just work. I hardly look when it does.
- MrGilbert 1y agoFrom personal experience, I'd like to add "I don't know what I'm doing, but LLM helps me pretending that I do" coding. And yes, that code ended up in production and caused issues. It was coded outside of the development department. The productive discussion left the chat some shareholder rounds ago.
- NitpickLawyer 1y agoIs it much more different (in quality) to "I don't know what I'm doing, but [SO/learn x in 24h bootcamp] helps me pretend that I do"? I guess I see your point in quantity. I could see how this would be more widespread than c/p from SO. And the results would "look" better crafted at a glance, but might explode later on.
- deleted 1y ago[deleted]
- zabzonk 1y agoWell, all code once written is legacy code. But at least if written by a human you can talk sensibly to someone about it.
- deleted 1y ago[deleted]
- henriquegodoy 1y agoI'm seeing a real-world example of Jevons paradox playing out here. When AI coding tools first emerged, everyone predicted mass developer unemployment. Instead, I'm watching demand for skilled developers actually increase. What's happening is that all this "vibe coded" software needs someone to fix it when it breaks. I've been getting more requests than ever to debug AI-generated codebases where the original "developer" can't explain what any of it does. The security audit work alone is keeping me busy - these AI-generated apps often have vulnerabilities that would never pass a human code review. It reminds me of when WordPress democratized web development. Suddenly everyone could build a website, but that just created a massive market for developers who could fix broken WordPress sites, migrate databases, and patch security holes. The difference now is the scale and complexity. At least with WordPress, there was some underlying structure you could reason about. With vibe coding, you get these sprawling codebases where the AI has reinvented the wheel five different ways in the same project, used deprecated libraries because they were in its training data, and created bizarre architectural decisions that only make sense if you don't understand the problem domain. So yeah, the jobs aren't disappearing - they're just shifting from "build new features" to "fix the mess the PM made last weekend when they tried to ship their own feature."
- codingdave 1y ago> We already have a phrase for code that nobody understands: legacy code. Wow, no. Bad misunderstanding of what legacy means. Long-lived organizations all eventually go through tech renovations, where they re-platform their business functionality onto more modern systems. But sometimes, the cost/benefit analysis to that re-platforming doesn't make sense... yet. The pieces of the business still running on the former platform are legacy code. People do understand it. Often, deeply understand it because they wrote it, and have lived and supported it for years. They know the reason behind the tech debt, all the odd tech constraints that drove it to where it is, they can keep the thing running without breaking a sweat. It is second-nature to them. But it is not easy for anyone other than them. That is the true risk of legacy code, and that is probably where the author got off-track. They may have only ever worked in orgs after the last of the legacy coders left, and everything was a disaster. You definitely do not want to let a legacy system get to that point... and at the same time, if you ever do get there, the cost/benefit analysis has changed and you need to retire the legacy stack. All that being said, now, yes, we can compare it to vibe coding. If nobody understands the code from the beginning, you never have that magical timeframe when someone just keeps the system alive with ease. You never solved business problems with it. It is just bad code launching straight into the disaster-filled zone where nobody can maintain anything.
- bluefirebrand 1y ago> People do understand it. Often, deeply understand it because they wrote it, and have lived and supported it for years. They know the reason behind the tech debt, all the odd tech constraints that drove it to where it is, they can keep the thing running without breaking a sweat. It is second-nature to them. I don't think it counts as legacy code if the original devs are still around to work on it Legacy is not just "old" it is something that was left behind by someone else
- WD-42 1y agoThis definition doesn't make any sense to me. If code at an org is working, and there are people or at least a person at that company that understands it, how is it legacy? Just because it's been around for a while? At what age according to your definition, does perfect working code that can be improved or added to by currently employed developers, become "legacy"? I feel like you are falling into the "keeping up with the Jones'" trap. I much more agree with the blog author. Once the last developer that has a deep understanding of a codebase moves on (or simply forgets it all), that's the point it becomes legacy.
- xnx 1y agoIs the argument that it's better to start from an empty code editor than having AI create a working first version? I've found it faster to have AI write the code, revise with instructions as necessary, and delve into the code itself if I need to.
- stevekrouse 1y agoThe argument is that if you intent to maintain the code you should keep the AI on a very tight leash, and at least understand the architecture of the code, if not every line.
- xnx 1y agoThis is good advice for any code contribution. Current AI is definitely not better than the best programmers, but is often better than junior programmers (who often carry a "senior" title now).
- iambateman 1y agoYesterday, I wrote detailed requirements for a bit of software, and sent Claude to work. The code looked great until it…didn’t. It ended up being completely unworkable. I’ve noticed myself writing requirements for a feature and asking Claude to help me think through and expand. Obviously in a real project, there are challenges: (1) how do we tell Claude what is already in the project so it doesn’t reimplement existing methods? (2) how do we get Claude to fully implement the feature and not just “stub it out?” (3) how do we help Professionals maintain visibility and digest the new code? Claude recommends the explore-plan-code-commit loop. I’m working on a package which formalizes that process within a Laravel application.
- airstrike 1y agoI mean, that's why Windsurf and the like exist. Claude can navigate through the codebase in those environments and do more
- dabber21 1y agowe need a mandatory warning label for any services that were vibe coded. I really don't want to sign up for a service and then get my shit leaked immediately
- dweekly 1y agoIt will be interesting to see when this inverts - when it becomes scary to use an application that has only had humans review it and declare it safe and secure.
- deleted 1y ago[deleted]
- tux1968 1y agoThis has happened before. Non-technical or junior people developed and deployed applications, emboldened by the relative ease of Microsoft Access and Excel. There were all kinds of limitations, scaling problems, and maintenance nightmares. But there were a lot of upsides too, and it made the "professionals" up their game to obviate the need for such adhoc and unsanctioned developments. Come to think of it, the exact same thing happened when the PC became popular. Mainframe people were aghast at all the horrible unprofessional mess that the PC people were creating.
- Cthulhu_ 1y agoA lot of my work early on in new projects is setting up local and CI validations and rules, practices, reviews, git usage, design patterns / code architecture, etc - skipping all of those will lead to maintenance problems in the long run, whether code is written by a developer (I'm not even going to prefix it with 'junior' because I also suck lol) or an AI. But that validating is carried by the whole company at least. Where I work now we've got unit tests, linters, automatic formatting via Biome or Prettier, visual regression tests, Sonar with all the options enabled, minimum of two code review approvals, locked down main branch, etc etc etc. Some AI generated code does come through, but at that point it's already mostly alright. Code review is still required for things like unnecessary comments or detecting duplicate functionality (exact duplicate code is already pointed out by Sonar).
- lonelyasacloud 1y agoAlmost managed to forget the horror of all those enterprise "web" pages that worked just as long as the user was on a Windows machine with ActiveX ...
- Sateeshm 1y agoMy company still has internal sites that work only on windows
- ChrisMarshallNY 1y ago> and throwaway projects I have seldom encountered these. What I encounter, instead, are lashups that the engineering team thought would be throwaway, but which Management made "Final Ship" code. I have learned to always do "ship-shape" code; even for the most innocuous projects. I may be a bit sloppy as I'm exploring different paths, but the minute I decide on a firm plan, the code cleanup and documentation starts.
- stevekrouse 1y agoVibe coding is allowing everyone (including me!) to make way more apps in my personal life that are very throwaway. I think some folks are doing this in business contexts too. But this is a real game-changer for non-technical folks
- ChrisMarshallNY 1y agoYes and no. If you ship, and charge money for it, you are responsible for maintaining it. Can’t treat it as throwaway, even if you meant it as such.
- stevekrouse 1y agoYeah I definitely agree. I'm specifically talking about things you're not shipping or charging money for. Just little personal apps for you and friends or you and work colleagues. Internal tools, etc.
- deleted 1y ago[deleted]
- bulginess2173 1y agoUnfortunately this is common, especially if something is dev facing. Whenever I have to talk to devs from card processors, video services, etc. They seem more confused that their app is broken than anything else.
- 8thcross 1y agointeresting but i have thought about it. rarely is ours as well. All my code is original but based on my past experiences from learning, thinking about it, and improving it based on new knowledge i know. my 2cents.
- extr 1y agoIMO, the time of "code as math" is over. No sufficiently large software system that interacts with the real world is provable to be correct like a mathematical statement is. They are all complicated, engineered systems that are backed by a mix of formal guarantees, earned design principals, experimental testing, rules of thumb, acceptable performance envelopes, etc This is what all software will become, down to the smallest script. The vast majority of software does not need to be provably correct in a mathematical way. It just needs to get the job done. People love the craft of programming, so I get it, it's uncomfortable to let go. But what is going to win out in the end: - An unreadable 100K loc program backed by 50K tests, guaranteeing behavior to the client requirements. Cost: $50K of API tokens - A well engineered and honed 30K loc program, built by humans, with elegant abstractions. Backed by 3K tests. Built to the same requirements. Cost: $300K of developer time. If I am a consumer of software, and not particularly interested in the details, I am going to choose the option that is 6x cheaper, every time.
- trip-zip 1y ago> guaranteeing behavior to the client requirements > built by humans, with elegant abstractions Frankly, I look at both of these options and think I haven't seen either in the wild...
- skydhash 1y ago> An unreadable 100K loc program backed by 50K tests, guaranteeing behavior to the client requirements Until the next set of needed changes due to exterior requirements. And this software is one of the pillar in the business. That is when you switch vendors if you were buying the service. That is why support is always an essential part of B2B or even serious B2C. The world will change and you need to react to it, not just have the correct software now.
- kidbomb 1y ago// When I wrote this code, only Copilot and I understood what I did. Now only Copilot knows.
- emehex 1y agoI think the question to ask about your two scenarios: in which is it faster and cheaper to get from v1 to v2? From v2 to v3? I think, for right now, it's cheaper under scenario B. But in the future? Who knows!
- jes5199 1y agoa meme I heard 15 years ago is: What’s the definition of “Legacy Code”? It’s code that has business value. (otherwise you’d just delete it and move on)
- ridruejo 1y agoYes, if your code does not live long enough to become legacy ... the project failed. All good code is (or will be) legacy code by definition. Most companies and projects die because nobody cares about them, not because they were difficult to maintain.
- deleted 1y ago[deleted]
- whatever1 1y agoIf the code will be reviewed from the LLM of the future, then why does it matter? Let it review a trillion lines of code for a simple calculator app. I think that we devs are now very skeptical because we are the ones that have to fix the sh that llms spit out. But likely we will be taken out of the loop completely.
- zizee 1y agoThe vast majority of people cannot do the structured thinking to model the real world in a fashion that a computer can understand. That is a key attribute of a good dev. If someone can do this, and describe it well enough to a LLM, they are a dev. It's not devs that will be taken out of the loop, unless you define a dev as someone who is just a translator between human language and machine code.
- sshine 1y agoThe LLM + agentic framework supplements many core dev skills including sporadic habits of tirelessly testing things, spec-driven development (thinking what you’re gonna make before you do), and debugging. Some devs may have all of these, some may lack several. I certainly benefit from having a better overview while vibe-coding: I don’t get lost in some rabbit-hole trying to optimise something that is good enough, and my most important tasks are always well-defined before I start.
- bobjordan 1y agoCoding with AI is just a different kind of work than what those of us that coded before AI are used to doing. But, reading and understanding the code AI produces is required for anything complex. I had an inventory control app that I started five years ago without AI and picked the project back up this year. I had like 15-20 database tables in the app when I started with AI this year. Now, I have a "platform" database, a "tenant" database, about 125 tables in the tenant database and 30 in the platform database, full test suite that integrates both databases, like 100 services, etc., it would have taken me *YEARS AND YEARS* to do what I've done in the last 90 days with AI assistance. The biggest challenge has just been keeping up with all the code output and ensuring no technical debt accrues and it is all leveraging existing code. Ultimately, you have to understand what you've already built to ensure the AI uses it instead of constantly reinventing it. But, generating what would have taken years of my life in a few months? PRICELESS.
- sshine 1y agoI’ve been coding a git-powered issue tracker (like git-bug) that’s been on my wishlist for years. With agentic programming, I need issue tracking that is accessible from CLI, and in three evenings I’ve made what would have taken two weeks. The thing is, I would have just never finished it, or started in this case.
- user3939382 1y agoWhen you have 100+ tables and 100k+ loc you’re incapable of the context needed to write features without bugs which is why we have tests. LLMs are capable of like 5% of the context you are: Full context > human context capacity > LLM context capacity. We should all be able to agree on this and it should settle the debates around the efficacy of vibe coding.
- worldsayshi 1y agoI agree and we should be sceptical in ways we really aren't right now. But I also think that it is interesting to figure out when "vibe-like" coding works and how it can be made more useful. It doesn't, as you say, work for large and complex contexts. But it can work really well for automating parts of your work flow that you otherwise wouldn't have bothered to automate. And I wonder if there are more ways where it can be useful where the context can be narrowed down enough.
- sunnybeetroot 1y agoWe’ve gone from tiny context windows to 1 million tokens in a couple of years. At this rate LLMs will exceed human context and grow to have full context.
- cpursley 1y agoI don't agree with this, my code quality is much better now. But you have to stay on the LLM's ass in terms of guidance and review it all (this is a given). I think part of it is the LLMs writes more "standard" code instead of getting creative with architecture, etc. It helps to create guides and correct context, proper test coverage just as you would if working with other people.
- drdrey 1y ago> review it all (this is a given) that's great but that's not what vibe coding is though
- simonw 1y ago"I don't agree with this, my code quality is much better now. But you have to stay on the LLM's ass in terms of guidance and review it all (this is a given)." Sounds to me like you're not vibe coding, you're coding. https://simonwillison.net/2025/Mar/19/vibe-coding/ https://simonwillison.net/2025/Mar/19/vibe-coding/
- strogonoff 1y agoEverything exists in four dimensions (space + time). If a thing “looks good” in three of them but falls apart in the fourth (e.g., it works right at this moment but its continued existence is an impossibility or a hassle—be it physical artifact made from subpar material, unmaintainable tangle of excess code, etc.), then that thing does not look good. Getting a hang of what things look like in the fourth requires skill and wisdom that probably partly comes from having traveled it yourself.
- khaledh 1y agoI'm an experienced software engineer (20+ years experience). I really liked the agentic coding capabilities, especially Claude Code. In addition to using it at work (data engineering), I used it for a hobby project (that I intended to contribute as open source). It was a new systems programming language built from scratch, including the backend. It was not fully fledged, but it had the core pieces: a static type system, algebraic data types, pattern matching with destructuring, type checker, ownership (pointer capabilities), dynamic scope region-based memory management, lowering to SSA-based IR (including fast dominance analysis), graph coloring register allocator with liveness interference, and x86-64 assembly generation. I did this in two weeks, something I couldn't do by myself in 6 months. As I did this, I was keeping everything documented using a memory bank approach[1], so that I can fire up Claude Code and get it up to speed without explaining everything from scratch. Even with this disciplined approach, the code base got to a point where Claude would "forget" the big picture and start trying to optimize locally, hurting the global optimum. Eventually, I got burnt out by having to keep it in check every time it tried to do something stupid. I found myself always needing to remind it to check other modules to see how things fit together. I guess the memory bank got big with many concepts and relationships that Claude "got lost" in it. Also, I realized that I missed the opportunity to learn deeply all those topics. so now I'm back to coding things myself, with little help from Cursor Tab, that's it. Will see how that goes. [1] https://docs.cline.bot/prompting/cline-memory-bank https://docs.cline.bot/prompting/cline-memory-bank
- 8note 1y agoive been finding that letting an LLM write its own memory bank tends to have it regurgiate your prompts more than keep something actually useful.
- khaledh 1y agoThat is also true. Occasionally I would go in and clean up the docs and refocus them, but in the end I realized that I'm baby sitting the agent rather than relying on it to help me.
- hugs 1y ago"Vibe coding" is too perfect of a phrase. It's the next "cloud computing", where it continued to expand in meaning until even Gmail was considered "cloud computing". ("Cloud computing" used to have a very specific meaning - spin up a bunch of machines, do a task, then throw them away. It was built into Amazon's product name for it - EC2 - Elastic Compute Cloud. But "cloud" was too perfect of a metaphor to stay that limited.
- andy_ppp 1y agoI think most software is extremely buggy and it’s about to get much worse… just today several comments just disappeared from YouTube, did they even get written there? Uber has a whole feature about upgrading to Uber Comfort - it’s never worked once for me just gives an error. Three have managed to not take PAYG top up automatically for the nth time. Google’s UI is broken everywhere, loads of sites including John Lewis don’t seem to scroll on my iPhone 15 Pro Max and the camera still doesn’t work correctly in WhatsApp (macro mode is not automatic) and don’t get me started on how buggy Dynamic Island is etc. etc. There’s just shit buggy software everywhere now and I’m definitely not expecting AI to make the way we build things better.
- worldsayshi 1y ago> I’m definitely not expecting AI to make the way we build things better. There's a certain chance that this development will force our hands at inventing new ways to handle code verification though?
- tele_ski 1y agohttps://danluu.com/everything-is-broken/ https://danluu.com/everything-is-broken/ Always has been and always will be. This article was eye opening to me because I didn't even realize how often I was working around buggy software.
- mr_donk 1y agoDon't you think the next step is a programming language that isn't even meant to be human readable? What's the point of using an LLM to generate python or Swift or whatever? The output of the LLM should be something that runs and does whatever it's been asked to do... why should the implementation be some programming language that was designed for humans to grok? Once that's true the idea of it being maintainable becomes moot, because no one will know what it is in the first place. I don't think we're there yet, but that seems like the eventual destination.
- khaledh 1y agoIt might even get further. I imagine a day where AI would generate an executable neural network that models (and is optimized for) a specific problem; i.e. kind of a model that runs on a neural network runtime or VM. Who cares what the NN is doing as long as it's doing its job correctly. The big catch, though, is the keyword "correctly" and I would add "deterministically" to it, in order for users to trust it.
- ge96 1y agoWasn't there a word doc to code
- genewitch 1y agoWe're seeking angel investors for our startup that does this, we train models with "assembly" that does specific things and also complete "programs"; the end goal to prompt and it outputs executables. It's farther along than quantum computing at solving real problems, for instance, it can factor "15". this is like the third time i've mentioned this on HN (over a year.) Apparently everyone else is too busy complaining or defending Claude Code to notice.
- CharlieDigital 1y agoA story about a non-technical friend: friend vibe coded a SaaS last year and started generating revenue with almost no marketing; all word of mouth and inbound in a niche industry. Used Replit and Supabase to build the thing; I am still really impressed by what he was able to do given how complex the app ended up becoming as he interacted with customers. What I think happened: there are two incumbents in this space that are not happy about him showing up and charging a fraction of their monthly cost for a better, more modern product (their products are Windows-based desktop software). So they hired hackers to hack his SaaS (because these hackers have never demanded money). Unfortunately, that vibe-coding resulted in some bad code that made it easy to hack. First, the user list was leaked on the FE of the code and the hacker emailed all of the customers. Second, the hacker got a hold of his Stripe key and issued every customer a refund. Third, the hacker has been trying to inject XSS attacks into app (we'll see a random `<script>alert()</script>` tag in some fields) I think indeed, vibe-coded software in the hands of the inexperienced is instant tech debt. But at the same time, he was able to prove out a viable business in a matter of a few months with no engineering background and no technical capability. Now he's hiring a developer to shore it up. Was it worth it? Yes, it is terrible, shoddy, insecure code, but he proved out a viable business with just a few hundred dollars of investment.
- starkparker 1y ago> Was it worth it? Yes, it is terrible, shoddy, insecure code, but he proved out a viable business with just a few hundred dollars of investment. How much is it costing him to hire someone to reimplement his idea correctly?
- CharlieDigital 1y agoCurrently only equity. And it only works because has proven the revenue model and found the customers already.
- darepublic 1y agoCustomers that he screwed over with his shoddy code.
- isaacvando 1y agoprogramming as theory building mentioned
- jus3sixty 1y ago[flagged]
- TrackerFF 1y agoI think that in the near future, code itself will become abstracted away. High-level programming code will simply become the assembly or machine code of today. Interesting times ahead for sure.
- deleted 1y ago[deleted]
- Joel_Mckay 1y agoSlop in, Slop out... In general, a good code base teaches future developers how to leverage a pragmatic solution in the context of the use-case. Often, "vibe" code relies on superfluous computational heuristics overhead to compensate for people that had zero notion of what they were doing in the first place. To summarize, no one competent is fooled by low-value content farmed blogs, or the folks that rely on LLM. The age of Spam exceeding content is upon us. =3
- matt_cogito 1y agoAll production code will be written by AI. The question is not if. It is WHEN. What we are seeing right in front of our eyes is how the boundaries of what is possible in the realm of software programming has gone from AI/LLMs poorly writing simple scripts, to being able to "zero-shoot" and "vibe code" a complex system, with a set of instructions written in natural language. What we might be seeing in 2025 is how programming, the way it has been for the last decades, be disappearing and becoming a rare artisanal craft, not meant for being productive, but for showing off skill, for intellectual entertainment of the programmer. I know how hard this hits the real coders. I am one, too. But I cannot unsee, what I have seen. The progress is so undeniable, there is no doubt left in me.
- Joel_Mckay 1y agoStatistically salient answers are not necessarily correct. Real "AI" may happen some day, but it is unlikely going to be an LLM. =3
- code_runner 1y agoI’m also surprised at the progress but don’t quite share the “AI is doing a good job” perspective. It’s fine. Some things it’s awful at. The more you know about what you’re asking for the worse the result in my opinion. That said a lot of my complaints are out of date apis being referenced and other little nuisances. If ai is writing the code, why did we even need an ergonomic api update in the first place. Maybe apis stabilize and ai just goes nuts.
- 0x500x79 1y agoLLMs are doing a great job at generating syntactically correct output related to the prompt or task at hand. The semantics, hierarchy, architecture, abstraction, security, and maintainability of a code base is not being handled by LLMs generating code. So far, the syntax has gotten better in LLMs. More tooling allows for validation of the syntax even more, but all those other things are still missing. I feel like my job is still safe: but that of less experienced developers is in jeopardy. We will see what the future brings.
- 1y ago
- mattigames 1y ago"the more you understand the less you are vibing" also works as a philosophical claim, and a truthful one in the opinion of this one reader.
- dfabulich 1y agoVibe code may be "disposable," but isn't "legacy code" if it has automated tests that the product owner can read and understand. There are approximately two definitions of "legacy" code that I'm familiar with. One is: "valuable code that you're afraid to change." This definition is subjective. I might be afraid to change code that you're unafraid to change, especially if it's code that you wrote (because you remember, at least vaguely, how your code is "supposed" to work). Another definition of "legacy" is attributed to Michael Feathers: "Legacy code is simply code without tests." The definitions overlap because code without tests is definitely scary to change, because it's very hard to be sure whether or not you've broken it, or even understood it in the first place. When vibe-coding with an LLM that generates automated tests, (as they mostly all do nowadays), it's not legacy code. The tests both specify and ensure correct behavior. Automated tests are particularly useful for vibe coding, because they help prevent LLMs from hallucinating answers. (This is also why type checkers are so helpful for LLMs.) Once the code has tests, you can pretty much let the LLMs change anything they want, including refactoring the architecture. LLMs are extremely good at refactoring code with automated tests, in the sense that they'll puke out some hallucinated, hilariously wrong answer, and then refine their answer automatically until it passes the tests. (Just like I did when I was a junior engineer.) But watch out, because sometimes the LLMs try to delete tests that are hard to pass. If vibe-coding means reading no code, not even the tests, then, yeah, you're gonna have a bad time. But if it means "only reading the tests and not reading the application code," then vibe coding works pretty well, actually. What the new systems give you (and especially junior engineers/PMs) is disposable code with automated tests, ensuring that that you can dispose of the code and regenerate it (aka refactor it) and add features with confidence. That's the very opposite of "legacy code."
- dimal 1y agoHave you seen the tests that LLMs write if you just vibe code it and don't pay attention? They're generally worse than worthless. They test pointless stuff and they miss important stuff. If you have them on a tight leash, then you can get some useful tests, but then that's not vibe coding. > But watch out, because sometimes the LLMs try to delete tests that are hard to pass. If vibe-coding means reading no code, not even the tests, then, yeah, you're gonna have a bad time. But if it means "only reading the tests and not reading the application code," then vibe coding works pretty well, actually. Yeah, vibe coding means plowing forward with whatever the LLM does without understanding it. That's the definition. If you're using your brain, you're not vibe coding.
- apimade 1y agoAll code is legacy code. And as someone who’s reviewed plenty of production scripts, functions, and services written by junior developers, including my own early work, this take is overly absolutist. The problem persists in the vast majority of organisations. You can write articles criticising LLM-generated code, but if you’ve spent most of your career fixing, extending, or re-architecting systems built by others, you should know better. Until software engineering adopts the same standards, certifications, consistency, and accountability as traditional engineering, along with real consequences, these arguments don’t hold much weight. This entire modern industry was built on the opposite philosophy: agile. Move fast, break things. Ship iteratively with minimal design. Drop production? Just revert. Outage? Oops. Software is still treated like a toy. It’s playdough in the hands of toddlers led by other toddlers. You might be among the 1% who do things properly.. but the other 99% don’t. And odds are, if you’re reading this, you’re not the 1%.
- rolha-capoeira 1y agopiggybacking on everything you said, which is all true: Code is not a science, despite what pedants would have you believe. The annoying answer to "what's correct" code is, "it depends." Code is just a tool used to achieve a goal.
- QuiDortDine 1y agoI see that you're not alone in your position clearly, but still, this is such a strange take to me. Do people not seriously not see, nay, instinctively understand the ontological difference between the difference between using code someone no longer understands and deploying code no one ever understood? I'm not saying the code should be up to any specific standards, just that someone should know what's going on.
- AlecSchueler 1y agoI don't actually see the difference. If someone writes the code and understands it but then becomes unavailable, what's the practical difference with no one having understood it?
- mortsnort 1y agoYou can also vibe tackle tech debt tho. AI is pretty good at deciphering code for you when you need to jump into it.
- darepublic 1y agoI will vibe code functions that I fully understand how to program if I'm otherwise occupied and I want it to run in the background. A quick glance confirms the implementation is as expected
- bigcat12345678 1y agoGreat analogy! It's very true that any vibe code is immediately legacy after they are generated. In other words, they are incarnations of foreign minds, things from a realm that is shuttered from my access, and they are giant pile of code that is beyond immediate recognition to any human engineers.
- bdangubic 1y agoI have been SWE for almost three decades now - have read all the comments in this post and almost every negative comment about vibe coding holds true about almost every single ‘human-coded’ codebase I’ve ever seen ( some notable exceptions of course :) )
- raincole 1y agoYeah since when prototypes built to throwaway are a bad thing? They're arguably the most important step to build a business. Legacy code isn't a bad thing either. The majority of code that actually generates revenue right now is probably considered "legacy" by the devs working there.
- roywiggins 1y agoStuff that you know you aren't going to maintain? Vibe code it. It's fine. The article's point is that if you are planning to maintain something, you've created instant legacy code. Which might be fine, depending!
- qingcharles 1y agoThis. I'm using vibe-coding now to build little utils and apps that I will literally never maintain as they do one job, often a one-time job. In this situation vibe-coding is incredibly time-saving. I know zero about the code the LLM created, though. I've tried going through it, and it is all well-written, but it's all foreign. I wasn't there for any of its creation and I don't have any map in my head about the layout of the functions or the flow of the apps.
- ZeroGravitas 1y agoThe article is very pro-prototypes to throw away. I've also, in pre-llm days, seen warnings to not show visually polished prototypes to non-technical customers/salespeople/managers because they have no way of judging the quality and will try to force you to use the prototype immediately because "look, it's done".
- 1y ago
- artur_makly 1y agoSomeone should just create an app (*open-source ideally ) that stress-tests these vibe apps for security penetration risks and offers mitigation solutions.
- aussieguy1234 1y agoI think the quality of the code is going to be based on the skill of the person using the AI agent. An engineer knows a pyramid of doom pattern is bad, a non programmer would not. Engineers understand modularity and seperation of concerns, non programmers don't. An engineer can guide an agent to write good, modular code, but a non programmer can't.
- efitz 1y agoIf you vibe coded it, why can’t you vibe support it? I think the whole premise of the article is wrong because it compares apples to oranges, assuming that you’re going to maintain “vibe code” in a traditional way.
- sshine 1y agoBecause support requires understanding. If you can maintain long-term context for the LLM, then you have an approximation of actionable institutional knowledge. But context is text documentation, and that stuff rots just as much, if not more, when LLMs generate it. Nothing beats having the actual code and the thoughts that went onto it in your wetware. I still remember the hardest problems in my professional life in the last 15 years down to a scary detail.
- efitz 1y agoYou can have the LLM generate whatever context you need- documentation, developers guide, design patterns, whatever. You can have it do this, at the time you create the app, or later (I have done this for other peoples code I found on GitHub that was commented in a language I can’t speak). You store this by having your LLM coding agent write it down in a file. I do that all the time. It works really well.
- efitz 1y agoAnd if you have some kind of special case or something, the LLM will usually comment it when it writes it, but you can also just tell it to do so. The docs don’t rot because you can throw them away and have the LLM recreate them at any time. And they’re not for you, they’re for the agent. It’s a completely different mindset.
- ww520 1y agoVibe coding can get very far. Years ago I interviewed with a company whose business was doing price modeling on retail products. It was couple guys, who were not developers, writing some Excel VBA scripts and Access VBA scripts. They got big customers. Their system won't scale and was not robust; it's basically a proof of concept. They got tens of millions in funding. They hired a seasoned team of developers to build the real product. The project failed. They fired the team, and was interviewing me to restart. Their POC was basically vibe coding and actually got their pretty far. I didn't join because they had burnt through quite a bit of their funding, they had built the sales and marketing orgs while they didn't have a real product, they had fired the entire engineering team where all the organization knowledge had lost and it spoke of some deep distrust between engineering and the rest of the company, and their offer was completely not compelling.
- gleenn 1y agoSometimes you can just smell it when companies are bad. I went into an interview at a company that they were trying to escape out if SAP hell and the two founders weren't anywhere to be seen. The kitchen looked sad. I told myself I'd probably be eating lunch there every day and the founders being absent made me realize they probably didn't give a crap about their employees. Also they had junior developer managing the paperwork and hiring process even though the senior lead dev did the real interview. Definitely a shell of a company.
- laurent_du 1y agoThis is unironically the kind of project I love. My first job was a little bit like that, and I loved being the guy who was saving the day for everyone.
- gleenn 1y agoI would like to say I did a massive refactoring on a legacy project only to make separation of concerns by making a DB access layer with multiple backends just so I could test it. I wrote not even a single line of code. It did a fantastic job even abstracting between both databases. I was shocked. It then was a huge PR so I had it redo it in a step by step fashion and maintain the tests passing at each step so I could split it into 5 different pull-requests. This vibe-coded project did the exact opposite, it made it easy and possible to fix a mostly intested and poorly organized project far better. You can use this stuff for good SWE practices too
- dgfitz 1y agoI’ll never cease to be amazed about this industry. Programming for the web is a thing, sure. I’ve made a small fortune having never written a single line of JavaScript. The ecosystem is bigger than the internet.
- minikomi 1y agoPay as you go non-deterministic Chesterson's fence factories. Sometimes that's fine.
- ninetyninenine 1y agoJust have AI deal with this legacy bs so I don’t need to look at it.
- _ea1k 1y agoThe fundamental issue is that most AI tools are solving the wrong problem. We've never had a hard time writing code for well defined requirements. What we've had a hard time with is understanding what this article calls legacy code, and also understanding where our new changes fit into a larger context. It isn't at all dissimilar from the paintbrush analogy that all the (neo)vimmers love. We spend more time reading and navigating than we do writing. AI needs to help with that.
- mattxxx 1y agoall code is legacy code; git repos are mausoleums
- joshdavham 1y ago> If you don't understand the code, your only recourse is to ask AI to fix it for you, which is like paying off credit card debt with another credit card. Excellent article! But I wonder if the above point will always be true. Maybe AI at some point could become better at cleaning its own mess?
- sysmax 1y agoThere's a pretty good sweet spot in between vibe coding and manual coding. You still think out all the classes, algorithms, complexities in your head, but then instead of writing code by hand, use short prompts like "encapsulate X and Y in a nested class + create a dictionary where key is A+B". This saves a ton of repetitive manual work, while the results are pretty indistinguishable from doing all the legwork yourself. I am building a list of examples with exact prompts and token counts here [0]. The list is far from being complete, but gives the overall idea. [0] https://sysprogs.com/CodeVROOM/documentation/examples/scattered/flow https://sysprogs.com/CodeVROOM/documentation/examples/scatte...
- stevage 1y agoDo you do anything special to get it follow your preferred style?
- msephton 1y agoIn my experience it will follow quite closely to the style of any seeded code. And you can also pass it a style guide!
- sysmax 1y agoI use hierarchical trees of guidelines (just markdown sections) that are attached to every prompt. It's somewhat wasteful in terms of token, but works well. If AI is not creating a new wrapper, it will just ignore the "instructions for creating new wrappers" section.
- danielbln 1y agoI'm still finding the right sweet spot personally. I would love to only think in architecture, features and interfaces and algorithms, and leave the class and function design fully to the LLM. At this point this almost works, but requires handholding and some retroactive cleanup. I still do it because it's necessary, but I grow increasingly tired of having to think to close to the code level, as I see it more and more as an implementation detail. (in before the code maximalists get in my case).
- jongjong 1y agoI love using Claude Code. What happens is if your codebase is bad, Claude will produce bad code which follows the same general approach. So if the foundation is overengineered, it will produce over-engineered code on top. If your code is super clean and succinct, it will produce code that is equally neat and succinct. I've used Claude code with my own backend serverless platform and it's like it can read my mind. It's almost exactly how I would do it. It's like working with a clone of myself. I can implement nuanced features and ask for very specific changes and the success rate is extremely high. On the other hand, I've worked with some other people's code which was slightly over-engineered and it struggled. I managed to achieve what I wanted with a lot of manual intervention and careful prompting but it was a very different experience and the code it produced didn't look like my code. It looked like it was written by a mid-level dev. I can sense that it's a code completion engine because it clearly doesn't have an opinion about code quality. It doesn't know what metrics to aim for. It doesn't aim for succinctness; just as most human developers don't aim for it either. My assessment of LLMs is that they don't have a specific intrinsic goal so the goal/motivation is inferred from the text it sees (from the input). If the original author of the code was motivated by creating complexity for the purpose of lock-in factor and career advancement, the LLM will produce code which optimizes for that. Unfortunately, this describes the vast majoy of code which is produced. You can tell a lot about someone based on their code.
- stevage 1y agoOne of my current clients vibe coded an app then hired me to assess it, and ultimately rewrite it. I'm really curious whether that will become a trend.
- pmontra 1y agoA dozen years ago a company hired me to maintain an ecommerce system that had been built for them by a guy that left soon after. They told me "he is not even a developer." That was my assessment too. The system mostly worked but it didn't run fast enough to process their daily load. It was a mess but it would cost too much to rewrite. I managed to fix the worst parts, then switched to other customers. No idea if they found somebody else to keep fixing stuff. They kind of vibe coded that app well before vibe coding had been a thing.
- stevage 1y agoI guess when you put it like that there is a long history of production systems being built by people who had no business doing it. An access database running a whole company etc.
- laurent_du 1y agoA friend of mine was doing modelling (as in, being a model) in a large European city. He then worked as a product manager for a well-known luxury company. He ended up writing a system in visual basic that was responsible for a large amount of internal plumbing. He had no experience in programming.
- j45 1y agoAll code is legacy code eventually. Some code makes you aware of the limited shelf life of code.
- yashghelani 1y agoAs a freelance designer/developer, one of the most annoying aspects about dealing with non-technical clients is dealing with their ambiguous ideas, which they communicate using very general and abstract words. At most, they’ll point to another idea that looks/functions like how they want their own idea to look/function. I think vibe coding makes that initial conversation between a non-technical client and a technical designer/developer much more interesting. Because, now, that client can first communicate their ambiguous ideas to an LLM, have it generate something visual and concrete, and then communicate that generated thing to the designer/developer. A much better way to exchange ideas, no? But, yes, relying on vibe-coded code is not reliable.
- galaxyLogic 1y agoThat is a great insight, AI code is like legacy code, which is "legacy" because it was written long time ago and hasn't been worked on by anybody, so nobody knows and it is hard to learn how the code does its thing. But so why couldn't AI-generated code be maintained by AI? Why couldn't AI in general be used to fix and evolve legacy code?
- frocodillo 1y agoThat’s already addressed in the article; it’s like paying off credit card debt with another credit card. I guess it all depends on your end goal. If you intend to make your vibe coded app into a profitable, maintainable product with any sort of reliability guarantees you better understand its failure modes and how to fix things when they break. It’s really hard to create recovery procedures for a black box.
- ehnto 1y agoMy two insights are: Legacy code is difficult to work with because the reasons "why" something has to be some way are missing. The "whys" can change over time, be interwoven with business requirements not in the codebase, and compound/nest with other whys that have come and gone. Often only humans in the business know, and you have to figure out who and what to ask. Second insight is that LLMs have so far been very bad at holding on to the thread of winding, changing requirements, which is something it would have to be good at in order to revisit old codebases. Even one it wrote itself. It would need some kind of historical changes to business requirements database, which I have never seen a business keep, it'sjust the collective human knowledge of the business. Otherwise it'll make changes without accounting for historic requirements as well as your new ones. I think there are probably some workarounds, like getting it to write lengthy documentation to refer to. Long term perhaps it just gets smart enough. Legacy codebases are something I specialise in working with somewhat, I spent a long time consulting so I was often parachuting into unfamiliar codebases and trying to quickly understand years to a decade or more, of evolving requirements in a business/codebase. I have a lot more to say on the topic but those are two of my insights.
- galaxyLogic 1y ago
- Ekaros 1y agoThe difference is that legacy code has some certainty to actually work and be correct to the business logic. Vibe code has none...
- phplovesong 1y agoDid anyone think otherwise? AI generated code is obviously tech debt / legacy / whatever you want to call it. This was the same as 10-15 years ago when we saw that php dev copypasta from stackoverflow. I expect code quality to be way, way worse in the coming decade. Its not legacy because of age, its legacy feom day one. Pure nightmare fuel.
- phire 1y agoI think most experienced programmers get this. But it seems like advocates of "vibe coding" will fall into the trap of assuming "vibe code can't ever be legacy, because you can just point another LLM at it and it will pick up right where it left off"
- usui 1y agoWhat are you referring to with PHP dev copypasta from Stack Overflow?
- Karawebnetwork 1y agoFrom my experience and memory of that era, early versions of PHP had a very low barrier to entry and very simple and insecure methods for accessing a database. It was easy to program the CRUD logic of a website without knowing much about the rest of the pipeline, such as security or data cleansing. This was also the era of jQuery with easy to use AJAX methods, which enabled almost anyone to create a front-end that calls backend code. All of that was simple code that was easy to share with others on forums. This led to insecure websites where, to exaggerate slightly, every input field could be used for SQL injection attacks. To be fair with PHP of that era, it was possible to create secure websites with it. It's that the ease of use created the illusion that once the website worked, you didn't have to tackle any other portions of development process such as quality control or security. It was a glorious era.
- azath92 1y agoI often find that the hard part of writing big, persistant, code is not the writing but the building of a mental model (what the author calls "theory building"). This challenge multiplies when you are working with old code, or code others is working on. Much of my mental space is spent building and updating the mental model. This changing of my mental model might look like building a better understanding of something i had glossed over in the past, or something that had been changed by someone else. Or it is i think the fundamental first step before actually changing any lines of code, you have to at least have an idea for how you want the mental model to change, and then make the code match that intended change. Same for debugging, finding a mismatch between your mental model and the reality as represented by the code. And at the end of the day, AI coding tools can help with the actual writing, but the naive vibecoding approach as noted is that they avoid having to have a mental model at all. This is a falacy. They work best when you do have a mental model that is good enough to pass good context to them, and they are most useful when you carefully align their work with your model over time, or use them to explore/understand the code and build your mental model better/faster/with greater clarity.
- trymas 1y agoAll code is legacy code. As soon as you write it (no matter how) - it’s legacy. You need to maintain it.
- dragonwriter 1y agoThat's a broader definition of legacy than I’ve usually seen used; usually, “legacy code” is a fuzzy categort of code that lacks some significant subset of the maintainability properties expected as the norm in the category of “existing, actively maintained code”, such that issues in that code requiring working around the code, replacing code units wholesale, or expending extra effort research, document, develope tests for, or otherwise bring the code into a maintainable state to enable diagnosing and resolving issues with it.
- brokegrammer 1y agoVibe coding is only a problem when non-programmers do it. As a programmer, I know how to give precise instruction to models so that they end up writing high quality code. I also have the knowledge to manually fix code that models generate. Non-programmers can't do any of that. That's why I believe that programmers should use vibe coding to get work done faster, but non-programmers should restrict vibe coding high quality projects to their dreams only.
- cat-whisperer 1y agoI've found that the real issue with "vibe coding" isn't that it's inherently bad, but rather that it highlights a deeper problem: our industry's obsession with explicit, step-by-step documentation.
- mexicocitinluez 1y agoOh great. Another article about vibe-coding....
- rpastuszak 1y agoThis reminds me of a different phrase: every piece of untested code is legacy code.
- jono333 1y agosometime before 2026: "Hey Claude, rewrite all your code to make it look like you weren't vibe coding"
- marstall 1y agoit's not such a binary. we all of us, software developers, are using AI every day now. It's one of our tools and we're staying present for at, sensing its energy. we let it run wild and get bored watching it work. Whatever it does is miraculous, even if it will take as long to fit it into your big project as it would have taken to write it on your own. and then you'd have a better understanding of your tools, your product, maybe even your customer. we give it bits and pieces one after another and marvel at what its done. It nags at us that we can't reason about the outcome, but use it anyway. It's no problem. Or it is sometimes. We don't know what's going to happen. We switch tooling completely, then again. This shit is miraculous. Clock in.
- imcritic 1y agoI call bullshit on this article and most of its arguments. The article was written out of fear felt as programmers' gate keeping falls apart and programming becomes generally more available to the broader auditory. A quote from the article: > Programming is fundamentally theory building, not producing lines of code. We know this. Well, then you should understand that the "vibe coder" is someone with the idea for the code and during the vibe code session they build the theory for the program. Coding is less important than the idea behind the code. So what the resulting code is "one use" and "legacy" or whatever if it does the job? If the vibe coder has saved their prompts - it could be later reproduced, improved and extended just the same way!
- jonplackett 1y agoThe article is also just an ad for their product
- blurbleblurble 1y agoIdk, I always felt the vibe even more when I did understand what's was going on. Maybe that's not in the spirit of how the term was coined but still, it's way more satisfying when you can use these tools in a state of both flow and competence.
- boesboes 1y agoAfter 30 years of writing code myself, i am quite happy to let AI do the bulk. But, especially with legacy code and monoliths with a lot of different conflicting patterns, you MUST check every thought and step. Every change. Lest it goes off and forgets what it was doing because it is stuck rewriting the same code in different ways. tbh, I think it is fair to say these tools only really help if you are very senior and can smell bad code from the other room ;-) On real world legacy codebases at least. The code is ok and often on par with half the guys that work here, but they learn from mistakes and feedback ;)
- showcaseearth 1y agoOne of the best takes on vibe coding yet. Amazing writing, like always.
- dneighbo 1y agoI think the real risk isn't AI-generated technical debt, but the opportunity cost of not adapting fast enough. The engineers I see thriving aren't those maintaining perfect understanding of every line, they're developing what I call "the adaptation advantage": knowing when to dig deep vs. when to trust the process and iterate. This connects to a broader pattern I've been exploring, AI is creating a skill gap between those who see it as amplifying capabilities vs. those who see it as threatening their identity. https://www.derekneighbors.com/series/ai-excellence-gap/ https://www.derekneighbors.com/series/ai-excellence-gap/ The "vibe code" concern is valid for maintainability, but we might be optimizing for the wrong risk.
- fragmede 1y agoIf we accept that as true, them why have it generate Python and JavaScript? why not have it generate assembly, and reap some performance benefits?
- omgwalt 1y agoThe problem I have with this post is that it equates vibe coding with stupidity. You don't have to be stupid to be a vibe coder, and you can actually do things smarter than a traditional coder ... if you take the time to learn how to do it. His mistake wasn't being a vibe coder. His mistake was in not learning the proper way to connect it via API and failing to use tools to check the security.
- oxag3n 1y agoLegacy code may be very different - I saw legacy libraries implemented in C, with macros APIs that just worked. Same applies to "live" code with owners still within a team - it can be extremely bad. The issue with LLMs is you don't know what you get. It can produce a very robust routine, that will just work and have a clear API, or it will look like it, but will have a terrible design decision that will lead to an API redesign.
- cawksuwcka 1y agocoding needs to fade away altogether. it’s inhumane. for humanity’s sake i hope it keeps on fading and becomes legacy as a whole, as far as humans are concerned
- justanotherunit 1y agoI actually foreshadowed this about 6 months ago when Lovable was starting to gain heat here in Sweden. It was quite obvious that for a start and prototype, these kind of applications are good. But if you are going full SaaS, hire an engineer to set the app in stone. This might be a new branch of software developers on the rise. Those that take sloppy AI code and turn them into real applications for customers.
- ok123456 1y agoI have the same feeling about dynlang code.
- Ray_Casey 1y ago[dead]