> This isn’t incremental improvement. This is a phase change.

> This isn’t about one person copying one idea. It’s about the fundamental economics of software changing.

That "this isn't x, it's y" really is a strong tell

> I'm not joking and this isn't funny. We have been trying to build distributed agent orchestrators at Google since last year. There are various options, not everyone is aligned... I gave Claude Code a description of the problem, it generated what we built last year in an hour.

I am sure that whatever work was put into actually trying to implement that, was crucial in order to instruct Claude what to do. System design doesn't come by itself.

>> The evidence is overwhelming

> provides none

I'm pro LLM/AI, but most of hype are just pure vibes. There's no evidence, there are only anecdotes.

All the hype-men that I follow either have a stake at it (they either work for LLM provider or have an AI startup) or post billions of examples and zero revenue.

Execution in the article is simply having faster tech operations. Execution in a startup context doesn't imply that - execution is how the business operates - strategy, operations, hiring, marketing, legal handling, product building - all of that. Has AI made that easier, yes. But not how this article is soley focusing on an important but a very less significant part of a startup operation or the success it might have. Startup (even only a tech based) is not only tech product building, its a business. And, that execution incoporates all the functions of a business, not only tech product building.

> I’m not exaggerating. And neither is anyone else.

> Stack Overflow, the site that defined a generation of software development, received 3,710 questions last month. That’s barely above the 3,749 it got in its first month of existence. The entire knowledge-sharing infrastructure we built our careers on is collapsing because people don’t need to ask anymore.

"Because people don't need to ask anymore."?!

Yeah, I wouldn't call it exaggerating, I think I would call it a fundamental misunderstanding.

I wanted to comment on the code examples he shared. But they're they're all closed source. Which is a decision given the premise of the whole article, err I mean ad, that implementations are free these days.

I find that the LLMs are good at the 'glue code'. The "here's a rather simple CRUD like program, please tie all of the important things together in the right way". That was always a rather important and challenging bit of work, so having LLMs take it of our hands is valuable.

But for the code where the hard part isn't making things designed separately work together, but getting the actual algorithm right. That's where I find LLMs still really fail. Finding that trick to take your approach from quadratic to N log N, or even just understanding what you mean after you found the trick yourself. I've had little luck there with LLMs.

I think this is mostly great, because its the hard stuff that I have always found fun. Properly architecting these CRUD apps, and learning which out of the infinite set of ways to do this are better, was fun as a matter of craftsmanship. But that hits at a different level from implementing a cool new algorithm.

When software becomes cheap to build, a lot of strange second-order effects kick in. It’s not just that products are easier to create; sales, marketing, and every other business function can iterate faster alongside them. That speed erodes moats. As this reality sinks in, I think we’re headed for a brutal shakeout in SaaS.

People still argue that distribution is the real bottleneck now. But when the product itself is trivial to build and change, the old dynamics break down. Historically, sales was hard because you had to design and refine a sales motion around a product that evolved slowly and carried real technical risk. You couldn’t afford to pour resources into distribution before the product stabilized, because getting it wrong was expensive.

That constraint is gone. The assumptions and equations we relied on to understand SaaS no longer apply—and the industry hasn’t fully internalized what that means yet.

It's interesting that the the author created three saas over the weekend as some sort of proof that execution is useless now. But would any company ever buy one of these? No, because for a company to buy your saas you need salespeople or some marketing channel, compliance and regulatory checkmarks, SSO integrations, ability to take and implement special feature requests, SLAs, maintenance and support capacity, etc.

That's the execution part of creating a successful business and it's still entirely missing.

https://usedriftless.com/ -> start free -> https://codebasehealth.com/login -> join waiting list? WTH is codebasehealth? -> pricing -> 404

Searching for what to solve becomes far more important than how to solve it. Which niche you serve, how underserved the problem is, how quickly you build a solution, and how fast you iterate based on user feedback become the real differentiators. As a problem gains popularity, competitors will enter at an increasing pace, and the product’s price will be competed down to the bare minimum. At that point, the only real advantage for a builder is to be a serial builder for deep niches, spotting them faster than others and delivering quality product to users before anyone else.

I don't see much discussion on maintenance of software built by LLMs using LLMs.

We already know the hard part of software engineering is designing and implementing code that is maintainable.

