AI curriculum

Course outline for Claude Code Engineering

A coding tool can explore a repository and propose changes, but its plan is not permission to mutate every file. Examine a version-labeled Claude Code workflow and separate exploration, implementation, and independent review. Compare guided tool automation with an external deterministic controller using the same acceptance contract.

Technology: AI-Assisted Software Engineering
Duration: 6 hours
Modules: 3 · 2 hours each
Level: Level 3

About Claude Code Engineering

Claude Code Engineering Course Objectives

Map a bounded repository task to the supplied Claude Code workflow.
Prepare relevant context and reusable instructions without exposing credentials.
Classify tool actions as read, recommendation, or mutation.
Inspect supplied agent, hook, and MCP examples for execution and permission boundaries.
Verify a proposed patch with independent tests and exact-change approval.
Compare tool-led automation with a deterministic controller and record version-dependent assumptions.

Pre-requisites

AI-Assisted Software Development or equivalent ability to supervise and independently test a generated repository change.
Programming, Git, and command-line experience.
Familiarity with AI-assisted development; harness implementation is helpful but not required.

Before this course

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

Required preparation

AI-Assisted Software Development

Recommended preparation

Harness Engineering

Can supervise an AI-assisted repository change; harness knowledge helps evaluate current product behavior. This is a provisional tool specialization.

Find your place in the learning map

Lab Setup

Computer with Git, a familiar programming runtime, a test runner, and a disposable repository.
Version-labeled Claude Code traces, hook/configuration examples, MCP fixtures, patches, and a local permission-controller scaffold.
Approved nonproduction Claude Code access is optional; live labs use only instructor-verified documented features and never place credentials in prompts.

Detailed Course Outline

Module 1: Orient a scoped repository session (2 hours)

Claude Code mental model: Repository sessions, model proposals, and externally executed actions in a version-labeled trace; separate task guidance from permission enforcement.
Repository exploration: Relevant files, project instructions, dependencies, and test entry points; assemble a scoped context bundle while excluding credentials.
Skills: Reusable procedural instructions and selected task context in supplied examples; distinguish guidance from deterministic checks and verified product support.
Tools: Read, recommendation, and mutation capabilities; inspect who executes each action and where the local controller enforces allowed scope.

Practical outcome: Inspect a version-labeled session, prepare scoped repository context and reusable instructions, and classify available capabilities without assuming instructions alone enforce read-only behavior.

Module 2: Review extensions and authority (2 hours)

Agents: Supplied handoff traces, isolated responsibilities, and artifact ownership; compare delegated work with independent review without assuming version-independent product behavior.
Hooks: Supplied lifecycle extension examples and execution ownership; identify intended checks, permission boundaries, and product behavior requiring instructor verification.
MCP: Discovery, capability schemas, and invocation traces; distinguish protocol access from authentication, authorization, and approval of the exact change.

Practical outcome: Trace supplied agent handoffs, hook examples, and MCP exchanges, identifying who executes each action and where permission and exact-change approval must be enforced; record any product support that needs verification.

Module 3: Compare repeatable execution paths (2 hours)

Context management: Plan, execution, and review context separation; retain relevant artifacts and document information omitted from a bounded repository session.
Large codebase workflows: Dependency-aware task slices, scoped exploration, and relevant tests; limit the reviewed patch rather than promising whole-repository comprehension.
Automation patterns: Tool-led execution versus an external deterministic controller; compare artifact handoffs and identical tests, recording version assumptions and simpler scripting alternatives.

Practical outcome: Select a bounded slice of a repository, separate plan, execution, and review contexts, and compare a tool-led trace with an external deterministic controller using the same artifacts and tests.

Practical exercise

Produce an isolated change dossier with scoped instructions, annotated action trace, reviewed diff, and test results.
Accept the approved bounded patch; reject an unapproved mutation and a supplied change outside the allowed files using the local controller.
Account for every action in two supplied workflow traces and run the same acceptance tests against their patches.
Record the verified product version, extension assumptions, and when a stable script is simpler than dynamic tool-led execution.

What you will produce

Review a bounded Claude Code-assisted change with explicit action classification, independent tests, and documented approval boundaries.

How the work is checked

The task and allowed repository slice are explicit.
The trace identifies execution ownership and distinguishes proposal from mutation authority.
The local controller rejects unapproved and out-of-scope mutations.
The workflow comparison records independent evidence and version-dependent product assumptions.

Six-hour provisional guided specialization with exercises inside module time. Inspect product-specific extension traces but implement only the local controller check. Fixture-only study is not hands-on product operation. Current commands, permissions, hooks, and supported extensions must be instructor-verified; production automation and comprehensive product training are not promised.

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

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