Skip to main content

Phase 4 — Mastery: building, scaling, governing

Duration: 5 weeks · Dedication: 8–10h/week · Tracks: essential for 🔵🟣 · track 🟢 can focus on M21, M22, M24 Prerequisite: Phase 3 completed (you already build MCP servers, subagents, hooks, Skills and plugins). Primary focus: Claude Code · Transferable concepts: marked with 🌐.

Phase objective​

Move from "I use and extend Claude Code" to "I build my own agents, measure impact, lead adoption and govern risks". This is the phase where the technical knowledge from previous phases translates into product, team and company decisions.

By the end of this phase you can:

  • Build custom agents from scratch with Claude Agent SDK (not Claude Code, but the base SDK from which it is built)
  • Orchestrate multi-agent with patterns evaluated in production
  • Evaluate agent output with programmatic evals integrated into CI
  • Reduce usage cost by 40–70% with proven techniques
  • Measure real productivity with metrics beyond "vibes"
  • Navigate clearly the legal and IP risks of AI-generated code
  • Define enterprise governance policies for Claude Code use
  • Lead team adoption without becoming a boring evangelist
  • Know when NOT to use Claude Code and which alternative works better

Conventions​

  • Type: 📚 Official doc · 📖 Article/Paper · 🎓 Course · 🎬 Video/Podcast · 🛠️ Hands-on/Repository
  • Language: [PT] Portuguese · [EN] English
  • Cost: [Free] · [Paid] · [Freemium]
  • ⭐ essential · 🌐 universal concept (transferable to any agent)

M19 · Claude Agent SDK

Why this module​

Attention to terminology: the Claude Code SDK was renamed to Claude Agent SDK in 2025. The motivation: the SDK is not just about code — it is the same foundation Anthropic uses internally to build Claude Code, and you can use it to build any agent (customer support, finance, devops, legal, etc.).

Key difference compared to Claude Code:

  • Claude Code is a ready-made product (CLI + extensions + IDE plugins)
  • Claude Agent SDK is the library that lets you build your own Claude Code for your domain

When to build with the SDK instead of extending Claude Code via plugins:

  • You need a custom UI (web, mobile, voice)
  • You need non-coding flows (support, analysis, briefing)
  • You need to package it as a product for clients
  • You need full control over the execution loop

Topics​

  • Difference between Claude Code (product), Claude Agent SDK (library for agents), and Anthropic Messages API (even lower level)
  • SDK installation in Python (anthropic-claude-agent-sdk) and TypeScript (@anthropic-ai/claude-agent-sdk)
  • Agent structure with SDK: system prompt, tools, loop, context management
  • Native tools (file ops, bash, web search) already available
  • Streaming, structured tool calling, session management
  • Integration with MCP (MCP server also works in SDK)
  • Deploy: serverless, container, edge

Materials​

Official documentation ⭐​

Conceptual ⭐​

Practical tutorials ⭐​

For scale​

Practical exercise​

Build a custom agent for a real problem of yours that is not purely coding. Suggestions:

  • Support ticket triage agent that classifies, prioritizes and responds first
  • Financial analysis agent that reads invoices and generates reports
  • Market research agent that searches, summarizes and cites
  • QA agent that runs manual test cases via Playwright (MCP)

Requirements:

  • Use Claude Agent SDK (Python or TypeScript)
  • At least 2 custom tools
  • At least 1 integrated MCP server
  • Minimum deploy (CLI or simple web)
  • README with architecture and examples
  • Document in learnings-agent-sdk.md

Definition of Done​

  • You built at least 1 agent of your own with Claude Agent SDK
  • Know the difference between SDK and Claude Code (and when to use each)
  • Know the difference between Agent SDK and Messages API (one layer below)
  • Have your agent running in some real environment

M20 · Multi-agent orchestration with Claude Code

Why this module​

🌐 Multi-agent is universal. The 5 patterns from the Building Effective Agents paper (prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer) work in any framework. In Claude Code you implement via subagents + Agent Teams (Feb/2026 feature); in the SDK you implement programmatically.

