Skip to main content

Phase 1 — Fundamentals: understanding Claude Code

Duration: 3 weeks · Dedication: 6–8h/week · Tracks: 🟢🔵🟣 (all modules are essential) Prerequisite: Phase 0 (LLMs, tool use, taxonomy) or equivalent knowledge. Primary focus: Claude Code · Transferable concepts: explicitly marked in each module.

Phase objective​

Move from "I've heard of Claude Code" to "I have Claude Code installed, authenticated, and producing real code" in at least one of your projects. You will understand the code agent ecosystem just enough to justify choosing Claude Code, then dive deep into the tool.

By the end of this phase you can:

  • Explain what Claude Code is and how it differs from alternatives (in 2 minutes)
  • Install, authenticate and configure Claude Code from scratch on a new machine
  • Use interactive and plan modes, basic commands and the CLAUDE.md file
  • Write effective prompts and contexts for programming tasks
  • Deliver a small project on GitHub built with Claude Code

Marking conventions​

Each material is marked with:

  • Type: 📚 Official doc · 📖 Article/Paper · 🎓 Course · 🎬 Video/Podcast · 🛠️ Hands-on/Repository
  • Language: [PT] Portuguese · [EN] English
  • Cost: [Free] · [Paid] · [Freemium]
  • Level: beginner · intermediate · advanced

Materials marked ⭐ are essential — if you're short on time, cover only the ⭐ ones. Materials marked 🌐 are universal concepts (transferable to any agent).

M1 · Market overview and why Claude Code

Why this module​

Before diving into a tool, you need to understand where it fits on the map. This module is deliberately short (1–2 days): just enough for you to have reference of alternatives and justify choosing Claude Code. Without it, you'll feel insecure when someone asks "why not Cursor?".

Topics​

  • 🌐 The 4 categories of code agents in 2026:
    • IDE extension (GitHub Copilot, Cline, Continue)
    • Dedicated AI IDE (Cursor, Windsurf, Zed)
    • CLI/terminal agent (Claude Code, Aider, Codex CLI)
    • Cloud autonomous platform (Devin, OpenHands, Jules)
  • Where Claude Code fits (CLI/terminal-first) and its strengths:
    • IDE-agnostic — works in any editor
    • First-class MCP (was one of the pioneers)
    • Subagents, hooks, slash commands, skills, plugins
    • Own SDK (Claude Agent SDK)
    • Top-of-rank Anthropic models on SWE-bench Verified
  • Very brief map of alternatives — just to recognize the names
  • Personal justification: "why Claude Code for me/my team"

Materials​

Foundational conceptual ⭐​

  • ⭐ 🌐 📖 Building Effective AI Agents — Anthropic Engineering · [EN] [Free] intermediate Founding paper. Defines the difference between workflows and agents and the 5 basic patterns. Universal — read even as a Claude Code user.

  • 🌐 🛠️ Anthropic Cookbook — Agent Patterns · [EN] [Free] intermediate Python implementations of the 5 patterns. Seeing the concept in code solidifies it.

  • 🌐 📖 Building agents with the Claude Agent SDK — Anthropic Engineering · [EN] [Free] intermediate Practical follow-up. Good for understanding that Claude Code (product) and Claude Agent SDK (library) are different things — a distinction that recurs throughout the plan.

Quick comparisons (skim, not linear reading)​

Claude Code specific​

Practical exercise​

On a single page (markdown or Notion), answer:

  1. Which of the 4 agent categories does Claude Code fit into? Cite an alternative in each other category.
  2. Which 3 Claude Code strengths most attract you for your context?
  3. In what scenario in your current work do you imagine Claude Code adding the most value in the coming weeks?

This short document will be your reference when someone asks "why did you choose Claude Code?".

Definition of Done​

  • You can, in 2 minutes without consulting anything, answer:
    • What is an agentic workflow and how does it differ from an agent
    • The 4 categories of code agents and an example of each
    • 3 reasons why Claude Code makes sense for you

M2 · Installation, authentication and first steps in Claude Code

Why this module​

This is the module where you truly enter the tool. Solving setup once well, with CLAUDE.md configured and secure key management, prevents friction for months.

Topics​

