AI Coder: Complete Claude Code & Coding Agents Course

If you want to learn:

- What is vibe engineering, and how does it differ from vibe coding?

- How do you set up Claude Code CLI and use Claude Code for production-quality AI coding workflows?

- What are the best practices for staying accountable when using AI code assistants like Claude Code, Cursor, or VS Code extensions?

- How can experienced developers use coding agents to tackle complex tasks across large codebases?

- What skills do you need to effectively manage AI-driven coding workflows, from planning and code review to automated testing?

- How do you develop an instinct for what to outsource to AI and what to handle yourself?

Then this lecture is for you!

Welcome to Pro Week — the turning point where casual vibe coding evolves into disciplined vibe engineering. In this lecture, you'll be introduced to Claude Code, the powerful AI coding CLI and VS Code extension that will serve as your primary tool for the remainder of the course. You'll explore how Claude Code fits into the broader landscape of AI code assistants alongside tools like Cursor, Codex CLI, and Gemini CLI, and learn why CLI-based coding agents dramatically increase productivity over IDE-only workflows.

The lecture walks through Simon Willison's influential framework for vibe engineering — the practice where seasoned professionals accelerate their work with AI while staying fully accountable for the software they produce. You'll learn the core principles that separate responsible AI-assisted development from prompt-and-pray vibe coding: comprehensive planning, automated testing, strong Git version control habits, thorough code review, and effective prompt design.

You'll examine real-world best practices for integrating Claude Code into your workflow, including how to configure agentic loops, use Claude Code commands to manage sessions, run Claude Code across complex codebases, and tell Claude exactly what you need through well-crafted prompts. The lecture also covers critical professional skills — knowing when to delegate tasks like front-end code to AI versus when to jump in and manually refactor, how to set realistic project estimates when using AI coding tools, and how to build a culture of trust-but-verify through manual QA and MCP-driven automation. Whether you're building MVPs or working on mission-critical software, this session lays the foundation for using AI code tools like a true engineering professional.

If you want to learn:

- What is Claude Code and how did it evolve from a side project into one of the most powerful AI coding tools available today?

- How do you set up Claude Code and install it in VS Code step by step?

- What's the difference between using the Claude Code CLI in the terminal versus the Claude Code VS Code extension — and which one should you use?

- How do Anthropic's pricing plans work, and can you use Claude Code for free?

- Why did Opus 4.5 change the game for agentic AI coding workflows?

- What role does MCP play in the Claude Code ecosystem?

Then this lecture is for you!

In this lecture, you'll dive into the history and rise of Claude Code — from its origins as a side project called Claude CLI by an Anthropic engineer in late 2024 to its general release in April 2025 and the game-changing V2 update in September 2025 that introduced checkpointing, subagents, hooks, skills, background tasks, and the Claude Code SDK. You'll learn how landmark AI models like Claude Sonnet 4.5 and Opus 4.5 transformed agentic coding reliability, and where Claude Code stands alongside competitors like Cursor, Codex, and Gemini.

From there, you'll walk through the complete process of setting up Claude Code on your machine. You'll navigate Anthropic's pricing plans — including the free tier and the Pro subscription — then install Claude Code using the CLI directly in your VS Code terminal. You'll also install the Claude Code extension for VS Code and understand the key differences between running Claude Code as a terminal CLI app versus using it in the VS Code sidebar. You'll discover why working in the terminal gives you access to the full-featured Claude Code experience with more control over your workflow, making it the preferred approach for serious AI-assisted coding.

By the end of this lecture, you'll have Claude Code fully configured in VS Code and be ready to use Claude Code as your primary AI coding assistant — whether you're prompting Claude from the terminal, integrating MCP into your workflow, or exploring how to run Claude Code with free and paid models.

If you want to learn:

- How do you set up Claude Code CLI in VS Code and start using it in your terminal?

- What does the `/init` command do, and should you let Claude write its own claude.md file?

- How do you monitor context window usage with the `/context` command during a Claude Code session?

- What's the difference between claude.md and agents.md, and why does it matter for your AI coding workflow?

- How can Claude Code run tests, launch Docker, and manage your development environment from the command line?

- What are the best practices for configuring Claude Code before prompting it on complex tasks?

Then this lecture is for you!

In this hands-on lecture, you'll open an existing project in VS Code and launch Claude Code CLI directly from the terminal to begin working with Anthropic's powerful AI coding assistant. You'll start by running a `git commit` to establish a clean baseline, then type `claude` in a fresh terminal to enter the CLI interface — a deliberately retro, text-based environment designed for raw, direct interaction with the LLM.

You'll walk through essential Claude Code commands step by step. First, you'll use `/login` to authenticate with your Anthropic account. Then you'll run `/init` to have Claude analyze your entire codebase and generate a `claude.md` file — the Claude Code equivalent of an agents.md — complete with project overview, development guidelines, and key commands. You'll learn why writing your own claude.md is a best practice rather than relying solely on the auto-generated version.

Next, you'll use `/context` to visualize how much of Claude's 200,000-token context window is consumed by memory, messages, and the compaction buffer — a critical skill for managing long Claude Code sessions effectively. You'll then prompt Claude to read your project's plan.md for full project understanding before asking it to run all backend and frontend tests, spinning up Docker as needed.

Along the way, you'll see Claude Code's permission system in action — the 1, 2, 3 approval workflow for edits and commands — and witness Claude Opus intelligently launch Docker Desktop when it detects the daemon isn't running. By the end, you'll understand how to configure Claude Code, manage context, run tests, and integrate this AI code assistant into a real development workflow using the CLI inside VS Code.

If you want to learn:

- How do you use Claude Code to perform a comprehensive code review of an entire repo?

- What are hallucinations in code reviews, and why are they the least dangerous form of LLM mistakes?

- How do you identify and fix false positives when using LLMs for coding tasks?

- How can Claude Code refactor a monolithic Python module into organized packages?

- What is the best workflow for managing your context window and tokens in Claude Code?

- How do you use /compact, /context, and /status to stay in control of your Claude Code session?

Then this lecture is for you!

In this hands-on lecture, you'll follow a real-world workflow using Claude Code to run a full code review, catch LLM hallucinations, and refactor messy code into clean, testable modules. The session begins by prompting Claude Code to carry out a comprehensive code review of an entire repository, generating a structured report with prioritized actions saved to a markdown file. You'll watch Claude Code spin up parallel agents to review backend code quality, front-end issues, and infrastructure configuration simultaneously.

A critical teaching moment emerges when Claude confidently flags a false positive — claiming an API key is exposed in Git when the .env file is properly gitignored. This is a classic example of hallucinations in code generated by LLMs, and you'll learn exactly how to spot the telltale signs, push back, and get Claude to correct its review. The lecture reinforces why every AI code review must be verified by a human eye, no matter how authoritative the output sounds.

From there, you'll prompt Claude Code to address all critical, high, and medium priority issues it identified — from unpinned dependencies and SQL injection risks to Playwright hard-coding and missing input validation. You'll see how Claude Code makes its own cost-benefit decisions, choosing to defer the monolithic file refactor until explicitly asked. When prompted directly, it restructures a bloated main.py into well-organized modules and packages — config, models, database, AI, dependencies, and routes — then reruns all backend and front-end tests to confirm everything passes.

The lecture wraps up with essential Claude Code workflow management: using /compact to clear conversation history and free up your context window, using /context to monitor token usage, and using /status to check your model, session, and daily allowance. You'll walk away understanding how to run effective AI-powered code reviews with ChatGPT alternatives like Claude Opus 4.5, how to handle prompt-driven refactoring, and how to maintain a productive, hallucination-aware workflow when using LLMs for coding.

If you want to learn:

- What is OpenCode and how does it work as an open-source alternative to Claude Code?

- How can you use free models like GLM 4.7 for agentic coding without spending a dime?

- How do you install and set up OpenCode to connect with providers like OpenAI, Anthropic, and OpenRouter?

- What's the difference between Plan and Build mode in an AI coding agent CLI?

- Can free and open-source LLMs like GLM 4.7 or Kimi K2 actually compete with Claude Opus 4.5 for code reviews?

- How do you run local LLMs with Ollama through OpenCode, and what hardware do you need?

Then this lecture is for you!

In this lecture, you'll explore **OpenCode** — a powerful open-source CLI coding agent that serves as a flexible alternative to Claude Code. You'll walk through the full installation process, launch OpenCode inside VS Code, and discover how it automatically detects your existing AI provider connections like OpenAI. You'll learn how to switch between models using the `/models` command and connect to additional providers — including Anthropic, OpenRouter, GitHub Copilot, and Google — using the `/connect` command.

The core hands-on exercise puts **GLM 4.7**, the highly capable open-source LLM from Z.AI, to the test by running a full code review on a real project — completely free. You'll see how OpenCode's **Plan and Build modes** work in practice: first forcing the AI agent to reason through its approach, then switching to Build mode to execute and write the review to a markdown file. The resulting code review covers modular architecture, security hardening, TypeScript strictness, code duplication, and error handling — demonstrating what free models can realistically accomplish.

You'll also get a practical breakdown of how free model access works through **OpenCode Zen**, the trade-offs compared to frontier models like Claude Opus 4.5, and what to expect regarding rate limits and token usage. The lecture covers running **local LLMs via Ollama**, including honest hardware requirements (64GB+ of unified or GPU RAM), and recommends the most practical paths for using free or cheap models — whether through OpenCode's built-in offerings or by connecting your OpenRouter API key. By the end, you'll understand exactly how OpenCode fits into your agentic coding workflow and when to choose it over Claude Code.

If you want to learn:

- How does AMP Code work as an agentic coding CLI, and how does its free $10/day ad-supported plan compare to Claude Code?

- Can you replace Claude Code with open-source LLMs like Kimi K2 or GLM 4.7 using OpenRouter as your API provider?

- How do you configure Claude Code to connect to OpenRouter or run local LLMs through Ollama on your own machine?

- What are the key differences between Claude Code, OpenCode, and AMP Code for agentic coding workflows?

- Is it practical to run coding agents with local models on your GPU, and what are the trade-offs?

Then this lecture is for you!

In this hands-on lecture, you'll explore AMP Code — a provider-agnostic agentic coding tool that runs in the terminal and as extensions for VS Code, Cursor, and Windsurf. You'll walk through installing AMP, signing up for the AMP Free plan (which provides $10/day in frontier model credits in exchange for viewing ads), and running a full code review using its Smart, Deep, and Rush modes. You'll see how AMP automatically selects the best model behind the scenes and how to manage your credits and settings through the AMP Code dashboard.

Next, you'll learn how to hook up Claude Code to alternative providers by setting environment variables to redirect API calls from Anthropic to OpenRouter. You'll configure Claude Code to use Moonshot AI's Kimi K2 — one of the strongest open-source models available — as a drop-in replacement for Claude Opus 4.5, Sonnet, and Haiku. You'll verify the setup by checking OpenRouter activity logs and understand the limitations of running Claude Code's tooling with non-Anthropic LLMs.

Finally, you'll see Claude Code connected to Ollama for fully local LLM inference, running a model entirely on your own GPU with no cloud API calls. You'll observe the real-world performance trade-offs of local models versus cloud-hosted options and learn when it makes sense to use OpenRouter for cheap access to powerful open-source models versus running them locally.

By the end of this lecture, you'll have practical experience with three distinct agentic coding CLIs — Claude Code, OpenCode, and AMP Code — and know how to configure Claude Code to work with OpenRouter and Ollama, giving you flexible, cost-effective options for AI-powered coding with both frontier and open-source LLMs.

If you want to learn:

- What are the most useful Claude Code commands and slash commands for an efficient AI coding workflow?

- How do you manage context window, compacting, and memory in Claude Code sessions?

- What keyboard shortcuts in Claude Code can speed up your development process?

- How do you configure Claude Code permissions, settings, and the claude.md file for best practices?

- How does the @ syntax work in Claude Code to bring file and directory context into your prompts?

- What is the difference between /clear, /compact, and /context — and when should you use each?

Then this lecture is for you!

In this deep dive into Claude Code commands, shortcuts, and configuration, you'll move beyond the basics and learn how to use Claude Code like a power user. The lecture begins with a quick recap of the AI coding agent landscape — covering IDEs like Cursor and Windsurf, plugins like GitHub Copilot and Codex, and CLI tools including Claude Code, Gemini CLI, Opencode, and Amp — before diving into the hands-on workflow.

You'll explore essential slash commands including `/init`, `/model`, `/status`, `/context`, `/compact`, `/clear`, `/config`, `/usage`, and `/stats`, learning exactly what each does and when to use it during your Claude Code sessions. The lecture covers critical best practices around context window management — why you should proactively run `/compact` rather than letting Claude Code handle it mid-task, and how `/clear` gives you a fresh start by wiping conversation history back to your claude.md configuration.

You'll also learn key keyboard shortcuts like Shift+Tab to toggle between plan mode and accept edits mode, Control+O for detailed transcript output, and how Claude Opus 4.6 has reduced the need for manual plan mode. The lecture walks through configuring permissions directly in the `.claude` settings JSON file, giving you instant control over what Claude Code is allowed to do.

Finally, you'll discover the powerful @ syntax for referencing file paths and directory listings inside claude.md or prompts — including the popular trick of pointing claude.md to an agents.md file so you can maintain a single configuration that works across Claude Code and GitHub Copilot. Every tip covered is designed to give you a cleaner, faster, and more controlled AI coding workflow.

If you want to learn:

- What are Claude Code sessions, checkpoints, and how do they differ from each other?

- How do you rewind and undo changes in Claude Code to restore code to a previous state?

- What's the best way to manage your Claude Code workflow using Git, sessions, and checkpointing together?

- How do you name, exit, and resume Claude Code sessions to pick up right where you left off?

- What are the limitations of checkpoint rewinding, and when should you use Git commits instead?

- What are the best practices for tracking progress using claude.md and markdown files in your AI coding workflow?

Then this lecture is for you!

In this lecture, you'll master the three essential tools for managing your Claude Code workflow: **sessions**, **checkpoints**, and **Git**. You'll learn how each operates at a different level of granularity—and more importantly, how they fit together to give you full control over your coding sessions and conversation history.

First, you'll explore **Claude Code sessions**—how to name, save, and resume them to return to a specific conversation state. You'll see a live walkthrough where a session is named, exited, and resumed using `claude --resume`, demonstrating exactly how session context is preserved and restored.

