ninja nerdingRas Mic's software factory
Ras Mic's software factory
Ras Mic runs up to fifteen features at once on one app and barely reads the code. His software factory isn't a product. It's a handful of markdown files that walk any agent through four steps: isolate, build, prove, ship. The agent loops until an outside reviewer scores the work five out of five. Then he merges.
Jump to the four steps, the seven skills, or set it up yourself.
The video
31 minutes, posted Sept 14, 2026 on Greg Isenberg's channel. Timestamps on this page open it at that moment. The first minute and a half is intro and a sponsor read.
- 0:00 Intro (sponsor read until 1:28)
- 2:17 What “software factory” means
- 3:44 Why it matters, and his AGENTS.md
- 5:23 Step 1 · Isolate with Git worktrees
- 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 greploop and Greptile
- 26:52 Greg's physical factory analogy
- 29:21 A software factory is markdown files
- 30:02 Closing: use some code review agent
Nine signals
The whole episode in nine boxes. Each links to the part of this page that explains it.
- 0129:21
It's just markdown files
One AGENTS.md and a handful of skills. No special harness, no special model. Your workflow, written down so an agent can follow it.
How - 024:22
AGENTS.md holds the workflow
The file is sent to the agent with every message. Most people fill it with facts the agent could read from the code. He fills it with the steps, which it can't guess.
How - 035:23
Every task gets its own copy
Before any code, the agent makes a Git worktree and a branch for this one task. Two agents in separate copies can't overwrite each other.
How - 0411:34
Code follows one written structure
A skill says where the business rules go and where the reusable code goes. Without it, models ship code that works and is a mess inside.
How - 0514:52
Agents can't pinky promise
The agent has to show the change works: a before and after, a screen recording, or measured numbers. The proof goes in the pull request.
How - 0622:25
Loop until 5/5
A separate review agent, Greptile, scores the PR out of five. Anything under 5/5 sends the agent back to Build without asking you.
How - 0725:25
You ask, then you merge
He looks at the proof and the score, then clicks merge. He barely reads the code. The agent is told never to merge its own PR.
How - 0825:48
Many features at once
Each task is isolated and checks itself, so he can run several side by side. He says fifteen features on one app.
How - 092:25
Any model, any harness
It runs in Codex, Claude Code or Cursor. Two weeks later he changed his main model and the files stayed the same.
How
A factory is a few markdown files
“A software factory is literally just a bunch of markdown files.” No special harness, no particular model. Your workflow, written down so an agent can run it. 29:21
The problem
Think of the last app you built. You typed, looked, didn't like it, typed again. One feature at a time, you in the middle of every step. That doesn't scale past one chat window.
The move
At each step of building, ask how to get the most out of the model and how to keep moving. Write the answer as a skill. Then write one file, AGENTS.md, that says which skill runs when.
Why AGENTS.md
It's sent to the agent ahead of every message. Most people fill it with facts about the code, which the agent can read for itself. He fills it with a workflow, the one thing the agent can't guess. 4:22
15features at once
Different agents and subagents on one app, each in its own worktree. He only shows up to merge.
4terminal tabs
What he shows on screen: four features on Bezalel at the same time. An email client, a Linux computer, a landing page.
5–6markdown files
What he says the whole factory is: one AGENTS.md and a few skills. The repo holds seven skills today.
5/5before he looks
A PR reaches him only after Greptile scores it five out of five with no open comments.
On models: in this episode he calls GPT-6 Astra his workhorse and says Fable writes code better than some of the best engineers he's seen. Two weeks later he had moved to Opus 5.5. The walkthrough never needed any of them. It runs in Codex, Claude Code or Cursor. His numbers are his own; nobody has audited them.
Words on this page
Twelve terms, in plain words. Skip this if you already ship code through pull requests.
- Git worktree
- A second copy of the repo on disk, checked out on its own branch. Each agent works in its own copy, so two agents can't overwrite each other's files.
- Branch and main
- A branch is a separate line of changes in a Git repo. main is the branch that holds the real, shipped version. His agents never commit to it directly.
- Pull request (PR)
- A request to fold a branch's changes into main. It shows what changed, and it's where the proof, the review comments and the score end up.
- Merge
- Folding a pull request into main so the change goes live. In this workflow only he clicks merge. The agent is told never to merge its own PR.
- Greptile
- A code review agent that reads a pull request, leaves comments and gives it a confidence score out of five. greploop keeps fixing the PR until Greptile says 5/5.
- gh CLI
- GitHub's command-line tool. The agent uses it to list open PRs, open new ones and edit their descriptions. You sign in once with gh auth login.
- Harness
- The program that runs the model and gives it tools, such as Claude Code, Codex, Cursor or OpenCode. Some harnesses make worktrees on their own.
- Computer use
- An agent operating an app the way a person would: clicking, typing, looking at the screen. The evidence recorder films the agent doing this.
- Cloud agent
- An agent that runs on a remote machine instead of your laptop. He assigns bug tickets to Cursor or Devin cloud agents and finds a PR waiting.
- Port
- A numbered address where a running app listens on your machine, like port 3000. Worktrees don't separate ports, so two agents can collide on one.
- Lockfile
- A file that records the exact version of every package a project installs. When two branches change it, the rule is to regenerate it, never merge it by hand.
- Vendored
- Copied into his repo from someone else's. Three of the seven skills are vendored: from Vercel Labs, Greptile and Cursor's pstack.
The four steps
Click a station to read it. Or press Start and follow one feature down the line, including the laps back to Build when the review comes in under five.
Follow one feature
Eleven beats, from your prompt to your merge, with the review scores from the example he draws: 3/5, 4/5, 5/5. Watch how often it passes through Build without you.
Station 1 of 4
Watch at 5:23Isolate
Before any code, the agent fetches the latest main, checks open PRs for overlap, then makes a fresh Git worktree and branch for this one task. A worktree is a second copy of the repo on disk. The agent works in the copy and never on main.
Why: Most “my agent deleted my files” stories are two agents on the same branch. One is fixing the landing page, the other decides to rewrite that page's API calls. Separate copies can't collide.
What you see
A new folder and a new branch per task. Four terminal tabs can run four features on one app.
In a real factory
A custom order gets its own station, so it doesn't mess with the rest of production. Ras admits “isolate” is a bad name. Greg says it sounds like whey protein.
The seven skills
All in michaelshimeles/skills. Each is a folder with a SKILL.md the agent loads when the task matches. Three are his, one is his variant, three are borrowed. You rarely type any of them: AGENTS.md calls them in order.
- /new-feature01 IsolateStarts every task in its own Git worktree and branch, cut from the latest origin/main.
- /code-structure02 BuildA house style for code. Actions decide why and when. A service layer holds the reusable how.
- /evidence-driven-testing03 ProveThe agent tests the app by hand, clicking and typing through computer use, while a bundled recorder films the screen and stamps each check onto the video.
- /before-and-after03 Prove · 04 ShipTakes a before and an after screenshot of a page or one element, uploads the pair, and prints a table ready to paste into a PR.
- /greploop04 ShipKeeps fixing a PR until Greptile gives it 5/5 confidence with zero unresolved comments.
- /greploop-apps04 Ship · big PRsThe same loop for huge PRs. It tags @greptile-apps, which gets past the file-count limit that makes Greptile skip a big change.
- /unslopEvery step that writes for peopleEdits anything a person will read so it stops sounding machine-made. 31 named patterns: puffery, filler, hedging, chatbot phrases, em dashes, bold labels.
/new-feature
01 Isolate
Starts every task in its own Git worktree and branch, cut from the latest origin/main.
When to use it
- ·At the start of every feature, fix or task, before any code.
- ·Whenever more than one agent or session shares a repo.
What you type
Just ask for the feature. AGENTS.md makes this step one. To force it: /new-feature
What it does, in order
- 1Sync: git fetch origin.
- 2Scope check: list open PRs and the files they touch. If your task needs the same files, stop and ask.
- 3Name the task in lowercase with hyphens plus a short suffix, like user-auth-0816a. Never reuse a name.
- 4Create the worktree in a gitignored folder, on a new branch from origin/main.
- 5Go in, confirm the branch isn't main, install dependencies fresh.
- 6After the PR merges: remove the worktree, delete the branch.
git worktree add .worktrees/user-auth-0816a \ -b agent/user-auth-0816a origin/main
Needs: git and the gh CLI. In Claude Code and Cursor the harness makes worktrees itself, so the skill skips its own add and remove steps there.
Watch out: A worktree doesn't isolate ports, databases or lockfiles. Two agents can still fight over port 3000. Check a port is serving your process before you trust what it shows.
Read new-feature/SKILL.md His own
/code-structure
02 Build
A house style for code. Actions decide why and when. A service layer holds the reusable how.
When to use it
- ·Adding a feature that shares mechanics with one you already have.
- ·The same operational code is copy-pasted in two or more places.
- ·A bug fixed in one flow is still broken in another.
- ·Not when the logic has a single caller. That's over-abstraction.
What you type
Nothing. The agent reads it while it builds. To force it: /code-structure
What it does, in order
- 1Write the flow in the action first, so the behavior is clear.
- 2Mark the operational chunks that repeat across callers.
- 3Extract only those into small service functions. Explicit inputs, structured results, no reaching into the database.
- 4Swap one caller over, verify, then the rest.
- 5Keep auth, state changes and error handling in the actions.
Needs: Nothing to install. It's one markdown file. The examples are TypeScript but the rule isn't tied to a language.
Watch out: This is his taste, and he asks you not to copy him blindly. If a service layer isn't how you think, rewrite the skill for the structure you'd want to read. Keep the idea of having one.
Read code-structure/SKILL.md His own
/evidence-driven-testing
03 Prove
The agent tests the app by hand, clicking and typing through computer use, while a bundled recorder films the screen and stamps each check onto the video.
When to use it
- ·Any change that needs proof instead of a sentence saying it works.
- ·Bug fixes: record the failure before writing the fix.
- ·No screen to record: it falls back to scripted screenshots and Playwright video.
- ·Nothing visible at all: measured numbers, output pairs, transcript excerpts.
What you type
Nothing. It runs at step three. To force it: /evidence-driven-testing
What it does, in order
- 1Run doctor to see if this machine can record.
- 2Get the app to its starting state, window maximized.
- 3Start the recorder, then drive the app live.
- 4Annotate as you go: setup, test_start, and an assertion marked passed, failed or untested.
- 5Stop. You get evidence.mp4, report.md and manifest.json.
- 6Check the key frames, fill in caveats, post video and summary to the PR.
python3 $EVIDENCE doctor python3 $EVIDENCE start --output .artifacts/<task> --title "<what>" python3 $EVIDENCE annotate "$SESSION" --type assertion \ --result passed --message "<what you checked>" python3 $EVIDENCE stop "$SESSION"
Needs: Python 3 and ffmpeg (with libx264 and the ass filter). A screen it can capture: on macOS that means Screen Recording permission. An agent with computer use, or cua-driver in its place. The gh CLI to post.
Watch out: The hardest skill to get running. It won't record a screen showing secrets or customer data, and gh can't attach a local video, so the upload goes through a browser or a file host. If it won't work on your machine, before-and-after is the fallback.
/before-and-after
03 Prove · 04 Ship
Takes a before and an after screenshot of a page or one element, uploads the pair, and prints a table ready to paste into a PR.
When to use it
- ·The PR changes something you can see.
- ·Your machine can't do screen recording.
- ·You already have two PNGs from the Prove step. It accepts images as well as URLs.
What you type
Take before and after screenshots for this PR. Before is production, after is my local build.
What it does, in order
- 1Check the CLI is installed; install it if not.
- 2If a URL is a protected Vercel preview, sort out access first.
- 3Capture: before URL, then after URL. Add a selector to shoot one element.
- 4Upload with --markdown to get the table.
- 5Append the table to the PR description with gh pr edit.
before-and-after <before-url> <after-url> --markdown before-and-after before.png after.png --markdown before-and-after <url1> <url2> ".hero" --mobile
Needs: npm i -g @vercel/before-and-after agent-browser, and the gh CLI. The package name matters: plain before-and-after on npm is something else.
Watch out: The default upload host, 0x0.st, is public. Fine for a landing page, not for an admin screen. Pass --upload-url, or use the gist adapter, for anything private. It also treats the current state as After and will ask you where Before lives.
/greploop
04 Ship
Keeps fixing a PR until Greptile gives it 5/5 confidence with zero unresolved comments.
When to use it
- ·Right after the PR is open with its proof. AGENTS.md runs it for you.
- ·By hand, on any PR you want cleaned up before you look at it.
What you type
/greploop, or /greploop --max-iterations 5 to bound the cost.
What it does, in order
- 1Push, then ask for a review with an @greptile review comment, unless one is already running.
- 2Wait for Greptile's check to finish. It gives up after about ten minutes.
- 3Read the score and every unresolved comment.
- 4Fix the actionable ones. Resolve the threads.
- 5Commit, push, go again.
- 6Stop at 5/5 with nothing open, or at the iteration cap (10 by default). Report the result.
Needs: Greptile installed on the repo, and an authenticated gh CLI. Also works on GitLab (glab) and Perforce (p4).
Watch out: It resolves threads it judges to be false positives too. Skim what it dismissed. And a 5/5 is one reviewer's opinion. The before and after is still yours to look at.
/greploop-apps
04 Ship · big PRs
The same loop for huge PRs. It tags @greptile-apps, which gets past the file-count limit that makes Greptile skip a big change.
When to use it
- ·greploop comes back with “Too many files changed for review”.
- ·He puts the line at around 10,000 changed lines. The agent picks the variant on its own.
What you type
/greploop-apps
What it does, in order
- 1Same cycle as greploop.
- 2Every push needs a fresh @greptile-apps review comment, because auto-review skips these PRs.
- 3If no check run appears, it watches Greptile's summary comment for an edit with a new score.
Needs: Same as greploop.
Watch out: A PR too big for the reviewer is usually too big for you. Split the task if you can.
Read greploop-apps/SKILL.md His variant of greploop
/unslop
Every step that writes for people
Edits anything a person will read so it stops sounding machine-made. 31 named patterns: puffery, filler, hedging, chatbot phrases, em dashes, bold labels.
When to use it
- ·Before committing, posting or sending: commit messages, the PR title and body, docs, code comments, the closing reply.
- ·Only on text the agent wrote or changed. It leaves the rest alone.
What you type
Nothing. He edited the skill so agents apply it unprompted. To force it: /unslop
What it does, in order
- 1Scan for the patterns.
- 2Rewrite, keeping the meaning.
- 3Add voice: opinions, mixed sentence length, specifics.
- 4Self-audit: what still makes this obviously AI? Fix that.
Needs: Nothing to install.
Watch out: It isn't mentioned in the video. He says five or six files; the repo has seven skills, and this is the one he doesn't walk through.
The AGENTS.md
Skills are parts. This file is the assembly order. About 100 lines, six sections. It's written as a template: drop it in your repo and fill in the blanks.
- 01Workflow
The four beats, each naming its skill by slash command: isolate, build, prove, ship. Plus three notes on the ship step, including the public upload host.
- 02Writing for humans
Run /unslop over anything a person will read before it's committed, posted or sent.
- 03Multi-agent rules
Seven rules for agents sharing a repo. They are listed below.
- 04Completing a task
Eight steps from “stay in scope” to “present the PR URL”. Then one line: do not merge unless explicitly told to.
- 05Repo-specific sections to add
The blanks you fill in: your check commands, hard rules, environment notes, test fixtures, and what can't be tested locally.
- 06Skill sources
A table of where each skill came from: his repo, Vercel Labs, Greptile, Cursor's pstack.
Rules for agents sharing a repo
In our words. This is what lets him open a fifth tab without thinking about the other four.
- Never commit directly to main.
- One worktree and one branch per task and per agent. Never touch another agent's.
- Scope check before starting: skim open PRs' changed files. On overlap, stop and ask.
- Never force-push to main. Elsewhere only --force-with-lease, only on your own branch.
- Lockfile conflict? Regenerate it. Never hand-merge.
- Worktrees don't isolate ports or databases. Confirm a port is yours; no schema experiments on a shared database.
- If a conflict can't be resolved confidently, stop and report. Don't guess.
How a task ends
Eight steps, always the same. The last thing the agent says is a link.
- 1Keep changes limited to the task.
- 2Run the repo's checks. You list the exact commands.
- 3Assemble the evidence into before and after pairs.
- 4Commit, rebase onto the latest origin/main, rerun the checks.
- 5Push the branch.
- 6Open the PR: what changed, how it was tested, the proof, risks. Title and body through /unslop.
- 7Run /greploop until 5/5 with zero unresolved comments.
- 8End by presenting the PR URL.
Then: don't merge unless told to, and keep the worktree until the PR is merged or closed.
What proof looks like
Three kinds, all from pull requests his agents opened. He looks at these and skips the diff.
1 · A before and after
He asked for an admin email page on Bezalel. The PR opens with two screenshots side by side. 16:29
Before
“No such page on Bezalel.” A 404.
After
The email admin page, in the dashboard, working.
Sometimes the agent looks at its own after shot, sees the feature isn't finished, and goes back to Build without being told.
2 · Numbers
Clicks felt slow. Nothing to screenshot, so the agent measured page loads before and after its fix. 19:22
Read off the PR on screen. His verdict on 800 milliseconds: a sin in web development.
3 · A video
A recording of the agent using the app, attached to the PR under “proof of improvement”. This one came from a Cursor cloud agent. 21:49
He watches it like a short clip: the agent built the thing, and it works. That's what lets him merge without reading the code. Greg's comparison is tapping through stories: yes, yes, no.
On your own machine this is the evidence-driven-testing recorder. No built-in computer use? The skill drives the app with cua-driver.
Then the review. Greptile posts a summary, inline comments and a confidence score on the PR. The one he opens reads “Confidence Score: 5/5 · Safe to merge”, and started as a 3/5. 22:59
Set it up
About half an hour if you stick to screenshots. You need a GitHub repo and one coding agent already working. Greptile has a free plan for one developer; see pricing.
- 01
Install the skills
One command puts all seven where your agent looks for skills. It works for Claude Code, Cursor, Codex and most other agents.
npx skills add michaelshimeles/skills
skills.sh/michaelshimeles/skills - 02
Drop AGENTS.md into your repo
Copy his file to the root of your project. This is the part that turns seven separate skills into a line: it tells the agent which skill runs at which step.
AGENTS.md in his repo - 03
Fill in the blanks
His file ends with a list of sections to add. At minimum, write your real check commands under “Completing a task”, step 2. Then add the rules an agent must never break in this repo.
## Commands & checks npm run lint npm run typecheck npm test
- 04
Put a reviewer on the repo
Install Greptile on your GitHub repo and sign in to the gh CLI. If you'd rather use CodeRabbit or Macroscope, do, but then the ship step in AGENTS.md needs rewriting, because greploop only speaks Greptile.
gh auth login
Greptile pricing - 05
Get proof working
Start with screenshots, which work anywhere. Then run the recorder's doctor command to see if your machine can do video. On a Mac you'll need to grant Screen Recording permission. The path below is Claude Code's; yours depends on where your agent keeps skills.
npm i -g @vercel/before-and-after agent-browser brew install ffmpeg python3 ~/.claude/skills/evidence-driven-testing/scripts/evidence.py doctor
- 06
Ignore the scratch folders
Worktrees and evidence must never be committed. Add both folders to .gitignore. Use whatever worktree folder your harness uses.
.worktrees/ .artifacts/
- 07
Run one small task
Pick a small change you can see. Use the starter prompt below and watch every step. Fix whatever doesn't fire before you scale up.
- 08
Then open more tabs
One tab, one feature, one worktree. He runs four on screen and says fifteen. Start with two.
FakeNerd starter · your first run
Read AGENTS.md and follow its workflow for this task. Task: [one small change you can see, e.g. "add an empty state to the settings page"] Before you write code, tell me: 1. which skill you will use at each of the four steps 2. the worktree and branch you created 3. how you will capture the "before" state Do not merge. When Greptile is at 5/5 with zero unresolved comments, give me the PR link.
After that first run the prompt is just the task. He types “build me this” and the file does the rest. Reviewers other than Greptile that he names: CodeRabbit and Macroscope. “I would use a code review agent of any kind.”
What he runs it on
From his stack video, two weeks after the episode. The factory is the same; these are the machines and models under it. Timestamps in this section open that video. Full list: Ras Mic's stack.
T3 Code, across his machines
His daily driver. It runs the real Claude Code, Cursor or OpenCode harness underneath and hands threads to a Linux box, a Mac or his laptop. Its sidebar marks a thread done when the PR merges, so he can see what's finished without opening each one.
Cloud agents, started from a ticket
For apps in production, a bug becomes a Linear ticket and he assigns it to a Cursor or Devin cloud agent. The agent starts before he has read the report. By the time he looks, a PR is waiting.
Opus 5.5 now, not Astra
In the episode above he calls GPT-6 Astra his workhorse. Two weeks later he says Opus 5.5 does nearly everything. The skills and AGENTS.md didn't change, which is what model-agnostic means in practice.
Next to Warp's factory
FakeNerd has another page called the software factory, on Zach Lloyd's version. Both use the name. They sit at different sizes.
Where it runs
Ras Mic: Your machine, in whatever agent you already use. Cloud agents work too.
Zach Lloyd: The cloud. Agents in sandboxes, running whether you're there or not.
What starts work
Ras Mic: You. One prompt per feature, one tab each.
Zach Lloyd: Triggers. A labeled issue, a schedule, a monitor alert.
Who checks it
Ras Mic: The agent's own proof, then Greptile, then you.
Zach Lloyd: A review agent and a verify station, then a person.
Where people step in
Ras Mic: Twice: you ask, you merge.
Zach Lloyd: Three gates inside a loop that feeds itself.
What you install
Ras Mic: Seven skill folders and one AGENTS.md.
Zach Lloyd: A factory definition, agents, triggers, and the infrastructure under them.
Good for
Ras Mic: One builder shipping many features on one repo.
Zach Lloyd: A team that wants issues to become PRs with nobody starting each one.
In Zach's terms this is a strong crawl: one person, real automation at every step, a human starting each job. It's also the cheapest way to find out if you like working this way. More from Ras Mic on this site: his design workflow and his stack. The unslop skill comes from pstack, covered on the pstack page.
FakeNerd's take
The loop is the point
Each skill alone is ordinary. The line that matters is the one in AGENTS.md that sends a 3/5 back to Build without asking you. That's what turns four steps into a factory.
5/5 is an opinion
Greptile is another model reading a diff. It can pass a feature that does the wrong thing well. The before and after is your check. Don't merge on the score alone.
Start with screenshots
The video recorder needs ffmpeg, screen permission and an agent that can drive a computer. Get before-and-after working first. You get most of the trust for a tenth of the setup.
Mind the public upload
By default, proof screenshots go to a public file host. His AGENTS.md says so in a ship note. Set a private upload target before you point this at anything with customer data.
It isn't free
Greptile's free plan is 50 credits a month for one developer; Pro is $30 a seat. Every lap of the loop is a review plus agent tokens, and fifteen tabs is fifteen of those. Cap the iterations.
Copy it, then change it
“I don't want you to blindly copy me.” The build skill is his architecture and the reviewer is his pick. Keep the four steps, swap the contents for how you work.
Attribution
- Building a Software Factory that actually works, Greg Isenberg with Ras Mic (Sept 14, 2026). The four steps, the examples and the factory analogy are from this episode. Quotes are from its captions; the load times and review score are read from the screen. Sponsored by Brex, which isn't part of the workflow.
- My Agentic Development Stack, Ras Mic (Oct 1, 2026). Only the “What he runs it on” section and the Opus 5.5 note come from it, from its captions.
- michaelshimeles/skills, read Oct 1, 2026 (1,195 stars). Skill behavior, commands and requirements are from the SKILL.md files and AGENTS.md, summarized in our words. Borrowed skills: before-and-after (Vercel Labs), greploop (Greptile, MIT), unslop (Cursor's pstack, MIT).
- rasmic.xyz, Michael Shimeles (Ras Mic). He posts as @Rasmic. Greptile prices from its pricing page, checked Oct 1, 2026.
- The eleven-beat walkthrough, the starter prompt, the comparison and the takes are FakeNerd's. Not sponsored by anyone on this page.