Claude Code

Agentic Development with Claude Code

Delegation, the Personalisation Stack, MCP and Parallel Agents

Overview

An assistant completes the line you are typing; an agent takes a goal, reads the code, makes changes, runs the tests and comes back with a result. This course teaches the working habits that make that delegation reliable. It is taught in Claude Code, and the ideas apply equally to other agentic tools such as Cursor, Codex and GitHub Copilot.

The first day covers delegating whole tasks, writing instructions an agent can act on without supervision, building loops, and the four-level personalisation stack: what the agent knows, what it can do, what it can reach and how it acts. The second day covers building and connecting MCP servers, a disciplined plan, build, test and review workflow with clear goals, running agents in parallel, governance, and a plan for adopting all of this in your own team.

Format: Practical workshops. Each module combines a short explanation with hands-on exercises in your own repositories or a provided project, and Day 2 closes with a discussion workshop on your team's real challenges.

Who it's for

Developers who already use an AI coding tool regularly, or who have completed our foundations course. It is especially suited to:

  • Developers already using AI tools
  • Technical leads responsible for team adoption
  • Platform and DevOps engineers who will build skills and MCP servers
  • Engineering managers planning an AI adoption roadmap

Prerequisites

  • Professional development experience, comfort with the terminal and working Git knowledge
  • Regular use of an AI coding tool, or completion of AI-Assisted Software Development Foundations

By the end of this course you will be able to

  • Delegate complete tasks to Claude Code with instructions, constraints and acceptance criteria that need little supervision
  • Build loops and goals so an agent keeps working until a checkable condition is met
  • Apply the four-level personalisation stack (knows, can, reaches, acts) and choose the right mechanism for each need
  • Create skills and subagents, and connect and build MCP servers with sensible access control
  • Run agents in parallel on isolated branches and merge and validate their output
  • Evaluate external skills and servers for risk, and draft an adoption roadmap for your team

Course outline

Times show the standard running order and can be adjusted when we tailor the course to your team. The trainer stays available during breaks to help anyone finish an exercise.

09:30
Welcome & orientation 10 min

How the two days run, the project we will use, and what each person wants to delegate.

09:40
From assistant to agent 40 min

The difference between an assistant that completes your line and an agent that takes a goal. Inline completion against agentic delegation, how agentic work changes the way tasks are split up, and a test for which tasks are suitable to hand over. Habits for working alongside an autonomous agent.

Try it: Sort twelve tasks from your backlog into assist, delegate and keep, and justify the two you are least sure about.
10:20
Delegations that work without babysitting 45 min

Writing instructions an agent can act on: the goal, business context, constraints and boundaries, and acceptance criteria with a check the agent can run. We use GCES (Goal, Context, Expectations, Source) as the frame and look at how little supervision a well-formed task needs.

Try it: Write a delegation for a real ticket with explicit acceptance criteria, run it, and count the interventions it needed.
11:05
Break 15 min
11:20
Building loops 40 min

Repeating work on a schedule or until a condition is met: loops that poll, retry or check back, how Claude Code's /loop and scheduled tasks work, when a loop is the wrong tool, and how to stop one.

Try it: Build a loop that runs your test suite, fixes the first failure it finds and stops when everything passes or after a set number of tries.
12:00
The four-level personalisation stack 40 min

A way to think about everything you can teach an agent: what it knows, what it can do, what it can reach and how it acts. Which mechanism answers which need, how they load into context, and how to keep your environment consistent across tools and projects.

Try it: Map ten pieces of guidance from your own team to the right level of the stack.
12:40
Lunch 45 min
13:25
Level 1 | Knows: CLAUDE.md, rules and AGENTS.md 45 min

Project conventions, coding standards, architecture notes and constraints in files the agent reads every session. Claude Code reads CLAUDE.md rather than AGENTS.md, so a CLAUDE.md that imports an existing AGENTS.md keeps guidance tool-neutral and consistent across your team and tools.

Try it: Write the conventions file for your project, import an AGENTS.md if you have one and test whether the agent follows it.
14:10
Level 2 | Can: skills 45 min

Skills as reusable units of specialist knowledge that load only when needed, which keeps context small and performance high. Packaging a workflow as a skill, and building a library of them for the team.

Try it: Write a skill for one repeated workflow and compare the agent's results with and without it.
14:55
Break 15 min
15:10
Level 4 | Acts: agents and subagents 50 min

How autonomous agents read, write, test and revise code, and how subagents with their own isolated context take on bounded tasks and report back a summary. Managing goal-driven work, and the oversight and human review that keep it safe.