Next, you'll dive into **Claude Code checkpoints and rewinding**. You'll learn that every prompt you send acts as a checkpoint, and you can step backward through your conversation to undo changes and revert code. You'll also discover the important catch: checkpoints can only roll back changes Claude directly made—not side effects from scripts or subagents that modified files independently.

Then you'll see how **Git** serves as the bulletproof, long-term version control layer. Unlike sessions (which track conversation context) or checkpoints (which handle step-by-step rollback), Git commits capture full snapshots of your codebase that you can revert to at any time.

Finally, you'll hear a practical, real-world workflow recommendation: use Git commits frequently as your primary code safety net, leverage checkpoints for quick undo of immediate mistakes, and track project progress through markdown files like `claude.md` and `plan.md` rather than relying solely on session history. This approach gives you a crystal-clear understanding of where you are in your project at all times—without the confusion of navigating old conversation context.

If you want to learn:

- How do checkpoints and rewind work in Claude Code sessions?

- How can you undo changes and roll back code to a previous snapshot in Claude Code?

- What's the difference between rewinding a checkpoint and resuming a saved session?

- How do you use Control+O to inspect Claude's thinking trace and debug its workflow?

- What is YOLO mode in Claude Code, and how does it differ from auto-accepting diffs?

- What are the best practices for version control and git workflow before making risky AI coding changes?

Then this lecture is for you!

In this lecture, you'll get a hands-on, step-by-step walkthrough of Claude Code checkpoints, the rewind feature, and YOLO mode — three essential tools for managing your AI coding sessions with confidence. You'll start by watching a live Claude Code session where Claude is prompted to summarize a project, perform a code review, and write results to a markdown file. Along the way, you'll learn how to use **Control+O** to expand Claude's thinking trace and inspect exactly what the agent is doing as it explores your codebase, and **Control+E** to show or collapse all details — giving you full visibility into how code changes are made.

You'll see how Claude Code handles mistakes during a refactor or review — like a false positive about an exposed API key — and how a simple follow-up prompt can push Claude to self-correct and update its output. From there, the lecture dives into **checkpointing and rewind**: you'll learn how to use the `/rewind` command to step back through your conversation history, select a specific checkpoint, and choose whether to restore the conversation, the code, or both. You'll watch the code revert to its prior state in real time, demonstrating how Claude Code snapshots let you safely roll back changes without losing control of your git history.

The lecture clearly explains the difference between **rewinding a checkpoint** within your current session (which reverts both context and code) and **resuming a previous session** (which restores conversation context only). You'll also learn why it's a best practice to run `git add` and `git commit` before entering YOLO mode, ensuring your codebase has a clean restore point. By the end, you'll be fully prepared to use Claude Code's checkpoint workflow, rewind feature, and version control integration to code fearlessly — with an introduction to YOLO mode coming next.

If you want to learn:

- What is YOLO mode in Claude Code and how do you enable it for autonomous coding?

- How do you bypass permissions in Claude Code using the `--dangerously-skip-permissions` flag?

- What are the real risks of running an AI coding agent autonomously without approval prompts?

- How can Claude Code autonomously revamp a project's UI without any human intervention?

- Why should you sandbox your environment before running Claude Code in bypass permissions mode?

- How do you safely commit changes after letting an AI agent work autonomously on your codebase?

Then this lecture is for you!

In this lecture, you'll experience the full power of Claude Code YOLO mode — running Claude Code with the `--dangerously-skip-permissions` flag to let this AI coding agent operate in a fully autonomous loop without asking for approval before executing commands. You'll see exactly how to launch Claude Code in bypass permissions mode, understand the warnings Anthropic provides, and learn what the real-world risks look like when you let an AI agent run autonomously on your machine. The lecture walks through a live demonstration where Claude Code is given a UI improvement task and left to work independently for nearly eight minutes — reading the codebase, making changes, and testing everything on its own. You'll witness the results firsthand: a completely revamped, mobile-responsive interface with improved horizontal layout, icon-based delete buttons, and intelligent section flow — all produced without a single manual approval. The lecture also covers why sandboxing is critical for more grandiose autonomous tasks, how to verify the AI's output by starting your dev server and testing in the browser, and the essential step of running `git add` and `git commit` to lock in your changes before anything else happens. This is a practical, honest look at what happens when you trust an autonomous AI coding agent to iterate on your project — and how to do it as safely as possible while getting started with Claude Code.

If you want to learn:

- What are Ralph Loops in Claude Code and how do they let AI coding agents run autonomously?

- How do you install and run the Ralph Loop plugin to put Claude Code on autopilot?

- What's the difference between running a single agent loop versus an autonomous outer loop that iterates multiple times?

- How can you safely use YOLO mode with Ralph Loops, and when should you use a sandbox?

- How do you turn an 8-minute AI coding task into an 80-minute autonomous build session?

- When should you use Ralph Loops versus a more structured, regimented coding process?

Then this lecture is for you!

In this lecture, you'll get hands-on with Ralph Loops — a powerful technique for running AI coding agents autonomously in Claude Code. Named after Ralph Wiggum from The Simpsons and pioneered by engineer Jeffrey Huntley, the Ralph Loop wraps Claude Code's inner agent loop inside an outer autonomous loop, allowing the AI to iterate on its own work across multiple cycles without stopping.

You'll start by installing the official Ralph Loop plugin using the CLI command `/plugin install ralph-loop@claude-plugins/official`. From there, you'll learn how to kick off a Ralph Loop with a structured task prompt and configure max iterations so Claude Code can run autonomously — building, testing, and improving your codebase iteration after iteration.

You'll watch a live demonstration where a single Ralph Loop prompt transforms a basic Kanban board into a comprehensive project management application complete with user management, authentication, multiple boards, and persistent data — all built autonomously in roughly one hour with over 1,300 lines of code added. The lecture walks through the real output, including logging in, creating accounts, switching between boards, and verifying that everything works.

Along the way, you'll learn practical safety considerations: how to balance YOLO mode (`--dangerously-skip-permissions`) with manual approval, why sandboxing matters when running autonomous AI coding agents, and how to monitor a Ralph Loop so you can jump in if something goes wrong. You'll also explore when Ralph Loops are the right tool — ideal for prototypes, MVPs, and experimentation — versus when a more controlled, regimented approach to AI coding delivers more predictable, reliable results.

By the end, you'll know exactly how to get started with Ralph Loops in Claude Code, configure iteration counts, craft effective prompts for autonomous builds, and decide when to let your AI coding agent run on autopilot.

If you want to learn:

- What are MCP servers, Claude Skills, and Plugins — and how do these three building blocks actually differ in Claude Code?

- How does the Model Context Protocol (MCP) connect external tools to your AI coding workflow, and why is everyone talking about it?

- When should you use MCP servers versus Claude Skills, and what are the real pros and cons of each approach?

- Why can too many MCP servers degrade performance by filling up your context window — and what's the smarter alternative?

- How do Plugins bundle MCPs, Skills, and other components into easy-to-install packages for Claude Code?

- What is the core innovation behind Claude Code's agentic AI capabilities, and how do tools make it all possible?

Then this lecture is for you!

In this pivotal Day 3 lecture from the Complete Guide to Claude Code, you'll master the three most important building blocks that unlock Claude Code's full potential: MCP servers, Claude Skills, and Plugins. This is the session where your expertise crosses an inflection point — moving from basic usage to a deep, architectural understanding of how Claude Code actually works under the hood.

The lecture begins by grounding you in the foundational concept that powers everything: **tools**. You'll learn how tools transform a token-predicting LLM into an agentic AI capable of taking real action — editing files, managing to-do lists, searching the internet, and executing complex coding workflows. Understanding this mechanism is essential before layering on MCP, Skills, or Plugins.

From there, you'll dive into **MCP (Model Context Protocol)** — Anthropic's open source standard for connecting Claude Code to external tools written by anyone. Often described as the "USB-C port for AI applications," MCP enables plug-and-play integration with third-party tool libraries. You'll learn exactly what MCP does well — seamless connectivity, a massive ecosystem, and easy sharing of tools — and where it falls short, including context window efficiency problems that can degrade performance when too many MCP servers are active.

Next, you'll explore **Claude Skills**, a newer approach that addresses some of MCP's limitations. Skills offer an alternative method for adding expertise and capabilities to Claude Code, with distinct advantages around context efficiency. You'll get a clear, honest comparison of Skills versus MCP servers — including why many developers believe Skills may eventually replace MCP in certain workflows.

Finally, you'll learn how **Plugins** tie everything together as higher-level packages that bundle MCPs, Skills, claude.md configurations, and other components into convenient, easy-to-install units. Since all three — MCP servers, Skills, and Plugins — can be installed, uninstalled, and activated independently, you'll gain the complete clarity needed to know exactly when to use which approach in your own automation and coding workflow. This step-by-step guide gives you the best practices and deterministic framework for making smart architectural decisions with Claude Code.

If you want to learn:

- What are MCP hosts, MCP clients, and MCP servers — and how do they work together in Claude Code?

- What's the difference between local and remote MCP servers, and why does it matter for your AI coding workflow?

- How do you discover and evaluate trustworthy MCP servers from marketplaces like mcp.so and Glamour.ai?

- What is the Context7 MCP server, and how does it give LLMs and AI code editors access to up-to-date API documentation?

- How do you install an MCP server in Claude Code with a single command line prompt?

- Why do most MCP servers run locally — and can they still connect to real-time online APIs?

Then this lecture is for you!

In this lecture, you'll build a clear understanding of the Model Context Protocol (MCP) architecture — the three core components every AI coding practitioner should know: the MCP host, the MCP client, and the MCP server. You'll learn exactly how Claude Code functions as an MCP host, how clients are managed internally, and why the MCP server is the piece you'll interact with most when bolting new AI tools into your workflow.

You'll explore the two transport modes MCP servers use — local (running on your machine via tools like npx or UV) and remote (running in the cloud via streamable HTTP or the legacy SSE method) — and clear up the common confusion between where an MCP server runs and where its tools actually fetch data. A local MCP server can still query real-time APIs, like retrieving live stock prices from Polygon.io, even though the server itself runs on your computer.

The lecture then walks through MCP server discovery — a practical challenge since there's no single centralized registry. You'll tour the official MCP registry, Anthropic's GitHub reference repo, and popular third-party marketplaces including mcp.so (17,000+ servers) and Glamour.ai (16,000+ servers with security and quality ratings). You'll see firsthand how to navigate the noise, verify authenticity by checking GitHub stars, issues, and recent activity, and find the correct MCP server among clones and unofficial versions.

Using the Context7 MCP server by Upstash as a hands-on example, you'll see how this tool solves a critical problem: LLMs hallucinate outdated code examples because their training data has a cutoff. Context7 provides real-time, version-specific documentation so Claude can generate accurate, up-to-date code. You'll learn the exact command to install the Context7 MCP server into Claude Code — one line in your terminal that instantly equips your AI coding environment with powerful new MCP tools. That simplicity is the core value of the Model Context Protocol: a shared standard that makes connecting AI agents to any set of tools as easy as running a single command.

If you want to learn:

- What is the Model Context Protocol (MCP) and how do you add MCP servers to Claude Code?

- How does the Context7 MCP server help LLMs and AI code editors access up-to-date documentation instead of hallucinating outdated answers?

- How can you connect AI tools like Claude Code to real-time market data using the Polygon.io MCP server?

- What's the difference between available MCP tools and loaded MCP tools, and how does Claude Code manage token usage efficiently?

- How do you add, configure, and remove MCP servers from Claude Code using the command line?

- Do you need an API key to use Context7 MCP or Polygon.io MCP, and how does authentication work?

Then this lecture is for you!

In this hands-on lecture, you'll learn exactly how to supercharge Claude Code by adding MCP servers that give your AI coding assistant powerful new capabilities. You'll walk through the full workflow of equipping Claude with the **Context7 MCP server** — a tool that lets LLMs query up-to-date, version-specific documentation and code examples for any library, eliminating the risk that your AI will hallucinate outdated information. You'll see how to install it with a single CLI command using `claude mcp add`, how the two MCP tools (resolve library ID and query docs) work together, and how to prompt Claude effectively using natural language to trigger tool use.

Next, you'll explore a non-coding MCP server — the **Polygon.io MCP server** (now under the Massive name) — to demonstrate just how far the Model Context Protocol extends. You'll configure it with an API key, connect Claude Code to real-time and historical stock market data, and query live share prices directly from your terminal. This example showcases how MCP servers can provide real-time data from external APIs, turning Claude into far more than just an AI coding assistant.

Along the way, you'll examine how Claude Code manages context efficiently by only loading the MCP tools it actually needs — keeping token usage low even when dozens of tools are available. You'll also learn how to inspect your configured MCP servers with `/mcp` and `/context`, and how to cleanly remove MCP servers when they're no longer needed using `claude mcp remove`. By the end, you'll have a clear, repeatable process for adding any MCP server to Claude Code and understanding how AI agents leverage these tools in practice.

If you want to learn:

- What are Claude Code skills and how do they compare to MCP servers?

- Why do many developers consider skills a bigger deal than MCP for adding abilities to AI agents?

- How does progressive disclosure work to keep your context window efficient?

- What is the file system architecture behind skills, and how do you structure a skill.md file?

- How can you build, install, and share skills using nothing more than markdown files and shell scripts?

- When should you still use an MCP server instead of skills?

Then this lecture is for you!

In this lecture, you'll explore Claude Code skills — the simpler, more elegant alternative to MCP servers for equipping coding agents with new abilities, expertise, and automation workflows. You'll learn exactly what skills are, how they differ from the Model Context Protocol approach, and why the AI community greeted them with a collective sigh of relief.

The lecture breaks down the three levels of progressive disclosure — metadata, instructions, and resources — and shows how this design keeps token usage low by only loading information into context when the LLM actually needs it. You'll see how a skill is nothing more than a folder containing a skill.md markdown file with YAML frontmatter metadata, detailed instructions, optional resource files, and Python or shell scripts that run outside the context window for maximum efficiency.

You'll walk through the exact directory structure: where to place your .claude/skills folder at the project or home level, how to name subdirectories for each skill, and how Claude Code discovers and triggers available skills based on the metadata description. The lecture also covers the honest trade-offs — skills vs MCP in terms of tool granularity, discovery challenges, and the sometimes ad hoc way you invoke a skill — so you know exactly when to reach for an MCP tool instead.

