Agentic Software Engineering using Claude Code

Agentic Software Engineering using Claude Code

Class Details

Feb, 2026 - Last Updated: Mar, 2026 · 3 Days
Claude Code Agentic Software Engineering Intermediate
← Back to Training & Team Enablement
This class teaches agentic software engineering the way Claude Code actually works - not as a smarter autocomplete, but as a collaborative development partner with its own reasoning model, memory architecture, and orchestration surface. The curriculum is built around six distinct mastery levels, each requiring you to unlearn the habits of the previous one. By day three you will have moved from issuing commands to orchestrating teams of agents working in parallel across isolated Git worktrees. You will understand why context quality degrades past 60% window utilisation, how to use extended thinking strategically, and how to turn repetitive workflows into skills that compound in value over time.

Curriculum

Module 1: Claude Code Architecture & the Mastery Mindset

  • How Claude Code is different: tool-use engine, not a code completer
  • The collaboration contract: co-thinker, not command executor
  • The 6 Mastery Levels framing
  • Installation & IDE integrations: VS Code, JetBrains, Dev Containers
  • Model selection strategy: Claude Opus 4 vs Sonnet 4 vs Haiku 4.5
  • Settings hierarchy: user-level, project-level, session-level
  • Permission model: allowed tools, bash restrictions, network controls

Module 2: Plan Mode & Extended Thinking

  • Plan Mode mechanics: how it works, how to enable it
  • The architectural dialogue: questions Claude surfaces in Plan Mode
  • Extended Thinking: how Claude's internal reasoning chain works
  • Thinking budget: token cost vs. quality tradeoff by task type
  • Visual inputs as context: screenshots for UI states, errors, and design specs
  • Planning complex refactors before a single line is written

Module 3: CLAUDE.md - The Project Constitution

  • What CLAUDE.md actually is: constitution, not configuration
  • Structure that works: conventions, architectural decisions, forbidden patterns
  • Multi-level CLAUDE.md: project root vs. subdirectory overrides for monorepos
  • Memory architecture: session memory vs. project memory vs. user memory
  • CLAUDE.md as living spec: updating as architecture evolves
  • Compounding value: how a good CLAUDE.md improves first-attempt output quality

Module 4: Context Engineering

  • The attention quality curve: degradation thresholds at 30%, 50%, 70%+ utilisation
  • Context rot: confidently wrong code, drifting conventions, missed constraints
  • /compact vs /clear: when to compress vs. when to reset
  • Context curation tiers: Essential, Reference, Peripheral
  • @ mentions & context variables: file injection, @git, @web references
  • Prompt caching: 90% cost reduction on repeated context
  • Token economics: context cost per session vs. quality degradation risk

Module 5: Claude's Native Tool Ecosystem

  • Tool use architecture: how Claude selects, chains, and reasons about tools
  • Built-in tools: web_search, code execution (sandboxed), text editor
  • Files API: uploading PDFs, images, and documents; referencing across sessions
  • Vision workflows: design mockups, error states, accessibility review
  • Prompt caching in tool-heavy sessions: caching large shared context

Module 6: Model Context Protocol - Deep Dive

  • MCP architecture: servers vs. clients, stdio transport, HTTP/SSE transport
  • Essential servers: filesystem, git, databases (Postgres, SQLite), Playwright
  • Remote MCP servers: connecting to hosted MCP endpoints
  • Building a custom MCP server: schema, handlers, MCP inspector, publishing
  • The surgical selection principle: why 5 well-chosen servers outperform 15
  • The tool overload trap: recognising when MCP config hurts output quality
  • MCP + prompt caching: caching the tool list to reduce session overhead

Module 7: Hooks - Governing Agentic Behaviour

  • Hook lifecycle: PreToolUse, PostToolUse, Notification, Stop
  • Hook configuration: JSON structure, matcher patterns, blocking vs. non-blocking
  • Shell execution model: shell=false, stdin for context, exit codes for blocking
  • Practical patterns: auto-formatter, security scanner, approval gate, notifications
  • Gotchas: infinite loops, unintentional session blocking, error propagation
  • Hooks in CI: enforcing policy in headless and automated sessions

Module 8: Skills, Custom Commands & the SDK

  • Custom slash commands: /project scope vs /user scope, Markdown prompt files
  • Agent Skills: architecture, Skills API, difference from slash commands
  • Skill anatomy: context gathering, execution steps, output format, parameters
  • The organic evolution pattern: manual x3, observe, codify
  • The 8-skill portfolio principle: pruning and the two-week trigger rule
  • Skill Creator: using Claude to bootstrap new skill definitions
  • Claude Code SDK: spawning Claude Code from Node.js/Python, streaming output
  • Headless mode: non-interactive execution, print mode, CI exit codes

Module 9: Multi-Agent Orchestration

  • Why single-agent sequential hits a throughput ceiling
  • Git worktrees: isolated parallel development environments
  • Orchestrator / subagent architecture: task decomposition and delegation
  • Context isolation: preventing cross-contamination between parallel agents
  • Synchronisation strategies: merge sequencing and conflict resolution
  • Monitoring and observability in multi-agent runs

Module 10: Quality, Testing & Verification

  • Agentic testing strategies: unit, integration, and end-to-end with Claude
  • Self-verification loops: agents checking their own outputs
  • Regression risk in long agentic sessions
  • Code review automation: using Claude to critique Claude
  • Human-in-the-loop checkpoints: when and how to intervene
  • Quality gates in CI with headless Claude Code

Module 11: Enterprise Integration

  • Claude API & tool use: direct API integration patterns
  • Multi-cloud deployment: Azure (Microsoft Foundry), Amazon Bedrock, Google Vertex AI
  • Azure Container Apps for headless agents
  • Cross-platform automation: Power Automate to Claude API
  • Authentication and secret management for agentic workloads
  • Triggering autonomous agents from enterprise event sources

Module 12: Spec-Driven Development

  • Spec-Driven Development with Claude
  • CLAUDE.md as project constitution
  • Specification & technical plan authoring
  • Task decomposition & sub-agent implementation
  • Measuring outcomes: definition of done for agentic work
← Back to Training & Team Enablement