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 26 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
| Day | Theme | Key Question | ACIs | Theory Density |
|---|---|---|---|---|
| 1 | The Landscape | Where are we? | 4 (all foundational) | 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 Reckoning | What goes wrong? | 5 (1 intermediate, 4 advanced) + case study + framework | Synthesis |
Day 1: The Landscape. Survey the agentic coding ecosystem. Establish the spectrum from autocomplete to autonomous. Quantify the utilization gap. 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). Health signals (stagnation detection, methodology transfer). Practical: Define and execute a steel thread, establish a session lifecycle, run a stagnation check.
Day 5: The Reckoning. The MeetZaya failure case study (3 parts: technical trajectory, strategic failure with "10 Rules" self-audit, when code is free). Regression cascades and recovery. The generation trap. Honest productivity data. The evaluation framework as a durable meta-skill. Practical: Regression analysis, "10 Rules" self-audit, evaluation framework application, personal practice roadmap.
Assessment Approach
This course does not use exams or certifications. The evaluation framework introduced on Day 1 and applied on Day 5 is the assessment tool. It measures capability across 6 dimensions (autonomy level, context engineering support, session continuity, verification and review, team readiness, methodology ecosystem) and 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
- 26 ACIs: the atomic insights, each with thesis, story, evidence, application, and anti-pattern
- MeetZaya case study: the three-part failure narrative for Day 5
- Evaluation framework: the six-dimension self-assessment tool
- 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.