By the end, you'll understand how to build, structure, and share agent skills as simple markdown files and scripts, making it easy to give Claude Code powerful new capabilities without the infrastructure overhead of spinning up an MCP server. Whether you use skills globally across all repos or scope them to a single project, you'll have a clear, practical workflow for extending any AI agent's toolkit.

If you want to learn:

- What are Claude Skills and how do they compare to MCP servers?

- Where can you find and browse available skills for Claude Code?

- How do you install Agent Browser as a skill in Claude Code?

- What is skills.sh and how does Vercel's skills marketplace work?

- How does the skill.md file format work with YAML frontmatter and markdown instructions?

- How can you share installed skills with your team through GitHub?

Then this lecture is for you!

In this lecture, you'll explore skills marketplaces for Claude Code and walk through a hands-on installation of the Agent Browser skill — giving your AI agent the ability to launch and control a browser directly from your coding environment. You'll start by browsing Anthropic's official GitHub Skills repo, examining real skill.md files to understand their structure: YAML metadata at the top, freeform markdown instructions below, and supporting scripts folders containing Python and JavaScript automation code. You'll see working examples including the skill creator skill, the PPTX PowerPoint skill, and the PDF generation skill. Next, you'll visit skills.sh, the curated skills marketplace built by Vercel, where you can discover and install community skills with a single command. Using Vercel's NPX Skills utility, you'll install the Agent Browser skill step by step — choosing Claude Code as the target agent, selecting project-level installation, and watching it create the necessary files inside your .claude/skills directory. You'll then install the headless browser dependencies including Playwright and Chromium, launch Claude Code, and verify the skill appears in context using only 68 tokens. Finally, you'll see Agent Browser in action as Claude Code autonomously navigates Resy and OpenTable to search for restaurant experiences — demonstrating how a simple markdown file and a few scripts can dramatically expand what your coding agent can do. You'll also learn why this file-based approach to agent skills makes team collaboration effortless: just push to GitHub and anyone who pulls the repo gets the skill equipped in their Claude Code immediately.

If you want to learn:

- What are Claude Code plugins and how do they differ from MCP servers and skills?

- How do you discover and install plugins from the Claude Skills Marketplace?

- When should you use plugins vs MCPs vs skills in your AI coding workflow?

- What are the best Claude Code plugins to install right now, and what do they actually do?

- How do you manage plugin marketplaces, including adding your own team or company marketplace?

- What are subagents like Code Simplifier, and how do plugins bundle commands, hooks, and MCP servers together?

Then this lecture is for you!

In this lecture, you'll explore Claude Code plugins — the highest-level and most streamlined way to extend your AI coding assistant with powerful new capabilities. You'll learn exactly what a plugin is: a curated bundle that can include one or more MCP servers, skills, slash commands, and hooks, all packaged together so you don't have to configure each piece yourself.

You'll walk through the official Claude Plugins Marketplace hosted on Anthropic's GitHub repository, learning how to browse, discover, and install plugins directly from within Claude Code using the `/plugins` command. You'll see the three core tabs — Discover, Installed, and Marketplaces — and understand how plugins are ranked by popularity and installs.

The lecture covers a hands-on installation of several top plugins, including Frontend Design for production-grade UI generation, Context Seven (which wraps the Upstash MCP server into an easy install), Code Review for pull request analysis, and Code Simplifier — Anthropic's own open-sourced internal agent designed to clean up LLM slop and simplify overly complex code.

You'll also learn the practical differences between plugins vs MCPs vs skills, and why the recommended approach is to start with plugins for most everyday AI-assisted development tasks. The lecture explains how to add custom or internal company marketplaces for team-wide plugin sharing, how to enable and disable plugins on the fly, and how uninstalling is as simple as removing a directory.

Whether you're new to Claude Code or looking to streamline your workflow with the right plugin strategy, this session gives you a clear, actionable framework for making the most of the Claude Code plugin ecosystem.

If you want to learn:

- What's the difference between MCP servers, skills, and plugins in Claude Code — and when should you use each one?

- How do you discover and install plugins from the Claude Code skills marketplace?

- Can you run subagents and slash commands through plugins without complex configuration?

- What are the real pros and cons of MCP vs skills vs plugins for your AI coding workflow?

- How do you choose the right setup when there are so many options for extending Claude Code?

- What's the simplest way to get started with plugins and let Claude handle code simplification, review, and more?

Then this lecture is for you!

In this lecture, you'll get a clear, practical breakdown of the three core ways to extend Claude Code — MCP servers, skills, and plugins — and walk away knowing exactly which one to reach for in any given situation. You'll watch a live walkthrough of browsing the official plugin marketplace, selecting and installing multiple plugins with a single command, and restarting Claude Code to load them. You'll see how to invoke an installed plugin like Code Simplifier using natural language, watch it run as a subagent across an entire codebase, and verify the application still works afterward. The lecture covers how plugins can bundle together MCP servers, skills, hooks, agents, and slash commands into one convenient, discoverable package — and why that makes them the recommended starting point for most workflows. You'll also learn when it makes sense to configure an MCP server directly for specialized tools like market data APIs or GitHub integration, and when to install a standalone skill from providers like Vercel for capabilities like an agent browser. The pros and cons of each approach are laid out side by side: MCP offers a huge ecosystem and flexibility but adds context overhead and setup complexity; skills are efficient and simple but more limited and still maturing; plugins give you the best of both with the easiest install experience, though they're currently exclusive to Claude Code and shouldn't be overloaded. By the end, you'll have a clear decision framework — start with plugins, reach for MCP or skills when you have a specific need — and the confidence to configure Claude Code for your own projects and share setups across your team using repository-level skills packages.

If you want to learn:

- How do you connect Claude Code to Jira using an MCP server for a real development workflow?

- What is the best approach for building business functionality with Claude Code, plugins, and MCP integration?

- How do you set up a Jira MCP server and use it to manage Jira tickets directly from your AI development environment?

- What are the pros and cons of using MCP servers, skills, and plugins in Claude Code — and when should you use each?

- How can you create a disciplined, end-to-end workflow that covers the full development life cycle using Claude Code and Atlassian Jira?

- How do you set up a free Jira project and configure it as the starting point for an AI-powered development process?

Then this lecture is for you!

In this hands-on lecture, you move beyond theory and start building a real development workflow using Claude Code, Jira, MCP servers, and plugins — all working together. The session begins with a focused recap of the three ways to extend Claude Code: the Model Context Protocol (MCP) for connecting external tools, skills for lightweight markdown-based expertise, and plugins that bundle MCP, skills, and commands into installable packages. You'll learn the practical trade-offs of each — when MCP's massive ecosystem is the right choice, when skills offer a simpler and more efficient path, and when plugins give you the best of both worlds.

From there, the lecture shifts entirely to doing. You'll follow a disciplined, end-to-end workflow for building business functionality that mirrors how real teams operate. The process starts where most development work begins: with a Jira ticket. You'll walk through setting up a free Atlassian Jira account, creating a Kanban-based project space, and configuring your first Jira issue — all as the foundation for connecting Claude Code to your project management workflow via a Jira MCP server.

The project you'll build is called PreLegal — an AI-powered tool for drafting legal documents like NDAs and client contracts from a template repository. This serves as the practical context for learning how to integrate Claude Code with Jira, GitHub, and MCP tools across a full two-day build. The lecture emphasizes a choose-your-own-adventure approach: follow along step by step, adapt the idea to your own direction, or build something entirely different using the same workflow and techniques. You'll come away with a repeatable process for using Claude Code, Jira integration, and MCP configuration to manage development from ticket to pull request.

If you want to learn:

- How do you connect Claude Code to a Jira MCP server for AI-powered project management?

- What is the Atlassian remote MCP server and how does OAuth 2 authentication work with it?

- How do you set up a GitHub repository and generate a fine-grained personal access token for Claude Code integration?

- How can you use Model Context Protocol to query and manage Jira tickets directly from your terminal?

- What permissions should you configure when creating a GitHub token for an MCP server integration?

- How do you clone a GitHub repository and prepare it for an AI development workflow with Claude Code?

Then this lecture is for you!

In this hands-on lecture, you'll connect Claude Code to both Jira and GitHub using Model Context Protocol (MCP), building a powerful AI development workflow that bridges project management and code repositories.

You'll start by adding the Atlassian remote MCP server to your Claude Code setup using the `claude mcp add` command with the official Atlassian MCP endpoint at `mcp.atlassian.com/v1/mcp`. You'll walk through the full OAuth 2 authentication flow to authorize Claude Code to access your Jira account, learn how to verify the connection using the `/mcp` command, and discover how to reauthenticate when the session expires. Once connected, you'll use Claude Code to query Jira tickets directly — pulling issue details, descriptions, and task information straight from your Jira workspace.

Next, you'll set up the GitHub side of the integration. You'll create a new private GitHub repository, then navigate to Developer Settings to generate a fine-grained personal access token scoped to that single repository. You'll configure minimal permissions — read access for contents and issues, plus read and write access for pull requests — following the security best practice of starting with slim permissions and expanding only when needed. Finally, you'll clone the repository to your local machine and prepare it for use with Claude Code.

By the end of this lecture, you'll have Claude Code connected to both a Jira MCP server and a GitHub repository, giving your AI assistant the ability to read Jira tickets, interact with your codebase, and manage pull requests — the foundation for a complete AI-driven development workflow.

If you want to learn:

- How do you set up the GitHub MCP server in Claude Code using a personal access token?

- How can Claude Code create GitHub issues and pull requests through Model Context Protocol integration?

- What is the Featured Dev plugin and how does Anthropic use it for disciplined AI development workflows?

- How do you connect Claude Code to both Atlassian Jira and GitHub MCP servers for a complete project management workflow?

- What's the difference between using MCP servers directly versus installing plugins in Claude Code?

- How do you configure a new project with .gitignore and proper Git housekeeping using Claude Code?

Then this lecture is for you!

In this hands-on lecture, you'll set up the GitHub remote MCP server in Claude Code and install the Featured Dev plugin to prepare for a disciplined, structured development workflow. You'll start by running the `claude mcp add` command to connect to GitHub's remote MCP server at `api.githubcopilot.com/mcp`, passing in your fine-grained personal access token via an authentication header — the same approach used for the Atlassian Jira MCP server configured earlier. Once connected, you'll verify the integration by running `/context` to confirm that GitHub-related tools are available, then put them to work by prompting Claude Code to create a GitHub issue and open a pull request — all from the terminal. You'll walk through the full cycle: writing an issue, updating the README, committing to a branch, pushing, and merging the PR directly on GitHub. The lecture explains why these two famous MCP servers — Jira and GitHub — are configured directly rather than through plugins, due to their particular authorization techniques. You'll then shift to installing the Featured Dev plugin, an official Anthropic plugin that guides Claude Code through a rigorous seven-stage feature development process with specialized agents for codebase exploration, architecture design, and quality review. You'll install it at project scope so all collaborators on the repo benefit. Finally, you'll use Claude Code to generate a boilerplate `.gitignore` for a Python FastAPI and Next.js web app, commit it, and push everything to GitHub — leaving your project fully configured with MCP server integration for both Jira project management and GitHub pull requests, ready to build features using a proper, disciplined AI development workflow.

If you want to learn:

- How do you use Claude Code to autonomously complete a Jira ticket and raise a PR?

- How do you connect the Atlassian MCP server to Claude Code for Jira and Confluence integration?

- Can Claude AI read a Jira issue, write code, and push a pull request without manual intervention?

- How do you automate your coding workflow from project management tool to GitHub using MCP?

- What happens when Claude Code hits roadblocks during autonomous execution — and how does it problem-solve in real time?

- How do you set up and reauthenticate the Atlassian MCP server inside Claude Code?

Then this lecture is for you!

In this lecture, you'll witness a complete end-to-end autonomous workflow where Claude Code reads a Jira issue, executes every step described in the ticket, and raises a pull request — all with minimal human intervention. You'll start by creating a real-world Jira task: a data curation project that involves browsing GitHub repos, downloading markdown legal document templates from Common Paper, organizing them into a directory, generating a catalog JSON file, and adding a license file. Then you'll install and configure the Atlassian MCP server in Claude Code, authenticate against your Atlassian account, and hand the Jira issue ID directly to Claude with a single prompt.

You'll see Claude Code autonomously fetch the Jira ticket details via the MCP server, interpret the high-level task description, and begin executing — first attempting to use GitHub tools, then self-correcting when it realizes that approach is too slow, and switching to direct download commands instead. This real-time problem-solving demonstrates the power of AI coding autonomy at its best. Once the files are downloaded, Claude Code commits the changes, creates a detailed pull request using MCP tools, and even attempts to update the Jira issue status to mark it as done.

Along the way, you'll encounter a common pain point — Atlassian MCP server authentication timeouts — and learn exactly how to reauthenticate and recover. You'll also see Claude Code work around merge permission limitations by merging locally and pushing to main. By the end, you'll understand how to integrate Atlassian Jira into your Claude Code workflow, automate multi-step coding tasks from a single prompt, and leverage MCP servers to bridge project management and AI-powered development into one seamless, autonomous pipeline.

If you want to learn:

- How can you use Claude Code to build a full Next.js application directly from a Jira ticket?

- How do you connect Atlassian Jira with Claude AI using an MCP server to automate your coding workflow?

- What is the featuredev plugin, and how does it guide Claude Code through a structured seven-step development process?

- How does Claude Code handle clarifying questions, generate files, and raise a GitHub PR — all in one automated workflow?

- Can AI coding tools like Claude Code produce a polished, functional web app with PDF download on the first attempt?

- How do you prompt Claude Code to run automated tests and trigger code reviewer agents after building a feature?

Then this lecture is for you!

In this lecture, you'll watch Claude Code build a complete, polished Next.js application from scratch — driven entirely by a Jira ticket and an integrated AI workflow. Starting inside Atlassian Jira, you'll create a real-world business requirement: a Mutual NDA Creator web app where users fill in a form, preview the document live, and download a finished PDF. The Jira issue is written loosely on purpose — just like a product team or business sponsor would write it — to see how Claude AI handles ambiguity.

