Claude Code in April 2026 is a layered system, not a prompt box. Most teams only use one or two of its layers. The cost of that is not obvious: it looks like productivity, but it shows up later as review debt, inconsistent enforcement, and invisible changes that only the author understands.
Course description:
This course teaches the design decisions behind each layer and how to wire them together so speed does not turn into breakage.
Course objectives:
• Design a layered Claude Code setup with clear ownership for each layer
• Decide when a task warrants a subagent, an agent team, or neither
• Write hooks that enforce standards the prompt cannot reliably enforce
• Choose the right permission mode per context and defend the choice
• Use checkpoints and rewind to run safe A/B experiments on non-trivial changes
• Run Claude Code in headless mode from a CI pipeline
• Package repeated work into reusable skills and plugins
• Connect Claude Code to real context through MCP without creating new exposure problems
• Present a 90-day rollout plan for the team, with named owners, success criteria, and a defined kill switch
Important information:
1) Pre-Course Self-Assessment:
• Every participant takes a 10-minute online self-assessment before the course. This lets day one open with "here is what this room already knows and where the shared gaps are" instead of generic material.
2) Take-Home Template Pack:
• Every participant leaves with a versioned template pack checked into a real repository. The pack is not a slideware deliverable. It is a working set of 10 to 20 files.
3) 30- Day Follow-Up:
• Two weeks after delivery, the instructor runs a one-hour follow-up with the cohort
The agenda is fixed:
• What has actually been adopted
• What broke
• What got quietly abandoned
Course content:
Module 1 - Claude Code As A Layered System:
We cover:
• CLAUDE.md for durable policy
• Skills for repeatable procedures
• Slash commands as the invocation surface
• Hooks for deterministic enforcement
• Subagents and agent teams for context isolation and parallelism
• Checkpoints for safe experimentation
• MCP for external context
• Plugins for packaging everything above
Participants receive the Claude Code Feature Matrix on day one and use it throughout the course
Module 2 - MCP And Real Context Without New Risk:
Where external context actually changes decisions, where it only adds latency and attack surface, and which MCP servers to trust, sandbox, or human-gate.
Lab:
• Participants select three MCP servers for their stack and justify each one against a risk checklist
Module 3 - Skills, Commands, And Plugins As Team Assets:
Turning repeated prompts into versioned, reviewable skills. Packaging related skills, commands, hooks, and subagents as a plugin so a new hire inherits the team's conventions on day one.
Lab:
• Participants author a skill from an existing repeated workflow and publish it as part of a small internal plugin
Module 4 - Parallelism And Safe Experimentation:
Subagents and agent teams look similar but solve different problems. We cover when each one earns its token cost and when both are just agent theater.
Lab:
• One task implemented once via subagent, once via agent team, and a third time explored with checkpoints
Module 5 - Hooks, Permission Modes, And Enforcement:
Deterministic control for the things a prompt cannot reliably guarantee.
We cover:
• Pre-commit hooks that block credential files
• Post-tool-use hooks that run lint and tests
• Session-start hooks that load the right context
• Permission modes for different usage contexts
Lab:
• Participants write three hooks for their own repo, then select a permission mode per context and document why
Module 6 - Capstone: Rollout Plan With A CI Footprint:
Participants design a 90-day rollout for their team. The rollout must include at least one headless-mode pattern, with Claude Code running inside a CI pipeline for automated review, release notes, triage, or documentation.
What participants leave with:
• The Claude Code Feature Matrix, annotated during class
• A layered-architecture diagram for their team's Claude Code setup, with an owner for each layer
• A 90-day rollout plan with phased scope, success criteria, kill switch, and at least one CI pattern
• At least one working skill, one working hook, a documented permission-mode policy, and a short MCP adoption shortlist, all committed to a repo.
• A subagent-vs-agent-team decision rubric written for their stack
Instructors: Rogier Muller & Vasilis Tsolis
Rogier Muller is CTO of BlueMonks Group, an Amsterdam-based fintech compliance company, and co-founder of several companies. He`s a lifelong coder who moved early into AI-assisted software development. Today, he is the only person in the world to combine official ambassador roles across the three leading agentic engineering platforms: Cursor, Claude Code, and Codex.
Rogier has hosted numerous events worldwide and works closely with engineering teams, founders, and AI tooling companies on the practical adoption of agentic software development. His specific expertise is using agentic engineering in highly regulated environments, including but not limited to fintech, financial services, KYC/CDD, AML, GDPR, AFM-supervised contexts, auditability, data isolation, and compliance-heavy software delivery.
Vasilis Tsolis is a pioneer in document intelligence and agentic coding helping teams to change how they work across industries. He is an official Ambassador for Cursor, OpenAI Codex and n8n. He is the partner of Cognitiv+, an AI consultancy and software factory that helps organisations practically implement and adopt AI with enterprise confidence.
He has co-founded several companies and trains development teams across the US and EU on AI-assisted coding, with a consistent focus on integrating it into real workflows without losing control of the codebase. Background: engineering and law, twenty years across AI, construction, energy, and tech. Vasilis has worked with JPMorgan, Intel, PwC, and others along the way.
Target audience:
Senior engineers, staff and principal engineers, tech leads, platform and developer-experience teams, and internal AI champions. The course assumes participants are not just power users. They are the people other engineers come to with questions.
Prerequisites:
• Has shipped at least one non-trivial change using Claude Code in a real production repo
• Can read and reason about team-wide engineering standards
• Comfortable editing JSON or YAML configuration and writing small shell scripts
• Has read the team's existing CLAUDE.md, or can confirm that one does not exist
• Has completed the pre-course self-assessment
Language:
• The course is given in english
Course material:
The course fee includes course documentation and exercises