Claude Code: From Foundations to Autonomous Development

Duration

 2 Days

Skills Gained

By the end of this course, participants will be able to:

• Apply prompt engineering and context-management techniques to Claude Code

• Configure Claude Code for terminal and IDE workflows and per-project conventions

• Drive code generation, refactoring, testing, and debugging through Claude Code’s agentic operation

• Integrate Model Context Protocol servers to extend Claude Code’s reach

• Evaluate Claude Code’s output against project quality and security standards

• Package repeatable expertise as Skills and extend Claude Code into CI pipelines through the Agent SDK

Who Can Benefit

This course is designed for:

• Software Developers

• Data Scientists & Analysts

• Anyone interested in coding agents

Prerequisites

Participants should enter this course with:

• Familiarity using Generative AI

• Practical Python experience

Organizational Objectives

This course assists organizations to:

• Accelerate first-draft code production through agent-driven generation, refactoring, and test scaffolding

• Reduce review cycles by codifying tool conventions in CLAUDE.md and shared configuration

• Keep AI tool use inside permission boundaries via MCP server allowlists and reviewed config hierarchies

• Build a team-wide working knowledge of Claude Code in two days

Software

All attendees must have a modern web browser and an Internet connection.

Module 1 - AI Coding Agent Foundations

By the end of this module, you will be able to describe how modern AI coding agents are architected, recognize the plan-execute-iterate loop in action, and apply the permission and review controls that keep autonomous file, terminal, and Git operations safe to delegate.

• AI coding agent architecture and components

• Context windows and token limits

• Agentic operation and the plan-execute-iterate cycle

• Autonomous file, terminal, and Git operations

• Reviewing and accepting proposed changes

• Tool permissions and safety controls

• Hands-on Lab: Walk a coding agent through a small refactor end-to-end, exercising the permission and review controls before any change is committed.

Module 2 - Context Engineering

By the end of this module, you will be able to apply zero-shot, few-shot, and chain-of-thought prompting to a coding agent, attach relevant code and docs through reference systems, and budget extended thinking and persistent memory so the agent stays focused on the task.

• Context management fundamentals

• Prompting techniques (zero-shot, few-shot, chain-of-thought)

• Reference systems (@file, @codebase, @docs, @web)

• Extended thinking modes and budget allocation

• Memory and cross-session persistence

• Hands-on Lab: Refine a vague coding request into a focused prompt that pulls in the right reference context and budgets extended thinking appropriately.

Module 3 - Configuration Standards

By the end of this module, you will be able to author a project-level configuration file (CLAUDE.md, AGENTS.md, or tool-specific equivalent), organize the configuration hierarchy under version control, and apply exclusion strategies to keep sensitive material out of agent context.

• Configuration file hierarchy and version control

• Universal context configuration (e.g., CLAUDE.md) and cross-tool compatibility

• AGENTS.md format and conventions

• Tool-specific configuration files

• File exclusion strategies

• Hands-on Lab: Author a project-level CLAUDE.md (or AGENTS.md) that captures the team’s conventions, exclusions, and review expectations.

Module 4 - Model Context Protocol (MCP)

By the end of this module, you will be able to describe the MCP host, client, and server roles, install and configure an MCP server, recognize the primitives the protocol exposes, and apply permission management appropriate to the tools the server grants access to.

• MCP architecture (hosts, clients, servers)

• MCP primitives (tools, resources, prompts)

• Configuration and server installation

• Security considerations and permission management

• Hands-on Lab: Install one MCP server, exercise its primitives from a coding agent, and audit the permission surface it introduces.

Module 5 - Practical Workflows

By the end of this module, you will be able to drive a coding agent across realistic tasks — generation, review, testing, debugging, refactoring, documentation, and Git operations — and recognize where agentic operation belongs inside an existing development workflow.

• Code generation and multi-file scaffolding

• Automated code review and security scanning (/review, /security-review)

• Test generation and test-driven workflows

• Agent-driven debugging and error diagnosis

• Refactoring patterns (single-file and multi-file)

• Documentation generation and Git integration with automated commit messages

• Hands-on Lab: Run a single feature ticket through generation, review, test, and documentation steps, then have the agent prepare the commit.

Module 6 - Claude Code Advanced Operation

By the end of this module, you will be able to operate Claude Code from the terminal and IDE as a first-class agent, delegate autonomous multi-step work safely using checkpoints and background tasks, package repeatable expertise as Skills, and extend Claude Code into CI pipelines through the Agent SDK.

• Terminal-first operation, the native VS Code/JetBrains extension, and Unix composability

• Plan Mode vs. Auto Mode: scoping work before execution vs. delegating it end-to-end

• Checkpoints and /rewind: recovering from a delegated task that went sideways

• Background tasks and parallel subagent workflows

• Skills: packaging repeatable expertise as reusable, composable SKILL.md workflows

• Headless operation via the Claude Agent SDK: running Claude Code in CI, scheduled jobs, and custom applications

• Hooks (PreToolUse, PostToolUse) and custom slash commands (.claude/commands/)

• Hands-on Lab: Configure a project-level CLAUDE.md and define one Skill, run a scoped task in Plan Mode, then delegate the same task with checkpoints enabled and rewind at least once.