You'll then connect Atlassian Jira to Claude Code using the Jira MCP server, authenticate with the Atlassian MCP server, and invoke the `featuredev` plugin to kick off a structured, seven-step development process. Claude Code reads the Jira ticket, analyzes the project repo, and returns clarifying questions — covering download format, layout preferences, and design polish — before writing a single line of code. Once you submit your answers, Claude Code autonomously scaffolds the Next.js app in a `frontend` directory, generates all necessary files, builds the UI with side-by-side form and live NDA preview, implements PDF generation, and raises a pull request on GitHub using MCP server integrations.

You'll see the finished app running locally with `npm run dev`, fill in the form with live-updating fields, and download a professionally formatted PDF — all produced zero-shot from a single Jira ticket and prompt. The lecture also covers an important lesson: Claude Code skipped the testing and code review phase (step six of the workflow), and you'll learn how to prompt it to go back, add extensive automated tests, run manual tests, and have code reviewer agents complete the review. This is a powerful, end-to-end demonstration of how to integrate Jira and Confluence workflows with Claude Code, automate feature development, and use AI to dramatically accelerate project management and productivity in a real IDE setup.

If you want to learn:

- What's the best debugging workflow when Claude Code goes off track or can't fix a bug?

- How do you use a disciplined, step-by-step approach to find the root cause of issues in AI coding sessions?

- Why should you document debugging lessons in claude.md and how does it prevent repeated mistakes?

- How can you use multiple LLMs like Codex alongside Claude Code to debug hard problems faster?

- What are the red flags to watch for when Claude Code latches onto false root causes from outdated GitHub issues?

- How do you integrate Jira, GitHub MCP servers, and a feature dev workflow into a single Claude Code automation pipeline?

Then this lecture is for you!

In this lecture, you'll walk through a complete end-to-end Claude Code dev workflow — from reading Jira issues via an Atlassian MCP server, through autonomous code generation and integration testing, to creating and merging a PR using the GitHub MCP server — all orchestrated from a single prompt. You'll witness Claude Code build a fully functional Next.js prototype application with over 8,000 lines of code and 76 passing tests across five suites, handling context window compaction and recovery along the way.

The core of this session introduces a disciplined debugging strategy for when AI coding assistants fail. You'll learn a structured five-step debug workflow: snapshot your work with a Git commit, attempt quick iterative fixes by pasting stack traces directly into Claude, and if that loop doesn't resolve the bug, shift to a regimented approach using a dedicated markdown file to document reproduction steps, investigation logs, hypotheses, root cause analysis, and proof of fix. You'll discover why explicitly guiding Claude Code through each phase — reproduce, investigate, hypothesize, prove, and fix — yields far better results than letting it reason autonomously.

You'll also learn critical best practices for catching common AI coding pitfalls, including Claude's tendency to jump to conclusions by latching onto obscure, years-old Stack Overflow or GitHub issues and declaring them as known problems with false confidence. The lecture covers how to challenge these suggestions, revert to your last commit when the agent goes off the rails, and use a second LLM as a fresh pair of eyes to break through stubborn bugs. Finally, you'll explore community-built debugging skills — structured prompt frameworks you can integrate into your Claude Code workflow — and see how documenting lessons learned in claude.md creates a safety net against repeated errors across compacted conversation threads and future iteration cycles.

If you want to learn:

- How do you set up a Claude.md file to customize your AI coding workflow?

- What are Claude Code skills, and how do they differ from MCP servers and plugins?

- How do you structure a skill.md file so Claude Code can progressively read instructions?

- What best practices should every developer follow when configuring a home directory Claude.md?

- How do you build your own AI-powered SaaS platform step-by-step using Claude Code agent skills?

- How do you keep your Claude Code instructions focused, efficient, and context-aware?

Then this lecture is for you!

In this hands-on building day, you dive into the practical side of deploying a SaaS platform using Claude Code, picking up exactly where the previous session left off. The lecture walks you through the three core ways to extend Claude's capabilities — MCP servers, skills, and plugins — and clarifies when to reach for each one. You learn the skill structure in detail: how metadata and instructions live together inside a skill.md file, how the file system architecture works with the `.claude` directory in both your home and project folders, and how Claude Code progressively reads only what it needs to preserve context efficiency.

A major focus of this session is setting up and optimizing your Claude.md files. You discover that there are two levels — a project-level Claude.md and a personal home directory Claude.md — and learn why the home directory version matters for establishing your coding style, mandatory code conventions, and debugging workflow across every project. The instructor shares a real-world Claude.md configuration covering incremental development, API usage, Python package management with UV, docstring conventions, emoji restrictions, and methodical debugging practices. You also handle essential Git workflow steps like committing Claude settings to your repo so your entire team shares the same plugin configuration.

By the end of this lecture, you will have a fully configured Claude Code environment with custom skills, a well-crafted Claude.md file tailored to your developer preferences, and a clear step-by-step guide for building an AI-powered SaaS platform — whether you follow the Prelegal legal document drafter template or transform the approach for your own project.

If you want to learn:

- How do you write an effective claude.md file to guide your Claude Code agent on a real SaaS project?

- What are Claude Code agent skills, and how do you build your own custom skill from scratch?

- How do you configure Cerebras as a fast inference provider through OpenRouter and LiteLLM?

- What is the correct skill.md file structure and format needed for Claude Code to recognize a custom skill?

- How do you set up a full-stack SaaS project with Docker, FastAPI, and SQLite using Claude Code?

- How do you use markdown files, .env configuration, and structured outputs to streamline your AI-powered development workflow?

Then this lecture is for you!

In this step-by-step guide, you'll learn how to write a well-structured claude.md file and create custom Claude Code agent skills tailored to your SaaS project. The lecture walks through building a claude.md for a real application — a legal document drafting platform — covering how to define project context, development process instructions, AI design directives, and technical design specifications including Docker, FastAPI, and a JavaScript frontend.

You'll then build your own Claude Code skill from scratch by creating the proper skill structure inside the `.claude/skills/` directory, writing a correctly formatted `skill.md` file, and providing clear code snippets and instructions that Claude Code can follow. The custom skill created in this lecture configures Cerebras as a high-speed inference provider, using LiteLLM and OpenRouter to call the GPT-OSS 120B model with structured outputs for fast, reliable AI responses.

The lecture also covers essential setup steps: using the `@` file reference trick to embed files like `catalog.json` directly into your markdown files, copying your OpenRouter API key into a `.env` file, configuring SQLite as a lightweight database within a Docker container, and formatting markdown properly for clean preview rendering. By the end, you'll have a fully prepared project environment — complete with a claude.md, a custom Cerebras skill, environment configuration, and clear technical directives — ready to deploy and build your AI-powered SaaS application with Claude Code.

If you want to learn:

- How do you set up Jira tickets to guide Claude Code through building a production-ready SaaS app step by step?

- What's the best workflow for transitioning from a prototype to a full V1 SaaS product using AI coding tools?

- How do you structure Jira tasks for frontend, backend, and AI chat features so an AI coding agent can execute them?

- How do you plan tickets that cover user authentication, database setup, and UI polish for a professional SaaS application?

- How do you authenticate and connect Jira with Claude Code using MCP servers in VS Code?

Then this lecture is for you!

In this lecture, you'll learn how to set up a structured Jira board with clearly defined tickets that Claude Code will use to build your V1 SaaS product from an existing prototype. You'll watch the entire process of creating four sequential Jira tickets — each representing a critical phase of development — and writing precise descriptions that an AI coding agent can interpret and act on.

The first ticket covers upgrading the prototype into a proper technical foundation, including frontend, backend, and a temporary database with start and stop scripts — all without changing product features yet. The second ticket introduces an AI chat interface that replaces the original question-based UX, where the AI asks the user about document fields and populates a legal document based on free-form responses. The third ticket expands functionality to support all legal document types with templates, including graceful handling when a user requests an unsupported document. The fourth and final ticket adds multi-user support with sign-up and sign-in screens, document history, UI polish for a professional SaaS look, and a legal disclaimer for generated drafts.

You'll also see how to re-authenticate the Atlassian MCP server, verify project skills and context inside Claude Code, and confirm that your GitHub and Jira integrations are ready before handing tickets off to the AI. This lecture demonstrates a real-world workflow where business requirements flow from Jira directly into an AI-assisted development pipeline — replacing a traditional engineering team handoff with Claude Code as your automated builder.

If you want to learn:

- How do you use Claude Code with Jira to automate feature development in a SaaS app?

- What does a production-ready workflow look like when building a SaaS with Claude Code and FastAPI?

- How do you manage context windows, compacting, and claude.md to keep AI coding sessions on track?

- How can you make smart architecture decisions during AI-assisted development — like choosing between streaming and structured outputs?

- What's the best way to handle MCP authentication, PR creation, and branch management using AI tools?

- How do you prompt Claude Code to ask the right clarifying questions before building backend and frontend features?

Then this lecture is for you!

In this lecture, you'll watch a real-time feature development workflow where Claude Code pulls Jira tickets, builds production-ready code, and creates pull requests — all from a single prompt. You'll see how to implement Jira ticket PL4 by guiding Claude through architecture decisions for a FastAPI backend with a Next.js static frontend, placeholder authentication routes, a single-container Docker Compose setup, and a clean project structure using pyproject.toml. You'll learn how to answer Claude's clarifying questions like a technical lead — making decisions about frontend/backend integration, database persistence, and deployment strategy.

The lecture then moves into building a more complex feature (PL5): replacing a traditional form UI with an AI-powered chat interface. You'll follow along as Claude Code launches three parallel architecture agents — minimal, clean, and pragmatic — and learn how to evaluate each approach, chat about tradeoffs, and guide the AI toward the right solution. You'll see a practical example of choosing a single structured LLM call over streaming responses when using Cerebras, and why simplicity often wins in scalable SaaS product design.

Beyond coding, this session covers essential workflow practices: how to manage context before it fills up, when and why to update claude.md to prevent information loss during compacting, how to use /clear to reset context safely, and how to reauthenticate MCP services like Atlassian when connections drop. You'll also see how to merge PRs locally, push to main, and keep your GitHub workflow clean — all orchestrated through Claude Code. Whether you're looking to build a SaaS with Claude Code or streamline your AI-assisted development process, this lecture gives you a repeatable, production-ready blueprint for turning Jira tickets into working features.

If you want to learn:

- How do you test an AI legal document generator built with Claude Code and Cerebras?

- How does Claude Code use skills to integrate with the Cerebras LLM and produce structured outputs?

- How can you automate legal document creation through an AI chat interface and generate downloadable PDFs?

- What does a real workflow look like when using GitHub PRs, Jira tickets, and Claude Code to build a SaaS product?

- How do you iterate on prompt engineering and UI fixes across multiple development cycles?

- How fast can Cerebras process LLM requests for legal document generation without needing streaming?

Then this lecture is for you!

In this lecture, you'll watch a live, end-to-end test of an AI legal document generator built using Claude Code and Cerebras. Starting with a completed Jira ticket (PL-5), you'll see the full GitHub pull request review — verifying that Claude Code correctly applied a custom skill to call the Cerebras LLM with the right model, structured outputs, and Pydantic objects across 456 lines of new code. You'll then follow along as the application is launched locally and tested in real time: an AI chat interface walks through creating a mutual non-disclosure agreement by asking guided questions, collecting template fields, and producing a downloadable PDF — all with near-instant LLM responses that eliminate the need for streaming.

After identifying UI issues — such as missing input focus and the AI failing to always ask follow-on questions — you'll see how these fixes are folded into the next Jira ticket (PL-6) alongside a major feature expansion: support for all legal document types, including a cloud SaaS agreement. The lecture demonstrates the full automate-and-iterate workflow: clearing context, re-authenticating MCP and Jira, prompting Claude Code to implement, test, and create a PR — resulting in 2,500+ lines of code across 16 files. You'll see the finished dashboard with correct brand colors, a working AI chat that uses prompt engineering to gather information step by step, and a final PDF output. This is a practical, real-world look at how to use Claude Code, Cerebras, GitHub, and Jira together to rapidly build and refine an AI-powered legal document SaaS product.

If you want to learn:

- How do you merge a final PR and complete a full SaaS project using Claude Code?

- Can you really automate legal document generation with AI and deploy a working app in just one hour?

- How does Cerebras fast inference power real-time AI summarization and structured outputs in a SaaS workflow?

- What does a product-led growth (PLG) freemium pattern look like when Claude Code builds it autonomously?

- How do you integrate Jira, GitHub, and Claude Code's Feature Dev plugin for end-to-end automated development?

- What role does prompt engineering and Claude.md play in keeping AI context clean across complex multi-ticket projects?

Then this lecture is for you!

In this final Day 5 session, you'll witness the complete wrap-up of a fully functional SaaS application built entirely with Claude Code — from merging the last pull request to running a live demo with user authentication, document persistence, and AI-powered legal document generation. The lecture walks through implementing the final Jira ticket (PL-7), which adds multi-user support and final polish, then testing and pushing the changes to GitHub as a PR with over 1,500 lines of code across 22 files.

You'll see the full SaaS demo in action: signing up, generating a pilot agreement through a guided AI chat, saving documents, signing out, and retrieving saved documents on return — all powered by Cerebras for lightning-fast LLM inference and structured outputs that populate legal document templates dynamically. The app follows a freemium, product-led growth pattern that Claude Code implemented autonomously without being prompted.

The lecture also covers essential Claude Code workflow practices — using `/clear` and `/context` to manage token limits, updating Claude.md to reflect project status, re-authenticating MCP tools like Atlassian, and compacting context to avoid compressed memory issues. You'll learn how tying together Jira for ticket management, GitHub for version control, and Claude Code's Feature Dev plugin creates a professional automated development pipeline where you remain at the helm, guiding the AI through each step with prompt engineering and answering its questions to achieve spectacular results.

This session marks the completion of Week 2 and Project 3 of the learning program — proof that we've crossed an inflection point where AI tools like Claude, GPT, and LLM-powered workflows can help you build, test, and ship real applications with remarkable speed and quality.

If you want to learn:

- How do sub-agents and multi-agent orchestration actually work in Claude Code?

- What's the difference between running multiple AI agents, sub-agents, and full agent swarms?

- How do you use hooks in Claude Code to enable automation like Ralph Loops?

- What does "controlled chaos" mean when orchestrating multiple AI agents in parallel?

