I recently set up a local llm to see what the fuss is about and other than the few ringer solutions my experience is as you described. 2min promping, 5min waiting, 3hrs debugging or just doing it myself.

I am very likely doing it wrong, and it does speed up some aspects, but I wouldn't say I trust llm code any more than my own. Until it runs and throws an error, the llm is 100% confident that it has written perfect code.

But these days, AI just generates code following the existing patterns of the codebase. In the past, staring at a blank screen meant going through a checklist of things to design—starting from policies and writing everything down step by step. Now, I just ask AI and it gives me a template—which is great. Then if the AI makes a mistake, I fix it manually.

Of course, I still hand-code sometimes—but only in the areas I enjoy. Most of the time, I use AI coding. Both are fun, and they complement each other in interesting ways. Doing both together is actually enjoyable.

Is this sarcasm?

Skill/Hook usage rates, budget spend, auto-approval rate, focus area heatmaps, MTTR, MTTD are all there now

Even that's hard. There aren't enough signals to attribute changes directly to AI, so these apps seem to correlate the signal that the user was interacting with AI to the changes they made e.g "Bob used AI at that time, and they opened a PR at a similar time, so Bob probably used AI to make that PR."

Until the tooling for gathering data on AI usage improves the data will be fairly interesting because correlations often point to something related, but won't be a source of truth.

who is winning here? lol

My guess is some will jump up (where the team has managed to make themselves move effective and responsive) and many will plummet (doesn't need explaining).

Then there might be something to look at.

It reminds me of matt levine's reframing of insider trading where it's not about fairness it's about theft. You're supposed to get secret insights and use them to get an edge. What you can't do is get an edge for yourself with secret insights that your employer got.

So it roughly comes down to "that data is valuable and rightfully belongs to the originating company." Which then makes this a contract diligence type situation.

I’ve kind of changed my mind on prompting, it’s definitely a skill. It’s a skill based on your own skills in the domain. I’m at the point where I can get the LLM to generate the same code (roughly speaking) that I would have written. So it’s basically generating the same thing I would write, just faster. So it’s like reading your own code. Using it as a crutch to do things you aren’t capable of is where people run into trouble. That’s where the massive amounts of code review come into play. For me, I’m only ever reviewing 100-300 loc changes at a time. Often less. Because I know what I’m doing and can break things down into manageable diffs.

Can’t see myself going back, but also can’t see myself doing it without the experience I have without LLMs. Which is a bit of an issue for new developers. Not sure what the solution is for that.

For hobby projects or things I start casually, I usually do not think about errors and such at all. When it is a tool I want to build or need for myself, I really do not care about that part.

In my case, I do not contribute to open source at all. Mostly, I deliver code for factory systems or specific companies, and usually, there are strict enterprise requirements. (To be precise, there is always that mandatory code the lead developer on their end dictates, right?) That kind of code is mostly no fun, but it has to meet their requirements and often clashes with my own style. Having AI write that code for me is a huge relief.

In that sense, I think it is just a difference in personality and preferences. I originally became a programmer because I wanted to make games. I started programming because I found it fascinating to see things drawn and displayed on the screen. Becoming a programmer was all because making Flash games was so much fun... So in that regard, for me, writing code is just 'drawing what I want on the screen', which is why I guess I do not mind if the code is written by AI.

When I contribute to other people's projects, I do not use AI for anything other than English translation, but for my own projects, I have no hesitation.

Is this really just a difference in inclination? It is not that I did not enjoy writing code, but rather that seeing what I want rendered on the screen brings me more joy.

When the concept of 'vibe coding' first came out, I really hated it (since my knowledge was earned over 4 to 5 years of getting scolded by lead developers as a subcontractor and factory software provider). But thinking about it, what I really wanted to do as a developer was just to build the worlds I envisioned, so I decided not to let it bother me too much.

We talk often here on HN, and I really enjoy debating with you. I learn a lot from you.Mr."skydhash", I actually remember you quite often, and I even steal a few keywords from your posts sometimes. Because we have different tendencies, we occasionally clash, but having these conversations is exactly what makes it enjoyable.

Thank you for always replying. Have a great day, and I hope this does not offend you in any way.

I always enjoyed writing code and I am very good at writing very performant and elegant code, but it would sometimes come at the detriment of focusing on the code and not the design.

It used to be that one person had one to three codebases they knew intensely at my company. If you needed a bug in codebase X fixed, person Y was the one to do it and if they aren't available, person Z can do it, just not as quickly.

Now every person on my team has to handle tickets for every single codebase. There are about two dozen different large codebases involved here.

It's a ludicrous antipattern because person Y still needs to review the PR that person A generated for codebase X, and it will take them about as much time to wrangle the 2000 line PR (oh boy do LLMs love their mocks for unit tests) as it would have been for them to do the 50 line code change.

On top of that, it has "allowed" us to add feature after feature onto codebases not designed for them without refactoring. Is it good that this Flask API went from a purpose built service that interacted with the data analytics for product A stored in database X, and now our sales guys can sell product B, C, and D stored in database X? Uh, I'm sure it's great for them. Oh, and now it all can be stored in database X, Y, or Z depending on what the customer wants or what sales promised them. Great. Now I'm looking at a Flask app.py that's 12,000 lines of repeated code.

It has allowed poor designs to still produce working code. For a while. We seem to be getting a lot of bugs lately that look really bad to customers because it's for really simple shit. And I can't help but notice that happening to all the various products and sites I use too...

This sounds possible but how can we know? It could just as well correlate. Effort of all kinds correlates with success even when it's not obvious or not... linear.

AI has created a generation of 0.125x engineers.

I don't think this is reasonable given how abusive the pro-AI rhetoric has been for years now.

I've been tinkering with things since a very young age, started learning about computers in middle school and really started with programming in college (I had the basics since high school, but I was interested more in 3D modeling). So writing code is more like tinkering for me and I don't really particularly care about the result other than making it happen (correctly). Once it's done, it's no longer a subject of intellectual interest.

So the joy of creating a program is in the creation itself. Once it's done I merely use it (or maintain it if it's part of the work).