The golden rule: multi-agent is overengineering in 80% of cases. Knowing when NOT to use it is as important as knowing how to implement it.

Topics​

Universal patterns 🌐​

  • Prompt chaining — simple sequence (output from A becomes input to B)
  • Routing — "classifier" agent decides which specialist handles the request
  • Parallelization — N agents in parallel, aggregation at the end
  • Orchestrator-workers — coordinating agent delegates and consolidates
  • Evaluator-optimizer — generator + evaluator iterate until criteria is met

Implementation in Claude Code​

  • Subagents in parallel (M14)
  • Agent Teams (Feb/2026) for native orchestration
  • SubagentStop hook to collect results

Implementation in Agent SDK​

  • Loops with multiple instances
  • Tool result aggregation
  • Error handling and retries

Anti-patterns​

  • "Team of 7 agents to write an email" (overengineering)
  • Agents that duplicate context
  • Very long chains without checkpoints
  • Missing token budget (cost explodes)

Materials​

Conceptual ⭐​

Patterns in Claude Code​

Alternative frameworks (reference) 🌐​

  • 🛠️ LangGraph · [EN] [Free] intermediate
  • 🛠️ AutoGen (Microsoft) · [EN] [Free]
  • 🛠️ CrewAI · [EN] [Free] These are not Claude Code. They are references for other multi-agent patterns to compare approaches.

Practical exercise​

Implement 2 different patterns on the same real task:

Task: "given a repository, generate a quality report (security, typing, coverage, outdated dependencies)"

Pattern A — Orchestrator-workers: 1 main agent delegates to N specialized subagents (security-checker, type-coverage-checker, deps-checker, etc.). Each returns a summary, the main agent consolidates into a report.

Pattern B — Evaluator-optimizer: 1 agent generates the report, 1 agent evaluates quality (coverage, clarity, actionability), and iterates until the score reaches a threshold.

Compare:

  • Total time
  • Total cost
  • Output quality
  • Reproducibility

Document in learnings-multi-agent.md.

Definition of Done​

  • Implemented at least 2 multi-agent patterns in a real task
  • Can explain when each pattern applies
  • Identifies overengineering in other multi-agent architectures
  • Has opinion on Claude Code subagents vs LangGraph vs AutoGen vs CrewAI

M21 · Evals — agent output evaluation

Why this module​

🌐 Evals are the "unit tests" of the AI era. Without evals, you're guessing whether the agent has regressed. With evals, you have an automated regression test runnable in CI.

In 2026 the ecosystem is mature:

  • OpenAI acquired Promptfoo for $86M (Promptfoo remains MIT, now with more investment)
  • Braintrust raised $80M in Feb/2026 at $800M valuation
  • Inspect AI (UK AI Security Institute) became the open source reference for safety evals

Topics​

Types of eval​

  • Programmatic — exact assertions (output ≡ expected)
  • Heuristic — regex, contains, format check
  • LLM-as-judge — another LLM evaluates qualitative output
  • Human-in-the-loop — human evaluates a sample
  • Golden dataset — fixed set of input → expected output

When to use each​

  • Programmatic: for deterministic tools
  • Heuristic: format, presence of sections
  • LLM-as-judge: clarity, helpfulness, tone
  • Human: sample to calibrate LLM-as-judge
  • Golden dataset: regression in CI

Tools​

  • Promptfoo — open source, YAML configs, red teaming focus
  • Inspect AI — UK AISI, capability/safety focus, MIT
  • Braintrust — commercial, all-in-one (datasets + experiments + CI)
  • Langfuse — open source observability + evals
  • Anthropic Console Evals — integrated, simple, official

Eval in CI​

  • Trigger: PR opened, push to main, schedule
  • Failure = merge block / alert
  • Comparison with baseline (no regression)

Materials​

Official documentation ⭐​

Guided courses ⭐​

