YAGNI

Matt just got back from Rails World, where DHH's keynote left a lot of people thinking Rails was over. Justin Searls of Breaking Change, who gave his own retirement talk at Rails World two years ago, joins him to sort it out. They cover why the keynote hit people's fears so hard, whether "the one-person framework" still means anything when agents skip the coding step, and why Justin thinks Rails is heading into another stable era. Justin also explains why taste is the skill that lasts, how he runs seven iOS apps with agents fixing bugs every hour, and what he'd tell someone who's scared right now.

Mentioned in this episode

• DHH's Rails World 2026 keynote: The "pencils down" keynote with barely any Rails in it. Justin watched it at 2x and heard things he's been saying for two years. For a recap, see Global Nerdy's "most confusing funeral I've ever experienced".
• The Empowered Programmer: Justin's Rails World 2024 talk in Toronto, the last one before he retired from speaking. He built the app behind it by hand, and even then he could see an end coming for framework conferences.
• Brooks's law: Justin and Scott Werner's octopus math. Eight engineers, each running eight agents, act like 64 people when it comes to coordination. That's why Justin thinks the ideal team size is now one.
• WebKit's performance policy: Safari got fast because any change that made it slower failed the build. Justin's example of a clear numeric target that agents can chase without stopping.
• Xcode 27's Device Hub: Apple's replacement for Simulator. Combined with Xcode's MCP tools, Justin runs 16 simulators at once with agents testing each one, and his Mac's fans running flat out.
• Mr. Meeseeks: Justin's model for AI code review. His Opus subagents exist only to review the diff and keep going round after round, sometimes 12 or 15 times, until they can't find anything to fix. As he puts it, no human was ever really reading pull requests anyway.
• Why Elixir is the best language for AI: José Valim's case for Elixir being ready for agents. Justin remembers Valim calling it maybe "the last language in the door," since nobody may build a new language once humans no longer care how it feels to write.
• The Jevons paradox: The idea behind Justin's argument about auto-industry jobs. Software has always been limited by how many good programmers there are, so demand for software will surge first. Then, like car factories, the hiring boom ends once demand is met. "Every shortage is followed by a glut."
• World of Warcraft: Forever: The epilogue. Two former WoW addicts ask whether "the millennial retirement home" will pull them back in, and whether automating your WoW questing with agents misses the point entirely.

Thorsten Ball, who works on Amp, doesn't like the term "software factory." He'd rather be in a workshop, a garden or a "primordial soup" of throwaway tools. He and Matt talk about custom tools you build in minutes and throw away, why the huge jumps in AI tooling make it hard to bring people along gradually, and which old coding rules still matter now that agents write the code. Along the way: a thumbnail picker, a Go interpreter made 16x faster, Dwarf Fortress's 2,000-line functions and whether Rails World is about to get strange.

Mentioned in this episode

• Putting an Agent in an Orb: Orbs are remote machines where Amp agents run on their own. Thorsten describes how the team rebuilt its repo so agents always have a "paved path." That's where Brad's throwaway video-thumbnail picker and the daily agent that clicks through the site checking for console noise both run.
• Declaration on Mathematics and AI: Terence Tao and 24 other Fields Medalists warn that AI labs and mathematics are "severely misaligned." Thorsten's takeaway: you can't bolt AI onto old processes, whether in academia or software. You have to rethink the processes.
• My Job Went to India: Chad Fowler's 2005 career guide, written for an earlier upheaval. Its lesson still applies: watch where the industry is heading, or you'll be "writing BlackBerry apps in 2026."
• John Henry: The folk hero who beats the steam drill and then dies from the effort. Matt's parable for developers racing the models.
• Writing an Interpreter in Go: Thorsten's own book, written test-first. He asked GPT-6 Astra to make the interpreter twice as fast and got 2.3x. Then he took the leash off and got 16x.
• The Wrong Abstraction: Sandi Metz on why duplication beats the wrong abstraction. Thorsten says the "wait for three copies" threshold might be nine now, since agents don't feel the pain of repeating themselves.
• How Dwarf Fortress is built: 700,000 lines, 20 years and a code style that breaks every guideline, and it's a huge success. Thorsten's point: nothing beats "it works."
• Software Engineering at Google: Thorsten's example of "the biggest trick the devil ever pulled." Practices built for a company with endless money got copied by 20-person startups that don't make money yet.
• Bun is joining Anthropic: Thorsten sees it as a sign that frameworks are no longer the biggest source of leverage. When an agent can build an S3 adapter in three minutes, why package it into a framework?
• Omarchy: DHH's Linux setup, where users now build their own custom apps. Thorsten predicts "500 different date pickers." It'll be cheap for everyone to have their own, so fewer things will be worth generalizing and sharing.

Further reading

• Raising an Agent: Thorsten and Quinn Slack's podcast, which he mentions a few times.
• What I believe about the future of software development: Thorsten's recent post, a written version of the "software as we know it is dead" argument.

