# The Bitter Lesson: How Software Changes in 2026 Source: https://www.youtube.com/watch?v=GyuwH3Q_FlQ Recap page: https://rapidrecap.app/video/GyuwH3Q_FlQ Generated: 2025-12-27T13:33:55.99+00:00 --- ## Quick Overview The future of software development by 2026 shifts from humans designing then agents building to agents building tools that other agents use recursively, driven by the principle that general methods leveraging massive computation always beat encoded knowledge at scale, as evidenced by AI advancements in Chess, Go, and now code generation. **Key Points:** - The core lesson from 70 years of AI research is that general methods leveraging computation outperform encoded knowledge by a large margin. - Software development is predicted to shift by 2026 from a linear, human-driven process ("Humans design. Then agents build.") to a recursive, agent-driven one ("Agents build. Other agents use."). - Current AI tools like Claude Code demonstrate early autonomy with file operations and web search, but the next generation (2026+) will see agents writing tools and infrastructure for other agents. - The progression of AI in problem-solving has moved from brute-force search (Deep Blue, 1997) to neural nets and self-play (AlphaGo, 2016) and is now accelerating into agents writing code better than frameworks (projected 2025). - The key insight is that progress is limited by the floor, not the ceiling, meaning each era enables capabilities of the next, and the surface of abstraction has barely been scratched. - The author strongly encourages adopting the computation-leveraging approach, warning that the human-knowledge approach will lose in the long run. ![Screenshot at 0:06: The slide introduces the core concept that "The Bitter Lesson splits into two paths. Everything changes. Both simultaneously," framing the discussion around two diverging streams in software development driven by AI progress.](https://ss.rapidrecap.app/screens/GyuwH3Q_FlQ/00-00-06.jpg) **Context:** This presentation analyzes Rich Sutton's "The Bitter Lesson," which posits that general AI methods that leverage massive computation ultimately succeed over methods that rely on encoding human knowledge. The speaker applies this lesson to the domain of software development, predicting a significant paradigm shift by 2026 where AI agents build tools for other AI agents, moving away from the current top-down, human-driven development process. ## Detailed Analysis The video dissects the implications of Rich Sutton's "The Bitter Lesson" for software development, splitting the future into two streams: "How We Build" (tools/methods) and "What We Build" (products/systems). The fundamental takeaway is that general methods that harness massive computation consistently beat methods that attempt to encode human expertise, as seen historically in Chess (Deep Blue's brute force) and Go (AlphaGo's self-play). The speaker projects that by 2026, software development will transition from humans designing and agents executing (a linear, top-down model) to agents building tools for other agents recursively (a bottom-up, agent-driven model). Current tools like Claude Code show agents gaining autonomy in file operations and web search, but the next leap involves agents creating tools, APIs, and infrastructure autonomously. This shift accelerates because every layer of abstraction opens new possibilities. The speaker emphasizes that this is not a preference but a mathematical inevitability: where data exists, general methods at scale will always beat encoded knowledge over time. The video concludes that current agentic systems, like GitHub Copilot, are just the beginning, and the tools that matter in 2026 will make today's systems look like simple autocomplete. ### Two Streams - HOW We Build: The tools and methods are evolving from assisting (Claude Code) to full autonomy (2026+), focusing on agents getting smarter via computation - WHAT We Build: Products evolve from no-code builders to agents writing software, then agents writing tools for agents, demonstrating that the surface hasn't been scratched - The Meta-Level: Agents shift from just writing software to writing infrastructure and generating tools for other agents. ### Historical Pattern Repeats - Chess (1997) used brute force search over expert systems; Go (2016) used neural nets and self-play over human intuition; Code (2025 projection) sees LLMs and agents shipping code better than frameworks, not just memorized syntax. ### The Inevitable Conclusion - This progression is mathematical, not preferential; general methods at scale beat encoded knowledge every single time where data exists. ### The Acceleration - Progression from GitHub Copilot (2021 line-by-line autocomplete) to Multi-File Edit (agents reasoning across entire projects) to Agentic Systems (Claude Code achieving minutes of autonomy) shows the accelerating pattern. ### How We Build Now vs. 2026 - Now is linear, top-down, human-driven (Humans design, then agents build); 2026 is recursive, bottom-up, agent-driven (Agents build; other agents use), where agents build web apps, tools, and APIs that become infrastructure. ![Screenshot at 0:00: The initial slide outlining the 'Two Streams' of change: HOW We Build \(tools/methods\), WHAT We Build \(products/systems\), and The Meta-Level \(agents writing infrastructure\).](https://ss.rapidrecap.app/screens/GyuwH3Q_FlQ/00-00-00.jpg) ![Screenshot at 0:47: A slide summarizing The Bitter Lesson quote: "General methods that leverage computation are ultimately the most effective, and by a large margin," alongside historical milestones in Chess \(1997\), Go \(2016\), and a projection for Code \(2026\).](https://ss.rapidrecap.app/screens/GyuwH3Q_FlQ/00-00-47.jpg) ![Screenshot at 1:26: A comparison slide contrasting 'The Trap' \(Encoding Knowledge: trying to encode expertise, optimizing for what we know\) against 'The Winner' \(Leverage Computation: giving general methods massive compute and letting them learn from data\).](https://ss.rapidrecap.app/screens/GyuwH3Q_FlQ/00-01-26.jpg) ![Screenshot at 3:56: A slide titled 'Why the Lesson is Inevitable' showing historical examples \(Chess, Go, Code\) and the inevitable conclusion that general methods at scale beat encoded knowledge every time.](https://ss.rapidrecap.app/screens/GyuwH3Q_FlQ/00-03-56.jpg) ![Screenshot at 9:37: A comparison slide contrasting 'How We Build Now' \(Humans design. Then agents build, linear/top-down\) against 'How We Build in 2026' \(Agents build. Other agents use, recursive/bottom-up/agent-driven\).](https://ss.rapidrecap.app/screens/GyuwH3Q_FlQ/00-09-37.jpg)