Who this Academy is for
The Academy is aimed at developers and technical leads who want to (or are expected to) work with coding agents but have no systematic prior knowledge of them yet. You do not need to know Claude Code or Codex, and you do not need to be a prompt expert. You should know what Git, a build and an automated test are; code examples are given in Java and TypeScript, but they are understandable without deep knowledge of either language.
If you operate the factory or are accountable for it in a regulated environment, you will also find the background on security, evidence, costs and operations here. The details of installation and configuration are in the manuals; the Academy explains why things are the way they are and how to use them well.
Theory and practice, alternating
Every chapter follows the same structure so you can find your way around quickly:
- Learning goals: what you can do after the chapter.
- Fundamentals alternating with “In the factory” boxes: the fundamentals explain a topic in a vendor-neutral way, as it applies to any work with coding agents. The practice boxes right after show how SoftwareFabrik implements it, with menu paths, terms and workflows. You can recognise them by their orange marking.
- Exercise: a short hands-on task, usually with an outline solution you can expand.
- Chapter questions: six to ten questions that test understanding, application and transfer. Each has a model answer you can expand. Formulate your own answer before you look.
mock adapter for practice: it goes through the complete run workflow without a real agent and at no cost.
The learning path
The eleven chapters build on one another and fall into four parts. If you are in a hurry, read chapters 1 to 6 and 11; if you use the factory in a team or in a regulated environment, you also need 7 to 10.
| Part | Chapters | Guiding question |
|---|---|---|
| Understand | 1, 2 | What is a coding agent, how does it work, and how does the factory run it? |
| Guide | 3, 4, 5 | How do I tell the agent what to do: with context, specs and plans? |
| Safeguard | 6, 7, 8 | How do I check what it built, how do several agents work together, and how does it all stay secure? |
| Take responsibility | 9, 10, 11 | How do I prove what happened and what it costs, and what does good everyday practice look like? |
Chapter 4 on specs and EARS is the longest and the most important: it shows you how to phrase requirements so that an agent builds the right thing and tests prove it. Allow about two hours for it.
The chapters
Each chapter is listed with its most important learning goals. After the chapter you can:
Chapter 1: What agentic coding is
Language model and agent, tools, the agent loop, the context window, strengths, limits and hallucinations. In the factory: the guiding principle “You describe. The factory builds. You approve.” and the roles of the people involved. About 50 minutes.
- explain the difference between a language model and a coding agent;
- describe the agent loop and the role of the context window;
- assess where agents are strong, where they fail and why verification is mandatory.
Chapter 2: How a coding agent works
Prompt and context, tools, permissions, headless operation, sessions and models. In the factory: execution adapters, run lifecycle and phases, subscription and API-key mode. About 55 minutes.
- explain how an agent works headless with restricted permissions;
- distinguish the factory's adapters and their operating modes;
- create a run and follow its lifecycle from
DRAFTtoCOMPLETED.
Chapter 3: Context is everything
Project description, conventions, AGENTS.md, guardrails and memory. In the factory: project wizard, project definition, prompt artifacts, engineering guardrails, project memory, teams and agent roles. About 55 minutes.
- justify why the quality of the context determines the quality of the result;
- fill in a project definition so that the first run succeeds;
- use guardrails, memory and agent roles deliberately.
Chapter 4: Specs and EARS
Why specs, the structure of a product spec, the five EARS templates, typical mistakes, Given/When/Then, from acceptance criteria to tests, traceability and spec drift. In the factory: creating and approving specs, spec mode, spec run and reverse spec. About 120 minutes, with four exercises.
- write a product spec with goals, non-goals and acceptance criteria with IDs;
- phrase requirements confidently in EARS and rewrite poor requirements;
- derive positive, negative and edge-case tests from every criterion and link them to the AC ID;
- use traceability and spec drift in the factory.
Chapter 5: Plan before you build
Decomposition, acceptance criteria per task, dependencies, milestones. In the factory: plan runs, backlog, spec and AC reference on the backlog item, activation, routines, milestones and releases. About 50 minutes.
- break a project down into small, verifiable tasks with dependencies;
- operate the factory's plan runs and backlog;
- bundle work into milestones and releases.
Chapter 6: Build and verify
Verification instead of trust, tests, reviews, correction loops. In the factory: a branch per run, pull request, quality gate with reviewers and modes, correction loop, approval points, PR and CI feedback. About 50 minutes.
- explain why agent code is verified rather than trusted;
- use the quality gate with its reviewers, verdicts and modes;
- make sensible use of approvals before execution and before the merge.
Chapter 7: Working in parallel
Multi-agent orchestration, conflicts, leases, contracts, merge. In the factory: workflow layer, task graph, child runs, contract registry, merge queue, integration gate and spec binding per task. About 55 minutes.
- justify why parallelism has to happen between isolated workspaces;
- use ownership rules, leases and contracts as tools against conflicts;
- plan, approve and integrate a workflow in the factory.
Chapter 8: Security
Prompt injection, tool permissions, configuration from foreign repos, MCP, supply chain, secrets. In the factory: MCP null state, canary isolation proof, MCP gateway, permission contract, neutralised hooks and project settings, SBOM and dependency scan. About 55 minutes.
- set up a threat model for coding agents;
- name the factory's layers of protection and their limits;
- enable MCP servers in a controlled way.
Chapter 9: Evidence and governance
Traceability, audit, policies, regulation. In the factory: signed audit chain, why-trace, policy-as-code, compliance profiles, audit export, offline verifier and mandatory specs via policy. About 55 minutes.
- explain how hash chains and signatures make evidence tamper-proof;
- understand and apply policies and compliance profiles;
- produce an audit export and have it verified independently.
Chapter 10: Models, costs, operations
Model choice, tokens, caching, budgets, tenants and roles. In the factory: model routing and role defaults, cost views, budgets, tenants, RBAC and SSO, licence tiers and operating modes. About 50 minutes.
- choose the right model for planning, building and reviewing;
- recognise cost drivers and set budgets;
- define tenants, roles and the operating mode of an instance sensibly.
Chapter 11: Everyday practice
A continuous example from the idea through spec, approval, plan, build, gate and acceptance to the release. Plus anti-patterns and checklists. About 60 minutes.
- carry out the complete workflow in the factory on your own;
- recognise and avoid typical anti-patterns;
- work with checklists before run, approval, merge and release.
Where to go from here
Start with Chapter 1. Alongside the Academy, these will help you:
- Introduction: glossary and mental model of the factory in brief.
- Quickstart and Tutorial: install the factory and do a complete run-through with a real adapter.
- User manual and Administration manual: the reference for every setting.
- Known limitations: what the factory deliberately cannot do today.