syllabus body

Configure your Claude environment for maximum productivity throughout the course. You'll customize communication preferences, writing style, and feature settings, then activate Claude's memory system to maintain context across conversations. Proper configuration ensures Claude adapts to your workflow, remembers your preferences, and delivers responses aligned with your goals and communication style.

Objectives:

• Configure Claude's personalization settings including communication style, tone preferences, response formatting, and feature toggles to match your workflow requirements
• Activate Claude's memory system and verify it's capturing conversation context, project details, and preferences across sessions
• Test personalized responses by comparing Claude's output before and after configuration to validate that settings are working as intended

Extend Claude's capabilities by configuring connections to external systems through MCP (Model Context Protocol). You'll connect Claude to remote MCP servers for services like Slack, GitHub, and Google Drive, then configure desktop connectors to access local applications and your filesystem. These integrations enable Claude to read data, trigger actions, and automate workflows across your entire tech stack.

Objectives:

• Configure MCP server connections to at least two remote services (e.g., Slack, GitHub, Google Drive, Notion) with proper authentication and permissions
• Implement desktop connectors to access local filesystem, applications, or services running on your machine
• Test integration functionality by executing Claude commands that read data from connected systems and trigger actions across multiple services
• Troubleshoot connection issues using MCP diagnostics to verify successful authentication, resolve permission errors, and validate data access

Transform your development workflow with an AI-powered code editor (Cursor or VS Code). Configure AI model integration (Claude, ChatGPT, Gemini, or other CLI models) that lets you generate code through natural language, get instant explanations for complex logic, and refactor with AI assistance. This workspace becomes essential infrastructure for building Skills, workflows, and Agents—enabling builders without deep coding backgrounds to create production-quality AI systems.

Objectives:

• Configure an AI-powered code editor (Cursor or VS Code) as your workspace for AI building block development
• Install and authenticate at least one AI model integration (Claude Code, ChatGPT Codex, Gemini CLI, or similar)
• Create and preview a Markdown file to verify your editor is properly configured

Implement GitHub version control as your safety net for AI building block development. Create a repository to store Skills, Prompts, Agent configurations, and workflows with full change history. Master the create-commit-push workflow that professional developers use to track iterations, experiment without risk, collaborate across teams, and recover from mistakes—critical infrastructure for building production AI systems.

Objectives:

• Create a GitHub repository to store and version your AI building blocks (Skills, Prompts, Agents, configurations)
• Execute the create → commit → push workflow to save a building block to your repository
• Verify your repository syncs between local and cloud to protect your work

Install and configure a voice-to-text application (Wispr Flow recommended) to enable hands-free interaction with AI tools and code editors throughout the course. You'll practice voice dictation, learn best practices for speaking with AI, and set up your environment for maximum productivity. Voice-first collaboration dramatically accelerates your workflow—especially for complex prompts and multi-step instructions.

Objectives:

• Install and configure a voice-to-text application (Wispr Flow or alternative) with proper permissions and settings for AI platform integration
• Practice voice dictation techniques including formatting commands, punctuation control, and natural speech patterns to achieve 90%+ accuracy
• Demonstrate hands-free AI collaboration by completing a workflow entirely through voice—from initial prompt to refinement to final output
• Apply voice-first best practices for complex multi-step instructions, ensuring clarity and reducing the need for manual typing throughout the course

Implement your operational control center for managing AI workflows and assets. Students replicate the Notion registry template, configure tracking fields, and document their first complete workflow including SOP and building blocks. Claude users integrate Skills with Notion MCP to enable bidirectional collaboration for reading and writing workflow data throughout the course.

Objectives:

• Implement your AI Operations Registry by replicating the Notion database template and configuring workflow tracking fields
• Integrate your AI platform with the registry to enable collaborative workflow management and building block documentation (Claude users: connect Skills via Notion MCP)
• Document one end-to-end workflow in your registry including SOP and associated AI assets

