I can’t take vibe coding seriously
Posted by bluetomcat@reddit | ExperiencedDevs | View on Reddit | 115 comments
I’ve been programming in one form or another since the early 2000s. For me, good code was always the result of clear intent and a precise mental model. I see it as a deterministic mechanism with many moving parts. When the interaction between the parts (modules) has clear boundaries (abstractions), I feel like I understand and own the thing.
What is happening with the kids these days? Why is translating imprecise and lousy human language to inscrutable amounts of formal language with hidden complexities and semantic anomalies advertised as a feature? I can agree that the technology is suitable for assistance with small locally-contained changes and rubber-ducking. But what is the value of thousands of lines of code that were generated after “create me a React address book app”? If everyone and their dog can come up with something like this, what is the pure economic exchange value of having code like this? What am I missing?
HiSimpy@reddit
Skepticism is rational if review ownership is vague. Teams struggle when AI increases output but not traceability. The practical move is tying each generated change to an explicit reviewer, risk tag, and rollback owner so confidence comes from process, not belief.
drink_with_me_to_day@reddit
Because of speed
If you put in the effort to keep up with what your copilot is doing, it can write faster than you, especially when doing time consuming UI state conditionals
Correct_Drive_2080@reddit
I had an opinion similar to yours.
Well, not really. I get the first part about being deterministic, and why you would see no value if anyone is making the same standard boilerplate app.
But... That's not really what's happening here. You can still vibe code and know what you're doing (which most likely you do, according to your message).
You can just give the full narrative to the LLM, enough to give it guard rails so it doesn't go out of scope. In the end, your expertise is still a valuable part in process and you can just "explain the task as you would to a junior", while just moving on to something else.
Baat_Maan@reddit
The difference is that when you give tasks to a junior they'll ask good questions and add their own value which helps things. With an LLM that doesn't happen. And that's considering that the ouput of the LLM is 100% reliable which it usually isn't even for the frontier models.
DaRadioman@reddit
You haven't used good agentic AI man. And it shows.
It does "ask questions", it does find scenarios you never brought up. It fixes patterns that are common when I have it fix one, and cam be "proactive"
And steering is a huge important aspect. You guide it as it makes changes. Just like you would a junior.
Baat_Maan@reddit
It doesn't ask GOOD questions. The things it does are helpful, but it shouldn't be compared to a junior dev is what I am saying, junior devs definitely are smarter and their value doesn't come from just following instructions and doing grunt work.
DaRadioman@reddit
Again, try a modern model (opus 4.6 or similar) with good agentic CLI harness and solid instructions or skills built. Ex GHCP CLI or similar with setup for your flows and instructions or skills to describe what you want (patterns/standards/etc)
It's not the models of even last year, this is so so much better in just the last 6 months. It proactively makes plans, splits up asks, parallelizes the investigations, and can even reflect on why it went wrong and help you refine the instructions to help it next time.
Still loses mcps or context occasionally, but I have it find similar but related issues without any prompting, and talks through solutions to make sure it has covered all the aspects of the ask.
I can have it make coordinated changes across 3+ repos and give it vague feedback or just raw error messages and have it figured out the full context.
Baat_Maan@reddit
Used Opus 4.6 with Kiro and cursor. Didn't use skills or whatever. I can still ignore code standards and guardrails if the code covers all functionality.
I don't like to let it keep doing stuff in parallel because it often goes on a tangent, assumes weird logic (especially when some code isn't logical and written just because we have weird data in some places) and handles imaginary scenarios that have no chance of happening. At least with the autopilot off I can fix it before it becomes unmanageable.
I'm not saying it's not helpful, it definitely is. But I was just comparing it with a junior or more specifically a good junior since it looks like people here haven't liked their juniors alot and the junior definitely asks important questions that the LLM can't replicate, especially questions like why some things are the way they are.
DaRadioman@reddit
That's fair, and no I'm not talking about autopilot, just single steps when I ask it to assess the current state it runs down all the rabbit trails at the same time, can be solving multiple problems at the same time or analyzing all repos for context at the same time.
And "why is this way" isn't something I have seen, but plenty of "oh this is a variant of what we are talking about even though the user mentioned something slightly different" so it's a fair point. I like juniors, mentored a number over the years, so it's not a competition, but it does great as long as you tell it to run down those rabbit trails and ask it to assess those sorts of things.
Baat_Maan@reddit
My original comment was just talking about why AI should never be considered a junior dev. AI is more like something to be used like a search engine.
Also idk how you're making AI work on projects in parallel without autopilot and how you're dealing with constant context switching working and reviewing code for different projects. And writing docs for AI? Nah I'd rather write code myself, I hate making docs.
DaRadioman@reddit
I use steering a lot mid process which probably helps. If I see it going off the rails I stop and redirect.
DaRadioman@reddit
But if you have oddities make sure you have instructions or skills to cope. It makes a huge difference. Think of the AI as a new team member and make sure your docs fully onboard without requiring an explanation. If you have docs that can fill the purpose and are consumable the that may work. Otherwise help it out
IdeaJailbreak@reddit
It's called plan mode? It tends to ask lots of questions.
Sometimes still has misconceptions or doesn't ask an important question, but that's no different than a human subordinate
Baat_Maan@reddit
Just answered another comment talking about this. I still don't find those questions as smart or trully intelligent like what a junior will ask. But that also depends on the kind of juniors hired at your place so YMMV
IdeaJailbreak@reddit
I tend to just read the plan and then ask it to make a few edits before building. Usually when it gets things wrong it's because I omitted an important detail. (It needs a fair bit of detail to produce a plan that's "close".) Almost never 100% nails a plan unless the change is small or widespread but very basic.
DaRadioman@reddit
A junior wouldn't nail it on the first try either.
People try to compare a first draft from AI to a finished product from a developer and that's not how it works. If you want it to be through, run tests, do validations, iterate with it, tell it to do those things, as skills it instructions to codify them as things that always should be done. You know, onboard them onto how the real works.
Why people don't accept a jrs work at face value, but think AI should be perfect on an initial pass blows my mind.
Baat_Maan@reddit
Yeah it obviously needs details, I don't expect it to read my mind. And as you said, doesn't nail the plan 100%. Also it would a lot of time suggest common patterns of how something is usually implemented, some of which may be unnecessary to our use case, a junior on the other hand will more likely spot some missing or unnecessary parts if I'm discussing the plan with them.
glhaynes@reddit
Ask it to ask clarifying questions before it starts. They’ll be so much better than any junior I’ve ever worked with in my career.
Baat_Maan@reddit
Yeah there's plan mode for that and I've used it. Still not as smart as a junior, especially when you're working on something that is not a common business problem.
But then again there's a huge variance in the quality of junior SWEs from place to place so YMMV.
rwilcox@reddit
With juniors I can explain things and know that, with a good junior, maybe next time I’ll have to explain less. I’ve invested in that juniors development.
With an LLM? Any instruction time I put into the AI, to get it to execute some task, is only to the benefit of that task at hand, and I’m going to have to say the exact same thing next time (yes I know about LLM instruction files)
IdeaJailbreak@reddit
True, I've never really put it into words, but definitely thought it.
Pale_Sun8898@reddit
So vibe coding is just letting the ai build it without reviewing it closely? I don’t even know what the definitions are anymore. If you know what you are doing and are good at scoping features and reviewing the code LLMs are a game changer. I think the people that can do that are going to be those who succeed in this new era, the people who can’t seem to harness AI effectively will be left to niche positions or retire
Urik88@reddit
Even if you review thoroughly, it's still a degraded outcome coming in exchange for speed.
Reading code is several times harder than writing it. Were you willing to take ownership and responsibility over every single PR you ever reviewed as if you were the one writing and publishing it? Because this is the new reality if you rely on LLM's for all of the code you're publishing.
theorizable@reddit
It's really not though. If you communicate with the LLM it can do pretty much exactly what you tell it to do.
vogut@reddit
Yes, but then you will need to read all the documentation, understand what's happening, decide the architecture, and then start coding. And lets be real, the coding part is the fastest on a scenario like that
failsafe-author@reddit
It’s not. Coding part takes a lot of time.
vogut@reddit
Yep, and still is the fastest part of all of this that I said.
theorizable@reddit
No it's not.
If you asked AI to create a binary tree for you, are you going to go read the documentation on binary trees?
If I ask it to throw a couple RL or Transformer networks together am I going to relearn how to code a transformer each time? No, I understand the underlying mechanism going on. It might be hard to remember, but when you remember it and communicate it to AI, AI makes what you ask it to make.
vogut@reddit
I'm not talking about boilerplate code or code that you can find on the internet and easily reproduce. I'm talking about working on a real system with real implications. Precisely what you said about understanding the underlying mechanism.
failsafe-author@reddit
I disagree. If you have a good plan, good documentation, and reviews well, you can get quality code out.
Wonderful-Habit-139@reddit
Not even close.
And the more you narrow down the scope until you have quality code, you end up being slower than doing things yourself with a proper dev environment.
failsafe-author@reddit
That’s simply not true. I am regularly shipping AI generated code that I have full confidence in, that looks exactly like what I’d have done had written it, and I’m capable of supporting and explaining to others.
You have to slow down and be intentional, but it’s still faster than coding by hand.
FWIW, I actually have built my own review tool that makes reviewing AI generated code a lot easier- it breaks it into related areas, and explains the choices made and design patterns used. I usually have to tweak the output, but it’s still faster than hand coding everything myself.
Urik88@reddit
Absolutely, that's not in doubt. The question is when prod is on fire how big will your understanding of that code be and how fast will you know where to look?
I'm all for letting LLM's help us on the way, but it frightens me when I see people feeding a Jira ticket to Claude and then just review what came out of it.
Code can be beautiful and still not have anyone know the ins and outs of it.
failsafe-author@reddit
That’s why you have to review well.
You can’t make the argument that you have to write code to know it well, because then only the author would really be cable of handling issues in prod. If that’s the case, there’s a bigger issue.
I’m not saying it’s easy to review code well, but it’s certainly dooable.
testy_balls@reddit
It's not really equivalent? Other people's PRs are more difficult to read and understand because you have a lot less context into their tasks, research, and thinking process. When asking the LLM to write code for you (effectively), you should already have a good idea at a high level how things should be done, and iterate code changes based off of that. You can also directly ask the model why things were done a certain way if unclear or if you have a different implementation in mind.
Pale_Sun8898@reddit
This, if you’re doing it right, you have designed the architecture and implementation before letting the LLM write a single line of code, so you are reviewing code that is familiar to you.
Pale_Sun8898@reddit
Not if you keep it scoped to small review cycles. I have been 3-5x as productive in terms of features and backlog items I never got around to before and my quality is sterling, as in 0 incidents or prod bugs. Use the brainstorming and code review skills available to have even better outcomes, my company has written an entire suite of skills to help with everything from code review, to opening jira tickets, to writing rollout plans, etc…
xDannyS_@reddit
There's so much bullshitting going on that it is indeed the definition now.
failsafe-author@reddit
Wasn’t it always the definition?
Wonderful-Habit-139@reddit
It was. Term coined by Andrej Karpathy.
failsafe-author@reddit
Yeah, exactly.
Backlists@reddit
Vibe coding is not reading code, just using the software and re prompt.
One recent headline was Garry Tan, the CEO of Y Combinator boasting about writing 37,000 loc in a single day.
Headlines like these are what they want us to be able to achieve. But no one can read 37,000 loc a day, let alone comprehend it, understand it, vet it and review it.
Pale_Sun8898@reddit
Yeah I would not want to produce feat, nor could I produce probably even 10k lines of quality code in a day
Backlists@reddit
We should be gathering metrics on how many lines of a juniors code seniors would review per day before 2022, and use that as a baseline
Pale_Sun8898@reddit
I can comfortably produce around 1-2 lines of code using agentic help depending on feature complexity that is prod ready. At least based on my recent metrics.
Backlists@reddit
Did you mean to say 1-2?
Pale_Sun8898@reddit
Haha no, 1-2k
Single_Positive533@reddit
Considering the review time takes usually 3 seconds per loc. Then the CEO just created something that requires 27 hours to review and test per person. So Considering 6 hours of productive work, we are talking 4 days and half of work to review and test.
How's that different than having two developers working on some task for 4-5 days.
LocoMod@reddit
I know right. These kids think that writing software in Python or TypeScript which are lousy and imprecise is real engineering. They should try writing pure binary like real SWE’s do.
testy_balls@reddit
I only do programming via punched cards into my IBM mainframe, the way God intended
slowd@reddit
I’ve been writing code since the 90s and I’m all in. I don’t touch the code anymore, every change I just describe in words. I typically have 2-3 Claude sessions running all day long.
IdeaJailbreak@reddit
Cursor native here -- trying out Claude code again mostly for the teams feature. 1) I feel like it's really annoying when the output expands past the tmux buffer (common with plans or if you just want to look back) and you need to Ctrl + b and then [. And then scrolling back seems quite slow.
Am I missing something?
DaRadioman@reddit
Just tell it to write it to a file somewhere if the content is to big to scroll. I use that for plans all the time. Leave it open, iterate on the plan and read the rendered MD as I yell at it to fix things and it refreshes on the fly 😂
rorschach200@reddit
Because the code works, and the purpose of the code is to solve people's problems, that it's economic value.
Being "good" is not the purpose of the code, customers don't give a shit about it being "good" or not.
Engineering spending time and money making code "good" was only tolerated in the past because it was needed, because people were the ones changing and maintaining it in the future and they needed it to be "good" to be able to keep it working long term, and they'd also rebel and leave if they are not allowed to spend at least some time on that as well.
If AI manages to maintain its own slop successfully, so that slop continues to work, incl. in the face of changing requirements, the code being or not being "good" loses all relevance altogether.
rwilcox@reddit
That’s certainly one of my worries: getting handed a 50,000 line vibe core app that’s “almost ready for production” - except no it’s not but some VP and half the stakeholders believes that since they saw a stupid man-behind-the-curtain demo it’s ready.
The other worry is are the tools AI gives you to refactor good enough to handle code at large volumes? I don’t think we as an industry know the answer to that question (but I do know that me, personally, I tend to see an LLM think it’s done with a large task when it really only did 2/7 things)
rorschach200@reddit
I think with today's AI those are "yes, it's a problem" and "no, they are not good enough", and I can add - it doesn't feel like today's AI can maintain large volumes of its own slop today - it seems to have the tendency of piling complexity on top of complexity post-processing results rather than fixing root causes when asked to fix issues.
Today.
AI of 12 moths from now?
Phew. I'm afraid we'd be surprised. A few more iterative additions so it by default starts with cleaning up and always contains simplification and code normalization techniques, always writes and runs tests, analyzes coverage, runs security analyzers, etc. etc. and before too long the 3 answers above will flip to their opposites.
DaRadioman@reddit
Even today it just needs a nudge. It generates bad code? Be a senior and review it. Guide it like you would any junior. Ask about patterns, push to fix things.
Really steer it and it's fantastic.
rorschach200@reddit
Agree.
I wouldn't call that level of guidance "vibe coding" (the OP's topic), however hard it is to define what that even means this week.
In professional SWE work though - yes, with rare exceptions that works out.
Ace-O-Matic@reddit
Although some of the language here is a bit too MBA pilled for my liking. As much as I hate to admit it you're not wrong in the sense of: code only needed to be "good" for the purpose of human maintainers. No one cared if the compiled code was good, because people didn't need to maintain the compiled code, I see a lot of similarities here.
rorschach200@reddit
precisely, assembly didn't need to be elegant for a long time now, but that's now how it's started.
failsafe-author@reddit
Code that is not good causes problems down the line. If it doesn’t, I agree it doesn’t matter.
pickled-pilot@reddit
You aren’t wrong. Garbage in, garbage out still applies. Try Claude Code and tell me the promise of natural language computing isn’t here.
smoss_benchwright@reddit
TL;DR: Because imprecise human language gets you something quick, and building within something is easier than building something.
Full explanation: There are 3 equal difficulty sections of a project, 0-10, 10-90, 90-100. However just because they're equal difficulty doesn't mean the problems are the same.
The 0-10 phase is more stressful and less fun than the 10-90 phase. You have to make so many decisions that create long term path dependencies:
- Which Frameworks will I use?
- Do I want to take this opportunity to try out a new technology or stick with what I'm comfortable?
- What's the actual process for setting up a DB?
- For setting up Docker files?
The list goes on, but eventually you complete it and you get into the 10-90 phase, where rather than answering wide open questions you solve fun challenges like "Why is this function slow?", "Is this the right data structure for this problem?", or "Can I refactor this whole section and get a -1000 line PR?".
Vibe coding let's you skip the 0-10 portion and get straight to the interesting challenges.
Obviously there's a downside, if you never actually dig into the code and understand what it's doing or why you're using one tech stack over another your code will become an unmanageable mess. But it's a mess that does something, which is way more interesting than stalling out in the 0-10 phase.
As for the 90-100 part, AI can help you, but realistically if you don't know what you're doing without AI, you'll just run very fast in the wrong direction. But history is littered with projects that failed to seal the deal that still had value because ppl learned a lot in the process of building them.
pansnap@reddit
Nailed it with rubber ducking, add in a bit of inertia removal.
DaRadioman@reddit
This is where agentic flows have been pretty groundbreaking for me. I am not a fan of what I worry AI will become, so don't peg me as some kool-aid drinker. I am just a pragmatist, this is coming either way. I embrace it or I get no change to help steer it.
Having a rubber ducky to remove the friction for making a change (largely routine things, running the tests, making branches, generating boiler plate, summarizing PR feedback so I don't have to chase it down) and to talk through decisions with research 10x faster than I could chase it down (have to force it to cite everything and provide links, but so much faster)
As long as you assume it's no different from pairing with the over-eager junior who may jump to conclusions sometimes, it unlocked my productivity a lot since I am always having to multitask in my role. Having threads/windows keep working on stuff in parallel is crazy fast.
mattgen88@reddit
Serious question to people who vibe code ... Do you have a product that a bug in production costs your company money? Do you have a product that has significantly complex business logic? Is your software more than just a crud app? Are you responsible for triage, work around, or hot fix? Are you subject to sox? Do you have to pass audits?
ExperiencedDevs-ModTeam@reddit
Rule 9: No Low Effort Posts, Excessive Venting, or Bragging.
Using this subreddit to crowd source answers to something that isn't really contributing to the spirit of this subreddit is forbidden at moderator's discretion. This includes posts that are mostly focused around venting or bragging; both of these types of posts are difficult to moderate and don't contribute much to the subreddit.
VibrantGypsyDildo@reddit
I am in embedded and AI just sucks. Either it cannot handle custom builds of tools, or it messes up with versions.
But when I am too lazy to write parts of a python script, especially related to regex or html parsing, it is very cool.
So I use it a couple of times per year.
sarhoshamiral@reddit
Have you written instructions and knowledge bases to help it process your flow?
Consider it to be a beginner dev, it will require documentation to make sense of the code. It will require build and test scripts to verify changes.
And if the language isnt something in the models training data, you may have to consider fine tuning or using a model with very large context window and include some specs about the language.
notquitezeus@reddit
Hear that ringing on your land line? That’s Ludd calling. They want your help with some looms.
disposepriority@reddit
It depends on what you do. I recently had claude do a small (\~800 lines) python script for aggregating data from a building's door access reports into spreadsheets with room usage stats, "hot time" for booking meeting rooms, attendance, etc etc etc.
This was really almost a one shot, and I can confidently say it would have taken me quite a few hours to do by hand.
If someone's work is centered around things like this, then it certainly seems like magic.
Today, I wanted to improve one of the internal libraries used by engineers in our company, so I started up a new repo, ambitiously called it libraryname-modern and got in the core logic.
I think I spent 2 hours trying to explain to Claude that some parts of the code it is seeing is not mutable and is not subject to change as well as how the libraries interfaces are used now and the desired change - and what we basically want is to add a (sane) layer of abstraction over the immutable part that would allow the API to be used in the following ways...
It really did not go well at all, and I suspect it's just really not amazing at dealing with in-house solutions or custom code at all and I ended up doing it myself (oh, the humanity).
That being said - even before AI you had engineers whose struggled to freely write code and completed their work exclusively by stitching modified versions of existing code in the project together or grabbing things off the internet. It's not a coincidence that "Have you implemented a new feature end to end in your product" was a pretty common interview question - there were people with 4+ years at a company who had never added new things to a system or had to make impactful decisions.
So - like they say, the more things change the more they stay the same.
zica-do-reddit@reddit
I did a job interview recently and I am convinced I lost the job because of my stance on vibe coding. I was asked about it and I said it's very useful but you need to verify the result. Later they revealed they are just using agents to pump out and review the code, no human intervention.
BoBoBearDev@reddit
Nope
1) write better unit tests
2) prompt clean code
3) stop pretending the past is unicorn, it was duck tapes with human slops and auto approvals, Heartbleed, shellshock, supply chain attacks, none of them were cuased by AI
existee@reddit
Programming is not software engineering; the latter tries to solve real world (read human) problems which do not easily afford deterministic and precise mental models, at least for more than a single moment in time, and do operate on natural language.
I have seen programmers that obsessively craft intricate machines and fall in love with their crap, but they always fall short of durable relevance to the problem at hand. This is even true for core libraries, kernels etc.
As much as I take issue with vibe coding it at least kills the turd polisher archetype. “Business function now or gtfo.”
hw999@reddit
The people that pay developer salaries don't understand a word of what you just said. They only understand "cheaper", and are willing to take huge risks, and ignore all reason in order to achieve "cheaper".
CelebrationWitty3035@reddit
Cheaper AND faster. They really don't care about what's under the hood.
pydry@reddit
There's about $4 trillion in stock market valuations riding upon the promise of vibe coding coming true and reddit is infested with bots so... this might not be the best place to ask that question.
godless420@reddit
Ya, the bots have almost completely ruined Reddit. Harder to get a gauge on what real people are thinking
DisneyLegalTeam@reddit
Bots or not, social media is an awful measure of reality.
Social media has a 1-5% engagement rate. By nature it amplifies a loud minority.
godless420@reddit
Yes, I do just enjoy engaging with actual people and diverse thought
Eric848448@reddit
That sounds like something a bot would say!
Agitated_Marzipan371@reddit
I'm onto you
Careful-Nothing-2432@reddit
I feel like people go too far on different sides of this issue. LLMs are tool, it is up to you to use these tools effectively.
I vibe code a lot, I also understand what LLMs are good at and not good at. Refactoring stuff? Let me change the API, update a class and a test and tell Claude to repeat that on a list of other classes.
Got annoying tasks that are hard to automate but generally repetitive and tedious? Throw Claude at it.
I don’t use Claude for docs or anything related to software architecture.
When we started getting new higher level languages engineers complained that the juniors don’t know how a computer works anymore. I remember the whole era of people shitting on web dev as not “real programming”
I think it’s incredibly valuable to be able to throw together a fancy chart using natural language, I also recognize that I can’t use Claude vibe code trading risk controls
wrex1816@reddit
Oh for God sake. I have opinions on vibe coding too, especially non-engineers. But I refuse to do the "get off my lawn" routine. Technology never stands still.
shan23@reddit
It’s a tool, you should be experienced enough to analyze it and understand its strengths and weaknesses and find ways to harness the first while avoiding the second.
Otherwise, you’re senior in name only.
allknowinguser@reddit
I’m not saying you’re wrong because some of what you say is true. But in my F500 company, engineers of all levels including architects are fully onboard the AI train and has transformed their day to day activities.
t-tekin@reddit
F500 here as well. Same situation. Everyone in my company uses it. But we have one major rule: “we don’t care if you use AI or not, you own your checkin and understand every line of it, and can defend it.”
I think the reality is in between the OP’s take and AI bros take.
My current belief is; * Small App industry is done. Anyone indeed can create those apps. (I needed a weightlifting app, days of work did it. Why buy an app when anyone can do this?) * Most B2B is also done. Before we didn’t want to deal with the maintenance. But most are isolated small scoped solutions with not that high impact surface. AI can deal with it. * Offshore outsourcing is done. Before we would do this for low scope, low importance things. AI can do that now.
AI still struggles a lot with architecture and big scope code bases. Requires a lot of hand holding. But we do use it everyday for any task that could be tackled by a junior engineer.
Ace-O-Matic@reddit
What you're missing is:
"Cursor, check out git for the last 3 most recent implementations of X feature. Use that as a guidance to implement the same feature but for model Y."
Being ran on a 10 year old codebase where X feature has had about a dozen different pattern implementation and no clear guidance on most recent patterns on a code base with thousands of contributors. Especially for something like tests.
You're basically replacing writing code with being a code-reviewer for a very literal and at time dumb team of juniors that write code really really really quickly. As a result it's great for tasks that are semi-ambiguous, meaning that there's a lot of relevant patterns from the code base to draw on, but none that are so identical that a copy+paste+replace will actually get the job done.
No one serious is saying "create me X app". Even if you're planning on a large feature, you're using something like a plan + research mode pattern. When you're first generating a complete implementation spec, adjusting it several times, and then having the AI actually implement the spec. The worst part of this process is that it can actually stick to the spec too much, where there will be some falsely made assumptions that you missed in the spec, and now it's over-engineering some nonsense to implement it anyways, when it would've been easier to just change the reqs cause it wasn't that improtant.
E3K@reddit
I've been a developer for 30 years. While I don't fully "vibe code", LLMs are now an important part of my tool kit. Just like IDEs, frameworks, CI/CD tools, testing harnesses, linters, and so on. I use LLMs because they save me incredible amounts of time. Instead of spending a huge chunk of my time focusing on being an expert at arbitrary programming languages, i can now spend that time solving problems and being an expert at the products i create. It's massively fulfilling, both for my own work life balance, and for my pocketbook. It's ok if you don't agree. But don't belittle those of us who know how to make the tools work for us.
dksourabh@reddit
Vibe coding done with review, iterations, re-prompting and midnful automation testing needs to be taken seriously. That is the way.
kari7ootsie6499@reddit
can't believe i read the whole thing
editor_of_the_beast@reddit
AI writes code just as good or better than the average engineer. That is indisputable.
Really take a look back at the code you and everyone you has written in aggregate throughout your whole career. You’re telling me AI is doing worse than that? Hard to believe.
Correct_Drive_2080@reddit
Well... Mostly likely yes. People just don't care because the time to re-fix your slop is lower than paying someone to do it properly.
Early_Rooster7579@reddit
I feel similar. I’ve worked at mostly places with pretty high barriers to entry. I would consider some of my teammates easily in the top 10% of all programmers if not higher. Lots of okayish code is running in production in the biggest places in the world. You guys should see what instagram looks like under the hood lol
Leading_Yoghurt_5323@reddit
you’re not missing much. “vibe coding” is useful for speed, but people keep pretending speed and understanding are the same thing when they clearly aren’t
valence_engineer@reddit
You are paid by a company to generate them money. Code does not make money. Code is a means of making money. Business efficiency is as always about cutting out the middleman. In this case that's code.
Early_Rooster7579@reddit
Realest take in here. I always wonder where these people work that spending so much time on artisanal code would fly
dbgtboi@reddit
I'm guessing unemployed lol
AI metrics are tracked where I work and if your token usage is low they basically said you will be fired in the next performance cycle
We were even told to check our own metrics out and make sure the usage is there, because you don't want to get caught up in a layoff when they axe the people at the bottom of the token leaderboard
frankster@reddit
It's worth thinking about why humans learn these weird computer languages to better communicate with computers.
Regardless of your opinion on vibecoding or the effectiveness of llm agents, it should be possible to entertain the possibility that humans might be more effective communicating in human language than in a weird computer language. But at the same time, we might also entertain that humans learning to think more like computers is more effective than computers guessing about imprecision in human computation, making weird computer languages more effective for specifying software than human language.
For now, I'm undecided.
hitanthrope@reddit
When I watched Peter Steinberger on Lex Friedman (which I thought was an excellent interview by the way), he said something that I thought was really interesting. He considers, "vibe coding" a slur, and prefers, "agentic engineering".
I do too. Actually, I think Peter may have slightly misspoke, because to suggest it is a slur suggests it's being used as an unpleasant synonym, but Peter also says, "Vibe coding is what I switch to at 2AM, and then in the morning I go back to agentic engineering to fix it all...". Show of hands? ;)
Here's the bottom line though. This shit is going precisely nowhere. It's here and it will forever be here. Nobody, every again, is going to build any large, complicated system entirely by hand. We can mourn it, we can say "we were there". It must have been love....
If, you want to find a little solace in this, I will give you my best shot, with nearly 30 years under my belt....
Quite a few of these "vibe coded" apps and services are going to take off, and the founders, investors, and bean counters... are going to quickly find they need some "agentic engineers" to take the project forward.
Sharpen those axes folks... this may well *not* be the end.
I have been doing quite a lot of this now, and what I am realising is that my absolute most effective way to work now is to *maximise* my time doing the part, that is hard, and that I do very well, which is reading, reviewing and approving complex technical plans. It's not that I don't write the code (as such), it's that I write it from a few hundred feet above where I used to write it.
By the time I hit "go" on a plan, I know exactly how the code will look. I just don't need to type it, I can start working on the next problem while it is being typed for me.
However... I am doing *more* of the stuff I am very qualified for... not less. Constant architecture and design work. I understand the software requirements that nobody else thinks to ask for. I know when it is time to take a step back and try another approach.
This technology is a *multiplier*.
What's happening right now is people with 0.01 software development skills have been given a 100x multiplication tool so all their shit is up to 1x standard. That 1x isn't going to be the standard for very long.
If you have greater than 0.01 software development skills. Sharpen your axes and sit back.... you will be needed again.
MasterHand3@reddit
The “kids” use and abuse the code agents. What you are missing as a self proclaimed senior, super coder is that you can use code agents as your own CHEAT CODE. If you understand the system design end to end, you can create the whole system by yourself. the only thing holding you back previously was the time it took to write all of the code.
Use code agents as your super power. Super seniors (myself) am worth 5x more bc I can the job of 5 people now. My salary doesn’t reflect 5x but it’s 2x the industry average. (Make Claude your bitch)
DowntownLizard@reddit
Lmao vibe coding goes brrr. Just get good honestly. In a lot of ways I dont care what the code looks like if it works. AI can just tell me what its doing or it can make a change to it. I dont have to maintain anything if I make sure we have solid tests and i test my work.
shifty303@reddit
I’ve always loved precise, clean and well planned code.
That said, code is a liability and a maintenance burden that used to also take a significant amount of time and effort to write. Now, code is still two of those things but can be written in a fraction of the time and when it’s well architected and reviewed you can achieve close to the same quality in a fraction of the time.
In the hands of a competent developer code is now disposable.
Reverend_Jones@reddit
Pretty much this. The only problem i’m seeing so far is incompetent developers from different fields that don’t know common pitfalls and consequentially introducing terrible code into the codebase. This is making it difficult on better architects and increasing PR workload for seniors. It’s also becoming much more challenging to snuff out the bullshitters. I do agree that it’s an overall improvement on my day-to-day though.
theorizable@reddit
The code is still deterministic. You can understand the mental model without actually writing the code. You can still do that. You just have to read the code.
You're missing what smart people can do with the LLMs. You're representing "hello world!" projects as emblematic of the broader ecosystem.
This post reads as someone who is deeply biased or is not an experienced dev.
mercival@reddit
Thanks for another Twitter post about AI.
Ok-Most6656@reddit
I am interested in their post. If you are not interested, you can skip it?
mercival@reddit
No. If we let this sub just becoming AI rants, this sub dies.
There's many other subs that this kind of AI rant is accepted.
This sub has for years being about substantial discussions for experienced devs.
Not "omg AI".
If you like this, and the OP does, why not discuss it somewhere more appropriate?
worst_protagonist@reddit
Code was always written based on imprecise and lousy human language. You just had more middlemen before
Imoa@reddit
That the value of a thing is not and never has been based wholly on the difficulty of making that thing. We buy furniture that we could make ourselves all the time. We pay for food we could cook at home all the time.
Prior to the spread of vibe coding people still wrote thousands of lines of garbage code and marketed poorly built garbage products. They’re just doing it on a faster turnaround at lower cost now. Quality and intelligent product design still differentiate themselves, vibe coding has just made it more apparent that “fast and okay” is more marketable than “slow but high quality” - which isn’t new, software development as a practice is just experiencing it more acutely now.
niveknyc@reddit
A completely new, informed, and totally unique take here.
FreeFortuna@reddit
Yes, and now all of us on Reddit know that OP only writes good code because they use a precise mental model of a deterministic mechanism.
micseydel@reddit
The kids aren't different, you're upset about misleading marketing aka >!capitalism!<.
Heavy-Focus-1964@reddit
why would you say something so controversial and yet so brave?
schmidtssss@reddit
DAE THINK THEYRE BETTER THAN EVERYONE RLSE!!?!??