Developer Track — Full Curriculum

Session-by-session breakdown

Everything you'll build and deploy across all 5 sessions. Code agents, CLI pipelines, MCP integrations, skills, hooks, multi-agent systems, and real-world capstones — each session is 1 hour of teaching + 1 hour of hands-on practice.

5 sessionsTotal
10 hoursHands-on
2.5 weeksDuration
15 maxGroup size
01

Agent Architecture + Your First Code Agent

Understand the difference between an API call and an agent. Set up your coding agent. Watch it scaffold, write tests, and debug.

Teaching Hour
  • API Call vs Agent — the architecture difference. Live demo: same task given to a raw API call vs a code agent
  • The Coding Agent Landscape — CLI agents (Claude Code, Codex CLI, Gemini CLI), IDE agents (Copilot, Cursor, Windsurf), autonomous agents (Devin, SWE-Agent)
  • Your First Code Agent in Action — live walkthrough of Claude Code CLI on a real project. The agentic loop: plan → act → observe → iterate
  • Deterministic vs Probabilistic Software — why agent-written code is never identical, testing strategies, the mindset shift to tech lead managing a fast junior dev
Practice Hour
  • Verify setup and troubleshoot CLI installs and API keys (group support)
  • Scaffold a project with Claude Code from a natural language spec — REST API with CRUD, validation, and tests
  • Iterate on features: ask the agent to add capabilities, fix bugs, refactor — observe the agentic loop
  • Group share: what worked? What surprised you? Where did it go wrong?
Homework

Use your code agent on a real task from your actual project — not a toy exercise. Document what you asked, what it did, what you had to fix manually, and time comparison vs doing it yourself.

02

Coding Agents Deep Dive

Compare agents head-to-head. Set up project memory with CLAUDE.md. Master context management and developer-grade prompting.

Teaching Hour
  • Agent Comparison — Claude Code vs Copilot vs Codex CLI vs Gemini CLI. Strengths, weaknesses, and when to use each
  • CLAUDE.md & Project Memory — persistent instruction files that give agents project context. Architecture, conventions, commands, patterns, hierarchy
  • Context Management — the context window as your most valuable resource. Fresh sessions, /compact, pointing at specific files, breaking large tasks
  • The Developer CRAFT Framework — Context, Requirements, Architecture, Format, Tests. Vague prompt vs spec-quality prompt comparison
Practice Hour
  • Same coding task across 3 different agents — compare code quality, correctness, speed, and hand-holding needed
  • Set up CLAUDE.md for a real project — write a comprehensive config, test before/after quality difference
  • Context management drill: complete a multi-step task efficiently without running out of context
  • Group share: which agent impressed you most and why?
Homework

Use 2+ different code agents on real work tasks. Track: task description, agent used, time taken, quality of output (1–5), and manual fixes needed. Bring your comparison data to Session 3.

03

Tool Use: CLIs, MCP & Integrations

Why CLIs are overtaking MCPs for many use cases. Build CLI tool pipelines for standups, PR reviews, and RCA. Learn MCP architecture for when you need it.

Teaching Hour
  • Function Calling Under the Hood — how agents call tools: structured requests, execution, result feedback. Why tool descriptions matter as much as code
  • CLI Tools: The Power-User Path — why CLIs are overtaking MCPs. Key advantages: data piped/filtered before context, composable (gh | jq | claude), agents build their own tooling. Real-world: standups, PR reviews, DB queries, root cause analysis
  • MCP Architecture & Custom Servers — the open standard for agent-to-tool connections. When MCP beats CLI (state, real-time, complex auth). Anatomy of an MCP server: transport, tools, resources
  • Connecting Agents to Infrastructure — databases via CLI and MCP, REST APIs, webhooks. CLI-based root cause analysis: logs + DB + git blame → traced to a commit
Practice Hour
  • Build a CLI tool pipeline — standup generator from git log + PRs, or PR review pipeline using gh, jq, and agent reasoning
  • Explore and build an MCP integration — configure GitHub MCP server, build a custom server connecting to a real API. Compare: when does MCP feel better than CLI?
  • Test, iterate, and share — break your integration, handle edge cases, group discussion: CLI vs MCP for your workflow
Homework

Build one CLI tool pipeline or MCP integration for your real workflow. Generate standups, review PRs, query a database, or post to Slack. Document your CLI vs MCP choice and why. Bring it working to Session 4.

04

Multi-Agent Systems, Skills & Deployment

Build agent teams. Package reusable skills. Wire event-driven hooks. The key insight: skills + hooks + cron = proactive agents on schedules.

