Just a few years ago, the meme in traditional human coding was "If it works, it works" or "Don't fix it if it's not broken." So everybody was 'on board' that human code sucked but worked. Now AI does the same thing, but gets called bad code/AI slop etc.
I'm a cybersecurity student so I used to study coding, but haven't got deep enough to distinguish good code from bad code, and then started vibecoding.
Also, the "secure-coding should never be vibecoded" is the current norm in the cyber security side of CS, so I guess that's also one of the major reasons I'm raising this question.
So is the code really that bad? Or is it actually acceptable, but people just had higher hopes for AI code?
Vibe code is this at march speed. Our company doesn't have enough testers, we don't have an end to end auto test suits. Adding random stuff no one understands to the code base is going to cause problems downs the line when you have to fix it.
This happens with bad processes and engineering practices. In typical it companies these practices are already extremely bad. Lack of tests and review processes.
Good AI setup mimics like an overclocked software company. Need ton of memory and hard disk space, reviewers for every possible role in the company. Lots of testing both automated and human.
If you try to run AI software development with modern day standards you are going to have the issues you just said.
For me, it's due to years and years of being given someone else's code to fix after they left or got busy with another project. It is the rule, not the exception. The worst case is when you have to fix your own code, long after you forgot why you wrote it in the first place.
Depends whose vibes are being coded and the scope of the software they are working on. Agents have a limited context and understanding which means for sufficiently complex software, there is significant context that needs to be held by the engineer directing them. Their taste matters, their understanding of good patterns and problematic ones matters, their understanding of what a good SDLC looks like matters, their understanding of the limitations of the LLMs they are controlling matters. There is already a ton of proof that vibecoders with little understanding of these things inevitably produce horribly insecure software that hits a wall at a certain complexity as they build. For trivial software, it's fine.
This has been my experience with trying to learn coding, I went from giant monolith web apps to polyglot mono repos in my first few months and basically I've been learning more and more how to direct different models inside of gated environments and forced spec based development and I've seen a huge increase in my ability to make an idea quickly, I'm still just a solo ai dev so I'm sure it's full of stuff I'm not accounting for but I'm working on mostly personal projects and have been building an agent harness and a few little game projects and calculation engines for astrology and I might not be learning the code but it's definitely been a lot of researching and learning how to assist a team of ai agents obtain the resources and context they need to turn my visions into tangible code concepts, and I think the effort that's taken is still a considerable amount of hours I've put in more so than the typical slop vibe code being slammed out like tracker or note taking app number 10747492010, so its really hard to just lump all vibe coders together just as I imagine it would be to jump all types of developers in general together , there's always pros and cons, and the person behind the wheel is ultimately the one who has to have the skills to drive the vehicle
I'm about to lose it in my company, because my non-CS boss (marketing origin) vibe codes shit. And then says "just continue this beautiful thing I made at the weekend, release next week, shouldn't be hard".
There's 4 types of tests missing, ISO duties to fulfill, document the process since it will be updated a lot, create tickets, release pipelines, UI. So 95% of the official duties are underneath the water, invisible.
For me it's like "I put salt on cherries yesterday, loved it. Change all our desserts on the menus in our 40 branches next week. Disregard everyone who I hired to decide on the menus, recipes. Just make them taste delicious, no mistakes".
Vibe coding does sound like a nightmare in the professional industry.. as a hobbyist dev who's been really learning a lot through ai coding it's been frustrating as hell to get my flows as strict as they are and because I'm not in the industry like this I'm sure I'm missing a lot, but I'm mostly just making things I've wanted to make and it's done work I never would've imagined myself being able to do even if sometimes it makes me wanna rip my hair out over what I'd expect to be easy for ai LOL but yeah if I had a boss doing this that would completely change my experience and view of the whole situation.. geez..
“If it works, don’t touch it” was never a good standard. People only ever said it when they seriously gave up on it due to having no time or will to modify it. Usually because the code was far too difficult to change.
If you’ve been learning cybersecurity, then you know various best practices and auditing source code is one of them.
If the team gave up on ever changing software, doesn’t that mean vulnerabilities in that thing can no longer be fixed?
This isn’t to say all agent written projects are going to become unmaintainable, by the way. Just that, if the person overseeing the project has no idea how the project is supposed to be like, you’ll end up with a mess.
You’re not going to get an objective, unbiased answer here in this sub. And you can read the answers - many are based on feels and speculation.
The fact is that there is nuance to the answer.
We do know that Claude is reasonably better at standard SaaS applications than most developers here - the patterns are mostly repetitive and there are millions of examples for Claude to draw from. If you provide Claude proper context and are able to apply guardrails like appropriate testing, there is tremendous upside to using Claude.
Is vibecoding suitable for everything? Maybe not. But most of us are not working in rare edge cases. If you ask it to “build a cybersecurity defense system looking for signs of foreign APTs,” you’re not going to get what you want. But if you ask it to “build a marketplace that allows me to buy and sell cat collars”, I guarantee you that you will be wasting your time trying to code it yourself.
I would be curious to see real life data about how much impact has been shipped with vibecoding vs how much business continuity has been lost as a result and what the ROI is.
the meme in traditional human coding was "If it works, it works" or "Don't fix it if it's not broken." So everybody was 'on board' that human code sucked but worked.
Anyone who actually had that attitude was a bad engineer.
In many cases, it’s acceptable, but the more you do it the worse the code becomes. Any heavy use of AI will degrade whatever you are doing up to the point of making it complete slop. So, great for prototyping but terrible for any serious work. Sure its fast and easy, but you get what you pay for. I call it the smoking of programming
I think this view is outdated and over generalized. Claude Code seems to be better than humans for SaaS applications in general, but of course there are edge cases. The amount of AI code that is getting shipped is huge now and the world hasn’t fallen apart yet.
No it is not outdated. It is how LLM are working with random temps for them to work.
Fable/Opus at any level with bigger codebase is a MESS. Technical debt after 2mo with using Claude was through the roof, we were cleaning it for months. Despite FULL HARNESS, full instructions for the Agents etc. etc.
AI simply is too random to always select the right way. In software engineering you have dozens of right ways. AI won't be able to select always the same. That is HOW THEY WORK and WHY THEY WORK.
First of all LLMs are deterministic at the core, yes temp and other things introduce "randomness" but that is not a big problem. LLMs especially if the Sol 5.6 and newer are very good at following rules and instructions. Including tidying up large code bases, you don't have to load 500k LOC into one context window. Claude is worse at this but better at some other things.
Look… in almost 20 years of working experience I have seen so many codebases rot away due to humans… even when someone is actively trying to keep it clean the years pile up
So can LLM code bases, just takes someone bothering to understand why it's fucked and then getting people to fix it. You improve LLM code bases in the same way.
No it cannot, LLM cannot keep the same level over big code base. It never happened, there is no proof, no software presented in git > 500k LoC was showing structured high quality code.
All is always AI slop, the bigger it's get => the bigger the slope. No matter fable or opus. They are too basically random and it is a part of HOW LLM is working. So unless you can present high quality codebase then please do not spread false ideas based on your beliefs. We already know what humans can do.
Okay I have gray hair and have been doing this for a long time. 2026 has changed things jusy because you haven't figured out how to work with this yet doesn't mean everyone else hasn't either. You can clean up code bases using LLMs, the best engineers are better. Keep up or sit down.
My position was never human out of the loop. I don't think human out of the loop is wise at this point. But managing even 500k LoC code bases is entirely possible. How they would fair on 20m LoC would be interesting but I don't have that on hand.
So unless you can present high quality codebase then please do not spread false ideas based on your beliefs.
Finally a high IQ post. I have been asking for a year now for a source repo link to an AI generated project of significant size which the AI boosters consider good quality. Never got a response
As I said in my original post: the codebase gets worse equally proportional to the amount of AI used. The guy claiming that "you can just fix it" obviously didnt get that as that would mean humans are being put back into the loop to correct the output of the slop bot, negating his own argument.
Mostly yes, and the more you let the AI alone the worse it gets. Not that you cannot get any decent code from AI, but doing so requires a lot of micromanagement, which is incompatible with the supposed x10 gain AI shills will throw around.
I often find it unreadable. Disorganised. Impossible to follow.
Give me even a badly coded all by a human and I can at least follow the structure. Vibe coded apps are just a mess that works not because it was designs dto but by happenstance.
I call vibe coded apps Mr burns apps because just like the Simpsons character they have a million diseases all at once that only happen to not kill him because they're perfectly balanced.
Vibe coding fails in two ways, missing context and readability.
If given a problem LLMs will find a solution that works, but because it can't hold context it will fail in a holistic solution
The readability problem is more annoying, LLMs will find solutions to things that sometimes aren't readable if you don't give it guardrails. Sometimes it will find functions that you have never seen or used before so you never know why it's being used.
At the end of the day, vibe coding is no better then copy and pasting stack overflow solutions to problems without judging the fallout from those choices
The implementation is usually very very generic. It is easy to miss out on many edge cases, because the developed code is not being ran over and over again until it works. It’s generated to be just good enough and is pushed forwards with AI generated unit tests. Lol.
Imagine the development as a video game. If you speed run through it, you will miss out on most the story and what it teaches you along the way.
This will probably lead to a vast amount of technical debt in the future. Yet still I do it for the most part of my job.
My journey: I started learning how to build android apps, i had some coding skills, but not something great. I was writing by hand what the teacher was explaining
Then i started to build my own apps... mostly google how to do things, then copy-paste and change to what i needed.
Then i used the autocomplete of Android Studio... it was a life saver.... much faster and mostly well done!!! I was much faster in writing the code, i spent most time learning on SO or google how to do things.
Then AI came and i asked the AI to write my code... and it did... always wrong... so I started to argue and ask for the modifications or just modify myself when the AI wouldn to it properly.
So in a few years i changed from manual coding to AI debugging... now i debug the code of AI...
BUT!!! the graphics of my apps are so much easier to do with AI... its nothing complicated... but for me it was hell!
Wouldnt it be nice if the stones were not there from beginning? And that you wouldnt need to burn the world such that does stones were not there in the first place?
I tend to vibe code in a lanague I know already so i can fix bugs manually if I really really needed to. I really haven't needed too.. it just fixes the bugs when I tell it.
No, but that is assuming the chef wouldn't have those small stones in your sandwich regardless. People forget how much shitty code we produced before agentic AI.
On my personal projects I turn yolo mode on and let Claude do its thing - but I also know what I’m looking for in bad code and the prompts to give to assess quality etc.
Vibe code is pretty bad if it’s a production system with no real guidance on what is happening.
It’s ok to let Claude go wild but you have to direct it before pushing to prod and make sure it’s tidy and secure.
If i turn my side project into a business you can bet il be going over every line of code and testing things thoroughly.
Why is this laughable exactly? With 15 years experience as a software engineer I know what needs to be avoided and what will cause security concerns or stall a project if we keep going down that route.
And to be honest I don’t really care what a guy called “addictedandwanthelp” thinks of my software engineering skills having seen all of one comment on Reddit. The fact that you decide to start off this interaction being an asshole tells me a lot about you
Your premise is wrong. Yes sometimes IDIOTS said "if it works..." and "dont fix it if its not broke ". These are the same sort of idiots that think ai "just works"
Most developers on Reddit does not want to hear this, but the code quality will be higher than most human developers can achieve. But it requires setting directions, deciding architecture, planning, reviews etc.
Everybody makes mistakes - and AI currently will also do it (it's learning from us), so ensure to have another model and yourself review the changes.
The code can be a bit of a lottery. It's still at the stage where you need to know how to code to determine how safe it is. It's only going to get better.
Currently, the biggest weakness of AI isn't its ability to produce good code but lack of agency. It does exactly what you tell it to. If you don't tell it to refactor code, it does not. If you don't tell it to audit code for security issues, it does not. But it's fully capable of doing both well with very little input if you even vaguely ask it to.
When you vibe code (as in, just prompt features without reading output), AI does "don't fix what's not broken" but amplified by orders of magnitude and in hours creates a mess that would take humans years.
It's probably possible to make vibe coding produce decent results by using a harness that will regularly call agents to regularly check for a variety of issues and fix them. However, most vibe coders aren't particularly technically literate, and just use the most popular products with default settings, so code that is fully vibe coded still tends to be awful.
Depends how good you are at wrangling AI, how good you are at system design, the limitations of your AI, your awareness of the limitations of your AI, your use of documentation, artifacting etc. You need to keep it grounded, you need to know what you are doing, you need good testing. If you work within the capacity of your AI and you design a good system and correctly implement it in pieces manageable by your AI the you can absolutely make good stuff.
Just a few years ago, the meme in traditional human coding was "If it works, it works" or "Don't fix it if it's not broken."
Yes, it was fine for code completely of 40 years ago. Yes, AI can reproduce the 40 years old code as if it had written it anew. The problem is that we already have this code and it works.
That’s not a problem, that’s a benefit. And that’s why vibecoding is so good for vanilla SaaS applications - because the patterns have been reproduced millions of times in well tested code. If you’re asking Claude to build a web app, you’re going to get a better version from Claude then what most developers will build from scratch.
So I think the question is, how bad are security patterns in Claude coded applications? And how does security improve when it’s part of the spec that Claude is provided?
There is no one answer to that. It depends on what the code is and how it is used. At my company where we do things like build integration, customize platform software, build internal utilities, etc - it’s more than good enough. For NASA it’s probably not good enough. A lot of places will be somewhere in between.
AI code if you respect a few fundamentals is a lot of times better than the majority of programmers. But you need to know the ins and outs and you must prompt it and set rules and have it create a lot of tests.
And you have to work with good models and harnesses. For me the standard is Opus High+ and Sol High+ .
And it also needs common sense. If you create a project that manages or moves files for example, of course you will be much most thorough with testing so it doesn't lose data.
If you are making an experimental website that "guesses your birthday" or whatever, who cares if it breaks.
What I have noticed while vibe coding is that common sense and IQ applies to software engineering.
There is usually a distinction between vibe and assisted coded.
It is less about the individual snippets of code and more design behind it. If you let the AI do things unsupervised, once the system gets more complex it starts to really show it builds things in isolation and stitches it together.
Once you as a human can no longer follow what the AI is doing and it breaks or needs adjustments, if the AI gets stuck and now what? How do you ensure the vulnerabilities are covered?
The concept of bad and good code comes down to modularity, adjustability and maintainability. In the end, you will be held accountable as a human.
Latest gen models can write very good code, on par with or better than a good programmer. Will it always be perfect? nope… neither will a human, thats why we have code reviews.
The key is how you use it, you could use it as reference and write your own version, or you could use it in isolated and boring places.
When you don't read it or understand what it produces or you let it write the entire system and make architectural decisions… then you're asking for problems.
Some of that "just works" code back in the day was well-written but hacky, and at the very least, a bad coworker could only write so much a day.
LLM code is very proficient in many ways but deficient in ways that are hard to pin down; whatever it is, it's pretty bad at architecture, code reuse, and x/y problems. What's more, the LLMs can write oceans of code, propagating these deficiencies across your code base.
Some code is not as important as other code. Bash scripts, ci harnesses, etc. LLM code is great for this, but if you want to keep your application maintainable, at least for now you need to scrutinize the code that's going into important areas of your app.
The "if it works, it works" standard is the wrong comparison. Human messy code is usually written by someone who understands what they built (well, in most cases)
AI-generated code can work fine and have nobody who fully understands it (not even the person who prompted it). That's a different kind of problem. The code just has no mental model attached to it, which means the moment something needs to change, nobody knows where to start.
Garbage in, garbage out. If you feed a strong LLM a good specification for a small chunk of work, provide it sufficient information about the coding standard and practises you expect, and get it to clarify anything it doesn’t understand, there’s a good chance the result will be strong. Repeat multiple times with appropriate review and testing, and you end with a perfectly serviceable feature or application, and you can have some confidence in the quality of the code that produced it.
If you ask it to one-shot a clone of Microsoft Office, good luck to you.
When people say AI is still coughing up shitty code, there’s a very good chance they aren’t using it properly, just as failing to use ANY tool properly results in a bad outcome. Think of it like forming joints in wood - I can use a saw to do that, and the end result might look fine, but if I used the saw poorly or didn’t understand how wood joins actually work, there’s a good chance that whatever I built will eventually fall apart.
So your telling me there is a skill needed where we need to break down requirements. Think of the underlying logic and how it fits in with the existing system. And then express these concepts in a detailed technical language.
Why have I never seen that before in software...
Regardless this is why I continue the position that ai is just another abstraction later.
Like how higher level programming languages abstract the lower level.
The concern here is that the abstraction is less consistent, so you can't just fully black box the lower levels of understanding
This is a little like asking, "If I drive drunk, will I get into an accident?" There are so many factors at play it's impossible to predict or generalize outcomes. Know that you're taking a risk whenever nondeterministic results are incorporated into a codebase. The model used, the language, the specific task or API, etc all have an effect. Sometimes LLMs generate working code first try, other times they generate a bug-riddled mess.
I only vibe code proof of concepts, which AI is great for. If the POC then gets approved as a solid feature it then gets designed and refined. AI may still make the changes but with more guidance than just an idea.
No its not. And your lack of understanding of the process of software development is rather apparent. Apparently every time I provide a design to an entry level engineer is vibe coding as well and then when I review it and tell them to make changes based on say our deployment structure or tables. That is not vibe coding.
Either way I am done with this. I am going to go back to my life and my job, which I am good at.
It's laughable that you think i dont understand software engineering because I'm pointing out the obvious. If your using AI to "draft your code" based on prompts. Regardless how detailed you are, that is vibe coding. Facts.
Fyi, there's nothing wrong with vibe coding. That is the future of software engineering.
It depends on who does it, if the person is a dev/coder then there’s no reason that the output is bad (2 years ago that would have been a different story…), but if the person who vibe codes knows scheisse about coding then it’s likely that the output won’t be good.
imo its not about whether the code is bad or good. Its the people. Everyone wants to set this narrative that none of it matters anymore. Its like they forgot that agents only work because humans use them. Most people are ok with "it works" other people want more quality and sometimes it is hard to get that out of AI.
Most of the work isn't developing an app, it's maintaining that app.
We often think about this backwards, so I would ask it this way. How easy is it to maintain a codebase that was vibe coded? This however isn't something that will play out in a few months, it will likely take a year or more to truly answer that question.
Now... If the app is a side project that you can just toss and remake, vibe code away as it doesn't matter. If it's an app that's going to be around for awhile and is a critical component of a business process, I would proceed very carefully.
If it works, it works -> is rule to prevent overengineering and overoptimisation Don't fix it if it's not broken -> is rule for risk managment in legacy code base
Answer for "IS vibecoding bad" depends of what you describe as vibecoding. For cases where "I tell agent to implement, and merge without ani QA or review" that is bad. Foi cases where "I tell agent to implement, but after implementation i check every line, and understand all the reasons why it was written like that, and how behaviuor changes, and we have quite extensive automatic QA, to catch what I missed" vibe coding is good.
Those statements are partly true because often you do go back and fix it or add on to it, which requires some sort of knowledge of the system. Whereas vibecoding mentally is no expectations of the entire system output.
It's the same as anything else. If you use your tools and expertise well then it will make good results. If you have no expertise or if you have shitty tools, you will be less efficient or just fully ineffective. People who fully "vibe-code" as in don't have any programming experience and don't check their code at all will 100% produce some slop. However, this is what it's like right now. It may very well be the case that eventually programmers won't need to write any of the code. But I think that having a learned understanding of how programming works and computer science in general will still be very beneficial for computer engineering when they are guiding the agents.
In the work place, depending on the work place, you have projects that you did, legacy projects that someone else did badly but are running. That person is no longer working in the company, and it’s your job to maintain that mess, and in that case refactoring the whole thing is better but it’s not always viable because you are also working on other projects or new projects all the time and that somewhat working mess, you don’t have time allocated to redo or management doesn’t want you to redo even if it doesn’t take much time.
Management usually sees value in that small project a junior dev did years ago and consider it an asset even if it’s bad.
Normally you should strive to make a good program that works, is designed well and doesn’t explode if you looked at it.
IMHO code generated by AI is as bad as you want it to be. It takes a strong software engineer to not only recognize bad code, but also be able to steer AI in the correct direction in order to generate good code.
If you're "vibe coding" and just throwing slop at the AI, then the AI will generate slop. If you're actually methodical in your approach then AI has no real issue generating pretty decent code.
It entirely depends on the problem, the potential risk, and need for maintainability. The problem with vibe coding is not so much not understanding every detail of the code, but not understanding why it works and what can bite you when an edge case pops up.
For example, we generated code to extract some data from zip files delivered to a bucket a while ago. The vendor always delivered 1 file so AI naturally wrote the solution expecting just 1 file in the zip file. Well the vendor then started delivering multiple part files in the zip file. It went 2 months without anyone noticing and we missed quite a bit of data in our product.
Our jobs as engineers are to design robust systems that account for things like these. AI so far does not do a good job of thinking about systems holistically and the potential what ifs. It tends to just design a solution given the examples shown to it. So if we turn to vibe coding and just measure whether something works in the moment under normal circumstances, there is a lot of potential risk when those circumstances change if we don’t design for it when using AI.
That’s my opinion and how I use it; I’m a systems engineer, and I’ve been using it recently, which makes my work more demanding (not necessarily more costly, but more exhausting). Of course, I could do 100 times more if I really wanted to, but that would mean working 20 times harder to check everything and debug it before deploying it to production. I base my approach on responsibility: if I start a project and am told to use AI, I make it clear that whatever happens if there isn’t enough time isn’t my fault – and if it isn’t done in the traditional way, well, that’s why I’m paid my full salary (I’m lucky to have that leeway in my company). It’s true that I now also use it to programme video games and quick apps that aren’t branded (though another one is, and I can make a copy); if I really want to study something, I can create summaries, personalised assignments and generally make the most of it.
At the end of the day, there are only two types of AI users: those who use their heads and those who don’t, whatever the situation. If anyone tries to tell you not to use it, let them be the first to take the blame if anything goes wrong.
In my experience, the argument for "if it works, it works" wasn't the rule but the exception. Usually at some business critical piece of code with high compexity levels. Code like that is as simple as it can be given the complexity of the problem it solves and there is a ton of risk and cost involved when changing it. It was a warning that "Here be dragons".
Opposed to that LLM's generate complex and verbose code to solve simple problems, often not overengineering but simply babbling because it's generating code from independent sample sets and then wiring it together to work.
Sorry, maybe corporations and entrepreneur-bros were on board with "if it works it works". Consumers haven't been on board for some time. For years hardware improved fast enough that the increasingly shitty code did not slow you down too much, but nowadays you can tell that many apps need longer to load then they did in windows 95 on hardware that was 1000x slower. Look at fucking notepad or the terminal on windows.
Having managed several teams through a slop explosion, it's intolerably bad. I can tell the difference instantaneously between a shill and an actual engineer depending on how they describe working with vibe code over time.
To be clear, the tools have their uses, but vibe slop is not sustainable in a professional coding environment.
Depends... Is it Greg down the street, who lives in his mom's basement and never wrote or read a line of code in his life, but is gonna build the next big saas product? Or is it you, hopefully a seasoned architect, as well as a herder and maintainer of both new and legacy systems, deciding to dip their toe in such efforts?
Actual true vibecode from non technicals? Yes, it really is that bad and is soup code.
"Agentic engineering" from a technical person who understands how to code and architect software? Not nearly as bad. But its usually bloated, subtly wrong (or technically correct but missed the true intention), and overengineers and/or writes tests for the wrong thing.
Still better than most code produced pre AI, but not close to truly well built and engineered software built by old head wizarda
yes. Even latest models are still generating horrible code. That's why I have my own context to provide best practices. If you don't have this... then yes... it duplicate code, writes inline types, uses any everywhere... at least on typescript.
Only the amateur used those memes . Also the memes about LOC
For any one with experience We know that
Making code that works ... thats level one for freash graduate
Code the scale and secure... thats level two
Code that is Minimal , readable, well structured, sputer optimized and ready for years of development without the cost rise exponentially....thats level three .
No project cant reach production ready and profitability without achieving level 3 .
If you let the Ai in hand of non techy at best you get to level1 , Ai in the hands of mid level tech can reach 2 .
But for 3 ... you need to do manual review and senior experience.
Why because the data that the Ai trained on are mostly level 1 and some level two .
Level 3 projects are closed source that the Ai never saw .
It mostly depends on your dunning kruger. If you know the subject and the tool then the generated code can be pretty good, if you just think you know the subject you probably end up with very crappy code. LLM are built to please the customer and provide plausible answers. If you don't know what to ask an AI will probably just try to make you happy without too much effort, leading to a crappy solution that looks great according to your knowledge of the subject.
Si tú software hecho con vivecoding gestiona vienes, es grave. Si no sabes programar realmente es catastrófico.
El vivecoding sirve para hacer una demo de cualquier cosa, funcionara, que lo haga bien es pedir mucho.
Hace poco ví una empresa al borde de la quiebra (aún no salen) por un hackeo que le hicieron a su app hecha con vivecoding que daba gratis el producto que vendía. Fue una perdida multimillonaria, intentaron solucionarlo con más vivecoding y pues no han solucionado nada realmente. Están a la espera de que finalmente les den el golpe maestro para dejarlos contra las cuerdas.
Será una lección dura de aprender... Quizá recapaciten pronto antes de la quiebra total.
De nada sirves un humano si solo le da aceptar a todo lo que la IA hace y no sabe leer código, eso no será suficiente para detectar cuando tengas una vulnerabilidad por causa de un atajo que hizo la IA ya sea por falta de contexto, por pereza de la iA o porque cumplía con los requisitos mínimos para cumplir los tests inventados. (Y si, he intentado usar vivecoding para agilizar mi trabajo y PS que te digo, por más de mil veces que le he repetido, le hecho skills, le he dado mil mcps, paquetes de 300 skills de trabajadores de la NASA y equipos de agentes basura, cuando leo lo que crearon, sigue siendo basura aparentemente funcional)
Tienes que saber mínimamente programar para solucionar lo que la IA no haga, o al menos decirle, "oye que basura acabas de hacer aquí, haz esto para corregirlo."
It's good enough for webdev and has the upside of giving the option to move really fast. It's really bad if you do something more technical and don't review every single line, because the slopification of codebase is very fast process and most of the times, there is no way back ;)
Janky human code at least had the potential for at least one human being to understand the code, why it is janky and what are the ramifications of it, and most importantly, somebody cared enough to create this jank themselves. Now slop is just produced in huge quantities, by people who do not give a shit about the entire product. It's not only about quality, but also WHY it exists.
its not that bad, and the blanket anti-AI stance is turning into the new “I program in Rust” or “I use Arch” virtue signaling.
the only upside to artisanal human-typed slop over AI-written slop is that human-written slop is easier to immediately recognize. AI-generated code is a bit harder to spot because it actually looks “good.”
if you’re still letting slop through to prod, that’s either a process failure at your org or you’re bad at reviewing and verifying what you ship. thats really it.
The "advantage" is people actually understand it and as a code base grows it enables you to make better decisions and handle requirement changes while aiming for stability.
Its not "artisanal code" its thst when yoi actually type something it sticks in yoir brain better and you think more about your decisions so when someone asks "why did you do that" you can answer.
If you want that from vibe code you end up taking just as long but this time you are reading it.
It really depends on how much you trust "ai can fix issues when are in the maintenance phase".
Because ultimate every software product is aiming for that phase.
It depends. The truth is, most software companies die within 10 years. There are many reasons for this, but for the ones that survive their first few years, the main one is technical debt. Technical debt imposes many taxes: you need more people to do the same work, information becomes unreliable and hard to piece together, and decision-making slows down. All of this makes the company expensive to operate. It’s a slow, painful, and often inevitable death. I’ve consulted for companies in this situation, and once the direction is set, it’s very hard to reverse. It’s rare to find a CEO with the years-long commitment it takes to turn things around by investing in the right things. Farming the company for a few years is just much easier.
Vibe-coded systems only amplify this. When a disposable piece of code becomes the core system, no one understands how it works and no one holds a mental model of it. Every change in direction becomes slow, expensive, and often impossible. Local changes are incoherent, and the system as a whole stops making sense.
So why does it depend? Because not every vibe-coded system is a core system. Sometimes it’s a piece of code with no real connection to the core business, and in that case vibe coding is a good, often recommended strategy. The problem is that most businesses don’t have a skilled engineer to decide what to vibe code and what not to. Once you start, you end up vibe coding everything.
I have seen a lot of people say this, but what about when u use ai to help fix technical debt. This isn’t possible with pure vibecoding but with an experienced dev giving driving it. I feel like this problem can be minimized with that approach.
Your post or comment was removed because r/developers does not allow external links. Please share the content or ask your question without linking out.
If no one knows the system model, what is technical debt is not well understood, and you can't address something you don't even know exists in the first place. Vibe-coding just makes failing faster, up to 90% of the software companies will continue to fail, for the same reasons, nothing really changed but the velocity of it. For companies, writing code was never the bottleneck. The bottleneck is understanding, reviewing, and making informed udgments and decisions.
I am confused as to why you think AI is unable to rapidly help an individual or team map a code base or system model?
My team does this on a frequent basis when trying to reverse engineer legacy APIs entangled across multiple complex dependencies.
These tools are absolutely phenomenal at assisting in building high level diagrams. I also have a number of tools for both PR review and code base refactoring that look for common anti patterns and aid in restructuring for improved design and maintainability.
System architecture and the system model are not the same thing. The architecture is only one layer of the system model: it describes how the technical systems are structured and how they communicate. The system model is broader. Beyond the architecture, it includes the users who interact with the systems, the stakeholders who depend on them, the data those systems generate, how that data drives business decisions, and the bottlenecks that emerge across the whole system. In vibe-coding system model is partially or completely lost, changes are purely opportunistic, many of them nonsensical and incoherent, technical debt is not even recognized as such.
Technical systems structure and communication is driven architectural and system design, as are data structures and delivery methods to the end users.
Is your position that we are losing site of the user and business outcomes when we use AI assisted development? Every feature, functionality and design decision our team makes is directly aligned with an optimal UX, whether that user is an admin or an end user.
If anything the ability to rapidly iterate allows us to put the product in the hands of test users much more quickly to receive real world feedback. We are already seeing this in situ with our pilot partners for our new platform.
Of course, and thank you for the thoughtful question and the honest conversation.
Let me try to put my intuition into words. You may be familiar with the idea that the machine shapes reality. It’s closely related to Conway’s Law, though many others have touched on it, both before and since. Churchill’s line “We shape our buildings; thereafter they shape us” captures the same idea.
The way a system imposes its rules on reality and bends it to its will is what I call the system model. In traditional development, that model is owned by an engineer, or a group of engineers. Ownership isn’t binary, of course; there are degrees of it. This isn’t an idea I came up with myself: Peter Naur’s “Programming as Theory Building” and Fred Brooks’s notion of conceptual integrity in The Mythical Man-Month both explore it. And I don’t have hard data to back this up, only anecdotal evidence and common sense, but my sense is that in vibe-coded environments nobody owns the system model, because not owning is the path of least resistance.
The result is that local changes work, and are often even high quality, but they’re likely incoherent with the system model: they break data patterns, disrupt information flow, and gradually erode the structure that holds the system together. The symptoms of this erosion existed long before AI, companies become slow, bloated, and expensive to operate. AI just makes it happen faster.
One more note to this: LLMs are fine-tuned in short-term intervals. Seconds to minutes, rarely hours, they are trained to solve right now the problem I have in front of my nose. Solving problems within bigger intervals, days to weeks or months is not remotely baked into weights. Every company is leaning short-term and erosion at this point.
I can understand your concern here - playing devils advocate: a quality engineer, in spite of the tools they are using (LLMs included) should retain a foundational understanding of the system model. To my knowledge, barring a very simple program, no engineer strives to memorize the entire codebase, more so the functional outcomes of the system components, their edges/nodes, dependencies, organizational structure etc. etc.
I completely agree that the degradation of comprehension and understanding of objective outcomes can occur both over time with human curation and potentially faster with LLMs. From my perspective it is more important to have a fundamental understanding of the functionality of the system model, than it is to remember exactly how the code was composed for a particular function, which is being abstracted away by LLMs.
Basic example: a check-list application that can also provide a high level dashboard showing how many days you completed your tasks, which days were the most active WoW etc. It is more important to know why each component was built and what it purpose it serves than exactly which method is used (assuming scalability, uptime, performance requirements are known when they are designed). LLMs allow for rapid development of the underlying how - yes, however; the engineer still needs to understand how the check mark becomes a data entry in Postgres and what process aggregates that data into the dashboard. Whether this is through erosion of human memory, or the memory itself never existed because the engineer didn't take the time to plan the system out accordingly are two different problems. Clearly, in the times where everything had to be developed by hand, the latter was less frequent, though copy an pasting of code that was not understood still occurred.
I cannot speak to how the models are trained, but I can speak to how I plan and build system componentry. When designing a component it still requires a plan, review, and multiple phases of implementation, all with the constraints and requirements of the system design in mind from inception. Obviously concepts evolve, and LLM's allow for much more rapid pivots when problems arise during the conceptual or early implementation phases. I would focus less on how LLM's are trained and more on how the engineer leverages the tooling.
Exactly, that is responsible AI use. You have to lean the other way by having someone that owns the system model.
I just watched something that perfectly illustrates this. Just two days ago, OpenAI released a huge batch of math “proofs”. One of the problems was about square packing: fitting a set of squares into the smallest possible area. The model brute-forced its way to a solution, and the result is super weird: there’s a tiny gap between two squares, just big enough for the corner of another square to poke into. Insane stuff. A day later, a mathematician showed that the exact same result could be derived from a Fibonacci torus. The same solution, showed both ways:
This single image captures exactly what we’ve been circling around. The one on the left is chaos, as weird as it gets. The one on the right has order, rhythm and balance.
If you're fully reviewing AI generated code, you're not really vibe coding in the first place.
I've worked in both worlds. A legacy piece of software where AI was used conservatively and everything was reviewed carefully, and a new software product where 10 devs fully vibe coded 20 years worth of code in 6 months. 15 parallel claude sessions, 60 PRs a day each. The second one is a complete fucking nightmare, but the biggest issue isn't the code quality, it's that none of the software developers really understand how the software works any more and are making decisions about code that really don't understand.
this is just false from my perspective. i've mostly been a single developer over the course of my 25 year career, so i've always done frontend, backend, database design and server infrastructure myself. coding time was always the limiting factor. LLMs definitely shifted this for me, as i've launched more apps and features in the past year than i did in the 5 years prior. features i never had time to spend effort on before i can now develop in a day, and if we don't like it we can quickly change or get rid of.
the problem with throwing 10 engineers at something is alignment. every developer needs to be on the same page which means multiple meetings, clear communication and planning. that means it takes even longer. one person directing AI is not even comparable.
Well, it sounds like we’re coming from exactly the same place. Code generation speed is a helpful tool, but the real work is in review, judgment, weighing the options, and making decisions. Aligning ten engineers is the same problem. The hard part was never generating the code; it’s deciding what we should generate, and just as importantly, what we shouldn’t.
It is a problem. When something used to take months, but can now be done in weeks? Adding more devs doesn’t always speed things up. Usually it causes more issues if u add too many.
Vibe coding is great, when used by people who know how to code. And it’s great at helping people learn to code. It’s great at making side projects for personal use. Those are the positives.
I’m not a pro coder, but I’ve been coding since BASIC on TRS-80. I learned all of the front end tools along my journey of being an ECD leading XD teams. I love vibe coding. But I understand what I’m doing and why and I’m not shipping products for sale. It allows me to make stuff I don’t have the time or aptitude to learn.
Professionally, I would only hire a great human coder. But it’s an advantage to be one who knows how to code AND where/when/how to vibe code.
Vibe code means asking an AI to generate code and using it without any review process or understanding of the code. If you look at the code and understand what it's doing, I would say you aren't vibe-coding, because there is functionally no difference between you typing it and a machine typing it.
The biggest problem the industry currently faces is juniors using AI, and developers always using AI for everything. As a junior you must write code to learn to understand it, and a senior developer's skills will atrophy if they do not occasionally write code.
Generally no, definitely not at the small scale. AI writes better code than the majority of humans. However correct systemic organisation matters the more code you write and this is something AI isn’t always handling well, especially when the humans prompting it don’t understand the system and ask for the wrong things
It is also good at making "things work", especially if it can check determinically. But broken architecture can work for a long time and AI might have no idea about it until it breaks some day
50 years ago: punchcards were still a thing. Screens were text mode and didn't carry colors.
Today...you can prompt an AI, wait less than a day and get a working prototype.
It took only 50 years. Now, with AI coding much faster than a human can, imagine what it will be in 10 years...
Coding is mostly dead, whether you like it or not. It's just a matter of time before no one is coding by hand anymore. When that happens, new AI-specific languages will come out. I mean, if we all survive until then.
The field is shifting to something new. Imagine what it will be in 10 years from now. That's 1/5th of the way between punchcards and high end GPUs, and everything's going much faster today than back then, with millions of coders and vibe coders on the clock...
I've vibecoded lots of helper functions to enable me to cover more ground in a shorter time, and it came with a cost:
They had bugs, and bad bugs at that. Memory corruption, and a total dismissal of responsibility by the LLM. It made mistakes, but the real mistake was my approval. Since then I've taken to iterating on such helper functions, until the clanker weeds out the most obvious shortcomings.
I'd still attribute more trust to code I wrote myself, even though I also make mistakes, because when I think through a solution, the mental model is what matters, and recall of that, is way more useful than any chat context when debugging.
I was programming for 25 years before vibecoding. I wasn't the best developer, sure. But 99% of the time now, AI is educating me about security rather than me finding faults in its work. AI may not make the best decisions where taste is involved but in terms of security I have not seen any reason to not trust AI for most projects.
The only times it requires a devs hands on is for financial work, sensitive data etc or anything where even a a small risk of a fault is not acceptable - or supporting a large number of users.
I think a lot of the "AI slop" brigade, when it comes to code, are just reacting and spreading rumours out of insecurity for their own careers. That's it.
I've noticed it often over-engineers things, yes. It produces significantly more code than ideal. But what usually matters is just how effective that code is. The one benchmark I think is becoming less important is human readability except for critical areas where human review is called for.
no, no over-engineering, i mean no engineering at all, it just duplicates things, calcs stats sycronously in the main thread, wont paginate humongous tables by default, sometimes makes endpoints to fix some things and wont delete them. Most of those platforms will work on for showing incredible dashboards and amazing visuals, but when put under load they will break and if it really were an amazin over-engineer that will never happen.
Your post or comment was removed because r/developers does not allow external links. Please share the content or ask your question without linking out.
Your post or comment was removed because r/developers does not allow external links. Please share the content or ask your question without linking out.
•
u/AutoModerator Oct 09 '26
Howdy u/JobOdd7262, and welcome to r/developers!
A few tips for a post that gets good answers:
Use a clear, specific title (what are you actually asking or sharing?).
Include code, the exact error, versions, and what you already tried.
Heads-up: this sub does not allow external links in posts or comments. Share code and details directly instead of linking out.
Join the r/developers Discord!
I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.