Agentic Software Factory for Engineers
Paramanantham Harrison
Head of Engineering at Jobbatical
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.
Every session ends with a new layer running on your repository, and Friday office hours are there for the moment something does not work on your stack.
I have been building software since 2011, and today I am Head of Engineering at Jobbatical and build production AI systems. The course is based on systems and workflows I build and use in practice, rather than isolated demos.
What you’ll learn
Build the system that turns real issues into verified pull requests on your own codebase, with isolation, verification and human control.
Map Boundary, Context, Skills, Execution, Verification and Delivery onto your repository.
Decide which tasks an agent may take on alone and where a human must approve the result.
Finish the first week with an architecture you can defend in a design review.
Give every agent task its own Git worktree that is created, used and removed.
Set sandbox boundaries for files, commands and network access so an agent stays inside its lane.
Run agent tasks in isolated worktrees without changing your working branch.
Replace the ever-growing prompt with rules, skills and task context loaded only when needed.
Turn repeatable engineering know-how into reusable skills instead of rewriting instructions for each agent.
Keep context small and relevant so agents stay accurate on a large, messy codebase.
Add static analysis gates that reject code which breaks your rules.
Write holdout tests the implementing agent never sees, so passing means the behaviour really works.
Read a failed verification and tell whether the task, the context or the code needs to change.
Connect Doer and Tester agents so failed checks return with the reason.
Set exit criteria and retry limits so a loop finishes, escalates or hands control back to you.
Recover from a failed check without restarting the whole run by hand.
Turn an issue into a task a background agent can execute without you.
Open a pull request only after isolation, context and verification have all done their job.
Keep a human delivery gate, so nothing merges without an engineer's approval.
Learn directly from Paramanantham
Paramanantham Harrison
Engineering leader, Agentic AI educator
Who this course 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
Prerequisites
You work in a real codebase
You are comfortable with Git, tests and pull requests in a project you are allowed to change.
You have used a coding agent
Any command-line coding agent works, and you do not need to be an expert with it.
You can build between sessions
The projects are where your Software Factory takes shape on your own repository.
What's included
Live build sessions
Every session is hands-on. You build the next layer of the Software Factory on your own codebase while I build it alongside you.
Weekly office hours
A live hour each Friday to get unblocked on your repository, your agent setup or your capstone.
Starter repo and sandbox
The Software Factory source code, ready to run from the first session, so your time goes into adapting it rather than setting it up.
Capstone demo and live feedback
You build an issue-to-verified-PR pipeline on your own codebase and demo it on the final Friday for feedback from me and the cohort.
Rejoin a future cohort
Keep lifetime access to the materials and join a later live cohort of this course at no extra cost.
Recordings you keep
Every live session is recorded, so a missed session or a second look is always there.
Cohort community
A space to share your harness, compare approaches and get help from engineers building the same thing.
Certificate of completion
Share what you built with your employer or on LinkedIn.
Maven Guarantee
Your purchase is backed by the Maven Guarantee.
Course syllabus
Week 1
Oct
19
Design Your Software Factory Architecture
Oct
21
Isolate Agent Work with an Execution Harness
Oct
23
Office Hours
Week 2
Oct
26
Route the Right Context to Every Task
Oct
28
Make Agents Prove Their Work
Oct
30
Office Hours
Frequently asked questions
Maven for Teams
Reimbursement
Get your company to pay
Everything L&D needs: email template, receipts, and certificate of completion.
Get reimbursedPrivate cohort
Run a cohort for your org
A dedicated cohort with a custom schedule and curriculum, tailored to your team.
Book a private cohort