Master the foundational framework for building AI systems that scale. You'll learn the autonomy spectrum—distinguishing automation, workflows, and agents—and the six building blocks (Prompt, Context, Project, Skill, Agent, MCP) that professional builders use. By the end, you'll identify which building blocks any workflow needs, avoiding the common mistake of reaching for fully autonomous agents when simpler approaches work better.

Objectives:

• Distinguish between automation, workflows, and agents on the autonomy spectrum
• Explain why agentic approaches outperform zero-shot prompting for multi-step tasks
• Identify which building blocks (Prompt, Context, Project, Skill, Agent, MCP) apply to a workflow
• Classify example workflows on the autonomy spectrum and identify building blocks in a sample workflow

Examine concrete examples of deterministic automated, collaborative AI, and autonomous agent workflows. Then use a structured meta-prompt to discover AI workflow opportunities in your daily work and categorize each candidate by workflow type.

Objectives:

• Distinguish deterministic automated workflows (rule-based, zero human input) from collaborative AI workflows (human-AI partnership) and autonomous agent workflows (goal-driven, adaptive) by analyzing concrete examples
• Apply a structured meta-prompt to systematically identify AI workflow opportunities across your daily work including high-frequency tasks, judgment-heavy processes, and repetitive operations
• Create clear, outcome-focused names (2-4 words) for identified workflow candidates using consistent noun phrase patterns that communicate purpose without requiring context

Build a dedicated Claude Project that maintains conversation memory and serves as a centralized knowledge repository. You'll configure project-level custom instructions, enable persistent memory that evolves with each interaction, and populate the knowledge base with reference files that Claude can access automatically—eliminating repetitive file uploads and creating a workspace that gets smarter over time.

Objectives:

• Build a Claude Project with custom instructions, persistent memory enabled, and project-specific settings configured for course workflows
• Populate the project knowledge base with essential reference files (workflows, documentation, templates) that Claude can access automatically across all conversations
• Test persistent context by verifying that Claude retains project-specific information across multiple sessions and references knowledge base files without re-uploading
• Apply project-based workflows by conducting a complete task entirely within the project to validate memory retention and knowledge base accessibility

Turn implicit workflows into structured specifications you can build from. You'll deconstruct two real-world workflows—one Collaborative AI, one Deterministic Automation—using the 5-question framework to surface discrete steps, decision points, data flows, context needs, and failure modes hiding inside each process. Then apply the same framework to your own workflow, producing a Workflow Definition that becomes your blueprint for Step 3 (Build).

Objectives:

• Apply the 5-question deconstruction framework to break down a workflow into detailed steps, surfacing the decision points, data flows, context needs, and failure modes that are often invisible in day-to-day execution
• Generate a structured Workflow Definition that captures every step with sufficient detail to serve as a build-ready specification
• Compare the deconstruction output of two workflow types (Collaborative AI vs. Deterministic Automation) to identify how step structure, decision complexity, and context needs differ between them

Dissect what Skills are—reusable instruction sets that teach Claude how to execute your workflows consistently. Analyze their anatomy: metadata, instructions, and resources. Then distinguish when to use Skills versus Prompts, Projects, MCP, or Agents.

Objectives:

• Analyze the anatomy of an Agent Skill including metadata, instructions, and resource structure
• Distinguish Skills from Prompts, Projects, MCP, and Subagents to select the right building block
• Identify when to use each agentic building block based on the workflow requirements

Transform your workflow knowledge into a production-ready Agent Skill from scratch. You'll structure your skill with proper metadata and instructions, test it in a live conversation, save it to your repository with version control, and export it to your local machine—making it available across Claude.ai, Claude Code, and Cowork.

Objectives:

• Build a production-ready Agent Skill that packages your expertise into reusable instructions for Claude
• Structure your skill with proper metadata, instructions, and supporting resources
• Save skills to your repository for version control and register them in your AI Assets database
• Export skills to your local machine for use across Claude platforms (Code, Cowork)

Package and ship your skills as installable resources. One command gives others access to your expertise—team members, clients, or the broader AI community. Your workflow knowledge becomes reusable, distributable, scalable.

