AI curriculum

Course outline for Claude Code Engineering

Use Claude Code to explore, change, test, and review a repository. Shape its behavior through project instructions, commands, skills, hooks, and integrations. Manage context and permissions, delegate bounded work, and run a dynamic workflow. Turn a recurring task into repeatable automation with independently checked results.

Claude Code Engineering Course Objectives

  • Configure a scoped session and complete a checked repository change.
  • Use session commands, project instructions, skills, and explicit context records.
  • Connect an MCP tool and customize behavior through supported extensions.
  • Delegate independent work and execute a bounded dynamic workflow.
  • Automate a repeatable task and investigate actual execution results.
  • Review correctness, permissions, context use, effort, and recovery behavior.

Pre-requisites

  • AI-Assisted Software Development or equivalent AI-assisted development, independent testing, and review competence.
  • Programming, Git, terminal use, and repository build/test commands.
  • No prior MCP knowledge is required; the course introduces it before integration.
  • Harness Engineering helps with Agent Skills and harness concepts but is not mandatory.
  • Codex and OpenAI Coding Agents and OpenCode and Open Agentic Coding Tools are alternatives, not prerequisites.

Before this course

Complete the required courses or bring equivalent experience. Recommended courses add useful depth; they are not enrolment gates.

Required preparation

Recommended preparation

Readiness checks

  • AI-Assisted Software Development or equivalent AI-assisted development, independent testing, and review competence.
  • Programming, Git, terminal use, and repository build/test commands.
  • No prior MCP knowledge is required; the course introduces it before integration.
  • Harness Engineering helps with Agent Skills and harness concepts but is not mandatory.
  • Codex and OpenAI Coding Agents and OpenCode and Open Agentic Coding Tools are alternatives, not prerequisites.

AI-Assisted Software Development or equivalent AI-assisted development, independent testing, and review competence.

Find your place in the learning map

Lab Setup

Delivery requirements: this environment, access, and the exercise materials must be prepared and verified before delivery. This outline does not certify that a lab package is ready.

A verified stable Claude Code release, authorized inference access, runtime/tests, Git, a disposable repository, controlled MCP service, and prepared hook/plugin scaffolds. Verify dynamic-workflow access, required commands, model compatibility, costs, and limits before delivery. Provide a small orchestration example rather than a large migration. Avoid production credentials and remote merge rights.

Detailed Course Outline

Module 1: Establish a controlled repository session (2 hours)

  • Setup and authentication: Installation, authentication, model choice, terminal and IDE entry points.
  • Execution responsibilities: Model, client, tool, and host responsibilities during execution.
  • Project guidance: CLAUDE.md guidance, project scope, configuration ownership, and permissions.
  • Repository change: Repository exploration, acceptance criteria, planning, edits, and test commands.
  • Verification and recovery: Diff inspection, independent verification, and safe recovery boundaries.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Produce and test a small patch with visible scope and permission decisions.

Module 2: Commands, skills, context, and memory (2 hours)

  • Commands and skills: Command discovery and built-in commands versus bundled and custom skills.
  • Session configuration commands: /init, /plan, /permissions, /model, and /effort during repository work.
  • Continuity commands: /context, /compact, /memory, /resume, and /rewind for task continuity.
  • Reusable skill: A reusable SKILL.md with arguments, references, and a deterministic helper.
  • Invocation and disclosure: Progressive disclosure, invocation controls, and relevant large-repository slices.
  • Memory and usage: Session history, project instructions, automatic memory, handoffs, and usage costs.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Invoke a reusable task and continue it using an inspected context record.

