←Back/Engineering/Claude
AdvancedEngineering

How to Build an Automated Software Factory with AI Agents

Turn a morning product brief into a queue of isolated builds, independent code review, working previews, and explicit merge decisions in Slack.

How to Build an Automated Software Factory with AI Agents

Source episode · 26:55

How I AI: Alex Finn's Local AI Fleet and Automated Software Factory

with Claire Vo

26:55 to 30:22: Alex Finn shows the morning-build conversation, separate Claude Code build and review loops, Slack handoff, Vercel preview, and rocket reaction that triggers the merge.

Read the full episodeWatch on YouTubeListen on SpotifyListen on Apple

Before you start

What you need

  • A repository with reliable setup commands, automated checks, and preview deployments
  • Claude or Claude Code with access to the repository
  • A task queue and isolated branches or worktrees
  • Slack or another review channel connected to the merge automation

What you’ll make

A repeatable delivery loop that turns a product conversation into reviewed, previewable changes and merges only the commit selected from its evidence.

Tools used

Step by step

The workflow

Follow the sequence once, then adapt the prompts, checks, and handoffs to your own setup.

6 steps

Step01

Turn the Morning Brief into a Build Queue

Begin with the product outcome for the day. Alex uses a morning-build conversation in Claude, answers questions about what he is considering, and turns the result into a short queue for Henry Intelligent Machines.

Example prompt
Create today’s build queue for [product].

Current state: [what works now]
Today’s outcome: [what should be true by the end of the day]
Constraints: [behavior, files, or systems that must remain unchanged]

Ask any product questions you need first. Then return three to five independent tasks. For each task include the user outcome, likely files or systems, acceptance checks, dependencies, and a clear finish condition.
Step02

Separate the Build and Review Loops

Run the builder and reviewer as separate Claude Code loops. The builder claims one queued task and records its checks; the reviewer starts from the task and diff, then fixes or returns problems before the preview handoff.

Example prompt
Review commit [SHA] for task [task ID]. Start from the task, acceptance checks, and diff. Do not rely on the builder’s explanation. Run the relevant checks and inspect the changed behavior. Return either:
1. Specific findings with file, consequence, and required correction, or
2. Ready for preview, with the checks and behavior you confirmed.
Step03

Post a Traceable Preview to Slack

After review passes, deploy the commit and send one Slack message that makes the artifact unmistakable. Alex’s message shows what was built, how to test it, and the Vercel preview before he reacts.

Example prompt
Post a Slack review message with:
Task: [ID and outcome]
Commit: [full SHA]
Preview: [URL]
What changed: [short list]
Checks: [commands and results]
How to test: [two or three exact actions]
Known gaps: [none or list]
Merge action: react with 🚀 to approve this commit.
Step04

Match the Review to the Change

Use evidence that matches the change. Open a user-facing preview and exercise the primary path; for a maintenance change, inspect the focused diff and test output. Send any failure back to the current task.

Example prompt
Evaluate [commit SHA] against these acceptance checks: [checks]. Record the result of each check, any unexpected behavior, and the exact reproduction steps for failures. Do not recommend merge while a required check fails.
Step05

Approve the Exact Commit with an Emoji

React with 🚀 only after the linked preview and evidence match what you intend to ship. The automation must associate the reaction with the message’s commit SHA, not merely the current branch head.

Example prompt
When a 🚀 reaction is received, read the commit SHA from that Slack message. Confirm the reaction is from an allowed user and that the preview still resolves to that SHA. If either condition fails, stop and post the mismatch.
Step06

Recheck, Merge, Deploy, and Report

Immediately before merge, compare the approved SHA with the branch head and required checks. Merge that commit, follow the deployment, and reply in the same Slack thread with the production result.

Example prompt
Finalize approved commit [SHA]. Confirm it is still the branch head and all required checks are green. Merge it, follow the production deployment, and post the production URL and deployment result in the original Slack thread. If the SHA or checks changed, request a new 🚀 reaction.

What good looks like

  • Each task is small enough for one build cycle and has explicit acceptance checks
  • A separate review context can reject the implementation and return a specific correction
  • The Slack handoff identifies the task, commit, preview, checks, and test instructions
  • The merge trigger is bound to the same commit that was shown and tested

Build your next product with ChatPRD

Turn an idea into a PRD, user stories, and a plan.

Try ChatPRD free

After the steps

Runbook notes

How to recover when the loop fails and where human judgment helps.

Recover

If it goes sideways

The morning brief produces broad tasks that cannot finish in one cycle.
Split each item by user-visible outcome, give it acceptance checks, and return unresolved product questions to the morning conversation.
The review loop repeats the builder’s assumptions or approves its own explanation.
Start the reviewer from the task, current diff, and acceptance checks in a clean context, then require file-level findings or a clear pass.
A reaction points at a preview whose commit has changed.
Put the commit SHA in the Slack message, compare it with the branch immediately before merge, and request a new reaction after any update.
The automated checks pass but the preview does not demonstrate the intended behavior.
Include exact test instructions in Slack and return the observed failure to the same task instead of opening a new one.

Keep building

Related workflows

Create a Production-Ready Design System Using Claude and Codex
intermediateDesignClaudeCodex+1

Create a Production-Ready Design System Using Claude and Codex

Use a hybrid AI workflow to bridge design and development. Generate high-level design concepts and tokens with Claude, then use Codex for robust implementation of the technical components in your codebase.

Open
Scale Code Quality with an Automated 'Land PR' AI Workflow
advancedEngineeringDevin

Scale Code Quality with an Automated 'Land PR' AI Workflow

Implement a QA loop for AI-generated code using Devin. This playbook combines automated code reviews with an agent-recorded video walkthrough for visual verification, ensuring high-quality merges at scale.

Open
Automate Business Health Checks with a 'Watchdog' AI Agent Playbook
advancedOperationsDevin

Automate Business Health Checks with a 'Watchdog' AI Agent Playbook

Build a reusable 'Watchdog' playbook in Devin to automatically monitor customer accounts. The agent proactively checks for errors, synthesizes a prioritized list of critical issues, and saves you time.

Open

Start shipping
better products.

Join 100,000+ product managers who use ChatPRD to write better docs, align teams faster, and build products users love.

Start building freeRequest a demo
Free to start
No credit card
SOC 2 certified
Enterprise ready