Claude Code for Developers

Introduction to Agentic Coding with Claude Code

Before diving in, it helps to understand what makes Claude Code different from chat assistants and autocomplete tools. This chapter explains the agentic loop that powers it.

• From autocomplete and chat to agentic coding
• Understanding Large Language Models
• LLM Static Knowledge vs. Dynamic Knowledge
• Training data cut-offs and the Context Window
• The agentic loop: reason, use tools, observe, iterate
• Claude Code vs GitHub Copilot vs Cursor and OpenAI Codex
• Where it runs: terminal CLI, IDE extensions, desktop and web
• Choosing between Opus, Sonnet and Haiku
• Plans and pricing
• Being cost- and token-aware
• Cost-control habits

Your First Session: Tools, Files and Slash Commands

With the concepts in place, we get hands-on. This chapter covers installation and authentication, the anatomy of an interactive session and the built-in tools Claude Code uses.

• Installation, authentication and a first run
• The REPL, keybindings and the slash command palette
• Built-in tools
• Feeding context
• LAB: Set up Claude Code and complete a guided first task

Effective Prompting and Communicating with Claude

This chapter teaches the prompting patterns that reduce corrections: scoping tasks, pointing to sources and existing patterns, asking codebase questions, and letting Claude interview you to produce a specification before any code is written.

• Scoping a task
• Pointing to sources and referencing existing patterns
• Asking questions to onboard to unfamiliar code
• Letting Claude interview you and writing a self-contained SPEC.md
• LAB: Explore an unfamiliar codebase

Managing Context and Project Memory with CLAUDE.md

Claude's context window is its most important resource, and performance degrades as it fills. This chapter shows you how to manage context deliberately and how to give Claude persistent project knowledge through CLAUDE.md so it stops repeating the same mistakes.

• Resetting and Compacting Context
• Checkpointing and rewinding conversations
• Project memory with CLAUDE.md
• LAB: Author and tune a CLAUDE.md for a real project

The Explore, Plan, Code, Commit Workflow

This chapter introduces the recommended four-phase workflow built around plan mode and the single most important habit for unattended work: giving Claude a verification signal it can run and iterate against on its own.

• Plan mode
• Extended Thinking
• Reviewing and editing the plan before execution
• Verify: tests, builds, linters and screenshots
• Gating completion with /goal conditions and a Stop hook
• When to skip planning: small, clearly scoped changes
• LAB: Drive a multi-file feature through plan mode with verification

Permissions, Auto Mode and Sandboxing

By default Claude Code asks permission before it can modify your system, which is safe but tedious. This chapter covers the three ways to reduce interruptions while staying in control, so you can choose the right level of autonomy for trusted work versus unattended runs.

• The permission model
• Auto mode: a classifier that blocks only risky actions
• Permission allowlists with /permissions
• Sandboxing: OS-level filesystem and network isolation
• LAB: Configure permissions and run a task in auto mode

Reusable Knowledge and Workflows with Skills

Skills are the most flexible way to extend Claude Code, packaging reference knowledge or repeatable workflows that Claude loads on demand or that you invoke with a slash command. This chapter shows you when to reach for a skill instead of CLAUDE.md and how to author your own.

• Skills versus CLAUDE.md versus rules
• Reference skills
• Authoring skills
• Using pre-built skills
• Plugins and marketplaces: bundling skills, hooks, subagents and MCP servers
• LAB: Build a reusable workflow skill such as /fix-issue

Working in Isolation with Subagents and Agent Teams

Because context is the fundamental constraint, delegating work to isolated contexts is one of the most powerful techniques available. This chapter covers subagents for research and review, running multiple Claude sessions in parallel on isolated Git worktrees, and the experimental agent teams that coordinate multiple independent sessions.

• Subagents for efficient context management
• Using subagents for investigation
• Custom subagents in .claude/agents/
• Parallel workflows
• Agent teams
• LAB: Delegate research and a security review to subagents

Deterministic Automation with Hooks

Hooks allow you to run scripts and agents deterministically at specific lifecycle events during Claude Code's execution. This chapter shows how to use hooks for automation and, crucially, for enforceable guardrails that an instruction alone cannot provide.

• Hook lifecycle events
• Hooks versus instructions
• Guardrails: blocking unsafe commands and protected files
• Feeding results back: lint-and-fix and formatting after edits
• Managing hooks
• LAB: Guardrail

Connecting External Systems with MCP

The Model Context Protocol lets Claude Code talk to external systems: issue trackers, databases, design tools, browsers, and more. This chapter explains how to connect and scope MCP servers, manage their context cost, and combine them with skills, alongside the often simpler alternative of CLI tools.

• What MCP is and how it fits the agentic loop
• Connecting servers to Claude Code
• Common MCP servers: GitHub, databases, Figma and browser control
• Tool search and keeping MCP context cost low
• The Skill plus CLI tools pattern as an efficient alternative
• LAB: Connect an MCP server and drive a task through it

Scripting with the Agent SDK

Everything so far has driven Claude Code interactively. The Agent SDK exposes the very same agent loop, tools, and context management as a programmable library for TypeScript and Python, so you can embed Claude in your own scripts, pipelines, and applications.

• The Agent SDK as a TypeScript and Python library
• Configuring agent runs
• Giving the agent custom tools
• Connecting external MCP
• Controlling autonomy
• Use cases: batch automation, CI/CD and building your own agentic apps
• LAB: Build a small custom agent with the Agent SDK