Trainings

Duration

2 days

Who it's for

• Whole DevOps teams: developers, QA / test engineers, ops / platform
• Mixed-role groups adopting agentic workflows together
• Engineering managers training their teams alongside them

Prerequisites

• Comfortable with git and the command line
• Writes features in at least one language (TS/Python/Go/etc.)
• Own laptop or desktop with Claude Code or OpenCode installed, plus at least an active Claude Pro subscription

What you'll learn

• Ship a working feature on a starter repo — tests, hooks, CI green from minute one
• Recognise the failure modes of AI-generated code in your own work
• Practise test-first with an agent without writing fake-passing tests
• Set up hooks and quality gates that survive the next sprint
• Use existing MCP servers in real workflows
• Leave with a governance starter your team can actually use

Price

€1.399€979,30 ex. VAT

Programme

Day 1 · Fundamentals: from concept to first tooling

1. 01

   Agentic engineering

   • What agentic engineering is, and how it differs from one-off prompts
   • The agent as a colleague that writes code, not autocomplete
   • Where it already works today and where you stay careful
2. 02

   Build your first feature

   • Build your first feature with the agent, from blank screen to live
   • Steer on the outcome instead of dictating each step
   • First feel for the loop: ask, review, adjust
3. 03

   Context architecture

   • CLAUDE.md, AGENTS.md and the folder layout that steer the agent
   • Rules files and project-wide configuration
   • Hierarchy: user, project, local overrides
4. 04

   Build out your feature

   • Add sections and functionality to your feature
   • Have the agent plan larger changes in steps first
   • Notice how good context tightens the output
5. 05

   Tone of voice via CLAUDE.md

   • Set a tone of voice the agent holds to consistently
   • Edit CLAUDE.md so your conventions stick across sessions
   • See the gap between asking each time and rules that persist
6. 06

   Getting out of the loop

   • Let the agent finish longer stretches on its own
   • Decide up front where you stay in the loop and where you don't
   • Build trust without losing control
7. 07

   Skills & Rules

   • When to write a skill
   • When to write a rule
   • Your first own skill
8. 08

   Creating and editing skills

   • Build your first skill from start to finish
   • Edit skill.md and watch behaviour change right away
   • Use the skill creator to stand up new skills faster
9. 09

   MCP servers (with Playwright)

   • What MCP servers are and when to use them
   • Connect existing servers (GitHub, Filesystem, etc.)
   • Playwright MCP: the agent clicks and tests in the browser
10. 10

    Plugins: Caveman & Superpowers

    • What plugins add on top of a bare agent
    • Caveman for compact, cheaper communication
    • Superpowers: skills that enforce workflows like TDD

Day 2 · Quality & advanced

1. 11

   Failure modes of AI-generated code

   • Hallucination, silent regression, false-green builds
   • Scope drift and undeclared rewrites
   • How to spot each before they ship
2. 12

   Test-first with agents (TDD)

   • The TDD loop with an agent driver
   • When tests precede code, when they don't, why it matters
   • Tests that prove behaviour vs. tests that satisfy the model
3. 13

   Subagents

   • Split work across multiple agents working in parallel
   • A lead agent that delegates subtasks and merges the results
   • When subagents help and when they're overkill
4. 14

   Rules vs hooks

   • Pre-commit checks: lint, format, type-check
   • Custom hooks for agent-specific risks
   • Rules vs. hooks: what belongs where, and why
5. 15

   Lab: your first quality feature

   • End-to-end on a starter repo: brief → tests → code → review
   • Put Superpowers skills and quality gates to work on your own changes
   • Ship with green checks from the first commit
6. 16

   Building a pipeline

   • Chain separate steps into a repeatable flow
   • Agents, tests and gates in one pipeline
   • A pipeline that still runs next sprint
7. 17

   Persistent memory

   • Let the agent remember what matters between sessions
   • What to keep in memory and what to leave out
   • Memory that helps without piling up noise
8. 18

   Spec-driven development

   • Write specs an agent can execute reliably
   • Scope the work before the agent starts building
   • From spec to a working, tested change
9. 19

   Regression strategy + governance basics

   • Golden tests, snapshot guards, property-based checks, mutation testing, etc.
   • Stress-testing agent output on real edges
   • What a sensible team review policy looks like
10. 20

    Ship a feature end-to-end

    • Implement a feature on a starter repo from a brief
    • Apply everything from both days: context, skills, tests, hooks
    • Demo and review with the group