Objectives:

• Create a properly structured marketplace.json file with plugin metadata for at least one skill
• Publish a GitHub repository containing their skill marketplace that others can add via /plugin marketplace add
• Configure distribution settings for three deployment scenarios: private team use, organizational access, and public community sharing
• Demonstrate the complete installation workflow by having another team member successfully install their published plugin

Master the two workflow patterns on the left side of the autonomy spectrum. You'll analyze the characteristics that distinguish deterministic workflows (fixed rules, predictable output, no human judgment during execution) from collaborative workflows (iterative, judgment-dependent, human-steered). Use the Pattern Selection Framework to match your deconstructed workflows to the right pattern before you build.

Objectives:

• Distinguish deterministic and collaborative workflow patterns by their characteristics: predictability, human involvement, iteration needs, and output consistency
• Classify your own deconstructed workflows as deterministic or collaborative based on whether they require human judgment during execution
• Select the appropriate workflow pattern for a given use case using the Pattern Selection Framework

Apply Step 3 (Build) of the Business-First AI Framework to transform a Workflow Definition into a deterministic workflow design. You'll upload your workflow specification, have the AI recommend an execution pattern, classify each step, and map building blocks — producing an AI Building Block Spec ready for construction.

Objectives:

• Apply the Build framework's Design phase to transform a Workflow Definition into an AI Building Block Spec with execution pattern, step classification, and building block mapping
• Evaluate the AI's recommended execution pattern (Prompt vs Skill-Powered Prompt) against your workflow's characteristics
• Identify input criteria, evaluation rules, and output template structure for a deterministic workflow

Construct and run your deterministic workflow using the Build framework. You'll follow the build path for your execution pattern, create the baseline prompt (and Skills if applicable), then run the workflow on a real scenario — iterating until the output is consistent and trustworthy without manual editing.

Objectives:

• Build a deterministic workflow prompt with clear step sequencing, input/output definitions, and error handling
• Package reusable workflow logic into Claude Skills where the execution pattern recommends it
• Test the workflow on a real scenario and verify consistent, usable output across multiple runs
• Register the workflow and building blocks in the AI Operations Registry

Apply the Build framework to design a collaborative workflow — one where AI handles research, drafting, or analysis while you steer, review, and decide. You'll identify where to place human review checkpoints, structure handoff points between AI and human, and produce an AI Building Block Spec optimized for iterative collaboration.

Objectives:

• Apply the Build framework's Design phase to produce an AI Building Block Spec for a collaborative workflow with human review checkpoints mapped
• Identify checkpoint placement where human judgment has the highest impact on output quality
• Design handoff points that structure the flow between AI-generated drafts and human review/refinement

Construct and run your collaborative workflow. You'll build the prompt with explicit checkpoint moments, run the workflow on a real scenario, practice steering the AI at each review point, and iterate until the checkpoint structure gives you confidence in the final output.

Objectives:

• Build a collaborative workflow prompt with explicit checkpoint moments where human judgment guides AI execution
• Implement feedback loops that incorporate your input to improve AI outputs iteratively
• Test the workflow on a real scenario, using checkpoints to steer the output, and verify the final result is usable
• Document the workflow with clear decision criteria for when to accept, refine, or redirect AI outputs

Reflect on both workflow types you've built. Compare when to use deterministic vs collaborative patterns, review your remaining workflow candidates, and plan which pattern each should follow — building a roadmap for systematizing your work beyond the course.

Objectives:

• Evaluate the strengths and limitations of deterministic vs collaborative workflows based on hands-on experience building both
• Classify remaining workflow candidates from your registry as deterministic, collaborative, or autonomous (future Session 5)
• Plan a workflow portfolio prioritizing which workflows to build next based on time savings and business impact

Analyze the core components every AI agent shares—LLM brain, tools, memory, instructions, and knowledge—then distinguish agents from structured workflows on the agentic systems spectrum to determine when autonomous agents are the right solution for a business problem.

