YAGNI

I need a software foreman w/ Stephen Margheim

Matt Swanson — Mon, 12 Oct 2026 14:16:28 -0700

🔗 Impatient Programming: an invite for YAGNI listeners. This is a free guide to how Stephen’s team at Zar builds software with coding agents. It reworks Extreme Programming’s rules for working with agents and includes case studies, essays and tools. Nothing is for sale; signing up gives you access to everything.

Stephen Margheim leads product engineering at Zar, a stablecoin neobank for developing countries. His first big push with AI agents left a mess he had to read through and fix file by file. Now he runs ten sessions a day, reads maybe 10% of what ships, and feels more confident than before. He explains what changed: if code is cheap, keeping the codebase clean is worth more than ever. He and Matt talk about all-or-nothing changes, why he’d rather have a “software foreman” than a software factory, how he rewrote all of Zar’s money-movement logic in 30 to 50 small releases, and why quality checks should set floors, not targets.

Mentioned in this episode

Code Is Cheap Now. That’s Why It Matters.: The essay behind the episode. Because agents learn from the code around them, a messy codebase spreads mess into every session your team starts. Making it consistent is now cheap enough to do in one pull request, the way a team runs Prettier across every file at once.
I Don’t Need a Software Factory. I Need a Software Foreman.: Stephen’s essay on why the real value is agents paying attention around the clock, not generating code. His foreman agent’s system prompt isn’t “find and fix bugs.” It’s “notice anything worth noticing.” Layers of filtering then decide what’s urgent, what needs a closer look and what’s ready for a fix. That way you get short, clear flags instead of a stack of automated PRs.
Rubber-band AI: Matt’s Mario Kart theory that people who never learned the old way may slingshot ahead. Stephen’s reply is that they may also be falling behind without realizing it.
exhale: A Rails gem built around Stephen’s “inhale and exhale” rhythm, where agents explore freely and then pull the code back together. It fails a pull request when it finds duplicated code that hasn’t been listed as intentional, along with the reason, in a “Contract” file. That keeps agents’ spread-out exploration from piling up.
ACID: Stephen borrows the database idea for every code change. A change is “zero or a hundred,” so if a pattern is better, you make it true everywhere in that PR. Debates happen afterward, based on real use, and his team is on version 3 of its runtime constants system that way.
Putting an Agent in an Orb: A callback to the Thorsten episode, where an agent checks the browser console every day. It’s an example of Matt’s point that a lot of this watching takes patience more than brilliance.
Goodhart’s law: The idea behind floors versus targets. Chasing numbers leads to lots of small, over-tuned pieces. A minimum bar, like “below 80 on evals means no,” keeps a system simple, with fewer parts that each do more.

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 haley@laravel.com and mention YAGNI

Retiring from programming w/ Justin Searls

Matt Swanson — Fri, 02 Oct 2026 06:30:36 -0700

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.

Irrefutable proof w/ Thorsten Ball

Matt Swanson — Fri, 02 Oct 2026 06:23:25 -0700

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.

Camping chair development w/ John Nunemaker

Matt Swanson — Thu, 01 Oct 2026 07:10:16 -0700

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.

LLM junk food w/ Justin Duke

Matt Swanson — Thu, 01 Oct 2026 06:58:46 -0700

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.

Infinite plausible PRs w/ Nate Berkopec

Matt Swanson — Wed, 30 Sep 2026 10:12:32 -0700

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.

What would you say...you do here?

Matt Swanson — Wed, 30 Sep 2026 05:58:02 -0700

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.

Programming Books w/ Aaron Francis

Matt Swanson — Tue, 05 Dec 2023 07:00:00 -0800

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

This season of YAGNI was made possible by our friends at Flipper Cloud - Are big launches stressing you out? Then you need feature flags!
Flipper Cloud helps your team deploy the code now and then roll out features when you’re good and ready. Get started for free at
flippercloud.io

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?