Tools (hands-on) ⭐​

  • ⭐ 🛠️ promptfoo/promptfoo (GitHub) · [EN] [Free] Open source, MIT, now from OpenAI but still open. Use in the exercise.

  • ⭐ 🛠️ UK AISI — Inspect AI · [EN] [Free] Framework from the UK AI Security Institute. Focus on capability and safety.

  • 🛠️ Braintrust · [EN] [Paid] (free tier) All-in-one commercial. Consider if you have a large team.

  • 🛠️ Langfuse · [EN] [Freemium] Open source observability, hosted or self-host.

Comparisons and guides ⭐​

Practical exercise​

  1. Set up Promptfoo (open source, lightweight) with YAML config
  2. Create a golden dataset of at least 20 input/expected output pairs for one of your workflows (e.g.: code review, refactoring, bug fix)
  3. Programmatic eval: output must contain X, must not contain Y, format Z
  4. LLM-as-judge: rubric of 1–5 for clarity, correctness, helpfulness
  5. Integrate into CI (GitHub Actions): run on every PR; fail if average score drops vs. baseline
  6. When you make a change to a prompt/agent, eval validates no regression
  7. Document in learnings-evals.md

Definition of Done​

  • You have an eval suite running in CI for at least 1 of your workflows
  • Have a versioned golden dataset
  • Know how to read LLM-as-judge results critically (calibrate with human eval)
  • Prompt changes never go to production without a green eval

M22 · Costs, tokens and optimization in Claude Code

Why this module​

The difference between $24/month and $80/month or $200/month and $2000/month is purely operational. Devs who don't understand cost either stop adopting (think it's too expensive) or burn budget unnecessarily. In 2026 Anthropic published official guides and the community documents reductions of 40–70% with proven techniques.

Topics​

Cost anatomy​

  • Input tokens vs. output tokens (output is 5x more expensive)
  • Cache reads (10% of normal price)
  • Cache writes (1.25x normal price — pays off in 2 reads)
  • Models: Haiku (cheapest) → Sonnet (medium) → Opus (premium)
  • Thinking budget (extended thinking) — extra tokens

Reduction strategies​

  • Prompt caching — CLAUDE.md is automatically cached; typical gain 40–50% on input
  • Auto-compaction — Claude Code summarizes context before overflowing the window
  • Choose the right model per task:
    • Haiku: lookups, formatting, boilerplate, grep, lint fixes
    • Sonnet: 80% of daily work (5x cheaper than Opus)
    • Opus: critical multi-file refactoring, subtle debugging, architectural decisions
  • Reduce context — don't dump entire repo, let Claude search
  • Batch API when applicable (50% discount, 24h SLA)

Monitoring​

  • Anthropic Console: usage dashboards, breakdown by model
  • Claude Code: /cost command to see session spending
  • Alerts and budget caps in teams

Real case (documented)​

70% reduction in an APAC team: $80/month → $24/month by switching majority Opus to Haiku + Sonnet + aggressive caching (Branch8 + DEV.to)

Materials​

Official documentation ⭐​

Practical guides ⭐​

Practical exercise​

  1. Audit your current usage in the Anthropic Console (last 4 weeks):
    • Breakdown by model
    • Cache hit rate
    • Average cost per session
  2. Apply 4 changes:
    • Move simple tasks (lint, format, boilerplate, lookups) to Haiku
    • Keep CLAUDE.md lean (effective cache)
    • For long sessions, use /compact instead of continuing until overflow
    • Reserve Opus for critical multi-file tasks
  3. Compare cost over the following 4 weeks
  4. Configure a budget alert in the Anthropic Console
  5. Document in learnings-costs.md with a before/after chart

Definition of Done​

  • You reduced usage cost by at least 30% vs. baseline
  • Know how to choose the model for a task in seconds
  • Have a budget alert configured
  • Know how to read the Anthropic Console dashboard and diagnose high spending

M23 · Productivity metrics and ROI

Why this module​

🌐 "I feel more productive with Claude Code" doesn't pass in a C-level meeting. Here you learn to measure real impact with metrics that fit a business case.

In 2026 the industry reports up to 79% delivery acceleration in teams that adopted Claude Code in a structured way — but there are also studies showing that gains are heterogeneously distributed (some devs gain 5x, others lose 10%).