John Nunemaker runs Fireside, Flipper and Box Out. He used to think of himself as a craftsman, until last December, when he found out that what he really loves is shipping. Now he reads the data models and queries but not the JavaScript. He's also dropping plugins and rewrote 80% of Fireside's infrastructure in three days while driving a camper. He and Matt talk about when you're the brain and when you're the hands, why agent tools hand you too many open loops at once, temporary scoped API keys, and why testing and verification might finally stop being seen as lower-status work.

Mentioned in this episode

• Compound Engineering: Every's plan, build, review, compound loop. The last step turns anything you did into a process you can reuse next time. John used it for about a month before paring back his setup.
• gstack: Garry Tan's Claude Code setup. John dropped most of it but kept the browse tools for before-and-after screenshots. Those led to his most-used homemade skill, /prove, which asks the agent to prove its work actually works from start to finish.
• Caddy on-demand TLS: This replaced Fireside's tangle of Nginx, background jobs and Redis for custom-domain SSL. The app says which domains get a certificate, and Caddy handles the rest. Claude suggested it after John asked what tool does this.
• Railway's canvas, for agents: This is John's pitch for fixing agent overload. He wants every worktree in Conductor, Codex or Cursor to be a box on an infinite canvas that you can group, connect and move out of the way, instead of an endless list of open loops.
• Codex remote access: Scan a code with your phone, and your Mac, fully set up and sitting on your desk, takes commands from a camping chair. This is what got John "mainlining" Codex.
• Cloudflare Tunnel: John's way to check work from his phone. The agent installs cloudflared, adds the host to Rails, restarts the server and gives him a link.
• Toxiproxy: Shopify's proxy for simulating slow, failing or flaky connections. John used it on GitHub's availability team so that a notifications database outage wouldn't take down all of GitHub.
• StrongDM's Digital Twin Universe: The "fake Slack" idea. Agents build single-binary clones of third-party APIs, so you can test OAuth, webhooks, rate limits and outages from any worktree. John now wants to do this for X and Meta at Box Out.
• Wispr Flow: After years of hand and arm pain, John now talks to his agents all day. The only problem is a sore throat.
• Flipper: John's feature flag product. His closing prediction: when nobody reads the code, feature flags and APMs matter more, so APMs will have to get much cheaper.

Justin Duke, who runs Buttondown, calls himself a "radical LLM centrist." About two-thirds of Buttondown's merged code comes from LLMs, but he still pushes back on the most extreme software factory takes. He and Matt talk about why most "factories" are only tuned for throughput and why so much agent work is snacking: low effort and low value. They also get into the rise of fake third-party services, and whether Kanban is a warning about borrowing manufacturing ideas without the principles behind them. Plus: a huge pile of regexes, CI that rejects PRs without screenshots, and why Buttondown's Storybook has quietly become its staging server.

Mentioned in this episode

• Snacks are cheaper and tastier than ever: Justin's post on how LLMs make low-effort, low-value work very tempting. You get the rush of 15 merged PRs and no effect on customers. It pairs well with his Be careful what you make easier.
• PlanetScale's self-improving database: Both teams feed PlanetScale's Insights and schema recommendations to agents that open PRs, some of which merge automatically. It's close to a free lunch, though Justin argues it's also where the factory metaphor breaks, since real factories don't improve themselves.
• Linear Customer Requests: Justin's favorite little-used Linear feature. You link issues to customers along with their revenue, so "who's asking for this, and does it change whether they churn?" gets answered before an agent starts on the backlog.
• Plain: Buttondown's support tool. Instead of sending every thread to an LLM classifier the way Plain would like, they use a "staggeringly terrifying" pile of regexes that's easy to improve over time. Matt's team went the same way, with LLMs writing the regex instead of being the classifier.
• StrongDM's Digital Twin Universe: This is the software factory's take on the manufacturing "digital twin." StrongDM had agents build clones of Okta, Jira and Slack from their public API docs so they could run thousands of test scenarios an hour.
• Miniflare vs. stripe-mock: What matters most in a fake service is keeping state. Cloudflare's local simulator remembers what you did. With Stripe's mock, if you create a customer and then list customers, you get an empty list.
• Litmus / Email on Acid: Testing email rendering still means somebody keeping a headless Windows XP box running. Now it's much cheaper to build that kind of internal tool yourself.
• Storybook + Buttondown's demo site: Buttondown's "storybook maximalist" setup has stories for every page, component and transactional email, all snapshot tested. The public demo site with realistic data covers everything else, so they barely use their old staging server.
• Rails forensics skill for CVE-2026-66066: After the Active Storage image-upload RCE, known as KindaRails2Shell, 37signals released agent skills that check whether you were vulnerable and whether you were actually exploited. A small team would never have done that kind of investigation before.
• The productivity paradox: Justin asks why GDP hasn't grown with technology. His test for LLMs is what they let you do that your people and budget couldn't do three years ago.

