Why all this hype around agent/vibe coding?

Similar, but with a much less involved setup. I have asked multiple models to do things with Ecto and it will hallucinate functions.

I have switched to improving the Phoenix generators for myself and that has saved me a lot of time and repetitive work. Now I know that a certain style will be adhered and the source of bugs is inspectable and fixable.

Claude started off well but I noticed it’s quite bad lately indeed. It outright hallucinates functions that don’t exist f.ex. when I casually asked it if there is a way to clamp a number between two values if we make a function that adds (or subtracts) a number to it, it said “use Enum.clamp”, lol. I only ask it superficial and short questions now.

“Vibe coding” is basically you giving instructions to an LLM to gradually evolve / create code, quickly checking the result (without putting almost any effort to it), running some tests and accepting the change, then do the same in a loop. The idea of the “vibe” word here is: you are not working very hard, in fact you are almost not working.

Link to Wikipedia.

Of course the terrible illusion here is that you’ll get good results. Some LLMs do give you good code. Most get confused easily.

This remains an issue. Partly solved by prompting to check every output with documentation. But even then AI comes up with bogus.

Sometimes it’s very good though. Let’s hope the ratio will improve.

Vibe coding is like swipe typing. If it works it’s great, if it doesn’t it slows you down more than you imagine and you always have to check the generated code yourself.

Oof, too close to home. To this day I refuse to type normally on a phone and insist on swipe typing. But I am already extremely sick of it… and of typing on phones. Not like we got any actual competition on smartphones, mind you, but I would have long ago went there if we did.

I have several successes with LLMs enabling and boosting me and yes that requires you to be a pedantic sonovabeech. I don’t mind though. I made very good money a while ago by being pedantic, and I keep winning in many situations by being so as well.

Us the good programmers, in this “AI” era, have only two things to do to not only remain relevant but to also start commanding even higher payments several years down the road:

1. Don’t give in to the temptation to outsource thinking to the really good models (DeepSeek, GeminiPro, Qwen3). Only use it as an educator, generator of boilerplate that will not make you a better programmer if you spend 3 hours typing it out painstakingly, and a discussion partner (tradeoffs, common wisdom and the like).
2. Not die. That’s right: “AI” makes the really good programmers even better, and the bad ones – even worse. We’ll win by merely staying alive.

Everybody is celebrating the death of programmers, but what I am seeing is that there will be need for them even more in a couple of years when the world wakes up from its sweet dreamy slumber and discovers how many “vibe coded” apps are in super crucial positions in society and even power.

And let’s not even mention EU’s re-militarization and their desire to stop being dependent on US infrastructure. How many jobs for highly qualified professionals will that create?

The future is looking pretty sweet for us.

I think this also comes down to selling shovels during a gold rush. anthropic, et al. don’t care about the stuff that comes out of their models as long as they can keep selling tokens.

Oh, absolutely. I am pretty sure every LLM company has some pretty smart folks who understand how detrimental can their products be for the society and even economics / politics at large – but they don’t care.

“It is difficult to get a man to understand something, when his salary depends upon his not understanding it.”

~ Upton Sinclair (allegedly)

I tend to agree completely with this and this is always a warning I issue to all beginners. If your plan is to master both the technology and the process of delivering reliable software in reasonable time, the only way to do that is by getting your hands dirty. LLMs will boost your output significantly when you are just starting out, however that is more or less the final ceiling of your performance, in 1-2 years you will be left behind in the dirt by the folk that decide to understand the problem fully before solving it.

I’ve worked some time ago (pretty much right when chatGPT was released) with a few developers that had about 2 years less experience than me and I was horrified at the end of the project. They were relying solely on prompts to do everything and while their performance was in some places better, the lack of direction and understatement of how the problem at hand can be approached made the project take longer than it would have if they were just not using the LLM. The main reason behind that is that they didn’t try to solve the problem but wanted the LLM to do that and the effect is that they introduced a lot of unnecessary external noise which made the process much longer and unnecessary complex.

Just like any other things, this is just a tool. Understanding when and where to use it is crucial, and most developers are simply horrible at assessing this. This dates from long ago and it’s no different if we speak about tools that came before it.

While I completely agree that we need to put food on the table, I would also say that the only way to win this is by not playing the game. I think we overestimate how important is the skill of writing fast code is, code should be considered a liability not an asset. A well solved problem will beat by at least a factor of 10x any kind of artificial boost, be it code generation or something else. I can say that this is certainly the case when it comes to elixir, there are countless small companies that can have 3-10 engineers over the lifetime of the company and are beating the competition to a pulp, and trust me those engineers spend less than 20% of their time writing code.