Objectives:

• Distinguish between agents and workflows by comparing their autonomy levels, decision-making capabilities, and appropriate use cases on the agentic systems spectrum
• Identify the core components of an agent (LLM brain, tools, memory, instructions, knowledge) and explain how these components work together regardless of platform
• Evaluate business scenarios to determine when autonomous agents are appropriate versus structured workflows, based on task predictability, complexity, and need for dynamic planning
• Select optimal use cases for agentic implementation by matching task characteristics (open-ended problems, multi-step complexity, tool requirements) to agent capabilities

Distinguish the five agentic capability patterns—Reflection, Tool Use, Planning, Multi-agent Collaboration, and Memory—then analyze how they work together in real scenarios and differentiate guardrails from human-in-the-loop controls for managing agent behavior.

Objectives:

• Distinguish the five agentic capability patterns (Reflection, Tool Use, Planning, Multi-agent Collaboration, Memory) by mapping each to its specific role in the agent execution cycle
• Analyze how multiple capability patterns combine in the customer exchange scenario to identify which patterns drive each step of agent behavior
• Differentiate guardrails from human-in-the-loop controls by identifying when each is appropriate for managing agent risk

Analyze four orchestration patterns for multi-agent systems—supervisor, swarm, hierarchical, and debate—then compare their strengths and tradeoffs to select the right pattern for different workflow scenarios.

Objectives:

• Analyze orchestration patterns for multi-agent systems: supervisor, swarm, hierarchical, and debate
• Compare pattern strengths and weaknesses for different task types and complexity levels
• Select the appropriate orchestration pattern for a given multi-agent workflow scenario

Apply the Business-First AI Framework to deconstruct your own workflow into discrete steps, map them to AI building blocks, and create a complete platform-agnostic agent design specification ready to implement on Claude Code, ChatGPT, Gemini, or any platform.

Objectives:

• Apply a systematic design process for agent systems by defining clear goals, processes, agent roles, instructions, and required tools
• Generate clear, unambiguous instructions for LLM agents using meta-prompting techniques and reasoning models to ensure reliable execution
• Design single-agent systems by specifying agent roles, responsibilities, and tool requirements for focused automation tasks
• Architect multi-agent systems by identifying and naming specialized agent roles that work together to accomplish complex goals
• Distinguish between single-agent and multi-agent approaches based on task complexity and the need for specialized expertise across different workflow components

Understand what Claude Code subagents are, master the critical distinction between Skills and Subagents, and learn when to use each approach. Explore the mental model of building a specialized team of AI agents, develop a decision framework for choosing between Skills and Subagents, and identify appropriate use cases for subagent-based solutions in business contexts.

Objectives:

• Define Claude Code subagents and explain their role in autonomous workflows
• Distinguish between Claude Skills (training manuals with shared context) and Subagents (specialized employees with isolated context) across key dimensions
• Apply a decision framework to determine when to use Skills, Subagents, or both for specific workflow requirements
• Analyze the "dream team" mental model to understand subagent specialization and delegation patterns
• Evaluate business scenarios to identify appropriate use cases for subagent-based autonomous workflows

Transform your agent system design into a working implementation. Configure MCP tools in Claude Code, create your subagent with appropriate tool assignments and instructions, and test it with real tasks. Learn to debug, iterate, and refine subagent behavior through hands-on practice. Students complete this lesson with a fully functional subagent ready for real-world use.

Objectives:

• Configure MCP tools in Claude Code to prepare tool access for subagent implementation
• Create a subagent by translating design specifications into Claude Code configuration (description, tools, model, system prompt)
• Evaluate subagent performance by testing with real tasks and observing delegation behavior
• Refine subagent configuration based on testing results to improve reliability and output quality

Master subagent execution from single-agent workflows to complex multi-agent orchestration. Learn three activation methods (explicit invocation, automatic delegation, chaining), understand when multiple agents outperform single-agent solutions, and apply orchestration patterns including sequential, parallel, and hybrid execution with hooks for reliable autonomous workflow behavior.