I don't condemn AI use, even when doing vibe coding. My main issue is with the hypers stating that it's ok to lower a codebase quality or encouraging recklessness (and the dubious anecdotes) in a collaborative settings. If you can ensure quality and collaborate easily with your colleagues, go ahead. If you can't, then you shouldn't send PRs around.

> Thank you for always replying. Have a great day, and I hope this does not offend you in any way.

Have a great day too. I always appreciate the different point of views on a subject. It's a big world and everyone has their own perspectives.

Very few businesses can accurately attribute customer value to the work they do, especially once they're passed start-up scale. A mature company makes lots of small changes and they're rarely measurable.

I cannot express strongly enough how much I'd rather work with you than with someone writing a 1000-word essay on how AI code generation is actually good enough this time.

I think this is exactly why our differences emerge.

I rarely collaborate with colleagues. In contract delivery work, that is simply how things operate. Usually, after the architecture is divided into modules, I take on the role of implementing one entire area from start to finish. Because of this, I actually have almost no experience with direct code level collaboration.

While multiple developers typically share a single code base and constantly exchange PRs, I take full responsibility for the internal implementation within the designed I/O interfaces, which seems to be where our divergence stems from.

When the modules are finally integrated, it only becomes a matter of accountability. In that sense, aside from my own website, I might not actually be doing any sustainable development. To be honest, as you know if you try AI vibe coding, the AI's abstraction and my abstraction are different. Because I am not used to its structure, it is not easy for me to manually fix the code generated by AI. Even if I do fix it, I mostly just tweak the surface level. In that regard, I completely agree that there are valid concerns regarding long term maintenance. However, since meeting strict deadlines and ensuring the required behavior are more important to me than long term maintainability, I tend to be more lenient toward AI generation.

It seems we reached different conclusions because we operate in completely different domains. It is always fascinating to see how perspectives differ depending on the field when having these conversations. Have a nice day.

I’m not anywhere close to an AI booster but I find value in it. I think we should think of it less like some intelligent being or “agent” and more as a code generation tool. It would both be more productive and healthier.

Do you have any users? Is the software important? I'd find a new job if I were you

> On top of that, it has "allowed" us to add feature after feature onto codebases not designed for them without refactoring. Is it good that this Flask API went from a purpose built service that interacted with the data analytics for product A stored in database X, and now our sales guys can sell product B, C, and D stored in database X? Uh, I'm sure it's great for them. Oh, and now it all can be stored in database X, Y, or Z depending on what the customer wants or what sales promised them. Great. Now I'm looking at a Flask app.py that's 12,000 lines of repeated code.

This is terrifying to me. I'm sorry.

>This sounds possible but how can we know?

If usage correlated with ROI, we would never stop hearing about it from the big AI firms.

The fact is that a bunch of marks and rubes got suckered into buying snake oil.

If you make an effort to use the new tools effectively, the gains are wild. Don't fall into a grumpy luddite trap, the train is leaving the station and you'll struggle to catch up if you don't learn and grow.

Not using AI for software development in 2027 will be like only knowing how to program via punchcard in 2010.

It's new. It's different. It's hard. It's your job. Learn how to use it effectively, embrace the new abundance mindset.

I look at my colleagues' screens and they're prompting shit like 'restart this program' and 'is [service] running correctly'. I have below average prompt frequency because I know crazy shit like #!/bin/bash and ps aux. It's so goddamn insane.

And to top it all off, my token count is above the average, it's just the prompt count that is low. Got questioned about it earlier this week.

If that's true things are truly hopeless for pre-school/school children who are not in position to jump on the train just yet.

I think AI made everyone so dumb that I'm a 10x engineer now.

The key question is how much value has been delivered on the other end for a given cost. Well used, tokens would be cheap at 10x the price right now.

I couldn't agree more. These AI users go on and on about "tooling" but would never take a week to learn how to use vim. These people are addicts. Don't take their words at face value. They are dependent on AI code generation.