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

Matt and Trevor talk about GraphQL and try to answer the question "do we need it?" (Bonus hot takes on VCR snapshot testing)

Trevor Turk on Twitter // Hello Weather
Matt Swanson on Twitter // arrows.to

GraphQL: The Documentary
GraphiQL
n+1 problems in GraphQL
BFF: Backend for Frontend
Graph Theory
Schema stitching

Bonus: VCR

Matt and Charity talk about Friday Deploys and try to answer the question "do we need them?"

Charity Majors on Twitter // honeycomb.io
Matt Swanson on Twitter // arrows.to

Friday deploy freezes are exactly like murdering puppies
Coaching tree
Frequency Reduces Difficulty (Martin Fowler)
Payoff space vs consistency space
Blame-aware postmortem
DORA metrics