- How do you create custom slash commands and shareable plugins for your Claude Code workflow?

- When should you choose tight control versus letting a coding agent swarm run freely?

Then this lecture is for you!

In this lecture, you'll dive into the pro-level features of Claude Code that transform how you work with AI coding agents at scale. This is Day 1 of the final week, and it sets the stage for everything from sub-agents to full multi-agent orchestration and swarm-based development.

You'll start by understanding the evolution from single-agent CLI workflows to multi-agent development — where multiple AI agents work in parallel, each with specialized roles. The lecture breaks down the critical distinction between sub-agents (where Claude Code spawns focused agents to handle specific tasks) and broader multi-agent setups where you run several Claude Code instances simultaneously across a codebase.

You'll explore hooks — a powerful Claude Code feature that lets you trigger automated behaviors, enabling techniques like Ralph Loops and other agentic coding patterns. You'll also learn how to create your own custom slash commands and build shareable plugins for your team or even a marketplace.

A central framework introduced here is **controlled chaos**: balancing the amplification of agent swarms and YOLO-mode automation with deliberate control mechanisms — file-system-based coordination, self-correcting code review processes, sandboxing, and orchestration hierarchies. You'll learn when to loosen your grip and let agents run, and when to pull back with negative feedback loops that keep your workflow on rails.

This lecture also previews Claude Code agent teams and orchestrator patterns that you'll build toward later in the week, giving you the full lay of the land for multi-agent orchestration. Whether you're working on a solo project or coordinating across a large repository, you'll walk away with a clear mental model for how to approach agentic coding with the right balance of speed and structure.

If you want to learn:

- How do you set up a multi-agent coding project from scratch using Claude Code?

- What's the best way to structure a plan.md file so multiple AI agents can collaborate on one codebase?

- How can you use Claude Code agent teams to build a full-stack trading application?

- Why is shared documentation critical for multi-agent orchestration and how do you implement it?

- How do you scaffold a real-world project so a swarm of coding agents can work in parallel?

- What role does a claude.md file play in coordinating subagents across a complex repository?

Then this lecture is for you!

In this hands-on lecture, you'll clone the FiNALLY (Finance Ally) repository and set up the foundation for a stunning AI-powered trading workstation — built entirely by orchestrated Claude Code agent teams. This is Day 1 of a multi-agent development capstone where you'll learn how to prepare a project so that multiple AI agents can collaborate effectively, working in parallel across frontend, backend, and database layers.

You'll start by cloning a scaffolded repository with a clear directory structure — including empty `backend/`, `frontend/`, `db/`, and `test/` directories — alongside a critical `planning/` folder containing `plan.md`. This plan document serves as the single source of truth: the shared documentation that every coding agent converges on to stay coordinated. You'll examine how the `claude.md` file uses the `@` notation to pull `plan.md` into every agent's context window automatically, ensuring consistent behavior across your agent swarm.

The lecture walks through the full business requirements document, covering the application architecture (FastAPI backend, React frontend, SQLite database, SSE-based real-time market data streaming), environment variables including OpenRouter API keys, LLM integration using structured outputs and the Cerebras skill from earlier in the course, Docker-based single-container deployment, and a simulated market data system that requires zero third-party dependencies. You'll see how this plan was iteratively refined using Claude as a chatbot — a practical workflow for generating robust project documentation before handing it off to subagents.

Most importantly, you'll learn the philosophy behind multi-agent orchestration: why clearly defined boundaries between components matter, how an orchestrator keeps agents aligned, and why simplicity in architecture decisions (like using one Docker container instead of many) is essential when you're letting AI agents build your application. This setup lecture lays the groundwork for running the entire build using Claude Code agents in controlled, coordinated chaos.

If you want to learn:

- How do you create custom slash commands in Claude Code for your projects?

- What is the `.claude/commands` folder and how does it power your CLI workflow?

- How do slash commands differ from subagents and why does that distinction matter for context management?

- Can Claude Code skills automatically become slash commands, and which approach should you use?

- How do you use `$ARGUMENTS` to make your custom slash commands flexible and reusable?

- What does a real-world doc-review slash command look like in action with Claude Code?

Then this lecture is for you!

In this hands-on lecture, you'll learn exactly how to create custom slash commands in Claude Code — one of the most powerful yet surprisingly simple features for streamlining your AI coding workflow. You'll start by building a practical `doc-review` slash command from scratch, walking through the entire process: creating the `.claude/commands` folder, writing a markdown prompt file, and using `$ARGUMENTS` to accept dynamic input from the CLI. You'll watch the command run live as Claude Code reviews a planning document, adds questions and clarifications, and suggests simplification opportunities — demonstrating the real value of human oversight when working with coding agents. The lecture covers both methods for adding slash commands: the traditional commands folder approach and the modern skills-based approach, explaining when and why you'd choose one over the other. You'll also gain a clear understanding of how slash commands differ from subagents in terms of context window usage and conversation history — a critical concept for managing tokens effectively as your agentic workflows grow more complex. Whether you're working solo or sharing your `.claude` configuration with a team via Git, you'll leave this lecture ready to build custom slash commands that accelerate your development process in Claude Code.

If you want to learn:

- How do you run multiple AI coding agents in parallel using Claude Code and Codex CLI?

- What are sub-agents in Claude Code, and how do they manage context efficiently?

- How do you build custom sub-agents by creating agent definition files from scratch?

- How can you use Codex CLI as a shell command to run a separate AI coding workflow alongside Claude Code?

- What is the difference between slash commands, skills, and custom subagents in Claude Code?

- How do you configure an agents.md file and invoke a sub-agent within your coding workflow?

Then this lecture is for you!

In this lecture, you'll explore the powerful world of agents and sub-agents within Claude Code, and learn how to extend your AI coding workflow by integrating Codex CLI as a collaborating agent. You'll start by seeing how to launch multiple Claude Code instances across terminals to parallelize tasks like building a front end, back end, and tests simultaneously — and why a well-defined plan document is critical to avoid chaos when running coding agents in parallel.

Next, you'll install and configure Codex CLI — OpenAI's command-line coding agent — and use the `codex exec` command to run a prompt-driven review task directly from the shell. You'll see how Codex reads a plan.md file, generates feedback, and writes output to review.md, all operating as an independent agentic process alongside Claude Code.

From there, you'll dive into sub-agents — what they are, how Claude Code uses built-in sub-agents like Explore and Plan to offload work into separate context windows, and why this matters for context management, token efficiency, and parallel execution. You'll learn that sub-agents can use cheaper models like Haiku for speed and cost savings, and that some MCP plugins ship with their own sub-agent definitions.

You'll then build a custom sub-agent from scratch by creating a `reviewer.md` file inside the `.claude/agents` directory, defining its name, description, and prompt — no menu wizard required. You'll invoke it naturally in conversation using the keyword "sub-agent," and observe how Claude Code delegates the review task to an isolated context, keeping your main session clean. The lecture wraps up by teasing the next step: wiring Codex CLI as the engine behind a custom sub-agent, combining two AI coding platforms into a single collaborative workflow.

If you want to learn:

- How do subagents work in Claude Code and why do they keep your context window clean?

- What's the difference between subagents and agent teams in Claude Code?

- How can you use Codex CLI as a subagent inside Claude Code for independent code reviews?

- How do you create custom slash commands that delegate tasks to a different AI coding agent?

- What is multi-agent orchestration and how do subagents lay the foundation for agent teams?

- How can you build a change-reviewer subagent that automatically reviews all changes since the last commit?

Then this lecture is for you!

In this hands-on lecture, you'll explore one of the most powerful Claude Code features: custom subagents — and how they compare to the experimental agent teams workflow. You'll start by building a practical Codex-Reviewer subagent that delegates a code review task to OpenAI's Codex CLI, running it as an isolated process directly from within Claude Code. You'll see exactly how to configure a custom slash command that triggers a shell command, launching a completely different LLM to analyze your planning documents — all without polluting your main context window.

From there, you'll refactor the subagent into a general-purpose change-reviewer that automatically reviews all changes since the last commit using git. You'll learn how the subagent handles all the back-and-forth — examining diffs, generating findings, and writing output — in its own isolated context, keeping your primary Claude Code session clean and token-efficient. While this workflow uses Codex CLI for a multi-LLM collaboration approach, you'll also learn how to accomplish the same task using Claude Code alone as the reviewing agent.

The lecture then breaks down the critical distinction between subagents and agent teams. Subagents follow a simple delegation pattern: the main Claude Code assigns a single task, the subagent executes it in isolation, and returns the result. Agent teams, by contrast, are an experimental feature where multiple coding agents run collaboratively, communicate with each other directly, and maintain long-running presence — enabling swarm-like orchestration where a tester agent can give feedback to both a front-end and back-end agent simultaneously. You'll understand when to use each approach and how subagents serve as the concrete, reliable foundation before scaling into full agentic orchestration on Day 4.

If you want to learn:

- What are Claude Code hooks and how do they automate your development workflow?

- How do you set up events and commands in Claude Code to auto-trigger actions like code reviews?

- What's the difference between command, prompt, and subagent hook types — and which one is most reliable?

- How do you configure settings.json in the .claude directory to register custom hooks?

- Can you automatically run a code review every time Claude Code finishes a task?

- How do hooks, events, and the plugin marketplace ecosystem extend Claude Code beyond its defaults?

Then this lecture is for you!

In this lecture, you'll explore one of the most powerful automation features in Claude Code: **hooks**. You'll learn exactly how Claude Code hooks work — how specific **events** (like a tool call, a session stop, or a notification) can trigger predefined actions that extend Claude's behavior without manual intervention.

You'll start by understanding the core terminology: events, hooks, matchers, and the three types of actions a hook can fire — a **shell command**, a **prompt to Claude**, or a **subagent**. You'll see why the command option is the most predictable and bulletproof approach for reliable workflow automation.

From there, you'll build a real hook step by step. You'll configure the `.claude/settings.json` file to register a **stop event hook** that automatically launches a code review every time Claude finishes its work. The hook runs a shell command — specifically a Codex exec call — that reviews all changes since the last Git commit and writes the results to a `planning_review.md` file. You'll also see how to manage hooks interactively using the `/hooks` menu inside Claude Code.

Along the way, you'll review the full list of available hook events — including pre-tool use, post-tool use, notification, session start, stop, subagent start, compaction, and more — so you know exactly where to plug in custom automation. You'll learn best practices for when to use hooks (and when not to), how to debug them, and how to reference the official Anthropic documentation for advanced configurations like matchers, validation, and schema details.

By the end, you'll have a working hook that auto-triggers a code review on every task completion — a practical, real-world example of how Claude Code plugins and hooks can streamline your development workflow and eliminate repetitive manual steps.

If you want to learn:

- How do you create and distribute a plugin marketplace for Claude Code?

- What is the structure of a Claude Code plugin, and how do you build one from scratch?

- How do Claude Code hooks work inside custom plugins to automate workflows like code review?

- How do you discover and install plugins from official Anthropic or custom marketplaces?

- What are the pros and cons of using subagents versus skills and commands to extend Claude Code?

- How do you share your own plugin marketplace with your team using Git?

Then this lecture is for you!

In this lecture, you'll build a fully functional Claude Code plugin from the ground up and learn how to package it inside your own plugin marketplace that teammates can discover and install. You start by creating the required directory structure — including the `.claude-plugin` folder, the `plugin.json` manifest with your plugin name, description, and version schema — and then add hooks, commands, agents (subagents), and skills as subdirectories within your plugin. You'll configure a `hooks.json` file to automate an independent code review workflow that triggers on stop, launching an external tool behind the scenes to validate changes since the last commit.

From there, you'll create a `marketplace.json` file that defines your custom plugin marketplace, register it locally in Claude Code using the `/plugin` command, browse available plugins, and install them at the project scope. You'll see the full lifecycle in action: writing a project README, watching the hook fire automatically, and confirming that a `review.md` is generated — all powered by the plugin you built.

The lecture also covers how to add marketplaces from GitHub repositories, how the official Anthropic plugin directory works alongside your own, and best practices for when to use subagents for parallel, self-correcting automation versus simpler skills or commands. You'll learn the tradeoffs — including context efficiency, compounding errors, boundary issues, and cost — so you can make informed decisions about how to extend Claude Code for complex development tools and workflows. MCP servers, debug strategies, and JSON validation patterns are referenced as topics explored in companion sessions.

If you want to learn:

- What is sandboxing in Claude Code and why does it matter for AI coding agents?

- How do filesystem and network isolation make it safer to run Claude Code autonomously?

- What is approval fatigue, and how does sandboxing eliminate the risk of blindly accepting permission prompts?

- How does sandboxing connect to cloud execution and running Claude Code remotely?

- What are the best practices for safely running an AI coding agent in a sandboxed environment?

- How can you go full YOLO mode with Claude Code without compromising security?

Then this lecture is for you!

In this lecture, you'll dive deep into one of the most critical — and surprisingly exciting — topics in the Claude Code ecosystem: **sandboxing and cloud execution**. The session begins with a focused recap of Day 1's pro features, including a clarification on when to use skills versus slash commands, how sub-agents free up context in your workflow, and how plugins can bundle MCP servers and even language server protocol (`.lsp.json`) configurations for supporting new programming languages inside Claude Code.

From there, the lecture shifts into the core topic: sandboxing for AI coding agents. You'll learn exactly what sandboxing means in the context of Claude Code — ring-fencing filesystem access and network isolation so that Claude can read, write, and execute code inside a specific repository or directory without reaching beyond permitted boundaries. You'll understand how restricting network access to approved domains and enforcing filesystem boundaries lets you run Claude Code in a truly autonomous mode, eliminating the constant permission prompts that lead to approval fatigue — that dangerous pattern where you mindlessly approve every action, creating a false sense of security.

The lecture makes a compelling case: sandboxing isn't just a security feature — it's a **productivity feature**. By properly isolating your coding agent's runtime environment, you unlock the ability to safely run Claude Code without manual intervention, whether locally in a Docker container or in a cloud environment. This sets the stage for the session's most exciting reveal: cloud execution and running Claude Code remotely, combining sandboxing best practices with scalable, secure infrastructure for agentic workflows. Whether you're using Anthropic's Claude Code on the web, Claude Code Remote, or building your own sandboxed setup, this lecture gives you the foundational knowledge to do it right.

If you want to learn:

