Why AI Hasn't Revolutionized Software Development – Insights from Jonathan Blow’s HN Debate
TL;DR – AI hasn’t solved software development
Jonathan Blow’s video claims that AI tools have not altered the way software is built, and the Hacker News thread largely agrees: the bottleneck is still system design, organizational processes, and legacy practices, not the ability to generate code snippets.
1. Blow’s Core Argument – Paradigms Remain Static
Blow contends that while large language models (LLMs) can produce "leaf functionality" (API calls, UI glue, simple scripts), they do not change the underlying software architecture or the cultural incentives that drive engineering work. He argues that:
- Most modern code is still organized around the same module, class, and service patterns developed in the early 2000s.
- AI merely speeds up low‑level implementation, leaving high‑level design, problem framing, and architectural decisions untouched.
- Without a shift in what engineers are optimizing for (e.g., speed of delivery vs. long‑term quality), software will look the same on the surface.
"AI gives you more of what you want and gives it faster, that doesn’t on its own change the culture or goals of a company." – @aavaa
2. Organizational Constraints – The Real Bottleneck
Multiple commenters point out that the process around code, not the code itself, limits productivity:
- Legal and compliance teams often dictate slow, heavyweight requirements that dominate release cycles.
- Pull‑request bottlenecks: one user reported merging 100+ PRs a week on a personal project but only 8 at work, illustrating that review overhead dwarfs any coding speed gains.
- Management priorities: AI is attractive to managers because it reduces the perceived effort of developers, not because it improves product quality.
"It takes an entire business to publish a software product, not just engineers. Legal teams contribute much more of the sloth than the engineering team." – @tonymet
3. Evidence of Change – Indie Success Stories
Some participants cite concrete examples where AI has accelerated development:
- A Swift annotation app was built with zero visible code from the author, yet delivered a polished UI and advanced features.
- Small teams are releasing complex indie RTS titles (e.g., The Scouring) that rival legacy AAA engines, partly because AI lowers the barrier to custom engine work.
- Individual developers report cutting months‑long projects down to weeks or even days using LLM‑generated code.
"I recently built a Swift app… I saw 0 code during the build process. The app works efficiently and looks better than anything I could have done after a decade of UI/UX study." – @dimavolo
4. Limits of Current LLMs – Quality vs. Quantity
Several comments stress that AI’s output is still noisy and often requires heavy post‑editing:
- AI excels at generating boilerplate but struggles with deep architectural reasoning, performance tuning, and security considerations.
- The "AI slop" phenomenon: a flood of low‑quality tools and games that would have been unacceptable a few years ago, diluting perceived overall quality.
- LLMs inherit bugs from their training data; without human oversight, they can propagate systemic issues.
"AI solved coding to the same degree that AI solved writing and creating images – it helps, but it doesn’t replace the craft." – @jdlyga
5. The Role of Human Judgment – Asking the Right Questions
Even enthusiastic users acknowledge that prompt engineering remains a critical skill:
- Knowing what to ask and how to frame a problem determines whether AI output is useful.
- Junior engineers may face a chaotic landscape where AI does the grunt work, but mentorship and design experience are still essential.
"There's still money in knowing what and how to ask." – @gchamonlive
6. Long‑Term Outlook – Incremental vs. Transformative Change
The consensus suggests a gradual shift rather than a sudden revolution:
- In the next 6‑12 months, we can expect faster prototyping, more personalized tools, and cheaper niche software.
- Large, complex systems (operating systems, AAA game engines, enterprise SaaS) will continue to evolve at a slower pace because they require deep domain expertise beyond LLM capabilities.
- Over the next decade, as models become more capable of reasoning about system design, we may see a more pronounced impact, but cultural and organizational inertia will still dominate.
"LLMs solved natural language processing, a 70‑year problem, overnight. Yet most of that capability remains in tech‑demo land for software engineering." – @grumbel
Key Takeaways
- AI accelerates low‑level coding but does not replace system design – the core architecture of software remains governed by decades‑old paradigms.
- Organizational processes (legal, review, management) are the dominant bottlenecks, limiting the observable impact of AI on shipped products.
- Indie developers and hobbyists are seeing the biggest gains, producing complex games and apps with tiny teams.
- Quality concerns persist: AI‑generated code often requires extensive review, and the flood of low‑quality tools can obscure genuine improvements.
- Human expertise in problem framing and architecture remains essential, and the ability to craft effective prompts is now a valuable skill.
The discussion underscores that while LLMs are a powerful new tool, they are a bicycle for the mind—they expand what individuals can achieve, but they do not, by themselves, rewrite the fundamental economics and practices of software development.
Sources
Related
- Dispatch
- Dispatch
- Dispatch
- Dispatch
- Dispatch