Try it: Define a research subagent and a verifier subagent, delegate to each and review where they went beyond their brief.
16:00
Day 1 practice: a delegated task end to end 20 min

Use what you built today on one real task: knowledge, a skill, a subagent and a clear delegation.

Try it: Run the task and write down what you would change in the delegation.
16:20
Close 10 min

Recap of Day 1 and what we will build on tomorrow.

Outcome: By the end of Day 1 you will have delegated a real task with acceptance criteria, built a loop, and set up the knowledge, skills and subagents an agent needs.

09:30
Welcome back 10 min

Questions from Day 1 and the plan for today.

09:40
Level 3 | Reaches: MCP principles and connections 40 min

What the Model Context Protocol is and what it adds to an agent: access to browsers, repositories, databases and documentation sources. Adding servers, scopes, sign-in, and the governance controls an organisation can apply.

Try it: Connect two servers (for example a repository and a documentation source) and give the agent a task that needs both.
10:20
Building a custom MCP server 50 min

Writing a small MCP server that exposes one tool from your own systems, running it locally, connecting it to Claude Code and controlling who can use it and what it can touch.

Try it: Build a server with one read-only tool, connect it and restrict it so the agent cannot call anything else.
11:10
Break 15 min
11:25
The disciplined agentic workflow 50 min

A repeatable process: brainstorm and plan with the agent, build collaboratively, test and validate the output, then review and finalise with verification steps. Setting goals with a checkable condition (Claude Code's /goal) so that work continues until the condition is met.

Try it: Set a goal with a test-based condition for a small feature and run the whole process once.
12:15
Parallel development 40 min

Running several agents at once in separate Git worktrees, coordinating who does what, and merging and validating the results. When parallel work pays for itself, and when it only adds cost and conflict.

Try it: Run three agents on three small tasks in separate worktrees, then merge and test the combined result.
12:55
Lunch 45 min
13:40
Risks, review and governance 40 min

Vetting external skills, plugins and MCP servers before you install them, security and governance risks (including prompt injection through untrusted content), permissions and access rights, protecting sensitive data and intellectual property, and review and quality-assurance routines.

Try it: Vet a sample skill and a sample MCP server with a checklist and decide whether each is safe to adopt.
14:20
AI adoption in software development: use cases and next steps 55 min

How organisations bring AI into the software development lifecycle (SDLC): individual, team-based and organisation-wide adoption, and typical use cases from requirements and prototyping to testing, review, documentation, DevOps and incidents. Governance models and policies, what to measure when judging productivity and return on investment (ROI), and how to build an internal roadmap. Use cases are illustrative patterns, and you add examples from your own sector.

Try it: Sketch the adoption approach and three measures of success for your team on a single page.
15:15
Break 15 min
15:30
Interactive discussion workshop 50 min

A facilitated session on your own situation: the challenges in your teams, the use cases worth adopting first, the risks and blockers, and an initial action plan for bringing agentic workflows into your organisation.

Try it: Leave with a one-page action plan with owners and a date for the first review.
16:20
Close 10 min

Recap of the two days and sharing the first actions.

Outcome: By the end of Day 2 you will have a working MCP connection, a goal-driven workflow, parallel agents merged safely and a draft adoption roadmap.

What you'll need

Claude Code

  • A Claude account that includes Claude Code: a Pro, Max, Team or Enterprise plan, or a Claude Console account (the free plan does not include it). Organisations may instead provide access through a cloud provider.
  • A laptop that can run Claude Code (a current macOS, Windows or Linux system with at least 4 GB of memory) and an internet connection. Installation is covered at the start of the course.
  • Git and a repository of your own that you may use for exercises, or the provided project. Node.js or Python for the MCP server exercise.
  • A few features used here, such as agent teams, are experimental; your trainer labels them in the room.

Practice files are provided for every exercise. You are welcome to use your own non-confidential projects where your organisation's policy allows.

Related courses

Claude Code AI-Assisted Software Development Foundations 14 hours (2 days × 7 hours) · Beginner Claude Code Claude Code in Practice 7 hours (1 day) · Intermediate Claude Code Claude Code in the Enterprise 14 hours (2 days × 7 hours) · Intermediate

Not sure which course is right for your team?

Book a free discovery call. We'll talk through your team, your tools and what you want to achieve, then recommend the right course or design a bespoke one.

Book a free discovery call Send an enquiry
From £1,50014 hours (2 days × 7 hours)
Enquire