Thank you to this season’s sponsor Laravel Cloud. Laravel Cloud is expanding beyond PHP to host your Rails, Node, or Django apps. For early access to the best place to host your app, email [email protected] and mention YAGNI

Back in February, Nate said that coding workflows built around adding more human-in-the-loop steps were a dead end, and that the end state is the "dark factory," where humans aren't allowed on the floor. Six months later, Matt asks him where he stands now. They cover why agents that produce endless plausible PRs haven't made anyone much faster, and why the real bottleneck is deciding what can actually be merged. They also talk about why software never learned to measure "quality" the way manufacturing does, why everyone's factory will probably be custom-built, and why feature development is the last thing you should automate. Along the way: Toyota fenders, bourbon tasters and a Dependabot setup you could build this afternoon.

Mentioned in this episode

• METR: AI's effect on experienced open-source developers: This is "the METR study nobody likes to cite." Experienced maintainers thought AI tools made them about 20% faster, but they were actually 19% slower. Compare it with the time-horizons graph that everyone does cite.
• Tobi Lütke's Liquid PR #2056: An overnight autoresearch loop found parse and render times 53% faster, with 61% fewer allocations. The tests pass, but the PR is still open, because Liquid runs all of Shopify and has no formal spec. Background: Shopify's autoresearch write-up.
• Hacker Typer: Nate's name for running six agent windows at once. It feels productive and hits every "chimp reward pathway," but that doesn't mean anything is getting done.
• Claude Code Review: Anthropic's multi-agent PR reviewer, which costs about $15–25 per review. It's an example of AI now beating humans at catching bugs, and of how token costs add up once agents are opening their own PRs.
• Cursor Automations: This is what Matt's team built their "gateway drug" factory on. When Dependabot opens a PR, an agent reads every changelog, checks the codebase for affected code, and then either merges the PR or flags a human.
• Intercom: AI is approving our pull requests: This is where Nate got the counter-metric of tracking how many auto-merges get reverted. It keeps "merge rate" honest.
• Why Ramp built its own background agent: Ramp and Intercom are both B2B SaaS companies, but they built very different factories. That's Nate's case for why every factory will be custom-built.
• whenwords: Drew Breunig's "software library with no code." It's just a spec and tests, and an LLM builds it in any language. Nate calls it the 3D printing of software factories: impressive but narrow.
• The Cockburn Scale: Alistair Cockburn's grid of team size against criticality, from "loss of comfort" up to "loss of life." Not every app needs the same factory, because HIPAA and rocket software aren't a CRUD app.
• The Mythical Man-Month: Brooks's law says adding people slows a project down because of communication overhead. Nate argues it doesn't apply to agents, and that's why factories can scale when teams of people can't.

Software used to be something you sat down and wrote.
Line by line. 
Decision by decision.

The work lived in the hands of the person at the keyboard.

That world doesn’t really exist anymore. Everything is changing: who does the work, how fast it moves, what counts as “writing,” what still needs a human in the loop

Instincts and best practices are built on ideas that are getting invalidated faster than ever. So we have to go back and figure out what we're actually doing here. 

Welcome to YAGNI, Season 3: The Software Factory.

Matt and Aaron talk about programming books and try to answer the question "do we need them?"

Aaron Francis on Twitter // PlanetScale
Matt Swanson on Twitter // arrows.to

Aaron's shed
Aaron reading printed docs on the beach
SQL Window Functions
The Pragmatic Programmer
The Timeless Way of Building
Culture is Stuck
Use the Index, Luke!
MySQL for Developers course
Why do programmers use books as monitor stands?

Matt and Nate talk about Redis and try to answer the question "do we need it?"

Nate Berkopec on Twitter // Speedshop
Matt Swanson on Twitter // arrows.to

"Redis is not faster than your database"
"Your data fits in RAM"
March of progress
neo4j
sidekiq
ACID
kredis
Wafris
"Running Sidekiq...with a volatile eviction policy"
Solid Queue
Solid Cache
The open source gift exchange
puma/puma
The Silver Rule

Matt and Jason talk about Service Objects and try to answer the question "do we need them?"

Jason Swett on Twitter // Code with Jason
Matt Swanson on Twitter // arrows.to

Jason's Snail Mail newsletter
Brevity is the soul of wit

Matt and Josh talk about automated testing and try to answer the question "do we need them?"

Josh Pigford on Twitter // Detangle
Matt Swanson on Twitter // arrows.to

Wittgenstein's Ruler
Why doesn't Stripe have a /mrr endpoint?
GitHub Project Paper Cuts
Baremetrics
Maybe
Laser Tweets
Cedar & Sail
The best restaurant in the world
Kim Kardashian - Kimoji app
Cursor AI Editor
Stated vs Revealed preferences