Objectives:

• Execute Claude Code subagents using three activation methods (explicit invocation, automatic delegation, chaining) to accomplish single-task workflows
• Evaluate when to use multiple specialized agents versus a single agent based on workflow complexity and context isolation needs
• Design a multi-agent workflow using sequential, parallel, or hybrid orchestration patterns for a complex business use case
• Implement hooks (guardrails, logging, human-in-the-loop) to ensure reliable multi-agent system behavior

Build complete multi-agent systems from your workflow specifications using Claude Code's AI-assisted configuration. You'll transform your Module 10 design into a working system—single or multi-agent—by prompting Claude Code to generate all necessary subagent configurations. Learn to review, refine, and validate auto-generated systems, ensuring proper orchestration and tool delegation. Master the AI-assisted workflow that makes complex agent systems buildable in minutes.

Objectives:

• Build complete agent systems by prompting Claude Code to auto-generate configurations from workflow specifications
• Evaluate generated subagent configurations against design intent to ensure proper tool assignments and orchestration patterns
• Refine multi-agent systems by adjusting delegation logic, tool restrictions, and coordination patterns based on testing results
• Apply judgment to decide system architecture (single vs. multi-agent) and when to use AI-assisted generation versus manual configuration

Learn to automate Claude Code subagent execution using native operating system schedulers. Configure Windows Task Scheduler and macOS cron jobs to run subagents on recurring schedules, implement error handling and notifications, and understand when scheduled execution is appropriate versus on-demand triggers. Students will schedule one of their existing Claude Code subagents to run automatically.

Objectives:

• Configure OS-level scheduling (Windows Task Scheduler or macOS cron) to execute Claude Code subagents automatically
• Implement error handling and notification mechanisms for scheduled subagent runs
• Evaluate which workflows benefit from scheduled execution versus on-demand triggers
• Test and verify scheduled subagent execution with proper logging and output capture

Master Claude Code's built-in tracing capabilities to gain visibility into subagent execution. Learn to read execution traces, understand multi-agent delegation patterns, diagnose failures, and debug common issues. Students will add tracing to their multi-agent systems and use trace data to troubleshoot and optimize subagent behavior.

Objectives:

• Analyze Claude Code execution traces to understand subagent delegation patterns and tool usage
• Diagnose subagent execution failures using trace data and error logs
• Evaluate subagent performance and identify optimization opportunities through tracing
• Implement tracing best practices for debugging multi-agent subagent workflows

Understand the mental model for autonomous task delegation with Claude Cowork. Learn the difference between interactive chat, Projects, and Cowork — and when each interface fits your workflow. Explore the delegation pattern: write a clear brief, let Claude work autonomously, then review results.

Objectives:

• Explain how Claude Cowork differs from chat and Projects in terms of autonomy, task scope, and interaction model
• Classify knowledge work tasks by delegation suitability — identifying which tasks benefit from Cowork's autonomous execution vs. interactive collaboration
• Summarize the Cowork delegation pattern: brief → autonomous work → review → iterate

Delegate real productivity tasks to Claude Cowork and evaluate the results. Practice the delegation cycle across research synthesis, document drafting, spreadsheet analysis, and presentation creation. Compare Cowork output quality against manual approaches to calibrate expectations.

Objectives:

• Execute the Cowork delegation cycle — brief, delegate, review, iterate — on at least 2 knowledge work tasks
• Apply effective briefing techniques that produce high-quality Cowork output on the first pass
• Evaluate Cowork results against quality criteria and iterate to improve output

Audit your recurring work tasks to identify Cowork candidates, then build a personal library of reusable Cowork task templates. Evaluate which daily tasks are best delegated to Cowork vs. kept as interactive chat, and create a playbook you can use immediately after the course.

Objectives:

• Build a personal Cowork task library with 5+ reusable task templates covering your most common knowledge work
• Evaluate your recurring tasks using delegation criteria to prioritize which tasks to automate with Cowork first
• Design a Cowork briefing template that captures the context, constraints, and quality criteria for consistent results

