
Discover what Claude Code is and how it brings AI-assisted development directly into your terminal. See how it can understand projects, generate code, troubleshoot issues, and streamline development workflows.
Step-by-step walkthrough of installing Claude Code on your machine. Covers prerequisites, setup, and verifying your installation works correctly.
Apply your Claude Code skills by building a practical expense-tracking application. Move from a basic project idea to working functionality using natural-language prompts and iterative development.
Explore cloud code architecture from the user interface to external services. Learn how a Google login feature is planned, authenticated via OAuth, and integrated across backend and frontend.
Learn how plot skills prevent repetitive instructions, eliminate manual context pasting, and ensure consistent institutional knowledge with specialized domain expertise, a lightweight token footprint, and on-demand context loading across sessions.
Identify whether tasks require real-time external data, autonomous multi-step execution, or repeatable domain knowledge to decide if skills, MCP, or agents are best.
Install skills on Cloud AI by enabling code execution, adding or selecting skills (including MCP Builder), and creating or uploading skills, then toggle them on to run locally.
Install skills on CloudCore and Cloud API by creating a .cloud directory with a skills file at project or user level, enabling team sharing and automatic discovery via API v1.
Create a valid skills markdown file from scratch and master Yammer front matter rules, install skills in Cloud Code or Cloud AI, and verify them with a test prompt.
Hands-on with Claude Code skills: reload a meeting notes skill, format text as meeting notes, and generate a meeting summary, key decisions, action items, and next steps in cloud code.
Understand the skills architecture and on-demand loading in cloud, where the VM file system's skills directory feeds the context window based on user requests, loading only the requested skill.
Cloud loads only what's needed by matching pdf text to the pdf processing skill's description, loading the relevant instruction and references, illustrating progressive disclosure for efficient skill execution.
Explore progressive disclosure as a design principle for dynamic skills loading: guide with references, domain organization, and conditional scripts to enable plan, validate, execute workflows.
master progressive disclosure by choosing right file structure via two patterns: guide with references and domain-specific organization; follow five rules, including under 500 lines, one level deep, and descriptive names.
Plan the skill before coding to define its domain, scope boundary, and necessary decisions for code review, including degree of freedom and pattern choices (template, example, workflow).
Explore code review fundamentals with a structured walkthrough that defines skill naming, description, calibration levels, review sections, and practical examples for quality auditing.
Execute a code review on a Python dbconnect file that reads a key-value config, connects to a database, and outputs a structured review with severity, strengths, and recommended next steps.
Master the skills anatomy and the YAML front matter, with name and description fields, and learn how the two zones—front matter and body—drive Claude's discovery with triggers.
Apply the design principle of the right degree of freedom for cloud skills, using a terrain analogy to decide high, medium, and low freedom based on the cost of deviation.
Explore the three design patterns—template, example, and workflow patterns—and how to structure skills files with fixed sections, input-output pairs, and a copyable checklist.
Describe three loading levels for skills, from startup front matter to domain expertise. Load level 1 at startup, level 2 on demand, level 3 as needed, with token optimization.
Explains how to invoke Anthropic skills via API, outlining required beta headers, code execution, skills references, and files API for downloading PowerPoint, Excel, Doc, or PDF outputs.
A quick roadmap for the module — five short lecture segments building toward a hands-on lab. See how "watching Claude Code work" becomes a concrete mental model you can code against by the end of the hour.
Every file read, edit, and test run you've seen Claude Code perform is the same underlying loop, running over and over. This lecture introduces that loop as the core mental model for the entire module.
Break the loop into its five named steps — receive, evaluate, execute, repeat, return — and see exactly which SDK message type shows up at each stage, from the initial SystemMessage to the final ResultMessage.
Compare a one-turn file lookup to a multi-turn refactor-and-test cycle using the same five-step loop. The key insight: the loop's shape adapts to the task, which is exactly why the SDK gives you dials to control it
Learn the precise definition of a "turn" and the five message types the SDK streams back — SystemMessage, AssistantMessage, UserMessage, StreamEvent, ResultMessage. Includes a full turn-by-turn trace of a real bug-fix session and the minimum code needed to handle each type safely.
Take the wheel with allowed_tools, disallowed_tools, and the five permission_mode values, then cap runaway agents with max_turns and max_budget_usd. Finish with effort levels — how to match reasoning depth to task complexity instead of defaulting to the most expensive setting.
The context window never resets mid-session. See exactly what accumulates — system prompt, CLAUDE.md, tool definitions, conversation history — and which of these get cached versus repriced on every single turn.
When context nears its limit, the SDK compacts automatically — but a summary isn't a transcript. Learn why persistent rules belong in CLAUDE.md, how to steer what compaction preserves, and how subagents and hooks keep long-running agents cheap and observable.
Walk through a single production-shaped script that combines everything from the module — allowed_tools, setting_sources, max_turns, effort, and full ResultMessage subtype handling — plus the five takeaways to carry into the lab.
Get your environment ready for the hands-on lab — install claude-agent-sdk, set ANTHROPIC_API_KEY, and preview the five message types you're about to see streaming live in your own terminal.
Write and run a script that streams every message type in real time, deliberately trigger an error_max_turns result and fix it, then compare effort="low" vs effort="high" on the same task to see the cost/depth tradeoff firsthand.
Explore how slash commands in Cloud Code automate repetitive tasks with reusable markdown templates, enabling project-based and user-scoped workflows, built-in and custom commands, for consistent team collaboration.
Master the slash command structure by learning the forward slash, command name, and positional arguments, illustrated with fix issue 123 high priority as the example.
Explore using slash commands with multiple inputs by leveraging positional parameters to pass arguments such as PR 121, medium priority, and John as the assignee, illustrated via ReviewPR.md.
Deep dive into frontmatter configuration for custom slash commands, including allowed-tools. Learn how frontmatter controls command behavior and permissions.
Understand the concepts behind embedding Bash commands inside custom slash commands. Covers how allowed-tools scoping works and why it matters for safety.
A practical, hands-on session writing slash commands that execute Bash. Reinforces the theory with real examples you can build and test.
Learn how to build a slash command that automates code refactoring tasks. Demonstrates how Claude Code can standardize and speed up common code cleanup work.
Build a custom slash command to automate git commit workflows. Shows best practices for scoping allowed-tools (e.g., Bash(git add:*), Bash(git commit:*)) safely.
Explore how slash commands can integrate with MCP (Model Context Protocol) servers. Covers connecting external tools/data sources into your custom commands.
See how slash commands fit into a real development workflow, standardizing repetitive tasks for you and your team. Ties together frontmatter, arguments, and Bash into one cohesive process.
This course uses artificial intelligence to enhance voice quality. Build Practical Claude Code Workflows for Software Development Claude Code can do far more than generate isolated code snippets. In this hands-on course, you will learn how to configure Claude Code as a practical development partner and build repeatable workflows for coding, testing, review, automation, and collaboration. You will begin with installation, IDE integration, core architecture, and a guided expense-tracker project. From there, you will progress into Agent Skills, subagents, memory, slash commands, the agent loop, Model Context Protocol (MCP), hooks, and GitHub Actions. What You Will Practice • Create reusable Agent Skills with effective metadata, progressive disclosure, scripts, references, and assets. • Build specialized subagents and coordinate sequential and parallel workflows. • Use slash commands to standardize refactoring, Git commits, testing, and repeatable development tasks. • Configure Claude Code memory to preserve project instructions and context across complex codebases. • Understand the agent loop and control permissions, turns, budgets, effort, and context. • Connect MCP servers through STDIO and integrate tools such as GitHub, Puppeteer, and Sequential Thinking. • Create hooks for formatting, activity logging, safeguards, debugging, and multi-step automation. • Use GitHub Actions for pull requests, code review, bug fixing, repository updates, and continuous automation. A Hands-On Learning Path The course combines concise explanations with practical demonstrations and labs. You will build an expense tracker, create and run custom Agent Skills, inspect agent-loop messages, develop general-purpose and developer-focused subagents, connect MCP servers, and assemble automated workflows that combine commands, agents, hooks, memory, and GitHub. The curriculum is organized so you can start with Claude Code fundamentals and then move into advanced workflow design. Developers can apply individual techniques immediately, while technical leads can use the broader architecture to evaluate repeatable team workflows. Who This Course Is For This course is designed for software developers, QA engineers, DevOps professionals, technical leads, engineering managers, computer science students, and AI builders who want practical experience with Claude Code. Basic familiarity with files, folders, and terminal commands is helpful, but previous Claude Code or AI-agent experience is not required. By the end of the course, you will be able to design and implement structured Claude Code workflows that connect reusable skills, specialized subagents, project memory, MCP tools, hooks, slash commands, and GitHub automation. Recent Updates July 2026: Added the Agent Loop module and hands-on lab. June 2026: Added the Agent Skills modules.