Design a Software Factory for Your Coding Agents

Sep 24, Reserve a seat

Agentic Software Factory for Engineers & Tech Leads

Build the system that turns real issues into verified pull requests on your own codebase, with isolation, verification and human control.

Join the cohort on Maven

Build the system that makes coding agents easier to trust.

You already work with a coding agent, but getting useful code from it still takes constant supervision. It writes a function in seconds, and then you spend the afternoon re-explaining your codebase, checking whether it broke something, and cleaning up the pull request.

The agent is not the problem. There is no system around it: nowhere safe for it to run, no reliable way to give it the right context, and nothing that checks its work before it reaches you.

In this course you build that system on your own codebase. You design the architecture, isolate agent execution in Git worktrees, route context to each task, and add verification that makes agents prove their work. By the final session, a real issue from your backlog becomes a verified pull request waiting for your review.

Who it is for

  • Senior and staff engineers who use coding agents daily and are tired of reviewing work they cannot trust
  • Tech leads who want agents on real backlog issues without risking the main branch or the team's standards
  • Engineering managers and founders who need a practical architecture for adopting agents, not another tool trial

What you will be able to do

What You'll Learn

Design a Software Factory around your own codebase
Run agents in isolation without touching your workspace
Route the right context to every task
Make agents prove their work before you review it
Build self-healing loops that fix their own failures
Ship verified pull requests from real issues

What each session covers

  1. Session 1

    Design Your Software Factory Architecture

    We start from your codebase, not a sample app. You map the six layers onto your own workflow and decide where agents may act alone. This architecture is what every later session builds on.

  2. Session 2

    Isolate Agent Work with an Execution Harness

    You build the execution harness live: an ephemeral Git worktree per task and sandbox boundaries around files, commands and network access. By the end, an agent can change code on your repository without touching your working branch.

  3. Session 3

    Route the Right Context to Every Task

    You structure repository rules, engineering knowledge and reusable skills so each task receives only the context it needs. We replace a long prompt with a context router and try it on a real task from your backlog.

  4. Session 4

    Make Agents Prove Their Work

    You add static analysis gates, holdout tests the agent never sees, and a verification step that decides pass or fail. Your harness can reject work that passes superficial checks but fails the required behaviour.

  5. Session 5

    Build Self-Healing Engineering Loops

    You connect a Doer and a Tester into a loop that returns failures with the reason attached, with exit criteria so it finishes or escalates instead of spinning. Your pipeline can now recover from a failed check without you restarting it.

  6. Session 6

    Orchestrate and Ship Verified PRs

    You connect every layer into one workflow: an issue becomes a task, the task runs in isolation, verification passes, and a pull request opens for human review. This is the pipeline you finish on your own codebase and demo as your capstone.

Schedule

All times Eastern. Sessions are live and recorded.

  1. Design Your Software Factory Architecture120 min
  2. Isolate Agent Work with an Execution Harness120 min
  3. Cohort office hours60 min
  4. Route the Right Context to Every Task120 min
  5. Make Agents Prove Their Work120 min
  6. Cohort office hours60 min
  7. Build Self-Healing Engineering Loops120 min
  8. Orchestrate and Ship Verified PRs120 min
  9. Cohort office hours60 min

What you get

  • Live build sessions
  • Weekly office hours
  • Starter repo and sandbox
  • Capstone demo and live feedback
  • Rejoin a future cohort
  • Recordings you keep
  • Cohort community
  • Certificate of completion
Questions

Cohort questions

Who is this NOT for?
If you have never used a coding agent or do not work in a real codebase, start with the free lightning lessons. This course is also not about model training or AI research.
How is this different from other agentic coding courses?
You build on your own codebase from the first session, each session ends with a concrete piece of the Software Factory applied to your repository, and you demo your capstone for live feedback.
What will I have built by the end?
A working Software Factory on your repository: isolated execution, context routing, verification gates, a self-healing loop and an issue-to-verified-PR pipeline with a human delivery gate.
Do I need a specific coding agent?
No. Bring the agent you already use. The architecture is built around the engineering system rather than one agent product, so any command-line coding agent fits.
What happens if I miss a live session?
Every session is recorded, so you can catch up before the next one. Bring your questions to Friday office hours, and remember you can rejoin a future cohort live at no extra cost.
What is the time commitment?
Plan for 4 hours of live sessions each week, the optional 1-hour office hours on Fridays, and 3 to 5 hours of project work on your own codebase.
Can I rejoin a future cohort?
Yes. Your enrollment includes lifetime access to the materials and a free place in a later live cohort of this course, so you can come back as the tools and the system change.
Can my company pay, and is there a team discount?
You can expense it as professional development if your company supports that. Maven applies 20% off automatically for 2 to 9 seats and 25% off for 10 or more.
What is the founding cohort price?
The list price is $1,997. Use code FOUNDING700 to get $700 off, which brings it to $1,297 while enrollment for this first cohort is open. The code closes when the cohort starts.
Is this mostly lectures?
No. Each session is a live build: I explain the layer, we build it together, and you apply it to your repository before the next session.
Will agents merge code automatically?
No. The pipeline opens a verified pull request and stops there. Merging stays with an engineer, which is how your team keeps control while it learns to trust the pipeline.
Can I take this self-paced?
A self-paced version opens after this live cohort, built from the same curriculum. The live cohort adds the sessions, office hours and live feedback on your capstone.

Build the way teams will build next

Join the cohort on Maven