Topics​

What to measure 🌐​

  • Lead time (PR opened → merged)
  • Cycle time (commit → production)
  • Throughput (PRs/dev/sprint)
  • Defect rate (bugs per release, bugs in production)
  • Test coverage (before/after)
  • Code churn (% of lines changed within 4 weeks after merge — proxy for quality)
  • Time-to-onboard (days for a new dev to open their first useful PR)

How to measure​

  • DORA metrics (industry standard)
  • Tools: GitHub Actions data, Linear, LinearB, Faros, GitClear
  • Quarterly developer experience survey (DevEx, SPACE)

Evaluation frameworks​

  • DORA (Deployment frequency, Lead time, MTTR, Change failure rate)
  • SPACE (Satisfaction, Performance, Activity, Collaboration, Efficiency)
  • DevEx (Friction, Flow, Cognitive load)

Statistical considerations​

  • Heterogeneity of gains (median ≠ mean)
  • Confounders (you adopted Claude AND changed something else)
  • Selection bias (devs who adopt tend to be enthusiasts)
  • Hawthorne effect (measurement changes behavior)

Materials​

Official frameworks 🌐 ⭐​

AI productivity studies ⭐​

Enterprise adoption​

Tools​

  • 🛠️ LinearB · [EN] [Paid] — DORA + SPACE metrics
  • 🛠️ Faros AI · [EN] [Paid] — engineering analytics with AI focus
  • 🛠️ GitClear · [EN] [Freemium] — code quality metrics

Practical exercise​

  1. Establish baseline of your metrics (4 weeks pre-adoption, if data exists):
    • Lead time, throughput, defect rate
  2. Define 3 testable hypotheses (e.g.: "Claude Code reduces lead time by 30%", "Claude Code reduces code review time by 50%")
  3. Measure 4 weeks with Claude Code active
  4. Short survey with yourself or the team: perception (1–5 scale)
  5. Calculate ROI: Claude Code cost (Anthropic invoice) vs. time saved × cost/hour/dev
  6. Compile into a 1-page business case to present to tech lead, manager or team
  7. Document in learnings-roi.md

Definition of Done​

  • You have a baseline and 4+ weeks of metrics with Claude Code
  • Have 1 page business case
  • Know how to articulate ROI in business language
  • Know the limits of your measurements (heterogeneity, confounders)

M24 · Legal aspects and IP of AI-generated code

Why this module​

🌐 This is not an optional topic. In 2025/26 there were important legal milestones that affect how you use Claude Code:

  • Anthropic settled a $1.5B class action in Aug/2025 — largest copyright settlement in the US, ~$3,000/title for use of works in training
  • U.S. Copyright Office: code generated predominantly by AI, without significant human authorship, is NOT eligible for copyright
  • Vendor indemnification: Microsoft, Google, OpenAI and Anthropic offer indemnification for enterprise use — terms vary

You need to understand enough to protect your work (yours, your team's, your company's) and navigate contracts with clients.

Topics​

Copyright and authorship 🌐​

  • When code is "predominantly AI": no copyright
  • When there is significant human authorship (iteration, editing, refinement): copyright attributable to the human
  • Implications for company vs. individual contributor (work-for-hire)

Infringement risk​

  • Generated code may reproduce snippets from sources with restrictive licenses (GPL, AGPL)
  • Higher risk in code with a long training trajectory (e.g.: OpenSSL, Linux kernel)
  • Mitigations: license scanners (FOSSA, BlackDuck), native provider filters

Vendor indemnification​

  • Anthropic Commercial Terms — verify specific indemnification clause for the plan
  • Microsoft Copilot for Business/Enterprise — copyright indemnification
  • Google Gemini for Workspace — similar indemnification
  • OpenAI — indemnification for Enterprise

Clauses in client contracts​

  • AI use disclosure
  • Attribution (Co-authored-by: Claude is a convention, not a legal obligation)
  • IP guarantee on output
  • Liability exclusion vs. passed-through indemnification

