Agentic Coding in Practice
A 5-day course built from 18 months of real development evidence.
Format
5 consecutive days. Each day has a 75–90 minute theory session (mornings) and a 75 minute practical session, followed by self-directed afternoon work. Theory sessions are facilitator-led with discussion. Practical sessions are hands-on with individual and paired exercises.
Target Audiences
The course serves two audiences through the same material with different emphasis:
Individual practitioners and small teams: Developers, tech leads, and solo builders who want to move beyond autocomplete-level AI tool usage. The individual pathway emphasises personal productivity, workflow discipline, and honest self-assessment.
Enterprise engineering teams: Engineering managers, platform teams, and technology leaders evaluating or scaling AI coding tools across organisations. The enterprise pathway emphasises governance, risk management, ROI validation, and team standardisation.
Both pathways use the same 31 Agentic Coding Insights (ACIs). The content is identical. The framing, emphasis, and discussion prompts differ.
Prerequisites
- Software development experience (any language, any level beyond beginner)
- A laptop with terminal access
- Willingness to install and use Claude Code during practical sessions
- No prior AI coding tool experience required (Day 1 covers setup)
Course Arc
The first four days teach single-agent agentic coding (SAAC) — one human directing one agent with discipline. Day 5 steps up to multi-agent agentic coding (MAAC) — one human running a fleet of agents as a single software house. MAAC is gated on SAAC fluency, which is why it comes last.
| Day | Theme | Key Question | ACIs | Theory Density |
|---|---|---|---|---|
| 1 | The Landscape | Where are we? | 5 (4 foundational, 1 advanced) | Orientation |
| 2 | The Conversation | How do we communicate with agents? | 5 (1 foundational, 4 intermediate) | Skill building |
| 3 | The Architecture | How do we structure code for agents? | 6 (4 foundational, 2 intermediate) | Deep practice |
| 4 | The Process | How do we plan and execute work? | 6 (1 foundational, 3 intermediate, 2 advanced) | Advanced practice |
| 5 | The Hypervisor | How does one human run a fleet? | 5 (all advanced) + case study | Synthesis |
Day 1: The Landscape. Survey the agentic coding ecosystem. Establish the spectrum from autocomplete to autonomous, and the two-tier map — single-agent practice (SAAC) now, the multi-agent fleet (MAAC) on Day 5. Quantify the utilization gap. Set an honest productivity baseline against the hype. Frame the course purpose. Practical: Install Claude Code, run a first agentic task, compare assistive vs agentic.
Day 2: The Conversation. Shift from prompt engineering to context engineering. Teach the delegation model. Ground theory in real evidence of good and bad task definitions. Address correction erosion and cross-project contamination. Practical: Write a CLAUDE.md from scratch, delegate a multi-step task, observe compaction.
Day 3: The Architecture. CLAUDE.md lifecycle management. The style-vs-architecture rule filter. The Highlander Rule for duplication prevention. Namespace design. Skills as procedural memory. Practical: Audit a CLAUDE.md, run a Highlander analysis, write a first skill.
Day 4: The Process. Steel threads as the natural work unit. Session lifecycle rituals. Scope discipline (when to stop, when not to over-plan). Then the reckoning: recovering from a regression cascade (the recovery protocol), the generation trap, and the MeetZaya case study — where the coding succeeded but the project failed. Practical: Define and execute a steel thread, establish a session lifecycle, and audit a failure against the recovery protocol.
Day 5: The Hypervisor. Multi-agent agentic coding (MAAC): one human running a fleet of agents as a single software house. The step up from single-agent fluency (SAAC), and why the fleet is gated on it. The shared whiteboard as the coordination substrate. The hypervisor's scarce inputs — concentration and taste — multiplied at fleet scale. Independent verification as the fleet's safety rail. Fleet failure modes and the signals that catch them, drawn from the Lamplight Fleet case study. Practical: run a small fleet through a shared whiteboard — claim, announce, verify, arbitrate.
Assessment Approach
This course does not use exams or certifications. The evaluation framework introduced on Day 1 is the assessment tool. It measures capability across 7 dimensions: the six single-agent dimensions — autonomy level, context engineering support, session continuity, verification and review, team readiness, methodology ecosystem — scored on Day 4, plus a seventh, multi-agent coordination, added on Day 5. It produces a profile that attendees use for ongoing self-assessment.
The course's measure of success: attendees leave with a personal practice roadmap they will actually follow, based on honest assessment of where they are and where the evidence says the gains are largest.
Materials Provided
The course is self-contained. Attendees get:
- Syllabus: This document
- Theory guide for each of the five days
- Exercises for each day, with worked solutions
- Reference card for each day: the day's key moves at a glance
- 31 ACIs: the atomic insights, each with thesis, story, evidence, application, and anti-pattern
- Case studies: the MeetZaya failure (Day 4) and the Lamplight Fleet (Day 5, the fleet worked example)
- Evaluation framework: the seven-dimension self-assessment tool
- Deep-dive tier: optional standalone treatments of selected insights (stagnation, regression cascades, methodology transfer) for readers who want more than the in-session day covers
- Reference shelf: the landscape survey, taxonomy, reading list, sample-repo spec, and course outline
- Build process: how the course was forensically extracted from real development
Evidence Base
This course is not built from opinions or best-practice recommendations. Every ACI is grounded in forensic evidence extracted from real development:
- 12+ repositories analysed across 18 months of agentic development
- 3,456 commits and 257 steel threads providing the quantitative evidence
- 155 Claude Code sessions (1.46GB of session data) mined for patterns
- 6 extraction lenses applied systematically: rule archaeology, plan-outcome delta, correction mining, architecture forensics, methodology evolution, failure archaeology
- One major project failure (MeetZaya) providing the failure case study, with both technical data and a first-person account of the non-coding reasons
The course teaches from evidence rather than authority. Every claim has a source. Every pattern has a counter-example.
About the Author
The course was developed by a practitioner who has built production software with agentic coding tools for 18 months across projects ranging from CLI tools to complex Elixir umbrella applications. The methodology (Intent, steel threads, TCA) emerged from that practice. The course is the distillation of what worked, what failed, and what the data says about the difference.