Module 3: Tools, MCP, hooks, and customization (2 hours)

  • MCP participants: MCP basics: host, client, server, tools, resources, and prompts.
  • Integration routes: Built-in tools, direct APIs, MCP, and local versus remote connections.
  • Actual MCP tool: Configure a controlled MCP connection and invoke its actual tool.
  • Connection diagnosis: Authentication, connection state, denied calls, and unavailable-service diagnosis.
  • Lifecycle hook: A harmless lifecycle hook around a deterministic repository check.
  • Plugin packaging: Plugin packaging of reusable skills, hooks, agents, and integrations.
  • Extension trust: Extension trust, configuration scope, disabling changes, and secret handling.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Exercise an MCP tool and a scaffolded hook, then package a small reusable extension.

Module 4: Delegation and dynamic workflows (2 hours)

  • Subagent delegation: Subagents, bounded responsibilities, separate contexts, and independent result review.
  • Background work and conflicts: Background tasks, worktrees, shared-file conflicts, and coordination costs.
  • Native dynamic workflows: Dynamic workflows as generated JavaScript orchestration, not just prompt chains.
  • Workflow branching: Script-held branching, intermediate results, and bounded parallel work.
  • Monitoring and reruns: Workflow monitoring, stopping, saved scripts, reruns, and resume boundaries.
  • Workflow authoring entry points: /workflows and supported authoring entry points; /batch as a related alternative.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Inspect and run a small dynamic workflow, review its branches, and check returned artifacts.

Module 5: Repeatable automation, review, and diagnosis (2 hours)

  • Non-interactive execution: Non-interactive execution, explicit inputs, output capture, and completion checks.
  • Review commands: /diff, /code-review, and /simplify for distinct review purposes.
  • Checks and bounded repair: Fixed checks around variable proposals and bounded repair attempts.
  • Exports and diagnosis: Session exports, usage evidence, diagnostics, and configuration troubleshooting.
  • Interruption and effects: Interrupted work, completed effects, rerun safety, and human escalation.
  • Merge boundary: A repeatable change-and-review workflow with an explicit merge boundary.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Rerun a bounded task, diagnose a failure, and verify the actual patch and tests.

Practical exercise

  • Improve a small repository with a configurable export option. Use commands to plan and control the session, apply project guidance, and invoke a reporting or review skill. Connect a provided MCP service and exercise a harmless hook. Package the prepared components as a small local plugin and verify invocation.
  • Delegate an independent investigation. Then use a small dynamic workflow to coordinate evidence collection and review with an explicit branch on the results. Inspect the generated script before execution. Monitor it and rerun it on changed input. Use a disposable workspace for interruption and recovery. Finally run a bounded non-interactive task and check the diff and tests outside the model's completion message. Record effort, context, and review costs.

Delivery and timing

  • Guided hours include explanations, demonstrations, learner practice, checks, feedback, questions, and contingency as allocated above. Breaks, bulk downloads, and prerequisite account/environment setup are additional. These allocations require a timed pilot before delivery; they are not measured completion times.

What you will produce

Configure Claude Code and run checked repository work, extensions, delegation, and a native dynamic workflow.

How the work is checked

  • Actual product execution produces a patch that meets independent acceptance criteria.
  • Commands and skills are invoked with relevant inputs and inspectable results.
  • MCP, hook, and plugin behavior is demonstrated, including a failure or denial.
  • The dynamic workflow runs actual subagents and exposes its branch and results.
  • Delegated output receives independent review rather than automatic acceptance.
  • Resume and rerun claims match observed state and completed effects.
  • The final automation retains permission, test, and merge boundaries.

10 guided hours. A product-specific specialization with a short Agent Skills refresher and MCP introduction. Native dynamic workflows are required scope, subject to verification on the selected stable release and accounts. If unavailable, delivery needs an explicit scope decision; generic scripts or supplied traces are not substitutes. Rewind does not guarantee reversal of external effects.

When another approach is better

  • Use deterministic automation when the operation is stable and tool-led replanning adds no value.
  • Do not enable a hook or integration whose permissions and current product behavior have not been verified.

How we train

Contact us for full course details, including duration, delivery options and lab requirements.

Ask about exercises, instructor feedback and the prior knowledge you need. Tool-specific courses marked provisional may become modules in a broader course.

Discuss your learning goals