LGPD/GDPR​

  • Sensitive data in the prompt/code
  • Where the data is processed (jurisdiction)
  • Data subject rights (access, correction, deletion)

Materials​

Primary sources ⭐​

Analyses ⭐​

Data protection​

  • 🌐 📖 Search for "GDPR and generative AI" — updated analyses available on legal and tech sites.

Practical exercise​

  1. Read Anthropic's Commercial Terms in detail (focus on IP and indemnification)
  2. Audit your current usage:
    • Are you on the right plan for your clients (Pro vs Team vs Enterprise)?
    • Are you in compliance with current NDAs/contracts?
  3. Create a personal "AI use policy" documenting:
    • When you disclose AI use to the client/employer
    • How you attribute (commit messages, PRs)
    • What data you never paste into the prompt (PII, secrets, client code)
  4. For freelancer/contractor: prepare 1 minimum contractual clause about AI use in your next contract
  5. For employee: check if your company has a policy and follow it; if not, offer to draft one
  6. Document in learnings-legal.md

Definition of Done​

  • You read the Anthropic Commercial Terms for the plan you use
  • Have a written personal AI use policy
  • Can answer in 1 minute: "is this AI-generated code mine/the company's? does it have copyright?"
  • Know the 3 main risk vectors (copyright, infringement, sensitive data)

M25 · Enterprise governance with Claude Code

Why this module​

🌐 In large teams, governance is what separates sustainable adoption from chaos. In 2026 Anthropic launched several enterprise features:

  • Claude Code bundled in Team/Enterprise plans (eliminated the "innovation vs. governance" trade-off)
  • Compliance API (Mar 24, 2026) — real-time programmatic access to usage and content
  • Granular Admin controls for IT
  • GitLab + Anthropic partnership for "Governed AI" enterprise

Topics​

Governance pillars​

  • Identity & access: SSO, SCIM, RBAC, audit trail
  • Data: classification, retention, residency, redaction
  • Compliance: SOC2, GDPR, LGPD, HIPAA (health), PCI-DSS (payments)
  • Cost & quota: budget caps, alerts, billing splits per team/project
  • Security: secrets management, mandatory sandbox, MCP allowlist
  • Auditing: prompt logs, tool logs, output logs, retention

Anthropic enterprise tools​

  • Anthropic Console — org admin, billing, audit
  • Compliance API — programmatic usage export to SIEM
  • Data residency (US, EU)
  • Customer Data Processing Agreement (DPA) on demand
  • Custom corporate system prompts

Frameworks​

  • AI Review Board — internal committee that approves use cases
  • Sandbox-first — all Claude Code runs in sandbox by default
  • Principle of least privilege in MCPs and tools
  • Policy-as-code — versioned governance settings

Emerging pattern: Compliance API​

Endpoints for:

  • Listing users, sessions, prompts, outputs
  • Applying automatic PII redaction
  • Integration with SIEM (Splunk, Datadog, Sentinel)
  • Alerts on suspicious patterns

Materials​

Official documentation ⭐​

Practical guides ⭐​

Practical exercise​

For your organization (real or hypothetical):

  1. Map the risk:
    • What sensitive data does your team handle? (PII, financial, health, proprietary client code)
    • What regulation applies? (GDPR, LGPD, HIPAA, PCI, SOX)
  2. Draft a 1-page policy covering:
    • Who can use Claude Code (every dev? only seniors? only with training?)
    • Where can Claude Code run (dev laptop? CI? prod?)
    • What NEVER enters the prompt (secrets, PII, client data)
    • Mandatory sandbox? Where?
    • Approved MCP allowlist
    • Auditing and retention
    • Who approves exceptions
  3. Configure (if you have admin access):
    • SSO/SCIM if team already has it
    • Budget caps per user/team
    • MCP allowlist
  4. Document in learnings-governance.md

Definition of Done​

  • You have a drafted enterprise usage policy (≥1 page)
  • Know which governance features come with each plan (Pro/Team/Enterprise)
  • Identified the 3 biggest governance risks in your context
  • Know the difference between Compliance API and Console UI

