I can give you a concrete example since things sometimes can be so philosophical. The other day I needed a LIS code (Longest Increasing subsequence) with some very specific constraints. It would've honestly taken me a few hours to get it right as it's been a while I coded that kind of thing. I was able to generate the solution with o3 in around 10 minutes, with some back and forth. It wasn't one shot, but took me 2-3 iteration cycles. I was able to get highly performant code that worked for a very specific constraint. It used Fenwick trees (https://en.wikipedia.org/wiki/Fenwick_tree) which I honestly hadn't programmed myself before. It felt like a science fiction moment to me as the code certainly wasn't trivial. In fact I am pretty sure most senior programmers would fail at this task, let alone be fast at it.

As a professional programmer, I deal with 20 examples every day where using a quality LLM saved me significant time, sometimes hours per task. I still do manual surgery a bunch of times everyday but I see no need to write most functions anymore or do multi-file refactors myself. In a few weeks, you get very good at applying Cursor and all its various features intelligently, like an amazing pair programmer who has different strengths than you. I'll go so far as to say I wouldn't hire an engineer who isn't very adept at utilizing the latest LLMs. The difference is just so stark - it really is like science fiction.

Cursor is popular for a reason. Lot of incredible programmers still get incredible value out of it, it isn't just for vibe coding. Implying that Cursor can be a net negative to programmers based on an example is a lot of fear mongering.

If you choose to accept bad code, that's on you. But I am not seeing that in practice, especially if you learn how to give quality prompts with proper rules. You have to get good at prompts - there is no escaping that. Now programmers do suck at communicating sometimes and that might be an issue. But in my experience, it can write far higher quality code than most programmers if used correctly.

Curious. Do you write deterministic code? Because I don't think I can write the same code for any non-trivial task twice. Granted, I would probably remember which algorithm or design pattern I used before, and I can try and use the same methods, but you can also prompt that information to an LLM.

Another question: Can you hire software developers who write code in a deterministic way? If you give the same task to multiple developers with the same seniority level, do you always get the same output?

> "typing until you more or less get the outcome that you want”

For the record, I don't use LLMs for anything that is beyond auto-completion, but I think you are being unfair to them. They are actually pretty good at getting atomic tasks right when prompted properly.

The other hypotheses in this thread (e.g. that it's largely a matter of programming language) seem much more plausible.

LLMs will routinely generate code that uses non-existent APIs, and has subtle and not-so-subtle bugs. They will make useless suggestions, often leading me on the wrong path, or going in circles. The worst part is that they do so confidently and reassuringly. I.e. if I give any hint to what I think the issue might be, after spending time reviewing their non-working code, then the answer is almost certainly "You're right! Here's the fix..."—which either turns out to be that I was wrong and that wasn't the issue, or their fix ends up creating new issues. It's a huge waste of my time, which would be better spent by reading documentation and writing the code myself.

I suspect that vibe coding is popular with developers who don't bother reviewing the generated code, either due to inexperience or laziness. They will prompt their way into building something that on the surface does what they want, but will fail spectacularly in any scenario they didn't consider. Not to speak of the amount of security and other issues that would get flagged by an actual code review from an experienced human programmer.

Exactly. And not just a careless developer, but one intentionally doing so.

Recently [this project][1] made it to the front page and amassed quite a few upvotes, positive feedback, and GitHub stars. Yet anyone giving it a cursory look would be able to tell that it's AI-generated slop, that is completely unnecessary at best, and possible malware at worst.

Not only that, but the author[2] fired off several AI slop PRs to popular projects in a single day (May 12th), which is exactly the cheap DoS you mention. The author of cURL wrote about AI-generated bogus security reports last year[3], and the work they add to open source maintainers who are already stretched thin. So this is a real problem that most AI proponents are ignoring.

[1]: https://news.ycombinator.com/item?id=44009321

[2]: https://github.com/dipampaul17

[3]: https://daniel.haxx.se/blog/2024/01/02/the-i-in-llm-stands-f...

I review a lot, revert a lot, reevaluate my life choices at times, it’s like supervising a toddler with 20 years of experience. It definitely contains security issues at times, perhaps less obvious ones, but subtle and harder to detect ones (the issues move up the stack).

It’s almost never correct and shippable on the first go, but it still saves me and my team a lot of time on boilerplate and heavy lifting, and let us focus on creating value for customers. It’s still software engineering, just the actual coding part is much more productive (Coding has never been the main activity that software engineers spend most of their time on. They design, gather requirements, define scope, architect, plan, test, review, gather feedback, iterate, etc. Now they simply have more time to do these activities)