- How do you run Claude Code remotely in a cloud sandbox instead of on your local machine?

- What is Claude Code on the Web, and how does it compare to running a local coding agent?

- How can you use the Claude GitHub app to let an AI agent autonomously work on your repo from a GitHub issue?

- What is the native sandbox in Claude Code, and how does it auto-approve permissions safely with filesystem and network isolation?

- How do third-party cloud sandboxes like Sprite.dev let you safely run any coding agent in a managed environment?

- Can you really control Claude Code from your mobile phone and pick up where you left off on your computer?

Then this lecture is for you!

In this hands-on lecture, you'll explore three powerful approaches to remote execution and cloud sandboxing with Claude Code — moving beyond running your AI coding agent locally and into managed, sandboxed environments that let you scale work, stay safe, and code from anywhere.

First, you'll learn how to use Claude Code's **native sandbox** — a lightweight, OS-level sandboxing feature triggered with the `/sandbox` command. This built-in capability provides filesystem and network isolation, auto-approves permission prompts within the sandbox, and runs more efficiently than Docker or dev containers. You'll cover platform requirements, including Mac, Linux, and WSL setup for Windows users.

Next, you'll dive into **Claude Code on the Web** — Anthropic's managed cloud sandbox. You'll see how to launch remote execution directly from your CLI using the `&` prefix or `claude --remote`, sending tasks to Anthropic's cloud where Claude Code spins up autonomously in a sandboxed environment. You'll also install the **Claude GitHub app** and learn how to raise a GitHub issue tagged with `@Claude` to have an AI agent clone your repo, execute work, and report back — all without touching your local machine. You'll explore features like **Teleport** to attach to running remote sessions and `/tasks` to monitor multiple autonomous agents working in parallel.

Finally, you'll explore **third-party cloud sandboxes** like **Sprite.dev** (by Fly.io), which offer fast, flexible, managed sandbox environments optimized for coding agents. These work with any AI coding agent — Claude Code, Codex, Gemini CLI, or others — giving you platform-agnostic remote code execution in a secure, sandboxed runtime.

By the end of this lecture, you'll understand the best practices for safely running Claude Code in sandboxed and remote environments, how to delegate work to multiple cloud-based agents simultaneously, and how to choose the right approach for your workflow.

If you want to learn:

- How do you set up a sandbox for Claude Code to run commands autonomously without constant permission prompts?

- How do you connect GitHub to Claude Code and install the Claude Code GitHub app in your repositories?

- What is the Claude Code sandbox mode, and how does it reduce interruptions when running Claude in your terminal?

- How do you install the GitHub CLI and authenticate so Claude Code can manage your workflow remotely?

- What are the GitHub workflows that Claude Code installs, and how do they let Claude respond to issues and pull requests automatically?

- How do you configure sandbox overrides and security settings to keep your coding environment safe?

Then this lecture is for you!

In this hands-on lecture, you will set up two powerful capabilities that transform how you work with Claude Code: the built-in sandbox and full GitHub integration for remote control.

First, you will enable the Claude Code sandbox using the `/sandbox` command directly in your terminal. You will walk through the configuration options — from no sandbox to fully autonomous execution — and learn how sandbox mode lets Claude Code run bash scripts, read and write files, and execute tasks without requiring you to approve every single permission prompt. You will also explore how to set overrides, allow or deny specific actions, and understand the key security considerations Anthropic outlines in the documentation.

Next, you will connect Claude Code to your GitHub account by visiting claude.ai/code, authorizing the Claude Code GitHub app, and selecting which repositories to connect. You will install the GitHub CLI (`gh`), authenticate from your machine using `gh auth login`, and then run the `/install github app` slash command inside Claude Code to bridge your repository with Claude's autonomous workflow system.

Finally, you will complete the setup by installing Claude Code GitHub workflows — including `claude.yml` and `claudecode-review` — directly into your repo via a pull request. Once merged, these YAML workflow files enable Claude to respond to GitHub issues, review pull requests, and operate autonomously on your codebase from the cloud.

By the end of this lecture, your Claude Code sandbox is configured for autonomous coding, your GitHub integration is fully wired up, and you are ready to run Claude Code remotely — from your browser, terminal, or even mobile.

If you want to learn:

- How can you run Claude Code remotely in the cloud instead of on your local machine?

- What are the different ways to launch autonomous Claude Code sessions from your terminal, browser, or phone?

- How do you use claude.ai/code to spin up a Claude Code sandbox and have it write code for you?

- How can you trigger Claude Code directly from a GitHub issue using the @claude tag?

- How do you manage multiple remote Claude Code sessions running in parallel as separate tasks?

- What are the tradeoffs between running Claude Code locally versus in a remote sandbox environment?

Then this lecture is for you!

In this lecture, you'll explore five distinct methods for running Claude Code remotely — moving beyond your local terminal to execute autonomous coding tasks in the cloud, on the web, from your mobile device, and directly within GitHub workflows.

You'll start with the simplest approach: using the ampersand command within a local Claude Code session to spawn a remote cloud instance that carries your full conversation context. Next, you'll learn how to use the `claude --remote` CLI command to kick off tasks directly from your terminal without tying up your machine.

From there, you'll dive into claude.ai/code — a browser-based interface where you configure your cloud environment, connect a Git repository, and assign Claude Code real work like reading planning documents and generating detailed design files with code snippets. You'll watch the entire workflow from prompt to pull request, including how Claude Code pushes commits that you review and merge in GitHub.

You'll also see how the Claude mobile app lets you launch and monitor Claude Code sandbox sessions from your phone — kicking off multiple autonomous tasks and reviewing results on the go.

Finally, you'll discover the most powerful method: tagging @claude in a GitHub issue. By simply creating an issue, writing your instructions, and tagging Claude, a remote Claude Code instance spins up automatically, reads your repository, executes the work, and reports progress — all within the GitHub UI. You'll see how this approach lets you set up multiple issues and have parallel Claude Code instances building features simultaneously, turning your repository into a fully autonomous development workflow.

If you want to learn:

- How do you run Claude Code in a third-party cloud sandbox without worrying about permissions?

- What is Sprites.dev and how does it provide a sandboxed dev environment for AI coding agents?

- How do you set up Claude Code in YOLO mode on a remote server so it can run without asking permission for everything?

- What are the differences between native sandboxing, Anthropic's built-in sandbox, and third-party cloud sandboxes like Sprites.dev?

- How can you clone a GitHub repository into a cloud sandbox and let Claude Code perform a full code review autonomously?

- Why does running Claude Code in a sandboxed environment with dangerously skip permissions make sense for remote workflows?

Then this lecture is for you!

In this lecture, you'll explore the third approach to running Claude Code in a sandbox — using a third-party cloud sandbox powered by Sprites.dev, built by fly.io. After covering native sandboxing and Anthropic's built-in cloud options earlier in the day, this session walks you through setting up a completely isolated, hardware-sandboxed dev environment on a remote server where Claude Code can run in YOLO mode with full permission bypass — safely and without risk to your local machine.

You'll start by creating a Sprites.dev account, installing the Sprite CLI, and authenticating via `sprite login`. From there, you'll spin up a cloud sandbox instance in under a second using `sprite create`, then clone a GitHub repository directly into that remote environment. Claude Code comes pre-installed on every Sprites.dev instance, so you'll launch it immediately, authorize your Anthropic account through a seamless browser-based login flow, and confirm that Claude Code is automatically configured to dangerously skip permissions — the expected behavior inside an isolated sandbox where nothing sensitive can be affected.

The lecture demonstrates a real workflow: pointing Claude Code at a project's planning documentation, instructing it to run all tests, perform a comprehensive code review, and write its conclusions to a new file — all executing autonomously on fly.io hardware, not on your local machine and not on Anthropic's cloud. You'll also see how to update Claude Code to the latest version on a fresh sandbox instance to ensure you're running the newest model.

By the end, you'll understand when and why to use a third-party cloud sandbox for running Claude Code, how it compares to the other sandboxing approaches, and how tools like Sprites.dev make it trivially easy to spin up disposable, sandboxed dev environments for AI-driven development workflows — from firing off GitHub issues to autonomous code reviews and test generation.

If you want to learn:

- How do you run Claude Code in YOLO mode without worrying about permission prompts?

- What's the best setup for running Claude Code in a sandboxed cloud environment?

- How do you push branches and create GitHub PRs directly from Claude Code?

- How can you use Sprites.dev as a remote sandbox for running AI coding agents securely?

- What are the key differences between built-in sandbox, Anthropic's remote execution, and third-party cloud sandboxes?

- How do you resume a Claude Code conversation after logging into GitHub via SSH?

Then this lecture is for you!

In this lecture, you'll watch a complete real-world workflow of running Claude Code in YOLO mode inside a cloud sandbox powered by Sprites.dev — and see exactly how to push code, create GitHub pull requests, and iterate on fixes without ever approving a single permission prompt.

The session begins with a recap of using `Ctrl+O` to review the full conversation history, then walks through authenticating with GitHub using `gh auth login` from a remote server. You'll see how to use the `/resume` command to pick up exactly where you left off after restarting Claude Code, and how to instruct Claude to push branches and open PRs — all running autonomously in a sandboxed dev environment.

From there, Claude Code is given a multi-step task: switch to main, pull latest changes, implement all documented fixes, run tests until they pass, and push a new branch to GitHub. Because the workflow runs inside a sandboxed VPS on Sprites.dev, YOLO mode operates with full autonomy — no permission prompts, no manual approvals — while keeping your local machine completely safe. You'll watch Claude Code fix bugs one by one, rerun tests, and submit a polished pull request ready for review and merge.

The lecture closes with a clear comparison of three sandboxing approaches covered across the day: the built-in `/sandbox` command (a lightweight Docker-based sandbox on your machine), Anthropic's remote execution options (including the web interface, mobile app, and GitHub issue tagging with Claude), and third-party cloud sandboxes like Sprites.dev via Fly.io — which provides a full remote dev environment accessible through your terminal or VS Code. Each approach is evaluated for ease of use, security, and how efficiently it enables running Claude Code in YOLO mode on real codebases and repositories.

If you want to learn:

- How do you use Claude Code and Codex effectively on large codebases?

- What are the best practices for working with AI coding agents in professional development teams?

- How do skills, sub-agents, and multi-agents work together to structure your AI coding workflow?

- How can you use sandboxing and Sprites.dev to safely run Claude Code in remote environments?

- What is the right way to automate development tasks using plugins, hooks, and the Claude.md memory system?

- How do you go from prompt to working demo with zero-shot AI code generation on a large codebase?

Then this lecture is for you!

In this lecture, you'll learn how to scale AI coding practices to large codebases using Claude Code, Codex, and third-party platforms like Sprites.dev. The session begins with a focused recap of professional-grade features — slash commands, skills, multi-agents, sub-agents, hooks, and plugins — and explains how each fits into a structured workflow for real-world development. You'll see how skills have become the preferred way to extend coding agent functionality, often replacing MCP integrations, and how to package custom plugins with sub-agents and commands into shareable marketplaces.

From there, the lecture dives into context engineering for large repos: delegating tasks to exploration sub-agents, managing directory structure across big teams, and using the Claude.md memory system to maintain continuity. You'll explore multi-agent strategies — from tagging Claude in GitHub issues to spinning up remote containers on Sprites.dev — and understand when to use native sandboxing versus cloud-based environments for safe, YOLO-mode automation.

The session culminates in a live demonstration where a market data simulator, built and pushed entirely by Claude Code running on a remote Sprite sandbox, produces a fully working terminal demo on the first attempt — no iteration required. You'll walk away with a clear understanding of best practices for integrating AI coding agents into large-scale development, structuring agentic workflows, and leveraging tools like Claude Code and Codex to automate meaningful output across distributed codebases.

If you want to learn:

- What are the best practices for using Claude Code on a large codebase with a big team?

- How should you structure your claude.md and agents.md files across a directory for effective context engineering?

- How do you create a consistent workflow for AI coding agents across your development team?

- What testing strategies prevent brittle, overly mocked tests when working with coding agents?

- How do plugins, skills, and subagents help standardize development with Claude Code on large codebases?

- Why should you break work into bite-sized chunks when using AI on massive repos?

Then this lecture is for you!

In this lecture, you'll learn the proven best practices for using Claude Code and other AI coding agents on large team codebases — the real-world scenario where these tools have historically struggled. You'll discover how to invest in a well-structured claude.md and agents.md memory system that uses progressive disclosure across every subdirectory, giving your coding agent exactly the context it needs without consuming unnecessary tokens. You'll learn how to structure project documentation so that agents can navigate it intelligently — summarizing at the top level and linking to detailed docs rather than injecting entire files with the @ sign. The lecture covers how to establish a consistent team workflow, whether you're using GitHub integration to tag Claude, Jira tickets, or GitHub Actions, so that everyone follows one agreed process. You'll explore how to choose and standardize plugins like feature dev and code simplification, and how to build custom skills that encode domain-specific knowledge — such as the right way to call a market data API or use a particular framework — ensuring all AI-generated code follows common standards. You'll also learn a smarter approach to testing: writing robust tests that validate real functionality rather than chasing coverage percentages with brittle, overly mocked unit tests. The lecture emphasizes the critical importance of human review, rejecting coding agent slop, and maintaining accountability for code quality. Finally, you'll learn why working in small, bite-sized chunks is absolutely crucial when automating development on large repos — and you'll get a hands-on assignment to practice these techniques on a real open source codebase.

If you want to learn:

- What is the Claude Agent SDK and how does it differ from traditional agent frameworks?

- How can you drive Claude Code programmatically using Python instead of the CLI?

- How do you set up a project from scratch to use the Claude Agent SDK with tool execution?

- What tools can you grant Claude Code access to when running it through code?

- How does the agent loop work when you call Claude Code via the SDK to build something autonomously?

- When would you use the Claude Agent SDK over interacting with Claude Code directly in the terminal?

Then this lecture is for you!

In this lecture, you'll see a hands-on, start-to-finish demo of using the **Claude Agent SDK** to programmatically drive Claude Code from a Python script — no terminal interaction required. You'll learn that despite its name, the Claude Agent SDK is not an agent framework; it's a powerful way to tap into the full coding agent capabilities of Claude Code by writing code that controls it.