M26 · Culture and adoption of Claude Code in teams

Why this module​

🌐 The biggest adoption barrier is cultural, not technical. Experienced devs resist out of pride, junior devs misuse it, managers push for metrics that become cargo cults, executives expect overnight ROI. Leading adoption well is product + facilitation + patience work.

Topics​

Adoption patterns​

  • Bottom-up (1 enthusiast → team → org) vs. top-down (mandate + training)
  • Hybrid works best: enthusiast gets mandate + budget for pilot
  • "Champion network" — 1 evangelist per team

Onboarding new devs into the AI flow​

  • First project: pair with champion using Claude Code together
  • Team's shared CLAUDE.md as a living tutorial
  • Team plugins as a "starter pack"

Handling resistance​

  • Resistance from pride ("I know how to code") — show use for tedious tasks, not replacement
  • Resistance from fear ("I'll be replaced") — be honest about what changes
  • Resistance from bad experience ("I tried it, it was bad") — a 2h pair session is worth 100 demos
  • Legitimate skepticism ("risky dependency") — discuss vendor lock-in honestly

Pair programming with AI​

  • Team sessions where 1 dev uses Claude Code with shared screen and narrates the process
  • Discussion about prompts that worked/failed
  • Collective calibration of "what to delegate vs. do manually"

Signs of healthy adoption​

  • 🟢 Devs sharing prompts in Slack/Notion
  • 🟢 CLAUDE.md evolving with team feedback
  • 🟢 Technical questions advancing ("how do I use subagents for X?")
  • 🔴 "That's all just hype" recurring
  • 🔴 PR diffs growing without caveats about critical review
  • 🔴 Human code review time growing instead of falling

Materials​

On adoption and change management 🌐​

Pair programming and culture​

Training​

Communities​

Practical exercise​

Choose between two paths:

Path A — You are a team champion:

  1. Propose a 4-week pilot with 3 colleagues (not all of engineering, yet)
  2. Create a shared CLAUDE.md for the team + plugin with 3 team Skills/agents
  3. Do 2 live pair sessions (1h each), narrating real use
  4. Collect feedback weekly (3-question Slack survey)
  5. Present results to the tech lead with metrics and qualitative data

Path B — You are solo / freelancer:

  1. Teach 1 colleague or make a short video sharing your workflow
  2. Contribute with an open source plugin or Skill
  3. Write a blog post or thread about your workflow with Claude Code

Document in learnings-adoption.md.

Definition of Done​

  • At least 1 other person adopted or learned from you
  • Have shareable material (post, repo, plugin)
  • Know how to identify productive resistance vs. paralyzing resistance
  • Have a realistic plan for the next 6 months of adoption evolution (team or personal)

M27 · When Claude Code is NOT the best choice

Why this module​

🌐 Specialization without reflection becomes dogmatism. This short module gives you intellectual honesty: real scenarios where another tool beats Claude Code, and how to recognize them.

The point is NOT to switch main tools — it's to have honest awareness to choose correctly case by case.

Topics​

Scenarios where alternatives win​

Cursor / Windsurf — inline in-editor autocomplete

  • Task: typing code with prediction and completion
  • Win: very low latency, integrated UX
  • Claude Code here: slow and inadequate (not the use case)

GitHub Copilot CLI — fast shell commands

  • Task: "how do I do a find that..." inline in the terminal
  • Win: integration via gh and speed
  • Claude Code here: overkill

Aider — minimalist git workflow, open source models

  • Task: solo dev, small project, prefers local models (Llama, Qwen)
  • Win: minimal footprint, no vendor lock-in
  • Claude Code here: dependency on Anthropic and cost

OpenHands / Devin / Jules — long autonomous tasks (hours)

  • Task: "resolve this issue from start to finish, open PR, respond to comments"
  • Win: fully autonomous loop in cloud sandbox
  • Claude Code here: excellent for 30min session, not as optimized for 4h+

Specialized models (Codestral, DeepSeek-Coder)

  • Task: completion in specific language where open source model excels
  • Win: zero or low cost
  • Claude Code here: unnecessary cost