Analyze the software development lifecycle — from envisioning a product through defining requirements, planning, implementing, verifying, reviewing, and shipping — and examine how Claude Code project instructions (CLAUDE.md) codify that lifecycle to guide AI-assisted development. Install official Claude Code plugins that supercharge each stage of the lifecycle, and understand how these plugins and project-level instructions work together to enable a structured, AI-assisted development workflow.

Objectives:

• Analyze the stages of the software development lifecycle (envision, define, plan, implement, verify, review, ship) and the purpose of each stage in AI-assisted development
• Examine how CLAUDE.md project instructions codify the development lifecycle, coding conventions, and repository structure to guide Claude Code's behavior
• Install and configure official Claude Code plugins that map to each stage of the software development lifecycle, understanding how each plugin supercharges a specific step
• Distinguish between project-level instructions (CLAUDE.md), plugins, and other Claude Code configuration (skills, agents, hooks) based on their scope and purpose

Collaborate with Claude Code to translate a fuzzy business idea into a structured Vision Brief — a business-language artifact that captures the problem, target users, key capabilities, and success criteria before diving into technical requirements. Use Claude Code's guided discovery workflow to clarify what you're building and why, prioritize capabilities, and scope the work into buildable features. The Vision Brief serves as input for your product requirements document in Lesson 3.

Objectives:

• Design a product Vision Brief from a business idea using Claude Code's guided discovery workflow to capture the problem, target users, key capabilities, and success criteria
• Distinguish between a Vision Brief and a Product Requirement Document based on their purpose, audience, and level of detail — understanding that the Vision Brief is a business-language ideation artifact while the PRD is an implementation-ready specification
• Prioritize key capabilities into must-have and nice-to-have categories to define the scope of work before writing technical requirements

Collaborate with Claude Code to develop a product requirement document that captures the business requirements for a product or feature, translating a business idea or problem into structured requirements, user stories, and acceptance criteria.

Objectives:

• Develop a product requirement document from a business idea by collaborating with Claude Code to define the problem, target users, and core requirements
• Translate business problems into structured requirements including user stories, acceptance criteria, and success metrics
• Refine the PRD by iterating with Claude Code to eliminate ambiguity, fill gaps, and ensure requirements are implementation-ready

Execute the software development lifecycle — from plan through ship — by building a working prototype from your product requirement document using Claude Code. Apply the plugins, skills, and agents installed in the previous session at each stage of the cycle, and develop fluency collaborating with Claude Code through iterative agentic coding. The goal is a proof of concept, not production-ready code.

Objectives:

• Build a working prototype from a product requirement document by executing the software development lifecycle (plan, implement, verify, review, ship) with Claude Code
• Apply Claude Code plugins, skills, and agents at each stage of the development lifecycle to accelerate prototype development
• Collaborate with Claude Code through iterative development cycles — reviewing output, providing direction, and refining results to ship a working proof of concept

Set up Claude Code GitHub App for automated code review on pull requests, learn to triage AI-generated review feedback by severity, respond to comments, and merge — completing the full development pipeline from PR to merge with automated quality gates.

Objectives:

• Evaluate code quality by installing Claude Code GitHub App and interpreting automated review feedback on pull requests
• Triage review comments by severity (critical issues, suggestions, style) and prioritize fixes that matter
• Justify why automated code review creates a permanent quality gate in the development workflow

Deploy your application prototype to a production environment using a hosting platform (Vercel, GitHub Pages, or Netlify). Verify the deployed prototype works at its public URL, set up continuous deployment so every push to main updates the live site automatically, and troubleshoot any deployment issues — completing the full build-to-ship arc.

Objectives:

• Deploy a web application prototype to a hosting platform (Vercel, GitHub Pages, or Netlify) and verify it loads at a public URL
• Verify the deployed prototype functions correctly at its public URL and matches the local build
• Set up continuous deployment so every push to main automatically updates the live prototype