Starting from a completely empty directory, you'll watch the entire workflow unfold: initializing a UV project, installing dependencies including `claude-agent-sdk` and `python-dotenv`, configuring environment variables for Anthropic API authentication, and writing a concise `main.py` that defines a prompt, specifies allowed tools (read, write, edit, and more), sets `ClaudeAgentOptions` including the model, and runs an async query loop that streams messages back as Claude Code executes autonomously.

The demo builds a fully functional Space Invaders game in vanilla HTML, JS, and CSS — all generated by Claude Code through the SDK with zero manual intervention. You'll see files created in real time, tool calls being made, and the final output running in a browser complete with sound, keyboard controls, and a score counter.

You'll come away understanding exactly how to use the Claude Agent SDK to build AI-powered applications on top of Claude Code's ecosystem — including its context window management, tool execution pipeline, MCP server support, and permission controls — giving you a programmatic foundation for building your own automated workflows and AI agents with the Anthropic platform.

If you want to learn:

- What is Claude Cowork and how does it bring agentic AI to everyday, non-technical tasks?

- How do you set up Claude Desktop and access the Cowork tab for personal productivity?

- Can an AI agent actually organize files, read receipts, and automate an expenses spreadsheet for you?

- How does Claude Cowork compare to Claude Code, and who is it designed for?

- What kinds of real-world workflows can you delegate to Anthropic's Cowork AI assistant?

- How do Cowork plugins extend what this AI agent can do beyond coding?

Then this lecture is for you!

In this hands-on demo, you'll see Claude Cowork in action — Anthropic's newest product that takes the powerful agentic experience of Claude Code and makes it accessible to business users, non-technical professionals, and anyone looking to automate everyday tasks. You'll walk through the full setup process: downloading and installing the Claude Desktop app, signing in, and navigating to the Cowork tab alongside the familiar Chat and Code interfaces. The lecture demonstrates a real-world workflow where Claude Cowork is pointed at a folder of twelve PDF receipts, reads each one as an image, extracts the relevant data, and produces a fully formatted expenses spreadsheet (expenses.xlsx) — all without writing a single line of code. You'll also explore the Cowork plugin marketplace, including Anthropic's official integrations for finance, legal document review, NDA triage, file organization, and more. This is a clear look at the future of AI-powered personal productivity — an AI assistant that can actually execute tasks on your desktop, organize your files, and delegate the tedious work you'd rather not do yourself. Whether you're evaluating AI agents for your workflow or simply curious about what Claude Cowork can do in its research preview, this lecture gives you a practical, step-by-step walkthrough of the experience.

If you want to learn:

- What is OpenClaw and how does it turn your computer into a personal AI assistant you can control from Telegram or WhatsApp?

- How do you install and set up OpenClaw as your own AI sidekick with a single command?

- What makes OpenClaw different from Claude Code and Claude Cowork — and why is it generating so much hype?

- How can a personal AI agent browse the web, control Spotify, manage smart devices, and automate tasks on your behalf?

- What are the security risks of running an autonomous AI agent on your computer, and how can you stay safe?

- How does OpenClaw bring the power of coding agents to non-technical, everyday productivity workflows?

Then this lecture is for you!

In this lecture, you'll get a hands-on walkthrough of **OpenClaw** — the open-source personal AI assistant that's rapidly gaining attention as a powerful AI sidekick you can interact with directly through **Telegram** and **WhatsApp**. Originally known as Claude Bot (CLAWD), OpenClaw was itself vibe-coded and extends the philosophy behind tools like **Claude Code** and **Claude Cowork** beyond software development into everyday personal automation and productivity.

You'll watch a complete live setup of OpenClaw on macOS, from running the one-liner install command in the terminal to configuring an AI model provider (OpenAI via OAuth), creating a Telegram bot through BotFather, and installing skills and plugins. You'll see how OpenClaw connects to your computer, gains access to files, browsers, and apps, and becomes an autonomous agent capable of executing multi-step tasks from a simple chat prompt.

The lecture includes a compelling live demo where OpenClaw is asked to look up the Tesla stock price, determine whether it went up or down, and then autonomously decide to play an upbeat or somber track on Spotify — all orchestrated from a Telegram conversation. This demonstrates how OpenClaw chains together web search, decision-making, and desktop app control into a seamless automated workflow.

You'll also learn about the important **security considerations** that come with giving an AI agent full access to your machine — including why security professionals are concerned, why running OpenClaw in a sandbox is recommended, and why the tool itself prompts you to run regular security audits. The lecture places OpenClaw in context alongside Claude Cowork for professional delegation and the Claude Agent SDK for programmatic automation, giving you a clear picture of the emerging future of AI agents that organize, automate, and execute tasks across your digital life.

If you want to learn:

- What are Claude Code agent teams and how do they differ from subagents?

- How do you coordinate multiple Claude Code instances to work together as a swarm?

- When should you use agent orchestration versus a single agent workflow?

- What are the step-by-step settings and commands needed to launch an agent team in Claude Code?

- How do you manage cost, context windows, and communication between AI coding agents?

- What are the best practices for dividing tasks among multiple agents working autonomously?

Then this lecture is for you!

In this hands-on lecture, you'll dive into the world of Claude Code agent teams, swarms, and orchestration — the advanced stages of AI-powered coding where multiple Claude Code instances work together to tackle complex projects. You'll learn exactly what distinguishes an agent swarm from structured agent orchestration, and where different multi-agent approaches fall on that continuum.

The lecture begins by comparing subagents to agent teams, clarifying when each approach works best. Subagents handle quick, focused tasks and report back to a main agent, while agent teams operate as independent Claude Code sessions with their own full context windows, a shared task list, and the ability to message each other directly. You'll explore practical use cases — from parallelizing research tasks to dividing work by frontend, backend, and LLM responsibilities — and learn how to strike the right balance between agent independence and coordination.

You'll then walk through the five concrete steps to set up Claude Code agent teams: configuring `settings.json` to enable the experimental feature, choosing a teammate mode (in-process or tmux), prompting the first agent to spawn a team, using delegate mode with Shift+Tab, and managing teammates with Shift up/down navigation and shutdown commands. The lecture also covers how to invest in your `claude.md` file so every agent starts with the right context, how to monitor token costs across multiple agents, and how to use Git as a safety net when an agent swarm goes off the rails.

By the end, you'll have a clear framework for orchestrating teams of Claude Code sessions — knowing when to use a single agent, when to spawn subagents, and when to deploy a full multi-agent swarm with structured coordination for maximum productivity.

If you want to learn:

- How do you set up Claude Code agent teams to build a full-stack project with multiple coding agents working simultaneously?

- What is the best way to coordinate and orchestrate multiple Claude Code instances for frontend, backend, and database development?

- How do you configure agent swarm settings, assign specialized roles, and manage dependencies between different agents?

- What are the best practices for preparing your project environment—including plugins, claude.md, and Git branches—before spawning an AI agent team?

- How do you navigate between Claude Code sessions using keyboard shortcuts and monitor an agent swarm in real time?

- When should you avoid adding extra agents like code reviewers to keep your multi-agent workflow efficient?

Then this lecture is for you!

In this hands-on lecture, you'll walk through the complete process of setting up Claude Code agent teams to orchestrate full-stack development from a single prompt. You'll start by preparing a clean project baseline—auditing your .claude directory, verifying that no conflicting MCP servers or plugins are installed, and selectively adding only lightweight plugins like frontend design helpers, Context7 for current API docs, and Playwright for browser testing. You'll update your claude.md file to give the orchestrator agent the right context, using progressive document loading so each agent only pulls in what it needs without bloating the context window.

From there, you'll handle Git housekeeping—committing your baseline and creating a dedicated branch for agent team experimentation so you can safely roll back. You'll then configure the critical environment variable `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` in settings.json and set the team mode to in-process, enabling Claude Code's multi-agent orchestration capabilities.

With the environment ready, you'll craft a prompt that spawns a coordinated agent swarm with clearly defined roles: a frontend engineer, backend engineer, database engineer, LLM engineer leveraging the Cerebras skill, an integration tester, and a DevOps engineer for Docker containers. You'll see how the main agent acts as a team lead—analyzing the project, building a dependency-aware task list, and spawning subagents that work autonomously on their assigned areas. You'll learn how to use Shift+Up and Shift+Down to flip between active Claude Code sessions, monitor each agent's progress in real time, and understand how blocked tasks queue behind dependencies.

Throughout the session, you'll pick up best practices for agent team composition—including why adding a code review agent can introduce too much noise—and how to balance autonomy with coordination when multiple Claude Code instances are writing code across your stack simultaneously.

If you want to learn:

- How do Claude Code agent teams coordinate multiple sub-agents to build a full-stack application from scratch?

- What does a multi-agent workflow look like when building a live trading dashboard with Claude Opus?

- How do you manage permissions, approvals, and delegate mode when running multiple Claude Code agents in parallel?

- How does the team lead agent handle task delegation, serial vs. concurrent execution, and integration testing across sub-agents?

- What shortcuts and tmux split-pane techniques help you monitor and navigate between agents in a Claude Code agent team?

- Can a multi-agent AI team deliver a working, zero-shot dashboard complete with real-time UI, portfolio tracking, and an AI assistant?

Then this lecture is for you!

In this lecture, you'll watch a complete multi-agent team build unfold in real time as Claude Code agent teams construct a live trading dashboard from the ground up using Claude Opus. You'll see exactly how a team lead agent delegates tasks to specialized sub-agents — a database engineer, backend engineer, front-end engineer, LLM engineer, DevOps engineer, and integration tester — orchestrating the full development lifecycle from SQL setup through Docker deployment.

You'll observe how the team coordinator manages workflow sequencing, choosing a serial execution pattern where each agent completes before the next is unblocked, and why this structured approach often produces better outcomes than running everything concurrently. The lecture walks through critical decision-making around permission approvals, including when to approve a command once versus always, and how to handle chmod, Docker build, and test execution requests safely outside of YOLO mode.

As the dashboard comes together, you'll see the integration tester catch five API response mismatches causing a front-end crash, and how the agent team handles bug fixes and coordination without human intervention. The final result is a fully functional trading dashboard featuring a real-time market data watchlist, portfolio heat map, PNL tracking, trade execution, and an AI assistant capable of adding tickers, executing trades, and offering portfolio rebalancing advice — all delivered zero-shot.

You'll also learn essential navigation techniques for managing multiple Claude Code agents using tmux split-pane views, Shift+Up/Down to flip between team members, and Control+T to toggle the task list. The lecture closes with a clean Git workflow, committing the agent teams build to a dedicated branch and pushing to origin, demonstrating how to preserve and manage multi-agent project output using version control.

If you want to learn:

- What is GSD (Get Shit Done) and how does it bring spec-driven development and multi-agent orchestration together for Claude Code?

- How does the GSD framework solve context rot and quality degradation as your AI agent's context window fills up?

- What makes GSD different from other spec-driven development tools like Spec Kit, OpenSpec, and Taskmaster?

- How do you install and configure GSD for Claude Code, and what does the full workflow look like from new project to verification?

- How does GSD use subagents and fresh context windows to keep every task executing at peak quality?

- What markdown files and project structure does GSD create to manage state across a multi-agent orchestration workflow?

Then this lecture is for you!

In this hands-on lecture, you'll watch a complete GSD framework setup and walkthrough inside Claude Code, exploring how this lightweight context engineering layer combines spec-driven development with multi-agent orchestration to produce reliable AI development results. You'll start from scratch — clearing the codebase, creating a fresh branch via git, and installing GSD using npx — then walk through each stage of the GSD workflow: new-project initialization (which spawns parallel mapper agents to analyze your codebase), discuss, plan, execute, and verify. You'll see exactly how GSD manages context rot by maintaining a structured set of markdown files — including project.md, roadmap, requirements, state, plan, and todos — that preserve project knowledge across fresh context windows so each subagent starts clean rather than working inside a degraded 200k context. The lecture covers how to configure GSD settings to select quality, balance, or budget models, how the orchestrator spawns subagents for parallel coding tasks, and how this approach compares to Claude Code's built-in agent teams functionality. You'll also learn why GSD works as a meta-prompting system for any CLI — including Claude Code, OpenCode, and Gemini CLI — and how its opinionated workflow structure keeps AI development on track without requiring you to manually manage prompt engineering or context windows across every task.

If you want to learn:

- How does the GSD framework for Claude Code handle multi-agent orchestration on a real-world project?

- What does a full spec-driven development workflow look like when building a trading platform with AI?

- How does GSD manage context rot and context window limits during long coding sessions?

- What happens when you compare GSD's multi-agent workflow to Claude Code's agent teams in terms of token usage, speed, and code quality?

- How does the GSD roadmap and phased execution process work from planning through verification?

- Can an AI development system build a production-quality application end to end without manual coding?

Then this lecture is for you!

In this 5-hour deep dive, you'll watch the GSD (Get Shit Done) framework for Claude Code tackle a complete trading platform build from scratch — and see exactly how it performs under real production pressure. The lecture walks through the entire GSD workflow: kicking off the discuss phase, answering the orchestrator's clarifying questions, approving auto-generated requirements, reviewing a 10-phase roadmap, and then executing each phase through GSD's spec-driven development pipeline.

You'll see how GSD's guided, on-rails orchestration process differs from free-running Claude Code agent teams. The framework generates detailed requirements in markdown files inside a `.planning` folder, creates phased roadmaps covering database foundation, REST APIs, portfolio trade execution, LLM chat integration, front-end development, and Docker packaging — then executes each phase with built-in verification and testing loops.

A major focus is context engineering in practice. You'll observe the context window filling up in real time, watch how GSD handles context rot as phases progress, and learn what happens when the 200K context limit gets tight. The lecture provides a direct, honest comparison: GSD consumed roughly 10x the tokens and took 10x longer than the Claude Code agent teams approach on the same project — but produced exhaustive documentation, hundreds of tests, and thoroughly checked code through its multi-agent subagent workflow.

You'll also see the realities of AI development at scale: the orchestrator spawning parallel phases, thrashing during test verification, and the tradeoffs of over-segmenting a roadmap into too many phases. By the end, you'll understand exactly when GSD's disciplined, serial multi-agent orchestration workflow is worth the cost — and when a lighter approach might get the job done faster.

If you want to learn:

- How do GSD and Claude Agent Teams compare when building the same AI coding project side by side?

- What are the real differences in speed, quality, and workflow between multi-agent orchestration approaches?