How to decide​

  • Criteria: latency required by the workflow
  • Criteria: cost (are you solo, small team, enterprise?)
  • Criteria: privacy (local model required?)
  • Criteria: desired autonomy (accompanied session vs. autonomous)

Mature devs use 2–3 tools together:

  • 1 IDE agent for autocomplete (Cursor or Copilot)
  • Claude Code for complex tasks and CLI
  • 1 local model for private experimentation (optional)

Materials​

Honest comparisons​

To try out (quickly)​

  • 🛠️ Cursor · [EN] [Paid] — IDE
  • 🛠️ Aider · [EN] [Free] — minimalist CLI, supports local models
  • 🛠️ OpenHands · [EN] [Free] — open source autonomous agent

Practical exercise​

  1. Choose 2 alternatives you haven't tried in depth yet (Cursor, Aider, OpenHands, Codex CLI, Cline)
  2. Use each one for 3 days in real tasks from your day-to-day
  3. Document:
    • Where the alternative beat Claude Code
    • Where Claude Code remains superior
    • What combination you'll adopt going forward
  4. Update your personal stack (which tool for which type of task)
  5. Document in learnings-alternatives.md

Definition of Done​

  • You tried at least 2 alternatives in depth
  • Have an explicit personal stack (tool per task type)
  • Can, in 1 minute, recommend the right tool to a colleague given a scenario

Final Plan Capstone

Time: 1–2 weeks after M27 · Tracks: 3 variants (choose 1)

Variant 🟢 — Light capstone (Personal productivity)​

Use Claude Code intensively in 1 real personal project:

  • Complete personal plugin (M16) with Skills + subagents + hooks
  • CI with Claude Code action and evals (M12, M21)
  • Sandbox + security policy (M18)
  • Rich documentation (M10)
  • Optimized costs (≥30% documented reduction — M22)

Variant 🔵 — Team capstone (Technical leadership)​

Lead a real Claude Code pilot in 1 team:

  • Documented governance policy (M25)
  • AI use policy (M24)
  • Delivered training or pair sessions (M26)
  • Baseline metrics + 4 weeks + calculated ROI (M23)
  • Team plugin with shared Skills (M16)
  • Retrospective with lessons and 6-month plan (M26)

Variant 🟣 — Product capstone (Platform / AI engineering)​

Build and publish something:

  • Custom agent with Claude Agent SDK (M19)
  • At least 1 multi-agent pattern (M20)
  • Published custom MCP server (M13)
  • Eval suite integrated in CI (M21)
  • Plugin published in official marketplace OR MCP server published in directory
  • Complete documentation, usage policy, cost dashboard (M22, M25)

Self-assessment at the end of Phase 4

  • I built at least 1 agent of my own with Claude Agent SDK
  • Implemented at least 2 multi-agent patterns
  • Have an eval suite in CI
  • Reduced cost ≥30% with optimization techniques
  • Have documented productivity metrics
  • Have a written AI use policy
  • Have a drafted governance policy (if applicable to context)
  • Led team adoption OR shared knowledge publicly
  • Tried at least 2 alternatives and have an explicit personal stack
  • Completed 1 of the 3 Capstone variants

If you checked 8+ items, congratulations: you completed the plan. You now have full autonomy to use, extend, build and govern code agents with Claude Code as your primary tool — and universal knowledge applicable to any agent that comes your way.

What comes next

There is no "end" in the agent field — it evolves quickly. How to stay current:

  1. Follow officially: Anthropic blog, Anthropic engineering blog, Latent Space podcast
  2. Practice real projects: publish plugins, contribute to awesome-claude-code, write posts
  3. Watch the standard: MCP, AGENTS.md, and new cross-tool protocols
  4. Re-evaluate your stack every 6 months: what changed in the alternatives? Does it make sense to switch?
  5. Share: teaching is the fastest way to consolidate and discover gaps

The plan serves as a map, not a rail. Return to specific modules when you need to go deeper — that is the correct use. Happy journey.