Design a Software Factory for Your Coding Agents
Coding agents become more reliable when the system around them controls context, execution, verification and delivery. In this session I walk through the six layers of a Software Factory (Boundary, Context, Skills, Execution, Verification and Delivery) and show why routing the right context to each task beats writing an ever-longer prompt. You leave with a map to apply to your own codebase.
The lessons, in order
Each lesson is one idea from the live build, cut to a few minutes, with chapters and the full transcript.
- 14:25
What a Software Factory Automates
A software factory is every step you can automate between a ticket and a merged pull request. What a small remote team automated first, and why the same factory will not fit a team that carries more risk.
- 24:03
Stop Babysitting Your Coding Agent
A small task works from a ticket alone. A larger one needs context the spec never states: the stack, the scale, how many pull requests. Without it you plan, iterate and re-run by hand, and you become the process.
- 34:47
Verification Is the Bottleneck
The six layers of a software factory, and the one teams stall on. An agent returns a 120-file pull request marked verified; nobody is confident enough to merge it. Plan in smaller chunks so each change can be checked and shipped.
- 44:40
Turn Agent Rules Into Gates
A prompt asks the agent to behave, and a strong model follows it about eight times in ten. A factory runs unattended, so the rules that matter become deterministic gates: allow docs and tests, ask a human about money, deny auth and production.
- 57:34
Boundary, Context and Skills
Set where the agent may write, give it your stack and style so it stops guessing, and write skills for the libraries and internal patterns it was never trained on. Skills also keep six engineers' agents writing in one flavor.
- 63:45
Isolate Every Agent Run
Run locally while you are one or two people, move execution to a cloud VM as the team grows, and give each task its own worktree. A hook cleans up the worktrees the agent leaves behind.
- 76:15
Why Verification Is the Hard Layer
Boundary, context and skills settle quickly. Verification does not: ask the agent to audit its work again and it finds more it missed, and six merged pull requests of 150 changes each leave no way to tell which one broke production. What good enough means depends on your product.
- 84:31
Tests First, Then Verify Outside the Agent
Plan the tests with the task, run them red then green, and rerun them as a long-running agent loses context. When the agent writes its own tests it writes tests it can pass, so an independent verifier also judges whether those tests are valid.
- 96:47
From Pull Request to Merge
Every run ends in a pull request that waits for you. Log each run's decisions so the next one starts smarter, choose which stages run unattended, and decide between a light factory with humans at each gate and a dark one.
- 104:50
Human Review Stays in the Loop
An automated loop can reach a passing run, but the model is probabilistic and a coding agent that verifies itself is not enough. Pair automated and manual evaluation, and keep human review once work leaves a single engineer.
What the course covers
Engineers who use coding agents every day and spend too long fixing what they write, and tech leads deciding how agents fit the team's workflow.
- Map the six layers of a Software Factory
- See what each layer does and which problem it removes from your daily agent work.
- Route context to each task
- Work out what an agent needs for a task and where that context should come from.
- Separate skills from prompts
- Keep reusable engineering know-how out of one-off prompts so every agent can use it.
- Find the missing layer in your setup
- Identify the gap that is causing rework when agents write code for you today.
More free mini courses
Every Lightning session becomes one, in the order the Software Factory gets built.