Agents can produce code quickly. Reviewers still need the request, proof that the problem exists, the real diff, passed checks, and any decision that belongs to a person.

You'll build a factory that keeps those records in durable, risk-routed work orders. Low-risk changes can proceed, ambiguous requests ask for clarification, false premises stop, and public API changes wait for approval.

The first payoff arrives before any service setup: you will trace a factory that refuses to fix a bug the repository proves does not exist. Live credentials and connector wiring wait until Section 3, when the factory needs them.

What you'll build

Our factory maintains a TypeScript notification SDK. Each GitHub issue becomes a durable work order that can:

Implement a supported change and prepare it for review
Ask a focused question when the request is incomplete
Stop when repository evidence contradicts the issue
Wait for human judgment before a consequential change

AI SDK classifies the request. Deterministic TypeScript selects its route, and scoped tools enforce the boundary. eve preserves the run across model calls, sandboxes, redeploys, and approval pauses.

The Investigator tests the issue's premise before code changes. The Builder works from an approved specification inside its own Vercel Sandbox. A Verifier checks the pushed branch in a fresh context and receives the real diff instead of the Builder's confidence.

Public software-factory material often names the stages classifier, analyst, implementer, and reviewer. This course refines that sequence around risk and evidence: classification and routing stay at the root, while the Investigator, Builder, and Verifier receive isolated capabilities for the work they are allowed to perform.

Want to learn more? Explore Foreman in Vercel's Agent Stack guide, a production software factory built on eve, and read how Vercel built the AI SDK software factory. Both show these patterns at production scale while keeping human judgment at the center of consequential decisions.

The factory may create a branch and open a draft pull request. Merge authority stays with the human reviewer.

Four case files

The course uses four issues to make the policy visible.

Uppercase channel names fail. Reproduce the plausible bug, build from the supported spec, and verify the candidate.

Clarify webhook retries. Ask for the missing behavior before editing.

Empty messages are delivered. Record that the SDK already rejects them, then stop with zero changed lines.

Add delivery priority. Wait for a person to accept the public API consequences.

These outcomes describe the whole run. The implementation uses narrower words at each layer:

Course outcome	Root decision	Work-order status	Investigator disposition
`fix`	`proceed`	`routed` → `investigating` → `building` → `verifying` → `ready-for-draft-pr`	`proceed`
`clarify`	`clarify`	`needs-clarification`	`needs-clarification` when investigation reveals the gap; otherwise no Investigator runs
`reject-premise`	`stop`	`stopped`	`unsupported`
`human-judgment`	`wait`	`awaiting-approval`	`proceed`; the evidence supports the request, but policy still requires approval

The course outcome summarizes the run, the root decision controls the next action, status records progress, and disposition records what investigation learned.

Course path

The Trust Bottleneck, about 35 minutes. Compare four outcomes and create a durable work order.
Decide What May Proceed, about 50 minutes. Classify each request and route it by risk.
Prove the Request, about 60 minutes. Connect the live services and reproduce the claim before changing code.
Build Without Blind Trust, about 75 minutes. Implement the specification and check the real diff.
Operate Selective Autonomy, about 70 minutes. Publish drafts and turn failures into evaluations.

Plan on roughly five hours for the full course. The lessons use prediction callouts and observable checks instead of scored quizzes, so every checkpoint stays attached to the factory behavior you just built.

What you'll need

This course is for developers who use coding agents and know basic Git, GitHub, and command-line workflows. We introduce eve and AI SDK from the beginning.

You will need:

Node.js 24 and pnpm
The latest Vercel CLI
A personal GitHub account with a repository you can connect
A Vercel Hobby account
Access to Vercel AI Gateway

The course starts from the Academy Software Factory repository. Lesson 1.1 gives you a deploy button plus fork and clone instructions. Section 3 adds the environment values and GitHub connector immediately before the first live factory invocation.

Cost and account scope

Fixture traces and unit tests run locally. Live work uses AI Gateway tokens and, for investigation through verification, Vercel Sandboxes. Use routing-only evaluations while iterating and save three-sandbox bug runs for checkpoints.

At the time of publication, AI Gateway's free tier includes $5 per month in credit, while a Vercel Hobby account includes five active Sandbox CPU-hours per month and 5,000 Vercel Connect token requests per month. Purchasing AI Gateway credits moves that account to the paid tier and ends the monthly free credit. The expected out-of-pocket cost is $0 only when those allowances are unused and you complete a careful single pass. Model choice, retries, prior account usage, and future pricing can make it higher. Check the linked pricing pages and your Vercel Usage dashboard before full evaluations. Lesson 5.3 includes a complete teardown for the deployment, trigger forwarding, connector, GitHub label, branches, and local credentials.

Lesson 1 begins by deciding which requests should be allowed to proceed.

Creating a Software Factory

What you'll build

Four case files

Course path

What you'll need

Cost and account scope