Teaching Hour
  • Why Multi-Agent? — the limits of a single agent: context limits, specialization, verification gaps. When to go multi-agent vs single agent with good tools
  • Orchestration Patterns — Coordinator/Specialist, Pipeline (write → review → test), Parallel, Checker/Verifier. Implementation with subagents and the Agent SDK
  • Skills & Hooks — skills: reusable agent procedures (/standup, /review, /deploy). Hooks: event-triggered behaviors (pre/post execution, notifications, guardrails). Skills + Hooks + Cron = proactive agents on schedules
  • Deploying Always-On Agents — deploy skills on schedules, hooks handle the glue. Cron jobs, CI/CD, GitHub Actions, cloud functions, headless mode
  • Production Guardrails — hooks as a natural guardrail mechanism. Permission boundaries, approval gates, output validation, cost caps
Practice Hour
  • Build a multi-agent pipeline — Agent A writes code, Agent B reviews, Agent C writes tests, wired together
  • Build a skill and deploy on a schedule — standup generator via cron, PR reviewer via GitHub Action, or health check via webhook. Add hooks for Slack notifications
  • Add guardrails via hooks — pre-execution validation that blocks dangerous operations, post-execution logging
  • Group share: show your skill + hooks architecture
Homework

Deploy one skill-based agent system that runs without you — triggered by schedule, event, or webhook. Add at least one hook (notification, validation, or logging). Let it run for a few days. Document the architecture and what went wrong.

05

Evaluation, Testing & Your Developer Agent Stack

Evaluate agent output programmatically. Monitor production with hooks. Real-world capstone tying it all together. Build your 10x developer agent stack.

Teaching Hour
  • Review Deployed Skills & Agents — how did your skill-based deployments perform? Hooks in action: what fired, what caught issues, what notifications landed
  • Programmatic Evaluation — test suites, LLM-as-judge, regression testing. Build eval pipelines: run → capture → score → aggregate
  • Production Monitoring — success/failure rates, token cost, quality drift. Hooks as monitoring touchpoints: log metrics, alert on failures, track costs
  • Skills, Hooks & Reusable Tooling — agents building their own skills. Shared CLAUDE.md patterns. Packaging CLI tools, MCP servers, and skills for teams
  • Agentic SDLC + Real-World Capstone — how agents change the full SDLC. Capstone examples: daily standup (CLI + skill + cron + hook), PR review (multi-agent + GitHub Action), DB queries & RCA (CLI tools + agent), repo health (skill + eval + monitoring)
Practice Hour
  • Build an automated eval pipeline for a task your agent handles — run it, measure results, identify improvements
  • Build your personal "10x developer" agent stack plan — map your workflow, identify where CLI tools, skills, hooks, and multi-agent pipelines fit
  • Present to the group: your agent stack + what you will build next
  • Final Q&A and troubleshooting
Take-Home Package

Your personal agent development toolkit (CLIs installed, API keys configured, MCP servers running, agents deployed), 5+ working agent workflows, custom skills and hooks you built, at least one deployed skill-based agent system, your CLAUDE.md templates, Agent Developer Playbook PDFs, private developer community access, and your 30-day agent adoption plan.

Your transformation, session by session

Session You walk in as… You walk out as…
01 "I've used Copilot autocomplete but agents are fuzzy" "I built a coding agent workflow that scaffolds, writes tests, and debugs"
02 "I've used one coding agent" "I know which agent to use when, and I have CLAUDE.md powering my workflow"
03 "Agents work in my terminal" "I built CLI pipelines and integrations that connect my agent to real services"
04 "I use agents interactively" "I have skills + hooks deployed on a schedule, doing work while I sleep"
05 "I have agents running" "I have an evaluated, monitored agent stack with reusable skills and a plan to 10x my output"

Tools covered in this course

CLI Coding Agents
Claude Code CLI, Codex CLI, Gemini CLI
IDE Coding Agents
GitHub Copilot, Cursor, Windsurf
APIs & SDKs
Claude API, OpenAI API, Anthropic Agent SDK
CLI Tool Pipelines
gh, jq, git log, psql, mongosh — composable CLI chains
Tool Integration
MCP (Model Context Protocol), custom MCP servers, function calling
Skills & Hooks
Custom slash commands, event-driven hooks, reusable agent procedures
Infrastructure
GitHub Actions, cron jobs, Docker, cloud functions
Git & Collaboration
Git agents, PR review agents, CI/CD integration
Evaluation & Monitoring
LLM-as-judge, test suites, hook-based logging, observability tools

Ready to level up?

15 seats. Developer track. Pilot pricing.

Reserve Your Seat