Can LLMs reliably create software and maintain it transparently without bringing in regressions ? How do people with no knowledge of software guide LLMs to build quality test suite to prevent regressions ?

Or is it the expectation that every new major release is effectively a rewrite from scratch ? Don't they have to maintain consistency with the UI, database and other existing artifacts.

I'm now several years out of a career as a web designer and running my own retail business on Shopify and so while I've always had a background in working with devs and having a vague idea of how to plan and spec something, my previous job was design and writing HTML and CSS and I always wanted to be able to make small tools or little fun projects for me but the other parts of the project - the js, caching, api integration etc were always beyond my skillset.

While I wouldn't say execution is necessarily "cheap" for everything, ChatGPT and Gemini helped me build out a little Spotify playlist generator [1] recently that scans my top 100 artists in the last 12 months then generate a playlist based on their bottom 50% of songs in terms of popularity with an option for 1 or 2 songs per artist.

Sadly the Spotify API limits will never allow me to offer it to more than 25 people at a time but I get so bored of their algorithm playing me the same top songs from artists it's a fun way for me to explore "lesser lights" and something I'd have absolutely never have been able to build before, let alone spin up in a couple of evenings.

It's quite liberating as a non-dev suddenly having these new tools available that's for sure.

[1] https://github.com/welcomebrand/Spotify-Lesser-Lights

> In that time, I internalized a simple truth: ideas are cheap, execution is everything.

This has never been true.

To believe this, you would have had to miss the number of functioning apps and games on all the app stores that no one cares about, to just give one example. Or all the excellent but abandoned open source projects.

Rewards follow an exponential distribution ("power law ..."). Ideas and execution are important ingredients. Furthermore, they are not easily separable.

Execution has gotten much cheaper in a small enough problem space. Yes, we get it, it's game changing. It doesn't mean you're building products. There's more to it than just writing code.

Writing a formbuilder and saying you've replicated Typeform is like finishing a todo app and saying you've replicated Jira. Yes, in a way I guess...but there is way more to the product and that's usually where the hard parts are.