Installation and authentication​

  • Prerequisites: Node.js 20+, modern terminal (zsh/fish/bash)
  • Installation via npm install -g @anthropic-ai/claude-code
  • Two ways to authenticate:
    • Via Anthropic Console (API key — pay per use, more flexible)
    • Via Claude.ai subscription (Pro/Max — uses plan quota)
  • Basic commands: claude, /help, /login, /logout, /exit

Operating modes​

  • Interactive mode (default) — REPL-style conversation
  • Plan mode — Claude presents a plan before executing (Shift+Tab to toggle)
  • Headless mode (-p or --print) — non-interactive execution, base for automation

First real interaction​

  • Start Claude Code inside one of your repos
  • Ask for an initial exploration ("explain this project")
  • Request a small edit
  • Difference between confirming actions with permission and using auto-accept

Initial project structure​

  • CLAUDE.md file — persistent instructions for Claude in the project context
  • Location: repo root (project memory) or ~/.claude/CLAUDE.md (user memory)
  • Hierarchical memory and how Claude reads these files

IDE integration​

  • Official plugin for VS Code
  • Official plugin for JetBrains (IntelliJ, PyCharm, etc.)
  • When to use IDE plugin vs. pure terminal

Secure API key management​

  • macOS Keychain
  • 1Password CLI (op)
  • direnv + .envrc that does NOT enter Git
  • Best practices for teams (variables in Anthropic Console)

Materials​

Official quickstarts ⭐​

Guided courses ⭐​

In Portuguese ⭐​

Short videos / reference​

Practical exercise​

Configure on your computer:

  1. Claude Code installed and authenticated — claude --version should return a valid version
  2. IDE plugin configured (VS Code or JetBrains) — Claude running alongside the code
  3. First real session: open Claude Code in an existing project, ask explain the architecture of this project, and read the answer
  4. Create a CLAUDE.md in the project with:
    • Languages and frameworks used
    • Team conventions (commit style, test patterns)
    • Important commands (build, test, lint)
    • What Claude should NOT do (e.g.: never modify migrations/, never touch secrets/)
  5. Make a real edit with Claude Code (a small function, improve a test, adjust README)
  6. Try plan mode (Shift+Tab) on a medium complexity task and observe the difference
  7. Your API keys are in a safe place (macOS Keychain, 1Password or direnv with .envrc in .gitignore)
  8. Document the setup steps in a personal README my-claude-code-setup.md

Definition of Done​

  • claude --version returns a valid version
  • You can open Claude Code in a project and request an edit it executes correctly
  • Have CLAUDE.md configured in at least 1 of your projects
  • Know how to switch between interactive and plan modes
  • Know how much you're spending per day (Anthropic Console or plan)
  • Your API keys are not in versioned files

M3 · Prompt engineering and context engineering with Claude

Why this module​

Claude Code is only as good as the context it receives. The biggest difference between devs who get 5x productivity and devs who say "these agents are kinda dumb" is here.

Note on terminology: in 2025/2026 the community migrated from "prompt engineering" to "context engineering" — because what matters is not the isolated prompt, but the entire context (instructions, examples, tools, memory, CLAUDE.md, MCP servers) the agent receives. We'll cover both sides.

🌐 The concepts in this module are universal — they work in Claude, GPT, Gemini, Cursor, Aider. The difference is how you materialize the context in each tool.

Topics​

Universal (any LLM/agent) 🌐​

  • Anatomy of a good prompt: role, context, constraints, examples, expected format, acceptance criteria
  • Chain-of-thought applied to programming tasks (and when NOT to use)
  • Few-shot prompting with code examples
  • Iteration: follow-ups, corrections, refinement
  • Common anti-patterns: vague prompts, missing acceptance criteria, "do better", scope-creep

Claude-specific​

  • XML tags — Claude responds particularly well to <context>, <example>, <rules>
  • Thinking modes in Claude Code (think, think hard, think harder, ultrathink) and when to activate
  • Extended thinking — when the model "thinks" before answering

Claude Code-specific context engineering​

  • CLAUDE.md as persistent context (project memory)
  • How to attach files to session context
  • When to ask Claude to read first vs. assume he knows
  • Signs that context is saturated (and what to do)

Materials​

Official documentation ⭐​

Free courses ⭐​

Articles / context engineering ⭐​