- How does a strict, regimented coding agent like GSD perform versus Claude Code's dynamic agent teams?

- What does a side-by-side UI comparison reveal about AI-generated frontend quality and functionality?

- How much time and tokens does each agentic coding workflow actually consume on a real-world project?

- Which AI coding agent delivers better results — and is faster always better?

Then this lecture is for you!

In this wrap-up lecture for Day 4, you'll witness the final side-by-side UI comparison between two portfolio applications — one built by Claude Agent Teams in roughly 30 minutes, and the other built by GSD's multi-agent orchestration over approximately five hours. You'll watch the GSD-built application launch, test its portfolio tracking features, execute buy and sell trades, and interact with its AI chatbot assistant powered by Cerebras. The lecture walks through how GSD's sub-agent workflow handled tool integration, noting where it followed the provided skill for calling Cerebras and where it diverged — using LightLLM and a different structured outputs approach, likely after encountering and autonomously fixing bugs. You'll see both UIs displayed side by side, comparing heat map rendering, watchlist functionality, price handling for new tickers, and overall polish. The honest assessment covers where each AI coding agent excelled and where each fell short, giving you a practical decision framework for choosing between dynamic agentic workflows like Claude Code's agent teams and the more regimented, thorough orchestration style of GSD. The day closes with key takeaways on token usage, YOLO mode trade-offs, and what the diligent test-driven approach of GSD means for code quality — all checked into GitHub as a complete codebase ready for review.

**If you want to learn:**

- What is Gastown and how does it orchestrate swarms of AI coding agents in parallel?

- How do you install and set up Gastown to run multiple Claude Code agents on a single project?

- What are rigs, crews, polecats, and the mayor in Gastown's multi-agent workflow?

- How does Gastown compare to Claude Agent Teams and GSD for AI coding orchestration?

- How does Steve Yegge's Gastown use Git worktrees, mailboxes, and beads to coordinate 20+ parallel agents?

- Can you really run a swarm of Claude Code instances without manually managing each one?

Then this lecture is for you!

In this finale of the series, you'll witness the most radical approach to multi-agent AI coding orchestration yet: **Gastown**, the workspace manager built by Steve Yegge that pushes Stage 8 of AI-assisted development to an entirely new extreme. After comparing results from Claude Agent Teams and the disciplined, spec-driven GSD orchestration layer, this lecture dives hands-on into Gastown — a platform designed to run swarms of Claude Code agents in parallel, coordinating them through a structured hierarchy of rigs, crews, polecats, and a mayor.

You'll learn Gastown's full vocabulary and architecture: **rigs** (projects), **crews** (workspaces), **polecats** (worker agents), **convoys** (bundled tasks), and **beads** (the Git-backed ledger system that tracks every task with a unique ID). You'll watch a real-time walkthrough of installing Gastown via the CLI, creating a rig linked to a GitHub repo, adding a crew, and launching the **mayor** — the single Claude Code instance you interact with directly while dozens of other Claude Code instances work behind the scenes.

The lecture covers how Gastown uses Git worktrees, a mailbox system for inter-agent communication, and a merge queue to manage controlled chaos across 6 to 30 parallel agents. You'll see how this compares to manually running multiple Claude Code agents in tmux sessions versus letting an orchestrator like Gastown handle coordination automatically. Whether you follow along on Mac or PC, or simply watch the demonstration, you'll walk away understanding what's possible when you orchestrate a full swarm of AI coding agents on a real project — and why this approach from Steve Yegge and Anthropic's ecosystem represents the bleeding edge of multi-agent development workflows.

If you want to learn:

- How does Gastown orchestrate multiple Claude Code agents to build an entire project in parallel?

- What are polecats, beads, convoys, and the merge queue in the Gastown multi-agent workflow?

- How do AI coding agents handle merge conflicts when running simultaneously on the same codebase?

- What does it look like to sling work to parallel agents using tmux, git worktrees, and an orchestration layer?

- How does Gastown compare to slower, more serial AI coding approaches like GSD?

- Can a swarm of Claude Code instances actually build a full-stack application from a single spec file?

Then this lecture is for you!

In this Day 5 session, Steve Yegge puts Gastown — the most chaotic and parallel of all the multi-agent orchestration frameworks — to the ultimate test. Starting from a completely empty repo and a single `spec.md` file, he commands the Gastown mayor to file issues (called beads), create a convoy, and sling all the work out to polecats — autonomous Claude Code instances that build in parallel across multiple tmux sessions and git worktrees.

You'll watch in real time as Gastown decomposes a full-stack fintech specification into ten beads, assigns them across phased convoys, and launches up to eight polecats running simultaneously: Rust, Chrome, Nitro, Guzzle, Shiny, Fury, Dust, and Thunder. Each polecat tackles a different slice of the project — backend market data and SSE, portfolio endpoints, LLM chat integration, frontend components — all coding at the same time against the same git-backed codebase.

The lecture walks through the entire Gastown workflow: how the orchestrator files issues from a spec, how phase one polecats run and merge before phase two beads unlock, how the refinery processes the merge queue and resolves git merge conflicts automatically, and how the mayor monitors progress and handles errors like a crashed deacon session. Steve demonstrates the tmux-based dashboard using `Ctrl+B W` to reveal every running Claude Code instance, checks bead status through the CLI, and navigates the real-time monitoring provided by the witness process.

This is a raw, unfiltered look at what happens when you run multiple Claude Code agents in parallel with minimal human intervention — no hand-holding, no pre-built implementations, just a spec and an orchestration layer powered by Anthropic's Claude. You'll see the merge queue process five branches, conflicts get resolved, and an entire project go from blank repo to merged main branch. If you're exploring AI coding agents, multi-agent orchestration, or want to understand how Gastown compares to more careful, serial approaches, this session delivers the full picture.

If you want to learn:

- What are multi-agent orchestrators, and how do they change AI coding in 2026?

- How do Gastown, Claude Agent Teams, and GSD compare as agent orchestration frameworks?

- How can multiple AI coding agents work in parallel to build a full project from scratch?

- What is the difference between spec-driven orchestration and chaotic multi-agent workflows?

- How do Codex Sub Agents compare to Claude Code agent teams for parallel AI coding?

- Which multi-agent orchestrator delivers the fastest, most reliable results for real projects?

Then this lecture is for you!

In this lecture, you'll witness a head-to-head comparison of three powerful multi-agent orchestration approaches — Gastown, Claude Agent Teams, and GSD (Get Sh- Done) — each tasked with building a complete financial dashboard application from scratch using AI coding agents. You'll see Gastown's mayor-and-polecat architecture coordinate eight parallel agents to build an entire codebase including a market data simulator, portfolio heat map, and LLM-powered chat interface, all from nothing more than a plan.md spec. The lecture walks through real debugging in real time: when the first build fails, the orchestrator is simply told to fix it, and its agents — including specialized workers like Refinery for merge requests and Witness for monitoring — self-coordinate to deliver a working product on the second pass.

You'll get a clear framework for understanding where each orchestrator sits on the spectrum from disciplined to chaotic. GSD represents the most controlled, spec-driven approach using structured markdown files, planning, execution, validation, and audit phases — ideal for larger projects with human-in-the-loop requirements. Claude Code agent teams sit in the middle, offering significant speed gains (from five hours down to thirty minutes) while maintaining a sense of control. Gastown pushes furthest toward autonomous, massively parallel orchestration — building more in the same timeframe but with a wilder, less predictable workflow.

The lecture also covers Codex Sub Agents, an experimental feature within OpenAI's Codex CLI that enables parallel agent spawning similar to Claude Agent Teams. You'll see how to activate it using the `/experimental` toggle, configure `agents.md`, and run it in `--yolo` mode inside a Sprite.dev sandboxed environment on Fly.io. The Codex sub-agent run completes the same project in roughly fifteen minutes — the fastest of all approaches tested. You'll also learn practical workflow techniques including using Sprite proxy commands to map remote ports to your local machine for live previewing, managing Docker containers inside remote environments, and adapting orchestration patterns across different AI coding assistants. By the end, you'll understand which multi-agent orchestration strategy fits your project's needs — whether you prioritize reliability, speed, or maximum autonomous output from your AI coding workflow in 2026.

If you want to learn:

- How does OpenAI Codex compare to Claude Code when building a full trading workstation with AI coding agents?

- Can an AI agent build a professional Bloomberg-style trader dashboard with live market data in just minutes?

- What does an agentic workflow look like when running multiple AI coding agents simultaneously with sub-agents?

- How do you connect real-time stock market data from Polygon/Massive to a Python trading dashboard built by AI?

- What's the best strategy for managing bugs and roadblocks when building with AI coding agents at 10X speed?

- How can you orchestrate Codex, Claude Code, and multi-agent systems together using Tmux for maximum productivity?

Then this lecture is for you!

In this capstone finale lecture, you'll witness the dramatic reveal of what OpenAI Codex built in just 15 minutes — a fully functional trader workstation with live market data — and why it emerged as the surprising winner over Claude Code, Claude Agents, and Gastown implementations. The lecture begins with a side-by-side comparison of all four AI-agent-built trading dashboards, testing each one with real trade executions, portfolio updates, and live chart rendering to determine which agentic coding workflow produced the most polished result.

You'll see the final Codex-built dashboard connected to real Polygon (Massive) market data, displaying live stock prices, after-hours trading activity, and a professional Bloomberg-style terminal complete with a position heat map, AI chatbot, and portfolio PNL tracking. The lecture walks through how Codex autonomously debugged a hard-coded API key issue and correctly identified after-hours trading conditions — all without human intervention in the code.

The most powerful segment demonstrates a multi-agent coding workflow using Tmux with four terminal panes: two Codex instances (one with sub-agents in YOLO mode), Claude Code in dangerously-skip-permissions mode, and a Git workflow terminal — all running simultaneously. You'll learn how to delegate backend Python work to Codex and UI tasks to Claude, coordinate agents using Markdown tracking files, and have agents review each other's output for quality.

The final FinAlly Trader Workstation showcases a watchlist of 60 live stock tickers across tech, financials, healthcare, consumer, industrials, and energy sectors, interactive charts, dark and light mode toggle, and an LLM-powered trading chatbot — all built in just a few hours of agentic automation. You'll also get practical guidance on deploying this Docker-containerized dashboard to the internet and realistic expectations for managing the inevitable debugging roadblocks that come with AI-assisted development.

If you want to learn:

- How do you deploy an AI-built application to the internet using a coding agent in just 15 minutes?

- What are the best practices for choosing between Claude Code, Codex, and other agentic coding tools?

- How should you manage context, markdown docs, and Git when working with AI coding agents?

- When should you use YOLO mode with sandboxing versus spec-driven design in agentic engineering?

- How do you maintain code quality and ownership when an AI agent writes code for you?

- What did Andrej Karpathy mean about the new layer of abstraction with agents, MCP, tools, and workflows — and how do you master it?

Then this lecture is for you!

In this final lecture, you'll watch a live deployment of a fully AI-built project to the internet using Fly.io — orchestrated entirely through a 15-minute conversation with Codex running in a secure sandbox via Sprite Dev. You'll see the complete application go live with working AI chat, portfolio views, and real-time market data, proving what's possible when you combine the right coding agent with the right workflow.

The lecture wraps up the course with a comprehensive review of every orchestrator used throughout the week — from Claude Code and Codex to multi-agent swarms — and delivers a clear verdict on which agentic coding tools performed best. You'll revisit the Andrej Karpathy tweet that launched the course and discover how concepts that once felt foreign — sub-agents, MCP, hooks, permissions, plugins, skills, and orchestration — now fit into a coherent mental model for modern software development.

You'll walk away with actionable best practices for agentic engineering: how to select plugins and skills for your project, when to use YOLO mode in a sandbox versus disciplined spec-driven design like GSD, how to proactively manage context with slash commands and markdown documentation, and how to use Git as your safety net during AI-powered development. The lecture covers a practical decision framework — matching your workflow to project maturity, risk appetite, and personal skill level, whether you prefer CLI tools like Claude Code or the interactivity of an IDE.

Most importantly, you'll learn the mindset that separates a vibe coder from an agentic engineer: own every line of code your AI agent produces, maintain ruthless quality standards, and embrace trial and error as your primary strategy in this rapidly shifting landscape of AI software development.

If you want to learn:

- How does the journey from vibe coding to agentic engineering actually unfold across a full training program?

- What tools and workflows—from Cursor and Claude Code to orchestrators like Claude Agent Teams—do professional AI engineers use daily?

- How do you progress from YOLO-mode prototyping to building enterprise-grade AI software with best practices, guardrails, and orchestration?

- What capstone projects can you build to prove you've mastered agentic coding with real-world software development skills?

- How can you apply Andrej Karpathy's vision of AI as a powerful tool by becoming a true agentic engineer who ships production code?

- What separates a vibe coder from an agentic engineer, and how do sub-agents, hooks, sandboxing, and multi-agent workflows fit into that shift?

Then this lecture is for you!

In this course recap, you'll walk through the complete transformation from vibe coding to agentic engineering—revisiting every milestone, tool, and technique covered across four intensive weeks. The lecture begins with Week 1's exploration of popular AI coding environments including Cursor, Copilot, Codex, and other IDEs, where you first experienced YOLO-mode prototyping and built a commercial MVP. It then revisits the shift into Claude Code, OpenCode, and AMP—introducing slash commands, checkpoints, and Ralph Loops that brought structure to your AI coding workflow. You'll recall how Week 2 integrated professional software development practices by connecting Jira workflows to Git pushes and building a full legal SaaS platform, marking the transition from casual vibe coder to vibe engineer. The recap covers Week 3's deep dive into agentic AI capabilities: multi-agent and sub-agent architectures, hooks, sandboxing, remote Claude Code execution, Sprite.dev, the Claude Agent SDK, and triggering AI agents directly from Git issues. Finally, you'll revisit the orchestration layer—GSD, Claude Agent Teams, and Gastown—along with Codex sub-agents that powered the capstone finance workstation project. Across six total projects (four commercial), you've built the skills that define an agentic engineer: someone who doesn't just write code with AI, but orchestrates autonomous LLM-powered workflows with guardrails, MCP integration, and enterprise-grade best practices. This lecture closes with a call to action rooted in Andrej Karpathy's insight—you now hold the missing manual to this powerful tool, and the most important next step is to build.