Building a Software Factory that actually works (Full Course)
Ross Mickey explains how to build a software factory—a systematic workflow using AI agents to ship high-quality software at scale. The factory concept uses markdown files to define agent behavior and follows four key steps: isolate (branching), build (with code structure guidelines), prove (with before/after testing), and ship (with automated code review).
Summary
A software factory is a model-agnostic, harness-agnostic workflow system that maximizes AI agent capabilities throughout the development process. Unlike manually prompting AI tools back-and-forth, a software factory structures how agents work to ensure speed and quality simultaneously. The system is built on markdown files injected into agent prompts, not proprietary products—making it accessible to anyone.
The workflow has four sequential steps. First, isolate: agents create fresh git work trees branched from main, allowing multiple agents to work on different features simultaneously without conflicts or overwriting each other's work. This solves the common problem where agents delete or overwrite code when working on the same branch. Second, build: agents follow a code structure skill (service layer architecture) that ensures code is written cleanly and maintainably, not just functionally. Third, prove: agents must provide before-and-after evidence of their work through screenshots, videos, or performance metrics to verify features actually work as claimed. Fourth, ship: automated code review tools (like Grapile) check pull requests and assign confidence scores; if the score is below five out of five, agents automatically loop back to the build step to address feedback.
Mickey demonstrated this with real examples: a PR showing before/after screenshots of an admin email page, performance improvements reducing page load times from 815ms to 61ms with actual metrics, and iterative code review feedback that agents address automatically until quality standards are met. The system allows him to manage 15 simultaneous features across different agents without conflicts. Once a PR reaches a five-out-of-five score, Mickey simply clicks merge—the agent has done the work without human code review. The factory approach treats AI agents like a coordinated engineering team, with isolation preventing conflicts, guidelines ensuring quality, proof enabling trust, and automated review maintaining standards.
About this episode
Get Your Complete Financial OS at https://startup-ideas-pod.link/brex_SIP I welcome Ras Mic back to the pod to explain the phrase "software factory." Mic shares his screen and walks through the exact system that he runs today. His factory has four steps: isolate, build, prove, and ship. He keeps the whole system in five or six markdown files, so it works with any model and any harness. By the end of this episode, you can boot up your own factory, run many agents in parallel, and trust the code that comes back. Create your own Software Factory: https://startup-ideas-pod.link/ras-software-factory Timestamps 00:00 – Intro 02:17 – Software Factory Definition 03:44 – Why the Software Factory Matters 05:23 – Step 1: Isolate With Git Work Trees 11:34 – Step 2: Build With the Code Structure Skill 14:48 – Step 3: Prove With Evidence-Driven Testing 22:25 – Step 4: Ship With Grep Loop and Greptile 26:52 – The Physical Factory Analogy 29:21 – A Software Factory Is Markdown Files 30:02 – Closing Thoughts Key Points • A software factory is a workflow of skills and domain knowledge, so it runs with any model and any harness. • Isolate: every feature starts in a fresh git work tree branched from origin main, so each agent keeps its own station. • Build: a code structure skill makes the agent write service layer code that a human developer can read. • Prove: the agent records a before state and an after state as video, screenshots, or numbers. • Ship: Greptile scores the PR, and the agent loops back to build until it earns five out of five. • Mic runs up to 15 features in parallel and reviews the visual proof instead of the raw code. Numbered Section Summaries 1. What a Software Factory Means Ras defines the term as a workflow, a set of skills, and domain knowledge, packed into markdown files. The word "factory" points to structure, speed, and a conveyor belt that keeps quality high. He is clear that a software factory is a method rather than a product you buy. 2. Why the Factory Matters Now Model intelligence keeps rising, and Ras names GPT-6 Astra as his workhorse and the model with the lowest hallucination rate. A factory lets you use that intelligence in a systematic way, instead of typing back and forth with a chat window. He offers his own skills for free, and he asks people to understand the process first and then adapt it. 3. The Agents.md File as the Master Instruction The agents.md file is a single markdown document that goes into the agent chat ahead of every message. Ras says most people fill it with facts the agent already reads from the code base. He fills his with a workflow instead, because the workflow is the part the agent lacks. 4. Step 1: Isolate A skill called "new feature" starts each task in a fresh git work tree branched from origin main. A work tree acts like a copy of the app, and the agent merges it back later. This keeps two agents apart, so one agent leaves the other agent's files alone. Michael shows four terminal tabs running four features on the same app. 5. Step 2: Build The code structure skill tells the agent to write in a service layer architecture. Models get the job done, and they often get it done in a sloppy way, so the skill supplies the guideline. The result stays readable for a hired developer, for Michael, and for any fresh agent that opens the code base later. 6. Step 3: Prove Two skills handle proof: evidence-driven testing and before and after. The agent records the broken state, does the work, and records the working state, then embeds both in the PR. When the after shot shows a gap, the agent sends itself back to the build step on its own. For work with an invisible surface, such as performance, the agent supplies numbers: one page went from 815 milliseconds to about 61. 7. Step 4: Ship The grep loop skill sends the PR to Greptile, a third-party code review agent, and Greptile returns feedback plus a confidence score. A three out of five sends the agent back through build, prove, and ship. Ras steps in at five out of five and clicks merge. He mentions Code Rabbit and Macroscope as alternatives. 8. The Factory Analogy and the Case for Code Review I map the four steps onto a real factory: a custom order gets its own station, the assembly line builds it, quality control tests it, and shipping sends it out the door. Ras agrees, and he says he may rename his skills to match. The #1 tool to find startup ideas/trends - https://www.ideabrowser.com LCA helps Fortune 500s and fast-growing startups build their future - from Warner Music to Fortnite to Dropbox. We turn 'what if' into reality with AI, apps, and next-gen products https://latecheckout.agency/ FIND ME ON SOCIAL X/Twitter: https://twitter.com/gregisenberg Instagram: https://instagram.com/gregisenberg/ LinkedIn: https://www.linkedin.com/in/gisenberg/ FIND MIC ON SOCIAL X/Twitter: https://x.com/Rasmic Youtube: https://www.youtube.com/@rasmic
Key Insights
- A software factory is completely model and harness agnostic—it's not a product but rather a workflow system built on markdown files that pack domain knowledge and development skills, independent of which AI model or tool is used
- The isolate step using git work trees prevents the common failure mode where agents overwrite each other's work by having each feature built on a separate branch copy rather than directly on main
- Even powerful models like GPT-4 and Astro write code that works but is structurally poor; the code structure skill forces agents to write in service layer architecture that's maintainable and understandable by humans or other agents
- Evidence-driven testing with before-and-after screenshots or videos serves as visual proof that work is completed, allowing non-technical reviewers to verify results without reading code
- When an agent's code review score is below five out of five, the system automatically loops the agent back to the build step rather than requiring manual intervention to fix identified issues
- The system enables one person to manage 15 simultaneous feature branches with different agents working in parallel without conflicts, compared to traditional linear sequential feature development
- Mickey demonstrated reducing page load times from 815 milliseconds to 61 milliseconds with actual performance metrics as proof, showing agents can optimize non-visual improvements with measurable data
- A software factory mirrors traditional software engineering practices like code review and PR-based workflows but applies them to AI agents instead of human developers, creating a system of trust through structured verification
Topics
Transcript
[0:00] What are software factories and why is it going viral? I mean, it's basically this concept that allows you to use AI agents to actually ship software that isn't sloppy at all that is more like a factory, more like think about an assembly line and you're just instead of building physical products, you're building software. And that's kind of the dream. I mean, if you're able to just create this factory that builds software and it's valuable software and you can create multiple apps that generate revenue and add value to [0:31] people's lives. That sounds pretty good to me. So, in today's episode, I brought on Ross Mike and he clearly explains the entire process. [music] By…
Full transcript available for MurmurCast members
Sign Up to AccessMore from Greg Isenberg
Instinct AI is For Real. What You Need to Know.
Hosts Greg and Remy review Instinct AI, an invite-only personal agent app raising at a $10 billion valuation, demonstrating its capabilities for booking flights, restaurants, obtaining visas, and other personal tasks. They highlight its impressive simplicity, human-like communication style, and network effects through its trusted agent connectivity, while flagging privacy and data retention concerns.
Build Bigger with GPT-6 Astra (here's what to do)
This episode explores practical applications of GPT-6 Astra beyond flashy demos, featuring nine actionable prompts for productivity and business, and demonstrating how Astra enables hardware projects through AI assistance with design, code generation, and supplier sourcing.
What are Agentic Loops?
Professor Ross Mike explains agentic loops — AI systems that self-iterate without human input — and argues they are largely impractical for most developers due to high token costs and poor assumption-making. He distinguishes between 'human in the loop' (iterative, guided development) and fully automated loops, recommending loops only for constrained, binary-feedback processes like code review. He shares his own GP loop use case as a rare valid example.
Clearest Explanation of AI Agents as Customers
The speaker argues that AI agents are becoming the primary 'customers' of the internet, replacing human users as the dominant force driving web traffic and commerce. This shift requires entirely new infrastructure — from agent-native inboxes and wallets to machine-readable websites — creating massive startup opportunities. The speaker frames this as a bifurcation of the internet into a human layer and an agent layer.
How to use Obsidian with Claude in 61 seconds
This short tutorial outlines three levels of using Obsidian with Claude AI to accelerate professional learning and career resilience. It covers connecting Obsidian to Claude via MCP, using the Smart Connections plugin to identify skill gaps, and prompting Claude to generate a public learning plan based on your notes.