I build accounting automation tools and this resonates hard. The codebase has ~60 backend services handling things like pattern matching, VAT classification, invoice reconciliation - stuff where a subtle bug doesn't crash anything, it just silently posts the wrong number to someone's accounts.<p>Vibe coding would be catastrophic here. Not because the AI can't write the code - it usually can - but because the failure mode is invisible. A hallucinated edge case in a tax calculation doesn't throw an error. It just produces a slightly wrong number that gets posted to a real accounting platform and nobody notices until the accountant does their review.<p>Where I've found AI genuinely useful is as a sophisticated autocomplete. I write the architecture, define the interfaces, handle the domain logic myself. Then I'll use it to fill in boilerplate, write test scaffolding, or explore an API I'm not familiar with. The moment I hand it the steering wheel on anything domain-specific, things go sideways fast.<p>The article's point about understanding your codebase is spot on. When something breaks at 2am in production, "the AI wrote that part" isn't an answer. You need to be able to trace through the logic yourself.
I don't know this feels extremely wrong I've put out more things (including open source for the first time in a long time) that I still feel proud of since at the end of the way I manually review everything and fix whatever I don't like.<p>But I think this only works is because I have a decade of experience in basically every field in the programming space and I had to learn it all without AI. I know exactly what I want from AI where opus 4.6 and codex 5.3 understands that and executes on it faster than I could ever write.
I think it all boils down to, which is higher risk, using AI too much, or using AI too little?<p>Right now I see the former as being hugely risky. Hallucinated bugs, coaxed into dead-end architectures, security concerns, not being familiar with the code when a bug shows up in production, less sense of ownership, less hands-on learning, etc. This is true both at the personal level and at the business level. (And astounding that CEOs haven't made that connection yet).<p>The latter, you may be less productive than optimal, but might the hands-on training and fundamental understanding of the codebase make up for it in the long run?<p>Additionally, I personally find my best ideas often happen when knee deep in some codebase, hitting some weird edge case that doesn't fit, that would probably never come up if I was just reviewing an already-completed PR.
It's very interesting to me how many people presume that if you don't learn how to vibecode now you'll never ever be able to catch up. If the models are constantly getting better, won't these tools be <i>easier</i> to use a year from now? Will model improvements not obviate all the byzantine prompting strategies we have to use today?
A good analogy might be synthesized music.<p>In the early days, the interfaces were so complex and technical, that only engineers could use them.<p>Some of these early musicians were truly amazing individuals; real renaissance people. They understood the theory, and had true artistic vision. The knew how to ride the tiger, and could develop great music, fairly efficiently.<p>A lot of others, not so much. They twiddled knobs at random, and spent a lot of effort, panning for gold dust. Sometimes, they would have a hit, but they wasted a lot of energy on dead ends.<p>Once the UI improved (like the release of the Korg M1 sampler), then real artists could enter the fray, and that’s when the hockey stick bent.<p>Not exactly sure what AI’s Korg M1 will be, but I don’t think we’re there, yet.
I think we are. I'm helping somebody who has a non-technical background and taught himself how to vibe code and built a thing. The code is split into two GitHub repos when it should have been one, and one of the repos is named hetzner-something because that's what he's using and he "doesn't really understand tech shit"
I do think that there's some meta-skills involved here that are useful, in the same way that some people have good "Google-fu". Some of it is portable, some of it isn't.<p>I think if you orient your experimentation right you can think of some good tactics that are helpful even when you're not using AI assistance. "Making this easier for the robot" can often align with "making this easier for the humans" as well. It's a decent forcing function<p>Though I agree with the sentiment. People who have been doing this for less than a year convinced that they have some permanent lead over everyone.<p>I think a lot about my years being self taught programming. Years spent spinning my wheels. I know people who after 3 months of a coding bootcamp were much further than me after like ... 6 years of me struggling through material.
> in the same way that some people have good "Google-fu"<p>or, perhaps, in the same way that google-fu over time became devalued as a skill as Google became less useful for power users in order to cater to the needs of the unskilled, it will not really be a portable skill at all, because it is in the end a transitory or perhaps easily attainable skill once the technology is evenly distributed.
Are the early tricks for LLMs still useful today?
It's hilarious. The whole point of "vibe coding" is that you don't need to learn or know anything.<p>It's like saying if you don't learn to use a smartphone you'll be left behind. Even babies can use it now.
That's another dumb thing that unfortunately some people can be led to believe. There have been parents who genuinely thought that screen time would make their kids digitally savvy and prepared for the future.
It has worked out quite well for some of them, but there's a lot of devil in the details of the implementation of that screentime that led to eg Mark Zuckerberg vs Markiplier.
Leave them with an old Toshiba and an Ubuntu cd. Good luck kid.
I do think there's value in trying out fully vibe coding some toy projects today (probably nothing real or security sensitive haha).<p>The AI will get better at compensating, but I think some of it's weaknesses are fundamental, and are going to be showing up in some form or another for a while yet<p>Ex, the AI doesn't know about what you don't tell it. There's a LOT of context we take for granted while programming (especially in a corporate environment). Recognizing what sort of context is useful to give the AI without distracting it (and under what conditions it should load/forget context), I think is going to be a very valuable skill over the next few years. That's a skill you can start building now
Even if that were true you'd still need to be good at UX
I think so, that's why I think that the risk of pretty much ignoring the space is close to zero. If I happen to be catastrophically wrong about everything then any AI skills I would've learned today will be completely useless 5 years from now anyway, just like skills from early days of ChatGPT are completely useless today.
I think there's something to this, but I also there there's something to the notion that it'll get easier and easier to do mass-market work with them, but at the same time they'll become greater and greater force multipliers for more and more nuanced power users.<p>It is strange because the tech now moves <i>much</i> faster than the development of human expertise. Nobody on earth achieved Sonnet 3.5 mastery, in the 10k hours sense, because the model didn't exist long enough.<p>Prior intuitions about skill development, and indeed prior scientifically based best practices, do not cleanly apply.
I think the AI-coding skill that is likely to remain useful is the ability (and discipline) to review and genuinely understand the code produced by the AI before committing it.<p>I don't have that skill; I find that if I'm using AI, I'm strongly drawn toward the lazy approach. At the moment, the only way for me to actually understand the code I'm producing is to write it all myself. (That puts my brain into an active coding/puzzle solving state, rather than a passive energy-saving state.)<p>If I could have the best of both worlds, that would be a genuine win, and I don't think it's impossible. It won't save as much time as pure vibe coding promises to, of course.
> I think the AI-coding skill that is likely to remain useful is the ability (and discipline) to review and genuinely understand the code produced by the AI before committing it.<p>> I don't have that skill; I find that if I'm using AI, I'm strongly drawn toward the lazy approach. At the moment, the only way for me to actually understand the code I'm producing is to write it all myself. (That puts my brain into an active coding/puzzle solving state, rather than a passive energy-saving state.)<p>When I review code, I try to genuinely understand it, but it's a <i>huge</i> mental drain. It's just a slog, and I'm tired at the end. Very little flow state.<p>Writing code can get me into a flow state.<p>That's why I pretty much only use LLMs to vibecode one-off scripts and do code reviews (after my own manual review, to see if it can catch something I missed). Anything more would be too exhausting.
I've had reasonable results from using AI to analyse code ("convert this code into a method call graph in graphml format" or similar). Apart from hallucinating one of the edges, this worked reasonably well to throw this into yED and give me a view on the code.<p>An alternative that occurred to me the other day is, could a PR be broken down into separate changes? As in, break it into a) a commit renaming a variable b) another commit making the functional change c) ...<p>Feel like there are PR analysis tools out there already for this :)
Don't you think automated evaluation and testing of code is likely to improve at an equally breakneck pace? It doesn't seem very far-fetched to soon have a simulated human that understands software from a user perspective.
The image generation side of the story is the prophecy.<p>I can confidently say that being able to prompt and train LoRAs for Stable Diffusion makes zero difference for your ability to prompt Nano Banana.
And most artists using the tools are still training LoRAs for Flux, Qwen, ZIT/ZIB, etc. Nano Banana is a useful tool, but not for the best work.
This is irrelevant to the point.<p>Using nano banana does not require arcane prompt engineering.<p>People who have not learnt image prompt engineering probably didn't miss anything.<p>The irony of prompt engineering is that models are good at generating prompts.<p>Future tools will almost certainly simply “improve” you naive prompt before passing it to the model.<p>Claude already does this for code. Id be amazed if nano banana doesnt.<p>People who invested in learning prompt engineering probably picked up useful skills for <i>building ai tools</i> but not for using next gen ai tools other people make.<p>Its not wasted effort; its just increasingly irrelevant to people doing day-to-day BAU work.<p>If the api prevents you from passing a raw prompt to the model, prompt engineering at that level isnt just unnecessary; its irrelevant. Your prompt will be transformed into an unknown internal prompt before hitting the model.
> Claude already does this for code. Id be amazed if nano banana doesnt.<p>Nano Banana is actually a reasoning model so yeah it kinda does, but not in the way one might assume. If you use the api you can dump the text part and it's usually huge (and therefore expensive, which is one drawback of it. It can even have "imagery thinking" process...!)
Yup, this is why even though I like ai coding a lot, and am pretty enthusiastic about it, and have fun tinkering with it, and think it <i>will</i> stick around and become part of everyday proper software development practice (with guardrails in place), I at least don't go telling people they need to learn it now or they'll be obsolete or whatever. Sitting back and seeing how this all works out — nobody <i>really</i> knows imo, I could be wrong too! — is a valid choice and if ai does stick around you can just hop in when the landscape is clearer!
And if you can never catch up, how would someone new to the game ever be a meaningful player?
If you’ve never driven a model T, how would you ever drive a corolla? If you never did angular 1, how would you ever learn react? If you never used UNIX 4, you’ll be behind in Linux today. /s
Exactly. If it’s so easy (which is the point) then there’s no risk at all. Just pick it up if/when it’s definitely useful.
FOMO is hell of a drug.
That's my take. I know LLMs arent going away even if the bubble pops. I refuse to become a KPI in some PM's promotion to justify pushing this tech even further, so for now I don't use it (unless work mandates it).<p>Until then, I keep up and add my voice to the growing number who oppose this clear threat on worker rights. And when the bubble pops or when work mandates it, I can catch up in a week or two easy peasy. This shit is not hard, it is literally designed to be easy. In fact, everything I learn the old way between now and then will only add to the things I can leverage when I find myself using these things in the future.
Model improvement. But certainly also the cli tool itself. That's where all the planning takes place
Wait around five years and then prompt: "Vibe me Windows" and then install your smart new double glazed floor. There is definitely something useful happening in LLM land but it is not and will never be AGI.<p>Oooh, let me dive in with an analogy:<p>Screwdriver.<p>Metal screws needed inventing first - they augment or replace dowels, nails, glue, "joints" (think tenon/dovetail etc), nuts and bolts and many more fixings. Early screws were simply slotted. PH (Philips cross head) and PZ (Pozidrive) came rather later.<p>All of these require quite a lot of wrist effort. If you have ever screwed a few 100 screws in a session then you know it is quite an effort.<p>Drill driver.<p>I'm not talking about one of those electric screw driver thingies but say a De W or Maq or whatever jobbies. They will have a Li-ion battery and have a chuck capable of holding something like a 10mm shank, round or hex. It'll have around 15 torque settings, two or three speed settings, drill and hammer drill settings. Usually you have two - one to drill and one to drive. I have one that will seriously wrench your wrist if you allow it to. You need to know how to use your legs or whatever to block the handle from spinning when the torque gets a bit much.<p>...<p>You can use a modern drill driver to deploy a small screw (PZ1, 2.5mm) to a PZ3 20+cm effort. It can also drill with a long auger bit or hammer drill up to around 20mm and 400mm deep. All jolly exciting.<p>I still use an "old school" screwdriver or twenty. There are times when you need to feel the screw (without deploying an inadvertent double entendre).<p>I do find the new search engines very useful. I will always put up with some mild hallucinations to avoid social.microsoft and nerd.linux.bollocks and the like.
> I think it all boils down to, which is higher risk, using AI too much, or using AI too little?<p>This framing is exactly how lots of people in the industry are thinking about AI right now, but I think it's wrong.<p>The way to adopt new science, new technology, new anything really, has always been that you validate it for small use cases, then expand usage from there. Test on mice, test in clinical trials, then go to market. There's no need to speculate about "too much" or "too little" usage. The right amount of usage is knowable - it's the amount which you've validated will actually work for your use case, in your industry, for your product and business.<p>The fact that AI discourse has devolved into a Pascal's Wager is saddening to see. And when people frame it this way in earnest, 100% of the time they're trying to sell me something.
Those of us working from the bottom, looking up, do tend to take the clinical progressive approach. Our focus is on the next ticket.<p>My theory is that executives must be so focused on the future that they develop a (hopefully) rational FOMO. After all, missing some industry shaking phenomenon could mean death. If that FOMO is justified then they've saved the company. If it's not, then maybe the budget suffers but the company survives. Unless of course they bet too hard on a fad, and the company may go down in flames or be eclipsed by competitors.<p>Ideally there is a healthy tension between future looking bets and on-the-ground performance of new tools, techniques, etc.
>must be so focused on the future<p>They're focused no the short-term future, not the long-term future. So if everyone else adopts AI but you don't and the stock price suffers because of that (merely because of the "perception" that your company has fallen behind affecting market value), then that is an issue. There's no true long-term planning at play, otherwise you wouldn't have obvious copypcat behavior amongst CEOs such as pandemic overhiring.
Every company should have hired over the pandemic due to there being a higher EV than not hiring. It's like if someone offered an opportunity to pay $1000 for a 50% chance to make $8000, where the outcome is the same between everyone taking the offer. If you are maximizing for the long term everyone should take the offer even if it does result in a reality where everyone loses $1000.
To be fair, that's what I have done. I try to use AI every now and then for small, easy things. It isn't yet reliable for those things, and always makes mistakes I have to clean up. Therefore I'm not going to trust it with anything more complicated yet.
There is also opportunity cost. Most people ignore most things because there are simply not enough hours in a day.
We should separate doing science from adopting science.<p>Testing medical drugs is doing science. They test on mice because it's dangerous to test on humans, not to restrict scope to small increments. In doing science, you don't always want to be extremely cautious and incremental.<p>Trying to build a browser with 100 parallel agents is, in my view, doing science, more than adopting science. If they figure out that it can be done, then people will adopt it.<p>Trying to become a more productive engineer is adopting science, and your advice seems pretty solid here.
> Test on mice, test in clinical trials, then go to market.<p>You're neglecting the cost of testing and validation. This is the part that's quite famous for being <i>extremely expensive</i> and a major barrier to developing new therapies.
> my best ideas often happen when knee deep in some codebase<p>I notice that I get into this automatically during AI-assisted coding sessions if I don't lower my standards for the code. Eventually, I need to interact very closely with both the AI and the code, which feels similar to what you describe when coding manually.<p>I also notice I'm fresher because I'm not using many brainscycles to do legwork- so <i>maybe</i> I'm actually getting into <i>more</i> situations where I'm getting good ideas because I'm tackling hard problems.<p>So <i>maybe</i> the key to using AI and staying sharp is to refuse to sacrifice your good taste.
Even within AI coding how people use this varies wildly from one people trying to one shot apps to people being barely above tab completers.<p>When people talk about this stuff they usually mean very different techniques. And last months way of doing it goes away in favor of a new technique.<p>I think the best you can do now is try lots of different new ways of working keep an open mind
Yeah, it's frustrating that it seems most AI conversations devolve into straw men of either zero AI or one shot apps. There's a huge middle ground where I, and it seems like many others, have found AI very useful. We're still at the stage where it's somewhat unique for each person where AI can work for them (or not).
Or just wait for things to settle. As fast as the field is moving, staying ahead of the game is probably high investment with little return, as the things you spend a ton of time honing today may be obsolete tomorrow, or simply built into existing products with much lower learning cost.<p>Note, if staying on the bleeding edge is what excites you, by all means do. I'm just saying for people who don't feel that urge, there's probably no harm just waiting for stuff to standardize and slow down. Either approach is fine so long as you're pragmatic about it.
Very reasonable take. The fact that this is being downvoted really shows how poor HN's collective critical thinking has become. Silicon Valley is cannibalizing itself and it's pretty funny to watch from the outside with a clear head.
It definitely comes up if you're just reviewing an already-"completed" PR. Even if you're not going to ship AI-generated code to prod (and I think that's a reasonable choice), it's often informative to give a high-level description of what you want to accomplish to a coding agent and see what it does in your codebase. You might find that the AI covered a particular edge case that you would have missed. You might find that even if the PR as a whole is slop.
This is basically Pascal’s wager. However, unlike the original Pascal’s wager, yours actually sounds sound.<p>Another good alike wager I remember is: <i>“What if climate change is a hoax, and we invested in all this clean energy infrastructure for nothing”</i>.
Interesting analogy, but I'd say it's kind of the opposite. In the two you mentioned, the cost of inaction is extremely high, so they reach one conclusion, whereas here the argument is that the cost of inaction is pretty low, and reaches the opposite conclusion.
> I think it all boils down to, which is higher risk, using AI too much, or using AI too little?<p>It's both. It's using the AI too much to <i>code</i>, and too little to write <i>detailed plans</i> of what you're going to code. The planning stage is by far the easiest to fix if the AI goes off track (it's just writing some notes in plain English) so there is a slot-machine-like intermittent reinforcement to it ("will it get everything right with one shot?") but it's quite benign by comparison with trying to audit and fix slop code.
> you may be less productive than optimal<p>There is zero evidence that LLM's improve software developer productivity.<p>Any data-driven attempts to measure this give ambivalent results at best.
Even if you believe that many are too far on one side now, you have to account for the fact that AI will get better rapidly. If you're not using it now you may end up lacking preparation when it becomes more valuable
> If you're not using it now you may end up lacking preparation when it becomes more valuable<p>How's that? If it ever gets good, it seems rather implausible that today's tool-of-the-month will turn out to be the winner.
But as it gets better, it'll also get easier, be built into existing products you already use, etc. So I wouldn't worry too much about that aspect. If you enjoy tinkering, or really want to dive deep into fundamentals, that's one thing, but I wouldn't worry too much about "learning to use some tool", as fast as things are changing.
I don't think so. That's a good point but the capability has been outpacing people's ability to use it for a while and that will continue.<p>Put another way, the ability to use AI became an important factor in overall software engineering ability this year, and as the year goes on the gap between the best and worst users or AI will widen faster because the models will outpace the harnesses
That’s the comical understanding being pushed by management in software companies yes. The people who never actually use the tools themselves, but the concept of it. It’s the same AGI nonesense, but dumped down to something they think they can control.
> Put another way, the ability to use AI became an important factor in overall software engineering ability this year, and as the year goes on the gap between the best and worst users or AI will widen faster because the models will outpace the harnesses<p>Is it, lol? Know any case where those “the best users of AI” get salary bumps or promotions? Outside of switching to the dedicated AI role that is? So far I see clowns doing triple the work for the same salary.
I mean if the capacity has outpaced people's ability to use it, to me that's a good sign that a lot of the future improvements will be making it easier to use.
I mean, right now "bleeding edge" is an autonomous agents system that spends a million dollars making an unbelievably bad browser prototype in a week. Very high effort and the results are jibberish. By the time these sorts of things are actually reliable, they'll be productized single-click installer apps on your network server, with a simple web interface to manage them.<p>If you just mean, "hey you should learn to use the latest version of Claude Code", sure.
The baseline, out-of-the-box basic tool level will lift, but so will the more obscure esoteric high-level tools that the better programmers will learn to control, further separating themselves in ability from the people who wait for the lowest common denominator to do their job for them.
Maybe. But so far ime most of the esoteric tools in the AI space are esoteric because they're not very good. When something gets good, it's quickly commoditized.<p>Until coding systems are truly at human-replacement level, I think I'd always prefer to hire an engineer with strong manual coding skills than one who specializes in vibe coding. It's far easier to teach AI tools to a good coder than to teach coding discipline to a vibe coder.
> If you're not using it now you may end up lacking preparation when it becomes more valuable<p>You think it's going to get harder to use as time goes on?
> you have to account for the fact that AI will get better rapidly<p>that's nowhere near guaranteed
Even if the models stopped getting better today, we'd still see many years of improvements from improving harnesses and understanding of how to use them. Most people just talk to their agent, and don't e.g. use sub-agents to make the agent iterate and cross-check outcomes for example. Most people who use AI would see a drastic improvement in outcomes just by experimenting with the "/agents" command in Claude Code (and equivalent elsewhere). Much more so with a well thought out agent framework.<p>A simple plan -> task breakdown + test plan -> execute -> review -> revise (w/optional loops) pipeline of agents will drastically cut down on the amount of manual intervention needed, but most people jump straight to the execute step, and do that step manually, task by task while babysitting their agent.
Nothing gets worse in computers. Name me one thing. And if the current output quality of LLM stays the same but speed goes up 1000, quality of the generated code can be higher.
Software has gotten considerably worse with time. Windows and MacOS are basically in senescence from my point of view. Haven't added a feature I've wanted in years, but manages to make my experience worse year to year anyways.<p>CPU vulnerability mitigations make my computer slower than when I bought it.<p>Computers and laptops are increasingly not repairable. So much ewaste is forced on us for profit.<p>The internet is a corporate controlled prison now. Political actors create fake online accounts to astroturf, manipulate, and influence us.<p>The increasing cost of memory and GPU make computers no longer affordable.
Windows
Hot keys. Used to be, you could drive a program from the keyboard with hotkeys and macros. No mouse. The function keys did functions. You could drive the interface blindfolded, once you learned it. Speed is another one. Why does VSCode take so long to open? and use so much memory and CPU? it's got a lot of features for a text editor, but it's worse than vim/emacs in a lot of ways.<p>Boot time.<p>Understandability. A Z80 processor was a lot more understandable than today's modern CPUs. That's worse.<p>Complexity. It's great that I can run python on a microcontroller and all, but boring old c was a lot easier to reason about.<p>Wtf is a typescript. CSS is the fucking worst. Native GUI libraries are so much better but we decided those aren't cool anymore.<p>Touchscreens. I want physical buttons that my muscle memory can take over and get ingrained in and on. Like an old stick shift car that you have mechanical empathy with. Smartphones are convenient as all hell, but I can't drive mine after a decade like you can a car you know and feel, that has physical levers and knobs and buttons.<p>Jabber/Pidgin/XMPP. There was a brief moment around 2010? when you didn't have to care what platform someone else was using, you could just text with them on one app. Now I've got a dozen different apps I need to use to talk to all of my friends. Beeper gets it, but they're hamstrung. This is a thing that got worse with computers!<p>Ever hear of wirths law?
<a href="https://en.wikipedia.org/wiki/Wirth%27s_law" rel="nofollow">https://en.wikipedia.org/wiki/Wirth%27s_law</a><p>Computers are stupid fast these days! why does it take so long to do everything on my laptop? my mac's spotlight index is broken, so it takes it roughly 4 seconds to query the SQLite database or whatever just so I can open preview.app. I can open a terminal and open it myself in that time!<p>And yes, these are personal problems, but I have these problems. How did the software get into such a state that it's possible for me to have this problem?
Why should I worry about lacking preparation in the future? Why can't I just learn this as any other skill at any other time?
The bit about "we have automated coding, but not software engineering" matches my experience. LLMs are good at writing individual functions but terrible at deciding which functions should exist.<p>My project has a C++ matching engine, Node.js orchestration, Python for ML inference, and a JS frontend. No LLM suggested that architecture - it came from hitting real bottlenecks. The LLMs helped write a lot of the implementation once I knew what shape it needed to be.<p>Where I've found AI most dangerous is the "dark flow" the article describes. I caught myself approving a generated function that looked correct but had a subtle fallback to rate-matching instead of explicit code mapping. Two different tax codes both had an effective rate of 0, so the rate-match picked the wrong one every time. That kind of domain bug won't get caught by an LLM because it doesn't understand your data model.<p>Architecture decisions and domain knowledge are still entirely on you. The typing is faster though.
> LLMs are good at writing individual functions but terrible at deciding which functions should exist.<p>Have you tried explicitly <i>asking</i> them about the latter? If you just tell them to code, they aren't going to work on figuring out the software engineering part: it's not part of the goal that was directly reinforced by the prompt. They aren't really all that smart.
> Architecture decisions and domain knowledge are still entirely on you. The typing is faster though.<p>Also, it prevents repetitive strain injury. At least, it does for me.
> However, it is important to ask if you want to stop investing in your own skills because of a speculative prediction made by an AI researcher or tech CEO.<p>I don't think these are exclusive. Almost a year ago, I wrote a blog post about this [0]. I spent the time since then <i>both</i> learning better software design and learning to vibe code. I've worked through <i>Domain-Driven Design Distilled</i>, <i>Domain-Driven Design</i>, <i>Implementing Domain-Driven Design</i>, <i>Design Patterns</i>, <i>The Art of Agile Software Development, 2nd Edition</i>, <i>Clean Architecture</i>, <i>Smalltalk Best Practice Patterns</i>, and <i>Tidy First?</i>. I'm a far better software engineer than I was in 2024. I've also vibe coded [1] a whole lot of software [2], some good and some bad [3].<p>You can choose to grow in both areas.<p>[0]: <a href="https://kerrick.blog/articles/2025/kerricks-wager/" rel="nofollow">https://kerrick.blog/articles/2025/kerricks-wager/</a><p>[1]: As defined in <i>Vibe Coding</i>: <i>Building Production-Grade Software With GenAI, Chat, Agents, and Beyond</i> by Gene Kim and Steve Yegge, wherein you still take responsibility for the code you deliver.<p>[2]: <a href="https://news.ycombinator.com/item?id=46702093">https://news.ycombinator.com/item?id=46702093</a><p>[3]: <a href="https://news.ycombinator.com/item?id=46719500">https://news.ycombinator.com/item?id=46719500</a>
I personally found out that knowing how to use ai coding assistants productively is a skill like any other and a) it requires a significant investment of time b) can be quite rewarding to learn just as any other skill c) might be useful now or in the future and d) doesn't negate the usefulness of any other skills acquired on the past nor diminishes the usefulness of learning new skills in the future
Agreed, my experience and code quality with claude code and agentic workflows has dramatically increased since investing in learning how to properly use these tools. Ralph Wiggum based approaches and HumanLayer's agents/commands (in their .claude/) have boosted my productivity the most. <a href="https://github.com/snwfdhmp/awesome-ralph" rel="nofollow">https://github.com/snwfdhmp/awesome-ralph</a> <a href="https://github.com/humanlayer" rel="nofollow">https://github.com/humanlayer</a>
On the using AI assistants I find that everything is moving so fast that I feel constantly like "I'm doing this wrong". Is the answer simply "dedicate time to experimenting? I keep hearing "spec driven design" or "Ralph" maybe I should learn those? Genuine thoughts and questions btw.
More specifically regarding spec-driven development:<p>There's a good reason that most successful examples of those tools like openspec are to-do apps etc. As soon as the project grows to 'relevant' size of complexity, maintaining specs is just as hard as whatever other methodology offers. Also from my brief attempts - similar to human based coding, we actually do quite well with incomplete specs. So do agents, but they'll shrug at all the implicit things much more than humans do. So you'll see more flip-flopped things you did not specify, and if you nail everything down hard, the specs get unwieldy - large and overly detailed.
> if you nail everything down hard, the specs get unwieldy - large and overly detailed<p>That's a rather short-sighted way of putting it. There's no way that the spec is anywhere as unwieldly as the actual code, and the more details, the better. If it gets too large, work on splitting a self-contained subset of it to a separate document.
> There's no way that the spec is anywhere as unwieldly as the actual code, and the more details, the better.<p>I disagree - the spec is <i>more</i> unwieldy, simply by the fact of using ambiguous language without even the benefit of a type checker or compiler to verify that the language has no ambiguities.
Everybody feels like this, and I think nobody stays ahead of the curve for a prolonged time. There's just too many wrinkles.<p>But also, you don't have to upgrade every iteration. I think it's absolutely worthwhile to step off the hamster wheel every now and then, just work with you head down for a while and come back after a few weeks. One notices that even though the world didn't stop spinning, you didn't get the whiplash of every rotation.
I think find what works for you, and everything else is kind of noise.<p>At the end of the day, it doesn’t matter if a cat is black or white so long as it catches mice.<p>——<p>Ive also found that picking something and learning about it helps me with mental models for picking up other paradigms later, similar to how learning Java doesn’t actually prevent you from say picking up Python or Javascript
I don’t think Ralph is worthwhile, at least the few times I’ve tried to set it up I spent more time fighting to get the configuration right than if I had simply run the prompt. Coworkers had similar experiences, it’s better to set a good allowlist for Claude.
The addictive nature of the technology persists though. So even if we say certain skills are required to use it, then also it must come with a warning label and avoided by people with addictive personalities/substance abuse issues etc.
It's addictive because of a hypothesis I have about addiction. I have no data to back it up other than knowing a lot of addicted people and I have studied neuroscience, yet I still think there's something to it. It's definitely not fully true though.<p>Addiction occurs because as humans we bond with people but we also bond with things. It could be an activity, a subject, anything. We get addicted because we're bonded to it. Usually this happens because we're not in fertile grounds to bond with what we need to bond with (usually a good group of friends).<p>When I look at addicted people a lot of them bond with people that have not so great values (big house, fast cars, designer clothing, etc.), adopt those values themselves and get addicted to drugs. This drugs is usually supplied by the people they bond with. However, they bond with those people in the first place because of being aimless and receiving little guidance in their upbringing.<p>I'm just saying all that to make it more concrete with what I mean about "good people".<p>Back to LLMs. A lot of us are bonding with it, even if we still perceive it as an AI. We're bonding with it because when it comes to certain emotional needs, they're not being fulfilled. Enter a computer that will listen endlessly to you and is intellectually smarter than most humans, albeit it makes very very dumb mistakes at times (like ordering +1000 drinks when you ask for a few).<p>That's where we're at right now.<p>I've noticed I'm bonded with it.<p>Oh, and to some who feel this opinion is a bit strong, it is. But consider that we used to joke that "Google is your best friend" when it just came out and long thereafter. I think there's something to this take but it's not fully in the right direction I think.
> knowing how to use ai coding assistants productively is a skill like any other<p>No, it's different from other skills in several ways.<p>For one, the difficulty of this skill is largely overstated. All it requires is basic natural language reading and writing, the ability to organize work and issue clear instructions, and some relatively simple technical knowledge about managing context effectively, knowing which tool to use for which task, and other minor details. This pales in comparison with the difficulty of learning a programming language and classical programming. After all, the entire point of these tools is to lower the required skill ceiling of tasks that were previously inaccessible to many people. The fact that millions of people are now using them, with varying degrees of success for various reasons, is a testament of this.<p>I would argue that the results depend far more on the user's familiarity with the domain than their skill level. Domain experts know how to ask the right questions, provide useful guidance, and can tell when the output is of poor quality or inaccurate. No amount of technical expertise will help you make these judgments if you're not familiar with the domain to begin with, which can only lead to poor results.<p>> might be useful now or in the future<p>How will this skill be useful in the future? Isn't the goal of the companies producing these tools to make them accessible to as many people as possible? If the technology continues to improve, won't it become easier to use, and be able to produce better output with less guidance?<p>It's amusing to me that people think this technology is another layer of abstraction, and that they can focus on "important" things while the machine works on the tedious details. Don't you see that this is simply a transition period, and that whatever work you're doing now, could eventually be done better/faster/cheaper by the same technology? The goal is to replace all cognitive work. Just because this is not entirely possible <i>today</i>, doesn't mean that it won't be tomorrow.<p>I'm of the opinion that this goal is unachievable with the current tech generation, and that the bubble will burst soon unless another breakthrough is reached. In the meantime, your own skills will continue to atrophy the more you rely on this tech, instead of on your own intellect.
> In the meantime, your own skills will continue to atrophy the more you rely on this tech, instead of on your own intellect<p>You’re right. I’m going back to writing assembly. These compilers have totally atrophied my ability to write machine code!
I'm doing a similar thing. Recently, I got $100 to spend on books. The first two books I got were <i>A Philosophy of Software Design</i>, and <i>Designing Data-Intensive Applications</i>, because I asked myself, out of all the technical and software engineering related books that I might get, given agentic coding works quite well now, what are the most high impact ones?<p>And it seemed pretty clear to me that they would have to do with the sort of evergreen, software engineering and architecture concepts that you still need a human to design and think through carefully today, because LLMs don't have the judgment and a high-level view for that, not the specific API surface area or syntax, etc., of particular frameworks, libraries, or languages, which LLMs, IDE completion, and online documentation mostly handle.<p>Especially since well-designed software systems, with deep and narrow module interface, maintainable and scalable architectures, well chosen underlying technologies, clear data flow, and so on, are all things that can vastly increase the effectiveness of an AI coding agent, because they mean that it needs less context to understand things, can reason more locally, etc.<p>To be clear, this is not about not understanding the paradigms, capabilities, or affordances of the tech stack you choose, either! The next books I plan to get are things like <i>Modern Operating Systems</i>, <i>Data-Oriented Design</i>, <i>Communicating Sequential Processes</i>, and <i>The Go Programming Language</i>, because low level concepts, too, are things you can <i>direct</i> an LLM to optimize, if you give it the algorithm, but which they won't do themselves very well, and are generally also evergreen and not subsumed in the "platform minutea" described above.<p>Likewise, stretching your brain with new paradigms — actor oriented, Smalltalk OOP, Haskell FP, Clojure FP, Lisp, etc — gives you new ways to conceptualize and express your algorithms and architectures, and to judge and refine the code your LLM produces, and ideas like BDD, PBT, lightweight formal methods (like model checking), etc, all provide direct tools for modeling your domain, specifying behavior, and testing it far better, which then allow you to use agentic coding tools with more safety or confidence (and a better feedback loop for them) — at the limit almost creating a way to program declaratively in executible specifications, and then convert those to code via LLM, and then test the latter against the former!
As someone with 20 years experience, DDD is a stupid idea, skip it and do yourself a favour.<p>You'll probably be forming some counter-arguments in your head.<p>Skip them, throw the DDD books in the bin, and do your co-workers a favour.
Agreed. I find most design patterns end up as a mess eventually, at least when followed religiously. DDD being one of the big offenders. They all seem to converge on the same type of "over engineered spaghetti" that LOOKS well factored at a glance, but is incredibly hard to understand or debug in practice.
DDD is quite nice as a philosophy. Like concatenate state based on behavioral similarity and keep mutation and query function close, model data structures from domain concepts and not the inverse, pay attention to domain boundary (an entity may be read only in some domain and have fewer state transition than in another).<p>But it should be a philosophy, not a directive. There are always tradeoffs to be made, and DDD may be the one to be sacrificed in order to get things done.
Of those 3 DDD books - which did you find the most valuable?
I was going to ask the same thing. I'm self taught but I've mainly gone the other way, more interested in learning about lower level things. Bang for buck I think I might have been better reading DDD type books.
Not GP, but the most impactful one I read was Learning DDD from O’Reilly<p><a href="https://www.amazon.com/Learning-Domain-Driven-Design-Aligning-Architecture/dp/1098100131" rel="nofollow">https://www.amazon.com/Learning-Domain-Driven-Design-Alignin...</a><p>It presents the main concepts like a good lecture and a more modern take than the blue book. Then you can read the blue book.<p>But DDD should be taken as a philosophy rather than a pattern. Trying to follow it religiously tends to results in good software, but it’s very hard to nail the domain well. If refactoring is no longer an option, you will be stuck with a non optimal system. It’s more something you want to converge to in the long term rather than getting it right early. Always start with a simpler design.
The #1 predictor of success here is being able to define what success looks like in an obnoxiously detailed manner. If you have a strong vision about the desired UI/UX and you constantly push for that outcome, it is very unlikely you will have a bad time with the current models.<p>The workflow that seems more perilous is the one where the developer fires up gas town with a vague prompt like "here's my crypto wallet please make me more money". We should be wielding these tools like high end anime mech suits. Serialized execution and human fully in the loop can be so much faster even if it consumes tokens more slowly.
There are different kinds of coding - web dev, low level coding, software, research, data science. There are some kinds of coding where carefully designing the architecture is important, and AI might not produce satisfactory code. Some kinds of coding, on the other hand, can benefit very strongly from AI. I suspect that many people who specialize in a particular area of coding form opinions based on how useful AI is in that area, and those opinions are perfectly valid for what coding means to them, but don't generalize to other people with different specializations.
Everyone seems to have different ways to deal with AI for coding and have different experiences. But Armin's comment quoted in the article is spot on. I have seen a friend do exactly the same thing, vibe coded an entire product hooked to Cursor over three months. Filled with features no one uses, feeling very good about everything he built. Ultimately it's his time and money, but I would never want this in my company. While you can get very far with vibe coding, without the guiding hands and someone who understands what's really going on with the code, it ends up in a disaster.<p>I use AI for the mundane parts, for brainstorming bugs. It is actually more consistent than me in covering corner cases, making sure guard conditions exist etc. So I now focus more on design/architecture and what to build and not minutea.
I think right now a good approach can be using AI everywhere where it helps us in doing the hard work. Not taking the hard work over, but making the task easier in a supporting role. Few things that work really well for me:<p>- AI creating un-opinionated summaries of PRs to help me get started reviewing<p>- AI being an interactive tutor while I’ll still do the hard work of learning something new [1]<p>- AI challenging my design proposal QA style, making me defend it<p>- boilerplate and clear refactorings, while I’ll build the abstractions<p>[1] <a href="https://www.dev-log.me/jokes_on_you_ai_llms_for_learning/" rel="nofollow">https://www.dev-log.me/jokes_on_you_ai_llms_for_learning/</a>
Twice I’ve used Claude Code for something important and complex. Stunning initial speed and time savings, all given back eventually as it became apparent that some fatally flawed assumptions were baked into the code right from the beginning.<p>The initial speed is exactly what the article describes, a Loss Disguised as a Win.
Your wording painted the picture of a drug high in my mind, probably an upper. Requiem for Dream style, amazing “Summer”, followed the brutal come down that is “Winter.”<p>Thank you for not using an LLM.
Just because you’re a good programmer / software engineer doesn’t mean you’re a good architect, or a good UI designer, or a good product manager. Yet in my experience, using LLMs to successfully produce software really works those architect, designer, and manager muscles, and thus requires them to be strong.
I really disagree with this. I don’t think you can be a good software engineer without being a good product manager and a good architect.
You're doing architect/designer/manager work while being treated, and paid, like a code monkey. This is by design.
My little anecdote of breaking the spell. Really I might not been truly under the spell, but I had to go far in to my project to loose the "magic" of the code. The trick was simply going back to a slower way of using it with a regular chat window. Then really reading the code and interrogation everything that looks odd. In my case I saw a .partial_cmp(a).unwrap() in my rust code and went ahead an asked is there an alternative. The LLM returned .total_cmp(a) as an alternative. I continued on asking why it generated the "ugly" unwrap, LLM returned that it didn't become available later version of rust with only a tiny hint of that it .partial_cmp is more common in the original trainingsets. The final shattering was simply asking it why it used .partial_cmp and got back "A developer like me... ". No it is an LLM, there is somewhere in the system prompt to anthropomorphize the responses and that is the subtle trick beyond "skinner box" of pulling the lever hoping to get useful output. There are a bunch of subtle cues that hijacks the brain of treating the LLM like a human developer. So when going back to the agentic flow in my other projects I try to disabling these tricks in my prompts and the AGENTS file and the results are more useful and I'm more prone to realizing when the output has sometimes has outdated constructs and be more specific on what version of tooling I'm using. Occasionally scraping whole branches when I realize that it is just outdated practices or simply a bad way of doing things that are simply more common in the original training data, restarting with the more correct approaches. Is it a game changer... no but it makes it more like a tool that I use instead of a developer of shifting experience level.
It's astonishing to me that real software developers have considered it a good idea to generate code... <i>and not even look at the code</i>.<p>I would have thought sanity checking the output to be the most elementary next step.
I think people got fatigued by reviewing already. Most code is correct that AI produces so you end up checking out eventually.<p>A lot of the time the issue isn't actually the code itself but larger architectural patterns. But realizing this takes a lot of mental work. Checking out and just accepting what exists, is a lot easier but misses subtleties that are important.
Those people aren't real software developers.
I wonder if this phenomenon comes from how reliable lower layers have become. For example, I never check the binary or ASM produced by my code, nor even intermediate byte code.<p>So vibers may be assuming the AI is as reliable, or at least can be with enough specs and attempts.
The addiction aspect of this is real. I was skeptical at first, but this past week I built three apps and experienced issues with stepping away or getting enough sleep. Eventually my discipline kicked in to make this a more healthy habit, but I was surprised by how compelling it is to turn ideas into working prototypes instantly. Ironically, the rate limits on my Claude and Codex subscriptions helped me to pace myself.
Isn't struggling to get enough sleep or shower enough and so on because you're so involved with the process of, you know, programming, especially interactive, exploratory programming with an immediate feedback loop, kind of a known phenomenon for programmers since essentially the dawn of interactive computing?
Sort of, but the speed at which I can see results and the ability to quickly get unstuck does pull me in more than just coding. While I find both enjoyable, I'm more of a 'end result' person than a 'likes to the type in the code' person. There was a conversation about this a month or so ago referencing what types of people like LLMs and which do not.
Using agents trigger different dopamine patterns, I'd compare it to a slot machine: did it execute it according to plan or did it make a fatal flaw? Also, multiple agents can run at once, which is a workflow for many developers. The work essentially doesn't come to a pausing point.
> did it execute it according to plan or did it [have] a fatal flaw?<p>That's most code when you're still working on it, no?<p>> Also, multiple agents can run at once, which is a workflow for many developers. The work essentially doesn't come to a pausing point.<p>Yeah the agent swarm approach sounds unsurvivably stressful to me lol
Articles like this amount to a straw man.<p>People seem to think that just because it produces a bunch of code you therefore don’t need to read it or be responsible for the output. Sure you can do that, but then you are also justifying throwing away all the process and thinking that has gone into productive and safe software engineering over the last 50 years.<p>Have tests, do code reviews, get better at spec’ing so the agent doesn’t wing it, verify the output, actively curate your guardrails. Do this and your leverage will multiply.
Of course people think that, because that is exactly how those agents are being sold. If you tell management that this speeds up the easy part, typing the code, they are convinced you are using it wrong. They want to save 90% of software development cost and you are telling them that’s not possible.
Thats exactly the thing what the term vibecoding describes.
The point about vibe coding eroding fundamentals resonates. I've noticed that when I lean too heavily on LLM-generated code, I stop thinking about edge cases and error handling — the model optimizes for the happy path and so do I. The real skill shift isn't coding vs not coding, it's learning to be a better reviewer and architect of code you didn't write yourself.
Fascinating - I find the opposite is true. I think of edge cases more and direct the exploration of them. I’ve found my 35 years experience tells me where the gaps will be and I’m usually right. I’ve been able to build much more complex software than before not because I didn’t know how but because as one person I couldn’t possibly do it. The process isn’t any easier just faster.<p>I’ve found also AI assisted stuff is remarkable for algorithmically complex things to implement.<p>However one thing I definitely identify with is the trouble sleeping. I am finally able to do a plethora of things I couldn’t do before due to the limits of one man typing. But I don’t build tools I don’t need, I have too little time and too many needs.
> I’ve found also AI assisted stuff is remarkable for algorithmically complex things to implement.<p>AI is <i>really good</i> to rubber duck through a problem.<p>The LLM has heard of <i>everything</i>… but learned nothing. It also doesn't really <i>care</i> about your problem.<p>So, you can definitely learn from it. But the moment it creates something you don't understand, you've lost control.<p>You had one job.
> when I lean too heavily on LLM-generated code, I stop thinking about edge cases and error handling<p>I have the exact same experience... if you don't use it, you'll lose it
I’ve learned the hard way that in coding, every line matters. While learning Go for a new job, I realised I had been struggling because I overused LLMs and that slowed my learning. Every line we write reflects a sense of 'taste' and needs to be fully controlled and understood. You need a solid mental model of how the code is evolving. Tech CEOs and 'AI researchers' lack the practical experience to understand this, and we should stop listening to them about how software is actually built.
Speaking just for myself, AI has allowed me to start doing projects that seemed daunting at first, as it automates much of the tedious act of actually typing code from the keyboard, and keeps me at a higher level.<p>But yes, I usually constrain my plans to one function, or one feature. Too much and it goes haywire.<p>I think a side benefit is that I think more about the problem itself, rather than the mechanisms of coding.
Actually, I wonder how they measured the 'speed' of coding, maybe I missed it. But if developers can spend more time thinking about the larger problems, that may be a cause of the slowdown. I guess it remains to be seen if the code quality or feature set improves.
I see AI coding as something like project management. You could delegate all of the tasks to an LLM, or you could assign some to yourself.<p>If you keep some for yourself, there’s a possibility that you might not churn out as much code as quickly as someone delegating all programming to AI. But maybe shipping 45,000 lines a day instead of 50,000 isn’t that bad.
You need to understand the frustration behind these kinds of posts.<p>The people on the start of the curve are the ones who swear against LLMs for engineering, and are the loudest in the comments.<p>The people on the end of the curve are the ones who spam about only vibing, not looking at code and are attempting to build this new expectation for the new interaction layer for software to be LLM exclusively. These ones are the loudest on posts/blogs.<p>The ones in the middle are people who accept using LLMs as a tool, and like with all tools they exercise restraint and caution. Because waiting 5 to 10 seconds each time for an LLM to change the color of your font, and getting it wrong is slower than just changing it yourself. You might as well just go in and do these tiny adjustments yourself.<p>It's the engineers at both ends that have made me lose my will to live.
I can't believe we're back to using LoC as a metric for being productive again.
> However, it is important to ask if you want to stop investing in your own skills because of a speculative prediction made by an AI researcher or tech CEO. Consider the case where you don’t grow your software engineering or problem-solving skills, yet the forecasts of AI coding agents being able to handle ever expanding complexity don’t come to pass. Where does this leave you?<p>The current Claude Code setup with Opus 4.6 and their Max subscription (the 100 USD one was enough for me, don't need the 200 USD one) was enough for me to do large scale refactoring across 3 codebases in parallel. Maybe not the most innovative or complex tasks in absolute terms, but it successfully did in one day what would have taken regular developers somewhere between 1 and 2 weeks in total.<p>I hate to be the anecdote guy, but with the current state of things, I have to call bullshit on the METR study, there is no world in which I work slower with AI than without. Maybe with the Cerebras Code subscription where it fucked some code up and I had to go back to it and fix it twice, but that's also because Vue had some component wrapping and SFC/TypeScript bullshit going on which was honestly disgusting to work on, but that's because you really need the SOTA models. The current ones are good enough for me even if they never improved further.<p>I never want to go back to soul sucking boilerplate or manual refactoring. It works better than I can alone. It works better than my colleagues can. I think I might just suck, maybe I'm cooked because at this point I mostly just guide and check it and sometimes do small code examples for what I want and explore problems instead of writing all of it myself, but honestly a lot of work was done in JetBrains IDEs previously where there's also lots of helpful snippets, autocomplete, code inspections and so on, so who knows - maybe it doesn't matter that I write everything line by line myself.
The "which is higher risk" framing in the top comment is exactly right, but I think it misses a third option that's working well in practice: using AI as a force multiplier while maintaining deep understanding of what it generates.<p>The failure mode isn't "AI writes bad code." It's "developer accepts bad code without reading it." Those are very different problems with very different solutions.<p>I've found the sweet spot is treating AI output like a pull request from a very fast but somewhat careless junior dev — you still review every line, you still understand the architecture, you still own the decisions. But the first draft appears in seconds instead of hours. The time savings compound when you know the codebase well enough to immediately spot when the AI is heading in the wrong direction.<p>The people getting burned are the ones skipping the review step and hoping for the best.
i used to lose hours each day to typos, linting issues, bracket-instead-of-curly-bracket, 'was it the first parameter or the second parameter', looking up accumulator/anonymous function callback syntax AGAIN...<p>idk what ya'll are doing with AI, and i dont really care. i can finally - fiiinally - stay focused on the problem im trying to solve for more than 5 minutes.
idk what you’re doing but proper IDE was doing that for me for past 15 years or more.<p>Like I don’t remember syntax or linting or typos being a problem since I was in high school doing Turbo Pascal or Visual Basic.
With all due respect, but if you actually wasted hours (multiple) each (!) day on those issues, then yeah, I can fully believe that AI assisted coding 10 or even 100x'd you.
How does AI help you here? Do you pass it a file and tell it to "fix syntax errors, no mistakes!" ??
Ive come to the realization after maxing the x20 plan that I have to set clear priorities.<p>Fortunately, I've retired so I'm going focus on flooding the zone with my crazy ideas made manifest in books.
I think most of the issues with "vibe coding" is trusting the <i>current level</i> of LLM's with too much, as writing a hacky demo of a specific functionality is 1/10 as difficult as making a fully-fledged, dependable, scalable version of it.<p>Back in 2020, GPT-3 could code functional HTML from a text description, however it's only around now that AI can one-shot functional websites. Likewise, AI can one-shot a functional demo of a saas product, but they are far from being able to one-shot the entire engineering effort of a company like slack.<p>However, I don't see why the rate of improvement will not continue as it has. The current generation of LLM's haven't been event trained yet on NVidia's latest Blackwell chips.<p>I do agree that vibe-coding is like gambling, however that is besides the point that AI coding models are getting smarter at a rate that is not slowing down. Many people believe they will hit a sigmoid somewhere before they reach human intelligence, but there is no reason to believe that besides wishful thinking.
The part about "dark flow" resonates strongly. I've seen this pattern play out with a specific downstream cost that doesn't get discussed enough: maintenance debt.<p>When someone vibe-codes a project, they typically pin whatever dependency versions the LLM happened to know about during training. Six months later, those pinned versions have known CVEs, are approaching end-of-life, or have breaking changes queued up. The person who built it doesn't understand the dependency tree because they never chose those dependencies deliberately — the LLM did. Now upgrading is harder than building from scratch because nobody understands why specific libraries were chosen or what assumptions the code makes about their behavior.<p>This is already happening at scale. I work on tooling that tracks version health across ecosystems and the pattern is unmistakable: projects with high AI-generation signals (cookie-cutter structure, inconsistent coding style within the same file, dependencies that were trendy 6 months ago but have since been superseded) correlate strongly with stale dependency trees and unpatched vulnerabilities.<p>The "flow" part makes it worse — the developer feels productive because they shipped features fast. But they're building on a foundation they can't maintain, and the real cost shows up on a delay. It's technical debt with an unusually long fuse.
I think a big part of this discussion lost for a lot is a lot of people are trying to copy/paste how we’ve been developing software over the past twenty years into this new world which simply doesn’t work effectively.<p>The differences are subtle but those of
us who are fully bought in (like myself) are working and thinking in a new way to develop effectively with LLMs. Is it perfect? Of course not - but is it dramatically more efficient than the previous era? 1000%. Some of the things I’ve done in the past month I really didn’t think were possible. I was skeptical but I think a new era is upon us and everyone should be hustling to adapt.<p>My favorite analogy at the moment is that for awhile now we’ve been bowling and been responsible for knocking down
the pins ourselves. In this new world we are no longer the bowlers, rather we are the builders of bumper rails
that keep the new bowlers from landing in the gutter.
I think tech journalism needs to reframe its view of slot machines if it's to have a productive conversation about AI.<p>Not everyone who plays slot machines is worse off — some people hit the jackpot, and it changes their life. Also, the people who make the slot machines benefit greatly.
That AI would be writing 90% of the code at Anthropic was not a "failed prediction". If we take Anthropic's word for it, now their agents are writing 100% of the code:<p><a href="https://fortune.com/2026/01/29/100-percent-of-code-at-anthropic-and-openai-is-now-ai-written-boris-cherny-roon/" rel="nofollow">https://fortune.com/2026/01/29/100-percent-of-code-at-anthro...</a><p>Of course you can choose to believe that this is a lie and that Anthropic is hyping their own models, but it's impossible to deny the enormous revenue that the company is generating via the products they are now giving almost entirely to coding agents.
One thing I like to think about is: If these models were so powerful why would they ever sell access? They could just build endless products to sell, likely outcompeting anyone else who needs to employ humans. And if not building their own products they could be the highest value contractor ever.<p>If you had midas touch would you rent it out?
Well there are models that Anthropic, OpenAI and co. have access to that they haven't provided public API's for, due to both safety, and what you've cited as the competitive advantage factor. (like Openai's IMO model, though it's debatable if it represented an early version of GPT 5.1/2/3 or something else)<p><a href="https://sequoiacap.com/podcast/training-data-openai-imo/" rel="nofollow">https://sequoiacap.com/podcast/training-data-openai-imo/</a><p>The thing however is the labs are all in competition with each other. Even if OpenAI had some special model that could give them the ability to make their own Saas and products, it is more worth it for them to sell access to the API and use the profit to scale, because otherwise their competitors will pocket that money and scale faster.<p>This holds as long as the money from API access to the models is worth more than the comparative advantage a lab retains from not sharing it. Because there are multiple competing labs, the comparative advantage is small (if OpenAI kept GPT-5.X to themselves, people would just use Claude and Anthropic would become bigger, same with Google).<p>This however may not hold forever, it is just a phenomena of labs focusing more on heavily on their models with marginal product efforts.
Arguably because the parts the AI can't do (yet?) still need a lot of human attention. Stuff like developing business models, finding market fit, selling, interacting with prospects and customers, etc.
It's not entirely surprising. You can prompt the AI to write code to pretty much any level of detail. You can tell it exactly what to output and it will copy character for character.<p>Of course at a certain point, you have to wonder if it would be faster to just type it than to type the prompt.<p>Anyways, if this was true in the sense they are trying to imply, why does Boris still have a job? If the agents are already doing 100% of the work, just have the product manager run the agents. Why are they actively hiring software developers??<p><a href="https://job-boards.greenhouse.io/anthropic/jobs/4816198008" rel="nofollow">https://job-boards.greenhouse.io/anthropic/jobs/4816198008</a>
They probably still need to be able to read and distinguish good vs bad code, evaluate agent decisions, data structures, feasibility, architectural plans, etc, all of which require specific software engineering expertise, even if they don't end up touching the code directly.
But that doesn't make sense. They claim that AI is writing 100% of the code, yet if they need to be able to read and distinguish good vs bad code, evaluate agent decisions, data structures, feasibility, architectural plans, etc, that implies they are writing at least some of the code? Or else why would they ever need to do those things?
Exactly. The fact that people laugh at the prediction like it's a joke when I and many others have been at 90%+ for a long time makes me question a lot of the takes here. Anyone serious about using LLMs would know it's nothing controversial to have it write most of the code.<p>And people claiming it's a lie are in for a rough awakening. I'm sure we will see a lot of posters on HN simply being too embarrassed to ever post again when they realize how off they were.
I wish one of those agents was smart enough to notice that their github-action which auto closes issues is broken: <a href="https://github.com/anthropics/claude-code/issues/16497" rel="nofollow">https://github.com/anthropics/claude-code/issues/16497</a>. Then maybe we could get some of these bugs fixed.
Why do they have so many GitHub issues then?
> A study from METR found that when developers used AI tools, they estimated that they were working 20% faster, yet in reality they worked 19% slower. That is nearly a 40% difference between perceived and actual times!<p>It’s not. It’s either 33% slower than perceived or perception overestimates speed by 50%. I don’t know how to trust the author if stuff like this is wrong.
> I don’t know how to trust the author if stuff like this is wrong.<p>She's not wrong.<p>A good way to do this calculation is with the log-ratio, a centered measure of proportional difference. It's symmetric, and widely used in economics and statistics for exactly this reason. I.e:<p>ln(1.2/0.81) = ln(1.2)-ln(0.81) ≈ 0.393<p>That's nearly 40%, as the post says.
so if the numbers were “99% slower than without AI but they thought they would be 99% fast”, you’d call that “they were 529% slower”, even though it doesn’t make sense to be more than 100% slower? And you’d not only expect everyone to understand that, but you really think it’s more likely a random person on the internet used a logarithmic scale than they just did bad math?
I get caught up personally in this math as well. Is a charitable interpretation of the throwaway line that they were off by that many “percentage points”?
Can you elaborate? This seems like a simple mistake if they are incorrect, I'm not sure where 33% or 50% come from here.
Their math is 120%-80%=40% while the correct math is (80-120)/120=-33% or (120-80)/80=+50%<p>It’s more obvious if you take more extreme numbers, say: they estimated to take 99% less time with AI, but it took 99% more time - the difference is not 198%, but 19900%. Suddenly you’re off by two orders of magnitude.
It's not a mistake. It's correct, and is a excellent way to present this information.
Isn't the study a year old by now? Things have evolved very quickly in the last few months.
Yes and if was done with people using cursor at the time and already had a few caveats back then about who was actually experienced with the tool etc.<p>Still an interesting observation. It was also on brown field open source projects which imo explains a bit why people building new stuff have vastly different experiences than this.
The exact numbers certainly would be different today, but you would probably still see the effect that there’s an overestimation of productivity
Yes. No agents, no deep research, no tools, and just Sonnet-3.5 and 3.7 - I’d love to see the same study today with Opus-4.6 and Codex-5.3
Agent assisted coding is just vibe-coding in disguise.
You still only glance over the code "just so it won't be considered vibe-coding", but at the end of the day, if you invest a proper amount of time reading and reasoning with the generated code - than it would take the exact same time, as if you would have wrote it by hand.<p>By not going through this process, you loose intent, familiarity, and opinions.<p>It's the exact same as vibe-coding.
Step 1. Stop calling it "vibe coding."
"Hell is other people's code"<p>Not sure why we'd want a tool that generates so much of this for us.
>Anthropic CEO Dario Amodei predicted that by late 2025, AI would be writing 90% of all code<p>Was this actually a failed prediction? A article claiming with 0 proof that it failed is not good enough for me. With so many people generating 100% of their code using AI. It seems true to me.
tl;dr - author cites a study from early 2025 which measured developer speed of “experienced open source developers” to be ~20% slower when supported by AI, while they’ve estimated to be ~20% faster.<p>Note: the study used sonnet-3.5 and sonnet-3.7; there weren’t any agents, deep research or similar tools available. I’d like to see this study done again with:<p>1. juniors ans mid-level engineers<p>2. opus-4.6 high and codex-5.2 xhigh<p>3. Tasks that require upfront research<p>4. Tasks that require stakeholder communication, which can be facilitated by AI
> which can be facilitated by AI<p>I’d be thrilled if that AI could finally make one of our most annoying stakeholders test the changes they were so eager to fast track, but hey, I might be surprised.
It can <i>facilitate</i> that, certainly. Idk about the background of that stakeholder, but AI can help drafting communication with the right tone to show the necessity. It can help to write a guide on how to properly test the specific feature. It can write e2e tests that the stakeholder could execute from their environment.<p>Of course, all of that can be done by humans, too. But this discussion is about average speed of a developer, and there’s a reason many companies employ product owners for the stakeholder communication.
For most people, blackjack is gambling. There are non-gamblers who play it though. You can just count cards and eventually beat the odds with skill.<p>I wonder if there's something similar going on here.
this is quite literally just coping and seething
<i>"they don’t produce useful layers of abstraction nor meaningful modularization. They don’t value conciseness or improving organization in a large code base. We have automated coding, but not software engineering"</i><p>Which frankly describes pretty much all real world commercial software projects I've been on, too.<p>Software engineering hasn't happened yet. Agents produce big balls of mud because we do, too.
which is why the most famous book in the world of software development pointed out that the long term success of a software project is not defined by man hours or lines of code written but by documentation, clear interfaces and the capacity to manage the complexity of a project.<p>Maybe they need to start handing out copies of the mythical man month again because people seem to be oblivious to insights we already had a few decades ago
[dead]
[dead]