Books (optional, intermediate)​

  • 🌐 📖 Prompt Engineering for Generative AI — O'Reilly (Phoenix & Taylor) · [EN] [Paid] intermediate

  • ⭐ 🌐 📖 AI Engineering — Chip Huyen, O'Reilly · [EN] [Paid] intermediate to advanced Broader reference book on engineering around LLMs. Chapters on prompts and context are excellent. An investment that pays off for years.

Practical exercise​

Pick a medium-complexity code task from your real work (refactor a function, write tests for a module, debug a non-trivial bug). Make three versions of the same prompt in Claude Code:

  1. "Lazy" version: "help here" + open the file
  2. Structured version: with role, context, constraints, format (use Claude XML tags: <context>, <rules>, <format>)
  3. Structured version with improved CLAUDE.md: version 2 + update the project's CLAUDE.md with relevant conventions first

Compare the three outputs. Document differences in learnings-prompt.md. This is the most valuable exercise of the entire phase.

Bonus: run the same version 3 with claude --think hard and compare with output without extended thinking.

Definition of Done​

  • You have a personal prompt template for 3 tasks you do every week
  • Know when to use chain-of-thought / thinking modes and when NOT to use
  • Can identify and fix a vague prompt in 1 minute
  • Have a rich CLAUDE.md in at least 1 of your projects

M4 · First hands-on workflows with Claude Code

Why this module​

Knowledge without practice evaporates in 2 weeks. This module is where you consolidate everything from Phase 1 in a small, real, personal project — which will become reference for the rest of the plan.

Topics​

  • Start a project from scratch using Claude Code as pair programmer
  • Refactor a piece of your existing code with Claude Code
  • Add tests to a module without tests
  • Use plan mode before executing big tasks
  • Version everything in Git and document the process
  • Learn to give feedback to Claude (correct, refine, replan)

Materials​

Practical ⭐​

Inspiration / real cases​

Phase 1 project (deliverable)​

Build a small personal and original project (don't copy from tutorial) using Claude Code as primary pair programmer. Suggestions:

  • Simple CLI in Python or Node.js that does something useful for you (e.g.: PDF organizer by topic, work hours counter, changelog generator)
  • Small REST API with 3 endpoints and tests
  • Migration or ETL script for some data of yours
  • Small internal tool (e.g.: slide generator from markdown)

Deliverable requirements​

  • Public GitHub repo with README
  • Complete CLAUDE.md in root, describing: project context, conventions, commands, restrictions
  • At least one documented use of plan mode (screenshot or session copy)
  • Minimum test coverage (≥60%)
  • Clean Git history with semantic messages (can be generated by Claude Code)
  • A LEARNINGS.md file documenting:
    • 3 prompts that worked well (with Claude's output)
    • 1 prompt that failed and how you corrected it
    • What you learned about Claude Code that wasn't in any tutorial

Estimated time: 6–10h over the last week of the phase.

Definition of Done​

  • Public project on GitHub
  • CLAUDE.md configured and useful
  • LEARNINGS.md with 5+ concrete observations
  • You can, in a 5-minute meeting, explain to another dev how Claude Code helped you in this project and what it COULDN'T do

Self-assessment at the end of Phase 1

Check ✅ what you can do now without help:

  • Explain the difference between LLM, copilot and autonomous agent
  • Cite the 4 categories of code agents and where Claude Code fits
  • Justify choosing Claude Code in 2 minutes
  • Install and authenticate Claude Code from scratch on a new machine
  • Configure a rich CLAUDE.md in a project
  • Switch between interactive and plan modes
  • Write a structured prompt (role, context, constraints, format) using XML tags
  • Identify when NOT to use Claude Code (or activate thinking mode)
  • Point out 3 common anti-patterns in code prompts
  • Explain Anthropic's Building Effective Agents paper in 2 minutes

If you checked 7+ items, you're ready for Phase 2. If you checked fewer than 6, consider redoing the corresponding module before advancing — Phase 2 assumes these fundamentals.

Next phase​

Phase 2 — Fluency: using Claude Code daily (4 weeks) covers modules M5 to M11: task automation, spec-driven development with Claude Code, TDD, Git/PR/code review, debugging, automated documentation, and large codebases.