i find it extremely ironic that he said he built 3 of these things in a weekend, and expects me to pay 100$/mo for one of them. You've just basically stated how dead simple it is to build it, I'm certainly not paying you that and instead going to build my own (although I didn't need an article to tell me this). Matter of fact, the broader point of this entire article and my experience with AI so far as a veteran in the industry, I lean towards quickly building things now rather than paying for SaaS products, unless it's far too complex and not worth it.

A lot of cost of mature SaaS products come from security, scaling, expensive sales teams, etc. For me, if I have something sandboxed, not available to the public, and only powerful enough to serve only _me_ as a customer, then I don't need to pay those extra costs and I can build something a lot simpler, while still maintaining the core feature that I need.

That's what I was thinking as well after letting Claude do a godoist clone in a few vibe coding sessions. Literally got most features I care about with a ui similar to todoist with all the bootstraping done. Deploying to my nas later this week and cancelling my subscription.

It's way past the point of "just" doing MVPs or simple proof of concepts. I'm talking about user auth, dynamic input parsing, calendar views, tags, projects, history of events and more, given a few prompts.

What's funny is that a lot people on Twitter claiming that they can just vibe-code away their SaaS subscriptions are building SaaS themselves.

> Remember when coming up with a great idea was the easy part? Ideas were worthless.

Great ideas are rare.

Baseline execution is cheaper. An LLM is not going to help you build a unique business.

"AI startups say the promise of turning dazzling models into useful products is harder than anyone expected":

https://www.wired.com/story/artificial-intelligence-startups...

This is not new. There is tech that enables new possibilities, but it's not a f---ing magic wand.

This is a pretty wild claim, so I think it is fair to be critical of the examples given:

- Driftless sounds like it might be better as a claude code skill or hook

- Deploycast is an LLM summarization service

- Triage also seems like it might be more effective inside CC as a skill or hook

In other words all these projects are tooling around LLM API calls.

> What was valuable was the commitment. The grit. The planning, the technical prowess, the unwavering ability to think night and day about a product, a problem space, incessantly obsessing, unsatisfied until you had some semblance of a working solution. It took hustle, brain power, studying, iteration, failures.

That isn't going to go away. Here's another idea: a discussion tool for audio workflows. Pre-LLMs the difficult part of something like this was never code generation.

Execution is cheap? How about you try a video game, and not 3 obvious and worthless automations I could have made as a quick fix at lunch time.

One underestimated productivity booster is that you can write code on your phone by giving orders to a coding assistant in a spare moment. You can fill extra time that way instead of reading social media or playing a game.

I was just coding a personal website the other day while waiting for our number to be called at the DMV. I couldn’t really review the code but it did give me a chance to test on mobile.

This is without doing anything special, just using one instance of Claude Opus 4.5 and exe.dev.

I still don't get. The author calls these "Not MVPs. Not prototypes. Working products", but how many users do these "products" actually have?

Have they iterated on user feedback? Have they fixed obscure issues? Made any major changes after the initial version?

More importantly, can the author claim with a straight face that they no longer need to read or understand the code that has been produced?

Just another one of those “look, I built a greenfield pet project over the weekend, software engineering is dead.”

LLMs are amazing.

Nothing replaces making simple UX instead of complicated kitchen sink products.

It’s easy to make stuff. It’s harder to make stuff people want.

I am thankful for the increase in product velocity and I also recognize that a lot of stuff people make isn’t what people want.

Product sense and intuition still matter.

Ideas are cheap for a very narrow vision of "ideas". Sure, you can build your recipe site, TODO list or whatever it is cheaply and quickly without a single thought, but LLMs are still just assembling lots of open-source libraries _mostly_ written by humans into giant piles of spaghetti.

There's a hilarious thread on Twitter where someone "built a browser" using an LLM feedback loop and it just pasted together a bunch of Servo components, some random other libraries and tens of thousands of spaghetti glue to make something that can render a webpage in a few seconds to a minute.

This will eventually get better once they learn how to _actually_ think and reason like us - and I don't believe by any means that they do - but I still think that's a few years out. We're still at what is clearly a strongly-directed random search stage.

The industry is going through a mass psychosis event right now thinking that things are ready for AI loops to just write everything, when the only real way for them to accomplish anything is by just burning tokens over and over until they finally stumble across something that works.

I'm not arguing that it won't ever happen. I think the true endgame of this work is that we'll have personal agents that just do stuff for us, and the vast majority of the value of the entire software industry will collapse as we all return to writing code as a fun little hobby, like those folks who spend hours making bespoke furniture. I, for one, look forward to this.

Finally, developers are realizing that it's not how you write code or who writes the code, it's figuring out WHAT to write. LLMs are finally exposing this because the feedback cycle is so short.

Sigh. Lines of code is not execution man. Having functional apps is not execution. A full stack, AWS-deployed, multi-stage scaleable microservices wonder is not execution!

LLMs make it a lot easier to build MVPs, but the hard work of VALIDATING problems and their solutions, which IMO was always >80% of the work for a successful founder, is harder than ever. With AI we now get 100 almost-useful solutions for every real problem.

Ideas are cheap, execution is cheaper, integration is expensive.

I keep reading these pro LLM articles. And I keep thinking that it is abysmal. Sure, for now it works, because there are senior engineers that refine the rough edges and know what's going on.

And especially some folks keep claiming that one just needs to get better at prompting and describe a detailed spec.

Wanna know what a detailed spec is called? An unambiguous one? It's called code.

LLMs still feel like a very round-about way of re-inventing code. But instead of just a new language, it's a language that nondeterministically creates "code" or a resemblance thereof.

And I am aware that this is currently not a popular opinion on HN, so keep the downvotes coming.

If you use LLMs outside the popular Github languages, it will fail hard on you. It is glorified text-completion, that's what it is.

If LLMs are so great at enabling execution, where are all the successful projects enabled by LLMs? Where are they?

Which means more of the business will work through obscurity - concealing the fact what it does, or that it in fact exists.

"The ability to actually build something—to turn a napkin sketch into working software—was the thing that separated dreamers from builders. It’s what made you valuable."

There is also the matter of having ideas that are good and knowing how to make them into good software, not something that simply "technically works". LLMs are not enough to overcome this barrier, and the author's examples seem to prove the point. The "working products with test suites, documentation, and polish" that are just another batch of LLM front-ends are frankly unimpressive. Is this the best that AI can offer?

What a waste of words. If you idea is easily replicable probably it was not a good idea after all. LLMs don't change the equation.