There is and always will be, but not for factory workers that are interested in typing code all day long. There is an extreme shortage of folk that can solve business problems and deliver a working solution, which is the hardest skill to learn and master (and will never be replaced by a LLM, as this is the tipping point where actual intelligence is required). I’ve personally had the luck to be thrown into the fire in starting and developing some amazing and complex products and I can say that I’ve failed miserably time after time to come with good solutions, however that taught me some of the most valuable lessons that made me see the profession of a developer as something different.

I think that the start of the gaming development industry symbolizes how being capable of solving problems is more important than anything else. I would highly recommend to watch Half-Life: 25th Anniversary Documentary, there is a point in that video where everyone points that most of the folk that worked on making the game were coming from other trades, they learned and created new tools and managed to deliver an amazing game.

Oh, a lot of business people are about to crash head-first into this reality, very soon, on a much bigger scale. Just you wait some few other months. I’ll be in the corner with

I do agree but we have to bring in some nuance here: if I became a full-blown businessman that can also code… why do I need employers again? I’ll blow them out of the water in their own business game. I will have all their abilities and connections and can code on top of that – and they can’t. They will have zero chance as my competition.

But that’s not what I am aiming at. I figured I’ll mostly stay in my tech area “corner” (a fairly huge corner, though, overlapping many other “corners”).

It’s absolutely crucial for a senior dev to be a half-businessman, half-customer-support-agent, half-salesman and a few other roles as well. When you talk with people on their own language, they warm up to you and give you more info and the whole process becomes smoother and with better outcomes for everyone.

But again… if I wanted to be an entrepreneur, then I would become one. I like coding. I agree we must never lose sight of the problems we are solving (and I don’t). But I still want most of my work to be the coding / programming, integrating with other systems, helping with Ops concerns etc. I have been a CTO and a VP of Eng in 3 places in total. Hated it like I hated very few other things in my life.

My 2 cents: I think there’s something to this vibe-coding There are many levels what people mean by it. And each level has its own probability of success.

Many folks understand vibe coding as - “I don’t need to know anything about programming and I’ll just one-shot my project with a single prompt”. Success probability? Roughly the same as hitting production on your first mix phx.new. Even if you use something mainstream for vibe-coding, like nodejs.

Then there is - “I don’t need to know anything about programming and I’ll just iterate with AI till I get it right”. This one is interesting. I think AI is capable to achieve something to test the idea.

Will it scale? No.
Will it be maintainable? Also no.
Will it impress investors if the idea is hot? Absolutely.

If your idea proves itself, you’ll either have investments or money to hire devs to build something decent and maintainable.
I don’t know much about the market of building MVPs, I imagine it involves outsourcing to countries with cheaper labor. But it’s still not cheap, especially if as a founder, you are investing your own money. Now you can do it yourself. That’s a serious shift for MVP economics. I imagine this will absolutely disrupt the MVP-for-hire industry.

And then there are people who: “I do know programming, and want to build something either for work or for myself”. I fall in this category.

At work I use AI for couple of things:

1. Help write documentation: code, tickets, internal documents.
2. Help write boilerplate code that is easily repeatable, based on some other parts of the existing code.
3. Build a throw-away prototype to demonstrate the concept.

All works pretty well.

And for my own projects I’ll add some more things:

1. Write HEEX markup with Tailwind. I can do it myself, but it will take me longer. Plus it’s a bit boring task for me. Claude does this exceptionally well and it’s super fast. The other day I asked it to fix dark mode. Worked after first try.
2. Generate assets like icons, logos, photos. It’s amazing how much money this saves. It’s basically free now. Used to cost me $$$ or my soul to stock photo sites, or beg my designer friends to help me.
3. Use AI to build an almost full featured demo. Just the frontend part of it, in order to understand myself better how it will behave. Before I needed to build it fully to only get disappointed that I don’t like it. Now I vibe with a fake frontend on v0.dev or lovable, click around, change my mind guilt-free.

I think that if you are in this camp - AI will only make you faster and better. You still need to code the parts that are important and interesting, boring repetitive parts will not slow you down, and on top of it - you will get extra things for free, like designs and validating a concept.

Another risk of going too far generating code with AI is to end up with a “system” that is surprising/hard to understand, and then, as a human, try to change, extend, or asses the security soundness of.