Course Overview
Great software no longer has to cost a fortune or consume every hour of your day. With Claude Code, you get an engineering partner that plans, builds, tests, and ships alongside you at a fraction of the time and cost. This isn't about prompting an AI. It's about designing systems that multiply what you can deliver.
Welcome to the new standard.
Agentic software engineering is a discipline shift, and once you experience it, there's no going back. Instead of spending days on tasks that take agents minutes, you orchestrate workflows that reduce cost, eliminate repetition, and scale your output without scaling your team. The developers who master this don't just move faster. They do more with less, and they do it consistently.
Across 14 hands-on modules, you'll go from Claude Code fundamentals to production-grade multi-agent pipelines. You'll design composable skills, build MCP tools that connect agents to real systems, architect parallel sub-agent workflows, and harden everything for real-world conditions. Every module is built around genuine engineering decisions, because the goal was never to write more code. It was always to build software that matters.
Who should attend
Software Architects, Developer (All)
Prerequisites
The exercises will be conducted in Python, TypeScript, and C#. Basic knowledge of these programming languages is helpful but not required.
Course Content
Module 1: Claude Code Fundamentals
- Introduction to Claude Code
- Setup & Installation
- Editors: Console, Desktop App, VS Code
- CLAUDE.md constitution, @-mentioning files and URLs
- Prompt caching, cost and token awareness
- Model Selection Strategy
- Permission Model: Tools, Bash, Network
- Git worktrees and the agents view for parallel sessions
- Artifacts: results as shareable pages
Module 2: Claude Code Configure Harness
- Settings Hierarchy: Global, Project, Session
- Rules and context via CLAUDE.md
- Slash Commands
- Hooks: PreToolUse, PostToolUse, Notification, Stop
- MCP Servers & Tools
- Skill folders and their sources (module 3 owns authoring)
- Plugins as distribution wrapper (module 11 owns marketplaces)
- Auto-memory: MEMORY.md index, four typed files
- Checkpoints & Session Safety
- Sub-agents as a harness file type (module 7 owns orchestration)
Module 3: Creating & Managing Skills
- Skills vs. slash commands
- Invocation model, anatomy, body structure
- Authoring: manual, or extracted from a conversation
- Front matter fields
- Allowed-tools restrictions and metadata conventions
- Composite skills: scripts, references, assets
- Cross-skill references and delegation patterns
- Dynamic context injection: command preprocessing
- Forked execution: context fork, agent selection, background
- Testing: Trigger, correctness, performance
- Distribution: portable folder, skills API, hosting
Module 4: Consuming & Designing MCP Tools
- MCP architecture: servers, clients, transports
- Session lifecycle: what servers and clients expose
- Remote auth: bearer tokens, API keys, OAuth 2.0
- Building a server in C#: Streamable HTTP, EF Core
- Inspection with the MCP Inspector
- MCP Apps: interfaces rendered inline in the host
- Artifact connectors: pages calling MCP at view time
- Tool design: granularity, descriptions, resources
- Error and deferred-loading contract
Module 5: Agentic CLI & Headless Execution
- Agent harness: tools, knowledge, action interfaces
- CLI, terminal, and where headless mode fits
- Headless mode: print, JSON output, CI exit codes
- Least-privilege tool scoping
- CI gates: sentinel tokens, deterministic exit codes
- GitHub Actions: scripting agentic workflows
- Parallel worktree lanes and task-queue orchestration
- PreToolUse policy gates across lanes
- Always-on goal patterns with turn limits
Module 6: Planning & Spec-Driven Development
- Plan Mode: mechanics and activation
- Stepwise context: questions and constraints
- Spec iteration via feedback loops
- Extended Thinking: steering reasoning chains
- Thinking budget vs. token cost
- Authoring specs and technical plans
- Decomposing tasks into sub-agent packages
- Defining and validating done criteria
- Spec Kit and BMAD-METHOD against hand-driven Plan Mode
Module 7: Sub-Agents
- Where single-agent sequential hits a ceiling
- Frontmatter: name, model, tools, permission mode
- Restricting tools and permissions per agent
- Backend agent: .NET, conventions skill, Microsoft Learn MCP
- Frontend agent: Angular, Angular CLI and DevTools MCPs
- QA agent: Playwright, no implementation authority
- Evaluating performance: test cases, edge cases, failures
- Orchestration: prompt delegation, loops, workflow graphs
- Context isolation between parallel agents
Module 8: Agent Teams
- Where a team beats a sub-agent, and where it loses
- Lead, teammates, shared task list, mailbox
- Enabling teams and what lands on disk
- Spawning teammates: names and models
- Display modes, agent panel, steering keys
- Task states, dependencies, file-locked claiming
- Messaging: lead to teammate, teammate to teammate
- Competing hypotheses: teammates disproving each other
- Plan approval and the team lifecycle hooks
- Team sizing, file conflicts, context window cost
Module 9: Optimizing the Agentic Harness & Continuous Learning
- Skills and agents as living artifacts
- Autoresearch loop: propose, evaluate, revert
- Deterministic experiments for skill quality
- Caveman skill: 60-75% output compression
- Compressing CLAUDE.md with caveman-mode
- Memory architectures: in-context loading, statefile, knowledge graph
- Updating harness from observed behavior
- Metrics: determinism, output structure, abort rate
Module 10: Security, Hardening & Observability
- Prompt injection: tool results and files
- Tool poisoning: validating MCP responses
- Untrusted content isolation in agent context
- Guardrails: hard stops and scope constraints
- Least privilege scoping per sub-agent
- Secrets: preventing cross-agent credential leakage
- Tracing tool chains and cost attribution
- Diagnosing stuck, runaway, hallucinating agents
- Artifact governance: toggles, retention, audit events
Module 11: Bundling & Distributing Plugins
- Plugins vs. standalone configuration: namespacing
- Plugin anatomy: manifest, skills, hooks, MCP
- Bundling skills, hooks, MCP configs
- LSP servers and background monitors
- Default agent activation via plugin settings
- Local testing: plugin directory and reload
- Converting a .claude configuration into a plugin
- Publishing to official and team marketplaces
Module 12: Agentic DevOps & Deployment
- The deployment sub-agent: allowlists, prove-it contract
- Bootstrapping and hardening Ubuntu over SSH
- Docker Compose behind a Caddy edge, automatic TLS
- DNS and ACME ordering: the trap retrying cannot fix
- Core Web Vitals and agentic SEO loops
Module 13: Claude Managed Agents
- Cloud containers with network and files
- Steering agents mid-execution via SSE
- OAuth vaults and token refresh
- Callable-agent patterns with isolated threads
- Session lifecycle: idle, running, termination
- Human-in-the-loop approval gates
- Managed Agents vs. Messages API
- Versioning agents as deployable units
Module 14: Claude Code SDK
- Spawning Claude Code via the SDK
- Sessions, context, streaming responses
- Custom tools as in-process MCP servers
- Typed output with Zod, SDK in CI
- Parallel agents: session isolation, orchestrator pattern
- Output control: tool choice, Structured Outputs, Batches
English
German