Nobody knows where AI development will be by the time you read this. The tool you master today may be deprecated next quarter, which is exactly why this Masterclass is built around harness engineering: the principles you’ll keep using long after the tools change.
The destination is harness engineering: building and tuning the whole system around the model so it produces reliable work, stays inside your token budget, and survives the next model release.
In this two-day workshop with Marco Heimeshoff, we’ll cover the practical end (CLAUDE.md, skills vs agents, forked vs clean subagents, fighting context rot) and the serious end (agent teams, observability, EU AI Act compliance, local LLMs on an open harness for privacy-sensitive work). And underneath all of it sits the why: modelling and intent, where 15 years of DDD practice turns an agent from a fast typist into a pair that understands what the software is for.
You will leave with a working harness for your own projects and the principles to keep adapting it as the ground keeps shifting.
This Workshop is co-organized with KanDDDinsky Conference. 💚
Learning Objectives
By the end of this Masterclass you will be able to:
- Trace the progression from prompt engineering to context engineering to harness engineering, and recognise which problem each layer actually solves so you stop reaching for the wrong one.
- Set up the anatomy of Claude Code (and Codex): CLAUDE.md, skills, agents, commands, plugins and hooks composed into a harness that holds up across long sessions and real codebases.
- Fight context rot and keep token usage slim: forked vs clean subagents, when to pick an agent over a skill, and the trade-offs of each.
- Apply the core agentic working patterns (prompt chaining, routing, parallelization, orchestration, evaluator-optimizer, the bookend pattern) and know when to reach for agentic vs programmatic workflows.
- Decide between MCP and CLI usage, wire up hooks correctly, and run agent teams without losing control of cost or context.
- Compare the existing agentic frameworks (Agentheim, BMAD, GSD, NWAVE) against your own harness rather than adopting one wholesale.
- Build memory and observability that fit your situation, from MD files and Obsidian up to enterprise systems, including compliance constraints (EU AI Act) and privacy-sensitive setups on local LLMs with an open harness.
- Use the domain-driven loop (modelling and intent) to give agents the why, so the software they produce matches what the business actually meant.
The Trainer
Marco Heimeshoff is a Software developer, Domain-Driven Design trainer, coach, and consultant who has worked with organizations ranging from Intuit, Lego, Mercedes, Spotify, and Starbucks to hundreds of smaller companies.
Marco co-founded the KanDDDinsky conference and VirtualDDD.com.
His development philosophy centers on lifelong learning, focus on language, and empathy.
Target Audience
This is an advanced masterclass, but you don’t need to arrive as an expert. It is aimed at developers, tech leads and architects who want to build agentic systems they can depend on rather than one-off demos. If you have solid development experience, two days are enough for us to bring you up to speed, whatever your starting point with agents.
You will get the most out of it if you:
- Code regularly and are comfortable in a terminal (no shell wizardry required, but `cd`, git and editing config files should not slow you down).
- Bring a laptop with Claude Code and/or Codex installed and an active subscription before day one. It is in person, so there is no time to debug installs on the day.
- Prior experience with Claude Code, Codex or a comparable agentic CLI is a bonus and will let you go further faster, but it is not a requirement. If you have already hit the wall where naive prompting stops scaling, you’ll recognise exactly what we’re solving.
Topics
- From prompt engineering to context engineering to harness engineering: the through-line.
- Anatomy of an effective Claude/Codex setup: CLAUDE.md, skills, agents, commands, plugins.
- The three loops: building software (what), the harness (how), domain and intent (why).
- Agentic working patterns: chaining, routing, parallelization, orchestration, evaluator-optimizer, bookend.
- Context discipline: preventing context rot, token saving strategies, subagents, agents-vs-skills, MCP-vs-CLI, hooks.
- Workflows and frameworks: agentic vs programmatic, and reading Agentheim / BMAD / GSD / NWAVE against your own harness.
- Governance and reach: memory systems, transient software, observability, EU AI Act, local LLMs on an open harness.
Agenda
Two full days, in person, run as one continuous build: roughly 9:00 to 17:00 each day with lunch and two coffee breaks. The room works a shared wall of physical stickies, and the harness each participant starts on day 1 is the same artifact they keep extending through day 2.
Day 1 – First Contact, and Why the Harness is the Point
The coding loop and the progression
- Run Claude Code, feel the coding loop, read `/context` and use `/clear`.
- The progression as a story: prompt → context → harness, and the three loops as the map for the whole workshop.
- Reality check: the METR slowdown finding vs structured-workflow gains (same model, different harness, opposite outcome).
- Your first real CLAUDE.md: the seed of the harness you extend all workshop.
Build the harness: anatomy of an agentic setup
- Prompt vs context vs harness engineering, with the historical progression and why each layer appeared.
- Anatomy of the setup: CLAUDE.md, skills, agents, commands, plugins and how they compose.
- The trade-offs: context rot prevention, token saving strategies, forked vs clean subagents, agents vs skills, MCP vs CLI, hooks for deterministic enforcement.
- Memory systems as a layer, from MD files and Obsidian up to enterprise.
Day 2 – The Harness in the Wild, and the Domain-Driven Why
Patterns, workflows, frameworks
- The named agentic working patterns: prompt chaining, routing, parallelization, orchestration, evaluator-optimizer, the bookend pattern, and when not to over-engineer.
- Workflows: agentic vs programmatic, agent teams, and hooks as safety rails inside the workflow.
- Framework bake-off: Agentheim, BMAD, GSD, NWAVE (what each opts into, where they agree, how to read one against your own harness).
Domain-driven harnesses: intent, compliance, transient software
- The domain-driven loop: modelling and intent as the why behind the coding and harness loops; ubiquitous language to reduce the ambiguity LLMs amplify.
- Interview-driven spec work as collaborative discovery, the Event Storming parallel this room already knows.
- Transient software: when a build is cheap enough, throwaway solutions become a legitimate design choice.
- Observability and EU AI Act compliance, plus privacy via local LLMs on an open harness. Swap the model, keep the harness.
Why you should join the Masterclass
Most courses teach you to use a tool. In the Agentic Developer Masterclass, you will learn to design the system around it, a different and more durable skill. Over two intensive, hands-on days we follow one spine (prompt → context → harness) through three loops: building software (the what), the harness itself (the how), and domain and intent (the why).
Along the way you will learn every component a dependable harness is made of, from memory and context management through workflows, tools and skills, and how they compose into a system you can actually rely on.
