Claude AI Masterclass: Claude Code, MCP, Agents & Automation

In this lecture, you will learn how to install and use Claude Code CLI to interact with your local codebase and automate development tasks using AI.

This session provides a hands-on introduction to Claude Code setup, configuration, and real-world usage, helping you integrate AI directly into your development workflow.

What You’ll Learn

✅ Claude Code Installation

• Install Claude Code using:

  • Native installation

  • Windows CMD / PowerShell

  • Mac/Linux terminal

• Required dependencies:

  • Node.js

  • NPM setup

Access Methods Covered

You’ll understand how to use Claude Code via:

• Terminal (CLI)

• VS Code (upcoming lectures)

• Desktop App

• Web Interface

Hands-On Project Setup

You’ll create a simple Python project with:

• app.py (basic calculator functions)

• CLAUDE.md (project rules & coding standards)

Using Claude Code in CLI

You’ll learn how to:

• Initialize Claude in a project directory

• Grant workspace permissions

• Read and analyze project files

• Ask AI to:

  • Explain code

  • Detect issues

  • Suggest improvements

Real-Time Code Improvements

You’ll see Claude Code:

• Detect problems like:

  • Missing docstrings

  • Missing type hints

  • Division by zero errors

• Automatically fix issues in your code

• Apply updates directly to files

Enforcing Coding Standards

Using CLAUDE.md, you’ll:

• Define coding guidelines (PEP8, docstrings, type hints)

• Enforce project structure

• Automate code quality improvements

Key Benefits

• AI-powered code review in real-time

• Faster debugging and optimization

• Automated adherence to coding standards

• Improved developer productivity

Real-World Applications

• Codebase analysis and refactoring

• Automated bug fixing

• Enforcing team coding standards

• AI-assisted development workflows

Who This Lecture Is For

• Python developers and software engineers

• Beginners learning AI-assisted coding

• Developers exploring Claude Code CLI

• Anyone wanting to boost productivity with AI

In this lecture, you will learn how to install and use Claude Code inside Visual Studio Code (VS Code) to supercharge your development workflow with AI.

This session focuses on integrating Claude directly into your IDE, allowing you to analyze, run, and improve code without leaving VS Code.

What You’ll Learn

✅ Installing Claude Code in VS Code

• Download and install Visual Studio Code

• Install the official Claude Code extension

• Understand extension setup and auto-updates

Setting Up Your Development Environment

You’ll work with a simple Python project:

• app.py → Calculator functions

• CLAUDE.md → Coding standards & rules

Learn how Claude automatically uses these files as context for intelligent responses.

Using Claude Code Inside VS Code

You’ll learn how to:

• Open Claude panel inside VS Code

• Start AI-powered chat directly in your editor

• Analyze your project files instantly

• Switch between:

  • Local workspace

  • Remote/web-based context

Hands-On AI Interactions

You’ll perform real tasks like:

• Explaining code in beginner-friendly language

• Understanding each function step-by-step

• Running Python code directly from Claude

• Verifying fixes (e.g., division by zero handling)

Key Features Demonstrated

• AI-powered code explanation

• Direct code execution from VS Code

• Context-aware responses using project files

• Seamless integration with local development

Why Use Claude Code in VS Code?

• No need to switch between tools

• Faster debugging and learning

• Real-time AI assistance inside your IDE

• Improved productivity for developers

Real-World Applications

• Code review and debugging

• Learning new codebases quickly

• Automating repetitive development tasks

• AI-assisted coding and testing

Who This Lecture Is For

• Developers using VS Code

• Beginners learning Python with AI help

• Engineers exploring AI-powered IDE tools

• Anyone wanting to boost coding productivity

In this lecture, you will learn how to use Claude Code through the Desktop Application, enabling you to interact with your local projects using AI without relying on terminal or VS Code.

This method provides a user-friendly interface to access Claude’s coding capabilities, making it ideal for beginners and professionals alike.

What You’ll Learn

✅ Installing Claude Desktop App

• Download Claude desktop app from the official platform

• Complete authentication and setup

• Understand system requirements

Accessing Claude Code via Desktop App

You’ll learn how to:

• Navigate the Claude desktop interface

• Switch between:

  • Chat

  • Co-work

  • Code mode

• Connect your local project folder

Hands-On Project Integration

You’ll work with a Python project containing:

• app.py → Calculator logic

• CLAUDE.md → Project rules and standards

Claude will automatically:

• Read both files

• Understand project structure

• Provide intelligent responses

Real-Time AI Interactions

You’ll perform tasks like:

• Understanding project overview

• Analyzing code structure

• Asking for improvements

• Generating new feature ideas (e.g., additional math operations)

Key Features Demonstrated

• AI-powered project analysis

• Local folder integration

• Model selection (e.g., Claude Haiku)

• Context-aware responses from project files

Why Use Desktop App?

• No need for coding setup (CLI/IDE optional)

• Beginner-friendly interface

• Quick access to Claude Code features

• Ideal for learning and experimentation

Real-World Applications

• Quick code reviews without IDE

• Brainstorming new features

• Understanding unfamiliar codebases

• AI-assisted prototyping

Who This Lecture Is For

• Beginners exploring AI coding tools

• Developers who prefer GUI over CLI

• Students learning Python with AI assistance

• Anyone using Claude for local project analysis

In this lecture, you will learn how to use Claude Code via the Web Interface, enabling you to interact with repositories directly from the browser without any local setup.

This approach allows you to connect Claude with your GitHub repositories, making it easy to analyze, modify, and improve code remotely using AI.

What You’ll Learn

✅ Accessing Claude Code on Web

• Navigate to Claude Code web interface

• Authenticate using your GitHub account

• Start a new session for code interaction

Connecting GitHub Repository

You’ll learn how to:

• Create a new GitHub repository

• Upload project files (app.py, CLAUDE.md)

• Connect repository with Claude Code

• Enable Claude to read and understand your codebase

Hands-On AI Interaction

You’ll perform tasks like:

• Reading project files from GitHub

• Understanding project purpose and structure

• Identifying coding standards from CLAUDE.md

• Detecting bugs and issues in code

Automated Code Improvements

You’ll see Claude:

• Suggest fixes for issues

• Modify code directly

• Perform Git operations like:

  • Commit changes

  • Attempt push to repository

Key Features Demonstrated

• Browser-based AI coding workflow

• GitHub integration with Claude

• Remote code analysis and editing

• AI-assisted version control actions

Important Insights

• Web version requires repository access (GitHub)

• Changes may require proper permissions for push

• Best suited for:

  • Quick edits

  • Remote code review

• Not always ideal for full production workflows

Comparison with Other Methods

• Terminal (CLI): Most powerful & flexible

• VS Code: Best for daily development

• Desktop App: Beginner-friendly

• Web Version: Best for remote & quick access

Real-World Applications

• Reviewing GitHub projects with AI

• Quick bug fixes without local setup

• Remote collaboration and code analysis

• Lightweight AI-assisted development

Who This Lecture Is For

• Developers using GitHub repositories

• Beginners exploring AI coding tools

• Engineers working remotely

• Anyone wanting browser-based AI coding

In this lecture, you will build a complete Python application using Claude Code in VS Code, demonstrating how AI can help you develop real-world projects from scratch.

You’ll create a Command-Line Travel Budget Tracker, where Claude assists in designing, structuring, and implementing the entire application step by step.

What You’ll Learn

✅ AI-Driven Application Development

• How to build a full project using Claude Code

• Breaking down development into modular steps

• Using CLAUDE.md to define project requirements

Project Overview: Travel Budget Tracker

You’ll build a CLI-based Python app that allows users to:

• Create trips

• Add expenses

• View trip summaries

• Store data persistently using JSON

Step-by-Step Implementation

You’ll create the application in layers:

? 1. Storage Layer (storage.py)

• Load and save trip data

• Handle JSON-based persistence

? 2. Core Logic Layer (tracker.py)

• Add trips

• Log expenses

• Generate summaries

? 3. Display Layer (display.py)

• Print trip summaries

• Display all trips in terminal

? 4. Entry Point (main.py)

• CLI menu system

• User input handling

• Application flow control

Hands-On Execution

You’ll:

• Run the application using Python

• Add new trips and budgets

• Log expenses

• View summaries in real time

Key Concepts Covered

• Modular Python architecture

• Separation of concerns

• AI-assisted code generation

• Iterative development using prompts

• Debugging and improving generated code

Real-World Insights

• How to guide AI step-by-step for better results

• Why breaking tasks into modules improves accuracy

• How to extend the app with:

  • Trip IDs

  • Additional fields

  • Delete/update functionality

Best Practices

• Always define requirements in CLAUDE.md

• Build features incrementally

• Validate outputs and refine prompts

• Use AI as a collaborator, not a replacement

Who This Lecture Is For

• Beginners learning Python project development

• Developers exploring AI-assisted coding

• Students building real-world CLI applications

• Anyone using Claude Code for project creation

In this lecture, you will learn how to debug Python code using Claude Code inside VS Code, making it easier to identify, understand, and fix both logical and runtime errors using AI.

You’ll work with a deliberately buggy script and use Claude as an intelligent assistant to analyze issues, explain problems, and automatically apply fixes.

What You’ll Learn

✅ AI-Powered Debugging Workflow

• How to identify bugs using Claude Code

• Debugging step-by-step with natural language prompts

• Understanding errors even if you’re a beginner

Hands-On Debugging Examples

You’ll fix real-world coding issues such as:

? Logical Errors

• Incorrect operator usage (multiplication vs addition)

• Wrong calculations leading to incorrect outputs

? Runtime Errors

• Division by zero issues

• NameError due to incorrect variable usage

? Type & Formatting Errors

• String vs float formatting issues

• Incorrect return types

? Hidden Bugs

• Off-by-one errors in loops

• Incorrect logic in calculations

How Claude Helps You Debug

You’ll see Claude:

• Analyze your code and explain the issue

• Suggest precise fixes

• Apply changes directly to your file

• Re-run and validate corrected output

Iterative Debugging Approach

You’ll learn how to:

1. Run the code

2. Capture the error

3. Ask Claude to explain

4. Apply fix

5. Re-run and validate

6. Repeat until all issues are resolved

Key Insights

• AI can detect bugs you might miss

• Debugging becomes faster and more intuitive

• Claude can identify both visible and hidden issues

• You can refine and validate outputs continuously

Best Practices

• Always verify AI-generated fixes

• Debug one issue at a time

• Use clear prompts with error messages

• Perform final validation for hidden bugs

Real-World Applications

• Debugging production code faster

• Fixing legacy codebases

• Learning debugging as a beginner

• Improving code quality with AI assistance

Who This Lecture Is For

• Beginners struggling with debugging

• Python developers improving code quality

• Engineers using AI for development

• Anyone learning Claude Code

In this lecture, you will learn how to refactor legacy Python code using Claude Code, transforming messy, hard-to-maintain scripts into clean, readable, and production-ready code—without changing the core business logic.

You’ll follow a step-by-step AI-assisted refactoring workflow, where Claude analyzes your code, identifies issues, and helps you apply improvements systematically.

What You’ll Learn

✅ What is Code Refactoring?

• Improve code readability and maintainability

• Eliminate bad practices without altering functionality

• Prepare code for scalability and future enhancements

Hands-On Refactoring Workflow

You’ll work on a real-world travel report script and progressively improve it using Claude Code:

? Step 1: Code Audit (AI Analysis)

• Identify bad practices and design issues

• Understand problems like:

  • Global mutable state

  • Poor function design

  • Magic numbers

  • Bad variable naming

? Step 2: Clean Variable Naming

• Replace unclear names (e.g., dyp, cpp)

• Improve readability with meaningful identifiers

? Step 3: Remove Global State

• Eliminate hidden side effects

• Make functions reusable and testable

? Step 4: Add Type Hints

• Improve code clarity and developer experience

• Use proper annotations like List[Dict]

? Step 5: Add Professional Docstrings

• Document every function clearly

• Describe inputs, outputs, and behavior

? Step 6: Apply SOLID Principles (SRP)

• Break large functions into smaller ones:

  • Calculation logic

  • Warning logic

  • Output formatting

? Step 7: Replace Magic Numbers

• Convert hardcoded values into meaningful constants

• Improve maintainability and flexibility

? Step 8: Enforce Coding Standards

• Follow consistent naming conventions (snake_case)

• Align with project standards defined in CLAUDE.md

? Step 9: Generate Unit Tests

• Automatically create test cases using Python’s unittest

• Validate refactored functions:

  • calculate_trip_stats

  • get_warning_level

  • calculate_average_cost

How Claude Code Helps

• Performs deep code audits instantly

• Suggests structured improvements

• Applies refactoring changes safely

• Generates test cases automatically

Key Takeaways

• Refactoring improves code quality without breaking functionality

• AI can guide you through best practices and clean architecture

• Well-structured code is easier to:

  • Maintain

  • Debug

  • Scale

Real-World Applications

• Refactoring legacy projects

• Improving team codebases

• Preparing code for production

• Writing clean, maintainable Python code

Who This Lecture Is For

• Python developers working with legacy code

• Beginners learning clean coding practices

• Engineers using AI tools like Claude Code

• Anyone aiming to improve code quality

In this lecture, you will learn how to generate and execute Python test cases using Claude Code, enabling you to identify hidden bugs, validate logic, and improve code reliability using AI-driven testing workflows.

You’ll work with a real-world trip booking application and use Claude to automatically create pytest-based unit tests, run them, and fix failures step by step.

What You’ll Learn

✅ AI-Powered Test Case Generation

• Automatically generate test cases using Claude Code

• Follow industry-standard testing practices with pytest

• Create structured and maintainable test files

Hands-On Testing Workflow

? Step 1: Understand the Codebase

• Analyze functions like:

  • calculate_total_price

  • apply_seasonal_discount

  • calculate_tax

  • get_price_category

? Step 2: Generate Happy Path Tests

• Create test cases for valid inputs

• Validate expected outputs

• Use descriptive test naming

? Step 3: Run Tests with Pytest

• Execute tests using CLI

• Understand test execution flow

• Fix import/path issues using conftest.py

? Step 4: Add Edge Case Testing

• Test scenarios like:

  • Zero or negative values

  • Invalid inputs (e.g., wrong month)

  • Unexpected behavior

? Step 5: Identify Hidden Bugs

• Detect silent failures in logic

• Catch missing validations

• Validate error handling

? Step 6: Fix Failing Tests

• Add proper input validation

• Handle edge cases correctly

• Improve robustness of functions

? Step 7: Re-run & Validate

• Ensure all tests pass successfully

• Confirm code stability after fixes

Key Concepts Covered

• Pytest framework basics

• Writing unit tests with AI assistance

• Handling test failures and debugging

• Importance of edge case testing

• Test-driven improvement workflow

How Claude Code Helps

• Generates test cases instantly

• Detects bugs you might miss

• Suggests fixes based on failures

• Improves test coverage automatically

Real-World Applications

• Testing production applications

• Improving code quality and reliability

• Catching bugs before deployment

• Implementing test-driven development (TDD)

Who This Lecture Is For

• Python developers learning testing

• Beginners struggling with pytest

• Engineers using AI for development workflows

• Anyone improving code reliability

In this lecture, you will learn how to integrate GitHub with Claude Code and perform complete Git operations directly using AI, including branch creation, commits, and feature development workflows.

You’ll see how to connect your repository, manage version control, and automate development tasks—without manually writing Git commands.

What You’ll Learn

✅ Git Integration with Claude Code

• Connect Claude Code with GitHub repositories

• Grant permissions using GitHub App integration

• Work with cloud-based repositories directly

Hands-On Git Workflow with AI

? Step 1: Create & Upload Repository

• Create a new GitHub repository

• Upload project files (booking.py, CLAUDE.md, test files)

• Prepare codebase for version control

? Step 2: Analyze Project with Claude

• Read repository files

• Understand:

  • Project functionality

  • Coding standards

  • Git branching conventions

? Step 3: Follow Git Best Practices

• Use feature branches instead of modifying main

• Naming conventions:

  • feature/<feature-name>

  • fix/<bug-description>

? Step 4: Plan Before Code Changes

• Ask Claude to:

  • Suggest branch name

  • Generate commit message

  • Define implementation plan

? Step 5: Create Feature Branch Automatically

• Let Claude:

  • Create new branch

  • Add new functionality

  • Update codebase

? Step 6: Implement New Feature

• Example: calculate_final_price()

• Combine multiple functions into a single optimized workflow

• Add:

  • Type hints

  • Docstrings

  • Input validation

? Step 7: Auto-Generate Tests

• Create pytest-based test cases

• Ensure feature reliability

? Step 8: Commit & Track Changes

• Claude performs:

  • Git commits

  • Code updates

  • Change tracking

? Step 9: Review Changes

• Compare feature branch vs main

• Validate:

  • Code changes

  • Test updates

? Step 10: Prepare for Pull Request

• Verify commit messages

• Ensure adherence to standards

• Ready for PR creation

How Claude Code Helps

• Automates Git workflows

• Suggests best practices

• Reduces manual Git commands

• Ensures consistent coding & commit standards

Key Takeaways

• AI can manage end-to-end Git workflows

• Feature development becomes faster and structured

• You can maintain clean version control practices effortlessly

• Claude acts as a Git + coding assistant combined

Real-World Applications

• Team-based development workflows

• Feature development with version control

• Automating Git operations

• Maintaining clean and scalable repositories

Who This Lecture Is For

• Developers learning Git with AI

• Beginners struggling with Git commands

• Engineers using Claude Code for development

• Anyone building production-ready workflows

In this lecture, you will learn how to create and manage Pull Requests (PRs), perform code reviews, and handle GitHub issues using Claude Code, enabling a complete AI-powered Git workflow from development to collaboration.

You’ll see how Claude can automate PR creation, review code like a senior developer, merge changes, and even manage issues—all without leaving your workflow.

What You’ll Learn

✅ AI-Powered Pull Request Workflow

• Create PRs directly from feature branches

• Generate professional PR descriptions automatically

• Follow best practices defined in project standards

Hands-On GitHub Workflow with Claude

? Step 1: Create a Pull Request

• Open PR from feature branch to main

• Automatically generate:

  • Feature summary

  • Implementation details

  • Benefits for users

? Step 2: AI Code Review

• Let Claude review your code like a senior developer

• Validate:

  • Docstrings

  • Type hints

  • Input validation

  • Test coverage

? Step 3: Review Feedback & Improvements

• Identify missing best practices

• Ensure compliance with coding standards (CLAUDE.md)

• Confirm readiness for production

? Step 4: Merge Pull Request

• Merge PR directly using Claude

• Verify:

  • Feature successfully added to main

  • Codebase updated correctly

? Step 5: Validate Final State

• Confirm updated repository structure

• Ensure new functions and tests are integrated

GitHub Issue Management with Claude

? Create Issues

• Add new feature requests (e.g., multi-currency support)

• Write clear and structured issue descriptions

? Collaborate via Comments

• Add implementation guidance

• Enable team discussions

? Close Issues

• Resolve and close issues directly via Claude

• Maintain clean and organized repository

How Claude Code Helps

• Automates PR creation and documentation

• Performs intelligent code reviews

• Ensures best practices compliance

• Simplifies issue tracking and collaboration

Key Takeaways

• AI can handle end-to-end GitHub workflows

• Code reviews become faster and more consistent

• PRs and issues can be managed effortlessly

• Claude acts as a developer + reviewer + collaborator

Real-World Applications

• Team collaboration in GitHub projects

• Code review automation

• Managing feature development lifecycle

• Streamlining DevOps workflows

Who This Lecture Is For

• Developers working with GitHub workflows

• Teams adopting AI-assisted development

• Beginners learning PR and issue management

• Engineers using Claude Code in production

In this lecture, you will learn how to use the CLAUDE.md file to control AI behavior in your projects, ensuring consistent coding standards, safe boundaries, and structured development workflows using Claude Code.

You’ll see how a simple configuration file can completely transform how AI writes, modifies, and manages your code.

What You’ll Learn

✅ What is CLAUDE.md?

• A project-level configuration file for Claude Code

• Defines coding standards, constraints, and project rules

• Controls how AI generates and modifies code

Hands-On Workflow

? Step 1: Without CLAUDE.md

• Generate a function using Claude

• Observe issues:

  • No type hints

  • No docstrings

  • Poor naming conventions

  • Direct use of global variables

? Step 2: Introduce CLAUDE.md

• Define project overview

• Specify:

  • Code structure

  • File responsibilities

  • Development guidelines

? Step 3: Enforce Coding Standards

• Apply best practices:

  • Python 3.10

  • PEP 8 guidelines

  • Snake_case naming

  • Mandatory docstrings

  • Type hints for all functions

? Step 4: Improve Code Quality Automatically

• Regenerate functions using Claude

• See improvements:

  • Clean function signatures

  • Proper input validation

  • Better readability and structure

? Step 5: Restrict AI Behavior (Safety Rules)

• Prevent modifications to sensitive files:

  • config.py

  • .env files

• Enforce boundaries for secure development

? Step 6: Define Testing Strategy

• Configure:

  • Use of pytest

  • Test file structure

  • Naming conventions

? Step 7: Auto-Generate Tests

• Claude creates:

  • test/test_starter.py

• Follows:

  • Folder structure

  • Naming standards

  • Test best practices

Key Concepts Covered

• AI configuration using CLAUDE.md

• Enforcing coding standards automatically

• Safe AI usage with restricted file access

• Standardized test generation

• Project-level AI governance

How Claude Code Helps

• Adapts to your project rules instantly

• Ensures consistent code quality

• Prevents risky or unauthorized changes

• Automates development with guardrails

Key Takeaways

• CLAUDE.md acts as a “rulebook” for AI

• You can control:

  • Code quality

  • Structure

  • Security boundaries

• AI becomes more reliable and production-ready

Real-World Applications

• Standardizing team coding practices

• Enforcing secure development workflows

• Managing large codebases with AI

• Automating development with consistency

Who This Lecture Is For

• Developers using Claude Code

• Teams working on shared repositories

• Beginners learning structured coding practices

• Engineers building production-grade systems

In this lecture, you will learn how to perform security audits and vulnerability scanning using Claude Code, helping you identify and fix critical security issues in your applications based on the OWASP Top 10 standards.

You’ll work with a real-world Flask-based travel booking API that intentionally contains vulnerabilities—and use AI to detect, analyze, and fix them step by step.

What You’ll Learn

✅ AI-Powered Security Auditing

• Perform full security audits using Claude Code

• Detect vulnerabilities automatically

• Classify issues based on severity (Critical, High, Medium, Low)

Hands-On Security Workflow

? Step 1: Understand OWASP Top 10

• Learn common vulnerabilities like:

  • SQL Injection

  • Command Injection

  • Broken Authentication

  • Hardcoded Secrets

  • Insecure Design

? Step 2: Scan Your Application

• Analyze multiple files:

  • app.py

  • database.py

  • config.py

  • CLAUDE.md

• Identify vulnerabilities across the codebase

? Step 3: Vulnerability Classification

• Categorize issues:

  • Injection vulnerabilities

  • Authentication flaws

  • Sensitive data exposure

• Assign severity levels:

  • Critical

  • High

  • Medium

  • Low

? Step 4: Fix SQL Injection

• Replace string concatenation with parameterized queries

• Understand:

  • Why SQL injection happens

  • How parameterized queries prevent it

? Step 5: Secure Sensitive Data

• Remove hardcoded secrets

• Move credentials to environment variables (.env)

• Use secure configuration practices

? Step 6: Identify Other Vulnerabilities

• Unauthenticated admin endpoints

• Command injection risks

• Exposure of sensitive error messages

? Step 7: Apply Fixes Iteratively

• Fix one vulnerability at a time

• Validate improvements

• Ensure application still runs correctly

Key Concepts Covered

• OWASP Top 10 security risks

• Secure coding practices in Python

• API security fundamentals

• Environment variable management

• Input validation and sanitization

How Claude Code Helps

• Performs deep security analysis instantly

• Detects vulnerabilities across multiple files

• Suggests secure coding practices

• Helps implement fixes step-by-step

Key Takeaways

• Security is as important as functionality

• AI can uncover hidden vulnerabilities quickly

• Following OWASP standards improves application safety

• Proper fixes prevent real-world attacks

Real-World Applications

• Securing production APIs

• Preventing cyber attacks

• Performing security audits in projects

• Building enterprise-grade secure systems

Who This Lecture Is For

• Developers building APIs

• Python & Flask developers

• Engineers interested in cybersecurity

• Anyone using AI for secure coding

In this lecture, you will learn the core concepts of Skills, Plugins, and Hooks in Claude Code, and how they extend AI capabilities to automate development workflows, enforce standards, and enhance productivity.

Using simple analogies and practical explanations, you’ll understand how to customize and scale Claude Code for real-world software development.

What You’ll Learn

✅ Understanding Skills, Plugins & Hooks

• What each concept means in Claude Code

• How they differ and when to use them

• How they work together in a development workflow

Concept Breakdown

? 1. Skills (Built-in, Plugin, Custom)

Skills are reusable instructions that teach Claude how to perform tasks.

Types of Skills:

• Built-in Skills

  • Available by default (e.g., /debug, /simplify)

• Plugin Skills

  • Installed from marketplace

• Custom Skills

  • Created by you in .claude/skills/

Key Features:

• No installation required (for built-in)

• Can be single-file or multi-file

• Define behavior using skill.md

? 2. Plugins (Extension Bundles)

Plugins are collections of tools bundled together.

Includes:

• Skills

• Commands

• Hooks

• Agents

• MCP servers

Capabilities:

• Installed via marketplace

• Extend Claude Code functionality

• Simplify complex workflows

? 3. Hooks (Automation & Enforcement)

Hooks are event-driven commands that execute automatically.

Types of Hooks:

• Pre-tool use → Runs before action (can block)

• Post-tool use → Runs after action

• Notifications → Alerts or triggers

Example Use Cases:

• Auto-format code after changes

• Prevent dangerous commands (e.g., delete operations)

• Protect sensitive files (.env)

• Trigger system notifications

Practical Use Cases

• Create custom skills like:

  • Code explainer

  • CSV summarizer

• Install plugins for:

  • Frontend design

  • Code optimization

• Use hooks for:

  • Security enforcement

  • Auto-formatting

  • Logging changes

Key Takeaways

• Skills = Teach Claude what to do

• Plugins = Extend Claude’s capabilities

• Hooks = Automate and enforce behavior

How Claude Code Helps

• Customizes AI behavior to your workflow

• Automates repetitive development tasks

• Enforces coding standards and safety rules

• Improves productivity with modular extensions

Real-World Applications

• Standardizing team workflows

• Automating DevOps tasks

• Enforcing security rules

• Building custom AI-powered tools

Who This Lecture Is For

• Developers using Claude Code

• Engineers automating workflows

• Teams implementing AI-driven development

• Anyone building scalable AI tooling

In this hands-on lecture, you will learn how to create, configure, and use custom Skills in Claude Code to control output format, automate workflows, and enhance AI responses for real-world coding tasks.

Through practical examples, you’ll understand how Skills transform generic AI responses into structured, consistent, and production-ready outputs.

What You’ll Learn

• How to create custom Skills in Claude Code

• How to structure the .claude/skills/ directory

• How to define behavior using skill.md

• How Claude automatically detects and invokes Skills

• Difference between default AI responses vs Skill-driven responses

Hands-On Implementation

? Step 1: Project Setup

• Create a working project folder

• Add sample Python files like:

  • fibonacci.py

  • sales.csv

• Open the project in VS Code with Claude Code enabled

? Step 2: Creating Your First Skill (Code Explainer)

You will:

• Create .claude/skills/code-explainer/skill.md

• Define:

  • Purpose of the skill

  • When it should be used

  • Output format (structured explanation)

? Result:

Instead of a generic explanation, Claude generates:

• Function overview

• Line-by-line explanation

• Real-world analogy

• Important notes

? Step 3: Skill Invocation

• Learn how Claude:

  • Detects relevant Skills automatically

  • Applies them based on your prompt

• Understand why sometimes restarting the session helps

? Step 4: Advanced Skill Example (CSV Summary)

You will build a second Skill to:

• Analyze CSV files

• Execute a Python script (summarize.py)

• Return structured output

? Output Includes:

• File name

• Total rows & columns

• Headers

• Sample data preview

Built-in vs Custom Skills

✅ Built-in Skills:

• /simplify

• /debug

• Pre-configured and ready to use

✅ Custom Skills:

• Created inside .claude/skills/

• Fully customizable

• Tailored to your workflow

Key Takeaways

• Skills allow you to control AI output precisely

• You can enforce:

  • Output structure

  • Coding standards

  • Automation workflows

• Claude can automatically select the right Skill based on context

Real-World Use Cases

• Code explanation for beginners

• Automated data analysis (CSV, logs, reports)

• Standardized documentation generation

• Workflow automation using scripts

Who This Lecture Is For

• Developers using Claude Code

• AI-powered coding enthusiasts

• Data analysts working with structured files

• Engineers building custom AI workflows

In this hands-on lecture, you will explore how to install, use, and manage Plugins in Claude Code to enhance your development workflow and extend AI capabilities.

Through a practical demo, you’ll understand how plugins work, how they differ from skills, and why they are powerful—but not always automatically invoked.

What You’ll Learn

• What Claude Code Plugins are and how they work

• How to install plugins from the Claude marketplace

• How to manage plugins using CLI commands

• When and why plugins may or may not be invoked

• Difference between Skills vs Plugins in real execution

Hands-On Implementation

? Step 1: Setting Up Plugin Demo

• Create a working directory (plugins-demo)

• Use a messy Python file (messy.py) with:

  • Unstructured logic

  • Multiple functions

  • Poor readability

? Step 2: Running Without Plugin

• Ask Claude to:

  • Simplify the code

• Observe:

  • Claude improves the code

  • Uses built-in intelligence (not plugins)

? Key Insight:

Even without plugins, Claude can perform optimizations using internal capabilities.

? Step 3: Installing a Plugin

• Navigate to Claude Plugin Marketplace

• Choose a plugin (e.g., Code Simplifier)

• Install using CLI:

/plugin install code-simplifier

• Verify installation using:

/plugin

? Step 4: Using Plugins

• Try prompting:

  • “Simplify this code using plugin”

  • “Use code simplifier plugin to optimize messy.py”

⚠️ Important Observation:

• Plugin is NOT always invoked automatically

• Claude may still rely on:

  • Built-in skills

  • Internal reasoning

Key Learning: Plugin Behavior

❗ Plugins Are Not Guaranteed to Run

Even after installation:

• Claude may ignore plugins

• It may choose a better internal method

✅ How to Improve Usage:

• Be explicit in prompts

• Mention plugin name clearly

• Use specific instructions

Key Takeaways

• Plugins extend Claude’s capabilities but are not always automatically used

• Claude prioritizes:

  • Context

  • Efficiency

  • Built-in reasoning

• You must guide the AI clearly to use plugins

Real-World Use Cases

• Code refactoring using plugin tools

• Enhancing productivity with pre-built extensions

• Integrating external workflows into Claude Code

• Experimenting with marketplace tools

Who This Lecture Is For

• Developers exploring Claude Code plugins

• AI engineers building extended workflows

• Programmers optimizing code with AI tools

• Anyone curious about AI plugin ecosystems

In this hands-on lecture, you will learn how to implement and automate workflows using Hooks in Claude Code, one of the most powerful features for enforcing rules and triggering actions automatically.

Through practical demos, you’ll understand how Hooks work in real scenarios like logging file changes and auto-formatting code—making your development process smarter and more automated.

What You’ll Learn

• What Hooks are and how they work in Claude Code

• Difference between Post-Tool Hooks and Pre-Tool Hooks

• How to configure Hooks using .claude/settings.json

• How to automate tasks after code execution

• How to enforce consistency using automated workflows

Hands-On Implementation

? Step 1: Project Setup

• Create a hooks-demo workspace

• Add sample files:

  • sample.py

  • messy.js

  • .env

? Step 2: Basic Operation Without Hooks

• Perform a simple task:

  • Add docstring to a function

• Observe:

  • Code updates successfully

  • ❌ No logging or automation occurs

? Step 3: Creating Your First Hook (Post-Tool Logging)

• Create .claude/settings.json

• Add a post-tool hook

? Purpose:

Automatically log every file edit

⚙️ Behavior:

• After any file change:

  • Log timestamp

  • Record file activity

? Result:

A hook_log.txt file is created with:

• Date & time

• File modification details

? Step 4: Auto Formatting with Prettier

• Add another hook using:

  • npx prettier

? Purpose:

Automatically format JavaScript files

⚙️ Behavior:

• After code modification:

  • Prettier runs automatically

  • Code is reformatted

? Result:

• Messy code → Clean, structured format

• Fully automated formatting workflow

Key Takeaways

• Hooks are always executed once configured

• They enable:

  • Automation

  • Logging

  • Enforcement

• You can chain multiple hooks for complex workflows

• Hooks work silently in the background

Real-World Use Cases

• Auto-format code using Prettier

• Log all code changes for auditing

• Enforce coding standards

• Trigger scripts after file updates

• Build automated DevOps workflows

Why Hooks Matter

Unlike Skills and Plugins:

• Hooks are guaranteed to run

• They enforce rules automatically

• They reduce manual effort significantly

Who This Lecture Is For

• Developers automating workflows in Claude Code

• Engineers enforcing coding standards

• DevOps professionals building automation pipelines

• Anyone looking to make AI-driven coding more reliable

In this lecture, you will dive deeper into Pre-Tool Hooks in Claude Code, where you’ll learn how to prevent dangerous operations and protect sensitive data before execution.

Through practical demonstrations, you’ll understand how to enforce security policies such as blocking risky commands and safeguarding environment files—making your AI workflows secure and production-ready.

What You’ll Learn

• What Pre-Tool Hooks are and how they differ from Post-Tool Hooks

• How to block dangerous commands like rm -rf

• How to protect sensitive files such as .env

• How to configure security rules using .claude/settings.json

• How Claude enforces policies before executing any action

Hands-On Implementation

? Step 1: Blocking Dangerous Commands

• Create a sample directory (tmp/) with files

• Configure a Pre-Tool Hook

? Objective:

Prevent accidental deletion using rm -rf

⚙️ Behavior:

• Detect unsafe commands

• Block execution instantly

• Return a warning message

? Result:

• ❌ Dangerous command is blocked

• ✅ System remains safe

? Step 2: Without Pre-Tool Hook (Comparison)

• Run the same delete command

• Observe:

  • Directory gets deleted successfully

? Insight:

Without Pre-Tool Hooks → No safety enforcement

? Step 3: Protecting .env Files

• Add a new Pre-Tool Hook to block:

  • Read

  • Write

  • Edit operations on .env

? Objective:

Prevent exposure of sensitive data (API keys, secrets)

? Result:

• ❌ Claude cannot read .env

• ✅ Sensitive data remains protected

Key Takeaways

• Pre-Tool Hooks run before execution

• They enforce:

  • Security

  • Safety

  • Access control

• Ideal for:

  • Preventing destructive commands

  • Protecting sensitive data

• Fully configurable via settings.json

Real-World Use Cases

• Prevent accidental file deletion in production

• Secure API keys and environment variables

• Enforce company-level security policies

• Build safe AI-assisted development environments

Why Pre-Tool Hooks Matter

• Act as a security firewall for AI actions

• Ensure AI does not execute unsafe instructions

• Provide full control over allowed operations

Who This Lecture Is For

• Developers concerned about AI safety

• DevOps engineers enforcing security rules

• Teams working with sensitive data

• Anyone using Claude Code in production environments

In this lecture, you will learn how to integrate AI-powered code review into a CI/CD pipeline using GitHub Actions and Claude. We walk through a practical example by creating a sample repository and automating the entire workflow—from code execution to intelligent review.

What you’ll learn in this lecture:

• Create and set up a sample GitHub repository (Student Grade Calculator)

• Understand project structure with Python code and test cases

• Configure a GitHub Actions workflow using a YAML file

• Automate steps like code checkout, environment setup, and dependency installation

• Execute automated test cases within the CI/CD pipeline

• Integrate Claude (Anthropic) for AI-based code review

• Define coding and testing standards using a claude.md file

• Enforce rules like type hints, docstrings, and test coverage checks

• Securely configure and use API keys with GitHub Secrets

• Automatically generate review status (Approved / Blocked) based on code quality

By the end of this lecture, you will have a hands-on understanding of building an intelligent CI/CD pipeline that not only runs your code but also reviews it for quality and best practices.

In this lecture, you will learn how to trigger your CI/CD pipeline using GitHub Actions and observe how Claude assists in debugging and improving your workflow. We walk through pushing code changes, creating branches, raising pull requests, and analyzing workflow execution step by step.

What you’ll learn in this lecture:

• Understand how GitHub Actions workflows are triggered (via Pull Requests)

• Test and validate workflow behavior before pushing changes

• Push code to GitHub and verify repository updates

• Create feature branches following project standards

• Add new functions with proper type hints, docstrings, and test cases

• Generate and manage Pull Requests from feature to main branch

• Monitor workflow execution in the Actions tab

• Identify and debug common CI/CD errors (e.g., missing files, incorrect paths)

• Fix issues like test failures and folder structure problems

• Use Claude to analyze errors and automatically suggest fixes

• Iterate through multiple fixes until tests pass successfully

• Understand common integration issues like API authentication and secrets errors

• Learn how real-world CI/CD pipelines fail and how to systematically troubleshoot them

By the end of this lecture, you will gain hands-on experience in triggering workflows, debugging failures, and leveraging Claude to resolve issues efficiently in a CI/CD pipeline.

In this lecture, you will learn how to troubleshoot and fix advanced CI/CD pipeline issues in GitHub Actions, especially related to authentication and workflow validation. You will also see how Claude enforces coding standards by approving or blocking pull requests based on predefined rules.

What you’ll learn in this lecture:

• Identify and debug GitHub Actions errors related to OIDC authentication

• Understand the importance of id-token: write permission in workflows

• Fix permission issues in GitHub Actions YAML configuration

• Learn why workflows may fail on feature branches but work on the main branch

• Understand workflow validation behavior in Pull Requests

• Apply fixes by updating the main branch and rebasing feature branches

• Manage branch synchronization and resolve conflicts using rebase

• Successfully trigger a working CI/CD pipeline after fixes

• Verify successful execution of tests and AI-based code review

• Understand how Claude evaluates code against claude.md standards

• See how clean code gets approved automatically

• Introduce intentionally bad code to test rule enforcement

• Observe how Claude blocks Pull Requests with violations (missing type hints, docstrings, etc.)

• Understand real-world CI/CD quality gates using AI-powered review

By the end of this lecture, you will have a clear understanding of handling authentication issues, fixing workflow failures, and using Claude as a strict quality gate in your CI/CD pipeline.

In this lecture, you'll set up the Claude Agent SDK development environment and create your first agent project. We’ll install the required dependencies, configure API access, create a simple Hello Agent application, and verify that everything is working correctly before moving on to more advanced agent development.

What You'll Learn

• Install and configure the Claude Agent SDK

• Understand the difference between the Claude SDK and Claude Agent SDK

• Set up and manage environment variables using a .env file

• Configure Anthropic API keys for agent development

• Create and run a basic Hello Agent application

• Resolve common package installation and dependency issues

• Troubleshoot virtual environment and interpreter configuration problems

• Diagnose API authentication and credit balance errors

• Validate your development environment before building production agents

By the end of this lecture, you'll have a fully configured Claude Agent SDK environment and a working agent application ready for further development.

In this lecture, you'll build your first practical AI agents using the Claude Agent SDK. You'll explore how agents can leverage built-in tools, custom tools, and reusable skills to perform complex tasks with minimal code and intelligent decision-making.

Starting with file summarization, you'll learn how Claude automatically selects and uses tools to read files, generate outputs, and save results. You'll then create a custom Flashcard Generator tool and finally enhance your agent with reusable skills for structured and consistent outputs.

What You'll Learn

• Verify and test a working Claude Agent SDK setup

• Understand how agent-based workflows differ from traditional SDK interactions

• Use built-in tools such as file reading, file writing, and web search

• Create agents that perform multi-step tasks from a single prompt

• Build and register custom tools using MCP servers

• Generate study flashcards automatically from source content

• Learn how agents discover and invoke custom tools

• Create reusable agent skills using the .claude/skills framework

• Configure skill-based behavior for consistent agent outputs

• Understand the hierarchy of prompts, tools, and skills within an agent workflow

• Build real-world study assistant agents with minimal code

By the end of this lecture, you'll understand how to combine built-in tools, custom tools, and skills to create more capable and intelligent Claude agents.

In this lecture, you'll build a real-world multi-tool AI agent from scratch using the Claude Agent SDK. You'll learn how agents can intelligently orchestrate multiple tools—including web search, custom calculators, and file operations—to solve complex tasks autonomously.

Using a travel budget planning assistant as a practical example, you'll see how a single prompt can trigger different tool chains based on user requirements, allowing the agent to gather information, perform calculations, generate reports, and save outputs without manual intervention.

What You'll Learn

• Build a multi-tool AI agent using the Claude Agent SDK

• Create and register custom tools with MCP servers

• Implement calculator tools for addition, multiplication, currency conversion, and cost splitting

• Combine built-in tools and custom tools within a single agent workflow

• Use web search tools to retrieve real-time information

• Enable agents to perform autonomous tool selection and sequencing

• Generate travel budgets and trip planning reports automatically

• Save agent outputs to structured Markdown files

• Compare CLI-based and UI-based agent implementations

• Build interactive agent interfaces using Gradio

• Understand how agents decide which tools to invoke based on task requirements

• Monitor tool execution logs and agent reasoning workflows

By the end of this lecture, you'll understand how to design intelligent agents that can coordinate multiple tools, perform end-to-end task execution, and generate practical business-ready outputs with minimal human intervention.

In this lecture, you'll explore the Google Agent Development Kit (ADK) and learn how to build intelligent AI agents using Claude models within Google's agentic framework. You'll set up the ADK environment, integrate Anthropic models through LiteLLM, and build practical agent workflows involving tool routing, session memory, and multi-agent pipelines.

Through hands-on examples, you'll see how Google ADK automatically selects tools, manages conversation state, and orchestrates multiple agents to complete complex tasks in a structured workflow.

What You'll Learn

• Install and configure Google ADK for agent development

• Integrate Claude models with Google ADK using LiteLLM

• Verify ADK setup with a simple Hello Agent implementation

• Create custom tools within the Google ADK framework

• Implement intelligent tool routing based on user intent

• Build word-count and reading-time estimation tools

• Understand how ADK automatically selects the appropriate tool

• Manage session memory and persistent agent state

• Store and retrieve information across multiple conversation turns

• Use in-memory session services for context retention

• Create state-aware agents that remember previous interactions

• Build sequential multi-agent pipelines

• Design Researcher, Writer, and Editor agent workflows

• Pass outputs between agents automatically using state variables

• Understand how Google ADK orchestrates multi-step agent execution

• Compare single-agent and multi-agent architectures for real-world applications

By the end of this lecture, you'll be able to build sophisticated Google ADK agents that leverage tools, maintain memory, and coordinate multiple specialized agents to automate complex workflows.

In this lecture, you'll build advanced multi-agent systems using the Google ADK framework. You'll learn how to design orchestrator agents, implement intelligent agent routing, create structured agent communication, and combine sequential and parallel workflows to build scalable AI-powered production pipelines.

Using practical newsroom and content-production examples, you'll see how multiple specialized agents can collaborate, exchange structured data, and work together efficiently to solve complex tasks.

What You'll Learn

• Build orchestrator agents that manage multiple specialized sub-agents

• Implement automatic agent routing based on user intent

• Create Researcher, Writer, and Reviewer specialist agents

• Understand dynamic task delegation in multi-agent systems

• Design structured communication between agents

• Pass outputs between agents using state keys and output variables

• Build agent pipelines with reusable intermediate results

• Create aggregators that combine outputs from multiple agents

• Implement sequential agent workflows for dependent tasks

• Understand when to use sequential versus parallel execution

• Build parallel agents that process independent tasks simultaneously

• Design newsroom-style content production pipelines

• Combine parallel and sequential workflows in a single architecture

• Coordinate Fact Research, Trend Analysis, Writing, and Review agents

• Optimize multi-agent systems for faster execution and better scalability

• Learn real-world patterns for enterprise-grade agent orchestration

By the end of this lecture, you'll be able to build sophisticated multi-agent architectures that intelligently route tasks, share structured information, and execute complex workflows using both sequential and parallel processing patterns in Google ADK.

In this lecture, you will build your first real-world “Hello World” project using Claude Co-Work, where AI directly interacts with your local files to automate complex tasks like file organization, renaming, and summarization.

This hands-on demo showcases the true power of AI-assisted workflows—transforming messy folders into structured, well-organized systems with minimal effort.

What You’ll Learn

• How to set up and use Claude Co-Work mode

• How to give structured instructions for file automation

• How AI can:

  • Organize files

  • Rename them intelligently

  • Detect duplicates

  • Generate logs

• How to perform multi-step workflows on local data

• How to analyze and summarize documents using AI

Hands-On Implementation

? Step 1: Setting Up Co-Work Workspace

• Create a working folder (co-work-demo)

• Add multiple unorganized files (documents, spreadsheets, etc.)

• Grant Claude access to the folder

? Step 2: Automating File Organization

Provide a structured prompt to:

• Create subfolders by file type:

  • Reports

  • Images

  • Videos

  • Spreadsheets

  • Meeting Notes

  • Invoices

• Move files into correct folders

• Rename files using consistent format:

  • YYYYMMDD_descriptive_name

• Detect duplicates and separate them

• Generate a detailed log file

? Result:

• Fully organized folder structure

• Clean file naming system

• Automated audit log (organization_log.md)

? Step 3: AI-Generated Automation Scripts

• Claude automatically creates:

  • Python scripts for file processing

  • Logging scripts for tracking changes

? Insight:

You’re not just getting results—you’re also getting reusable automation code.

? Step 4: Document Analysis & Summarization

• Focus on a specific folder (e.g., Meeting Notes)

• Ask Claude to:

  • Read all files

  • Generate a professional summary

? Output Includes:

• Executive summary

• Key decisions

• Action items with ownership

• Cross-meeting comparison

• Open issues

Key Takeaways

• Claude Co-Work can act as a file system assistant

• You can automate complex workflows using simple prompts

• AI can:

  • Understand content

  • Take actions

  • Generate reports

• Works within a safe sandbox (selected folder only)

Important Notes

• Co-Work operates only within the selected folder

• It does not retain memory across sessions

• You can define rules like:

  • “Never delete files”

  • “Only rename or move files”

Real-World Use Cases

• Organizing messy downloads folder

• Managing business documents

• Automating office workflows

• Creating summaries from meeting notes

• Building AI-powered file management systems

Who This Lecture Is For

• Developers exploring AI automation

• Professionals managing large file systems

• Data analysts working with documents

• Anyone looking to boost productivity using AI

In this advanced hands-on lecture, you will explore how to use Claude Co-Work directly on real system folders (like Downloads) to perform powerful file management tasks such as identifying executables, bulk deletion, and intelligent archiving.

This session demonstrates how AI can safely and efficiently handle large-scale file operations with user confirmation, structured workflows, and detailed reporting.

What You’ll Learn

• How to use Claude Co-Work on real folders like Downloads

• How to identify and filter files by type (e.g., .exe, .apk, .sh)

• How to safely delete unwanted files with confirmation

• How to automate file archiving based on age

• How to generate structured logs for tracking operations

Hands-On Implementation

? Step 1: Scan for Executable Files

• Analyze all files in the Downloads folder

• Identify:

  • Windows executables (.exe, .msi, .bat)

  • Linux binaries

  • APK files

  • Scripts

? Result:

• Categorized report of all executable files

• Clear visibility into unnecessary installers

? Step 2: Bulk Delete Executables (Safely)

• Provide instruction to delete:

  • All Windows executable files

⚠️ Safety Features:

• Multiple confirmation prompts

• Clear warning before deletion

• Step-by-step execution

? Result:

• All .exe files removed

• Final verification ensures zero executables remain

? Step 3: Archive Old Files Automatically

• Define condition:

  • Files older than 90 days

⚙️ AI Workflow:

• Scan all folders and subfolders

• Identify old files

• Move them into:

  • archive/YYYY/MM structure

? Output Includes:

• Organized archive folders (month-wise)

• archive_log.md with:

  • Total files archived

  • Monthly breakdown

  • File movement details

Real-World Use Cases

• Cleaning up Downloads folder automatically

• Removing outdated installers

• Archiving old business documents

• Managing storage efficiently

• Automating digital hygiene workflows

Best Practices Highlighted

• Always review before deletion

• Use confirmation prompts wisely

• Define clear rules (e.g., “Do not delete important files”)

• Use logs for audit and tracking

Who This Lecture Is For

• Developers managing large file systems

• Professionals dealing with messy downloads

• AI automation enthusiasts

• Anyone looking to optimize storage and workflows

In this advanced hands-on lecture, you will learn how to use Claude Co-Work for document intelligence and contract analysis, transforming unstructured PDF data into structured insights and automated reports.

This session demonstrates how AI can extract, organize, analyze, and summarize complex business documents like contracts—saving hours of manual effort.

What You’ll Learn

• How to analyze multiple PDF contracts using Claude Co-Work

• How to extract structured data from unstructured documents

• How to generate Excel reports automatically

• How to create professional summaries for each contract

• How to apply conditional formatting and business logic

Hands-On Implementation

? Step 1: Contract Data Extraction

• Provide a folder containing multiple contract PDFs

• Ask Claude to extract key fields such as:

  • Contract type

  • Parties involved

  • Financial details

  • Key dates

  • Obligations

? Output:

• Structured dataset compiled into an Excel file

? Step 2: Automated Excel Report Generation

Claude creates an Excel file with multiple sheets:

? Sheet 1: Contract Extraction Matrix

• All extracted contract data in tabular format

? Sheet 2: Financial Summary

• Aggregated financial insights across contracts

? Sheet 3: Key Dates & Alerts

• Important contract timelines

• Conditional formatting:

  • ? Expiring within 6 months

  • ? Expiring within 12 months

  • ? Long-term contracts

? Step 3: Contract Summarization

• Generate individual one-page summaries for each contract

? Each Summary Includes:

• Agreement type

• Key stakeholders

• Obligations

• Important clauses

• Next actions

? Step 4: Combined Summary Report

• Create a consolidated overview of all contracts

• High-level insights for quick decision-making

Real-World Use Cases

• Legal contract analysis

• Vendor agreement tracking

• Financial contract reporting

• Compliance and risk monitoring

• Business intelligence from documents

Why This Matters

• Converts unstructured data → structured insights

• Saves hours of manual review

• Enables data-driven decision making

• Scales effortlessly across multiple documents

Who This Lecture Is For

• Developers building AI document workflows

• Business analysts handling contracts

• Legal professionals automating document review

• Anyone working with large sets of PDFs

In this lecture, you will explore Claude Co-Work Connectors—a powerful feature that allows you to integrate AI with real-world tools like Gmail, Slack, and Google Drive to automate workflows and boost productivity.

You’ll learn how to connect external services, retrieve data, and perform multi-step tasks across platforms—all within a single AI-driven environment.

What You’ll Learn

• What connectors are and how they work

• How to integrate Claude Co-Work with external tools

• Step-by-step setup of Gmail, Slack, and Google Drive connectors

• How to fetch, analyze, and automate tasks using connected data

• How to build multi-tool workflows using AI

Connectors Covered in This Lecture

? Gmail Connector

• Connect your Gmail account securely

• Fetch recent emails (subject, sender, date)

• Create and manage email drafts

• Automate email-based workflows

? Slack Connector

• Connect Claude to your Slack workspace

• Retrieve channel information

• Read and analyze messages

• Enable AI-powered team collaboration

? Google Drive Connector

• Access and manage files from Google Drive

• Upload AI-generated reports

• Organize documents into folders

• Automate file storage workflows

Hands-On Workflow Demonstration

In this lecture, you will build a real-world multi-connector workflow:

1. Analyze multiple local files

2. Extract key insights and generate a report

3. Upload the report to Google Drive

4. Create a professional email draft in Gmail

5. Use Slack data for collaboration insights

Real-World Use Cases

• Automated email reporting systems

• Team communication analysis via Slack

• Document processing and storage workflows

• Business intelligence automation

• AI-powered productivity systems

Why This Lecture Matters

This lecture shows how AI is evolving from a simple assistant → full workflow automation engine, capable of interacting with real-world applications and executing complex multi-step tasks.

Who This Lecture Is For

• Developers building AI-powered tools

• Professionals automating daily workflows

• Data analysts working with multiple platforms

• Anyone looking to integrate AI with real-world apps

In this lecture, you will learn how to automate tasks using scheduling in Claude Co-Work, enabling you to run AI-powered workflows at predefined intervals without manual intervention.

You’ll explore how to create, manage, and execute scheduled tasks that can organize files, generate reports, analyze data, and even send notifications across platforms like Slack and Gmail.

What You’ll Learn

• How to create and manage scheduled tasks in Claude Co-Work

• How to automate repetitive workflows (file cleanup, reporting, etc.)

• How to configure task frequency (daily, weekly, custom schedules)

• How to combine scheduling with connectors like Gmail and Slack

• How to monitor, edit, and delete scheduled jobs

Hands-On Use Cases Covered

?️ 1. Weekly File Cleanup Automation

• Automatically organize files in a folder

• Rename files using a structured format

• Archive files older than a defined period

• Generate logs for tracking actions

? Key Rule:

• No deletion — only sorting, renaming, and archiving

? 2. Daily Morning Briefing Automation

• Summarize recent emails from Gmail

• Analyze project files

• Generate a one-page daily report

• Save reports in a predefined folder

• Send updates to Slack automatically

Real-World Use Cases

• Automated report generation for teams

• Daily business briefing dashboards

• File organization and maintenance

• Email summarization workflows

• Team notifications via Slack

Why This Lecture Matters

This lecture demonstrates how AI can act as a personal automation engine, running tasks in the background and keeping your workflow organized without manual effort.

Who This Lecture Is For

• Developers building AI automation systems

• Professionals looking to automate daily workflows

• Project managers handling recurring reports

• Anyone interested in AI-powered productivity

In this lecture, you will learn how to use Claude Co-Work Plugins—a powerful feature that extends AI capabilities by adding specialized skills, similar to apps in a marketplace.

You’ll discover how plugins transform Claude from a general-purpose assistant into a domain-specific expert, capable of handling finance, engineering, productivity, and more.

What You’ll Learn

• What plugins are and how they work in Claude Co-Work

• How to install and manage plugins

• How plugins use predefined skills for specialized tasks

• How to combine plugins with real-world data

• How to trigger plugins manually or automatically

Understanding Plugins (Simple Explanation)

• Plugins = Apps (like Play Store / App Store)

• Skills = Capabilities inside each plugin

• Connectors = Data sources (Gmail, Drive, etc.)

? Together, they create a complete AI ecosystem

Plugins Covered in This Lecture

? Finance Plugin

• Generate financial statements

• Perform expense analysis

• Reconcile data and prepare reports

• Automate accounting workflows

⚙️ Engineering Plugin

• Code debugging

• Architecture planning

• Code review

• Deployment checklist

? Productivity Plugin

• Task management

• Memory management

• Workflow updates

Hands-On Demonstration

In this lecture, you will:

1. Install multiple plugins (Finance, Engineering, Productivity)

2. Explore built-in skills inside each plugin

3. Analyze real-world data (invoices and receipts)

4. Generate financial insights using AI

5. Understand how plugins enhance task execution

Real-World Use Cases

• Financial reporting and expense tracking

• Automated code debugging and review

• Task and workflow management

• Business analytics from invoices and receipts

• Enterprise-grade AI automation

Why This Lecture Matters

Without plugins, AI is just a chatbot.
With plugins, AI becomes a powerful professional assistant capable of handling complex, real-world tasks.

Who This Lecture Is For

• Developers building AI-powered applications

• Professionals automating business workflows

• Finance, engineering, and operations teams

• Anyone looking to unlock advanced AI capabilities

In this lecture, you will learn how to activate and use Claude Co-Work Plugins effectively, and understand how Claude intelligently selects the right plugin and skills—even when not explicitly instructed.

You’ll explore a real-world use case where multiple invoices and receipts are analyzed to generate financial reports, variance analysis, and insights, showcasing the true power of plugin-based AI automation.

What You’ll Learn

• How Claude automatically selects plugins based on your task

• How to explicitly activate plugins for better control

• Difference between implicit vs explicit plugin usage

• How to analyze real-world data using the Finance plugin

• How to generate structured outputs like Excel reports and charts

Hands-On Demonstration

In this lecture, you will:

? 1. Analyze Financial Documents

• Process multiple invoices and receipts

• Extract structured financial data

• Perform variance and category analysis

? 2. Generate AI-Powered Reports

• Create Excel reports automatically

• Build financial summaries and insights

• Generate charts and visual analysis

⚙️ 3. Plugin Behavior Analysis

You will test two approaches:

? Without Plugin Activation

• Claude automatically selects relevant plugins

• Uses internal intelligence to choose:

  • Finance Plugin

  • Skills like variance analysis & financial statements

? With Explicit Plugin Activation

• Manually specify:

  
  

  /plugin finance → financial statement

• Ensures consistent and predictable results

• Gives full control over execution

Real-World Use Cases

• Expense and invoice analysis

• Financial reporting automation

• Business intelligence dashboards

• Budget tracking and variance analysis

• Enterprise data processing workflows

Why This Lecture Matters

This lecture highlights a critical concept:
? AI can think and choose tools automatically, but professionals should know when to guide it explicitly for optimal results.

Who This Lecture Is For

• Developers working with AI automation

• Finance professionals analyzing data

• Business analysts generating reports

• Anyone using Claude for real-world workflows

In this lecture, you will learn how to create and use Skills in Claude Co-Work—one of the most powerful ways to standardize, automate, and scale repetitive tasks using AI.

You’ll understand how skills act as predefined instruction sets (like SOPs) that Claude follows every time a specific task is executed.

What You’ll Learn

• What skills are and how they differ from plugins

• How to create a custom SKILL.md file

• How to define structured instructions for AI

• How Claude automatically detects and uses skills

• How to explicitly activate skills for better control

Understanding Skills (Simple Explanation)

? Skills = Reusable instruction templates for AI

Think of it like:

• Training a new employee once

• Writing down clear instructions

• Reusing them every time

Instead of repeating prompts, you create a skill once → reuse forever

Structure of a Skill (SKILL.md)

Every skill contains:

? 1. Header

• Name → Skill identifier

• Description → What the skill does

? 2. Instructions

• Step-by-step logic Claude must follow

• Defines how the task is executed

? 3. Output Format

• Structured response format

• Example:

  • Title

  • Summary

  • Sections (Completed, In Progress, Risks, etc.)

? 4. Rules

• Constraints and guidelines

• Example:

  • Keep report under 2 pages

  • Use professional tone

  • Handle missing data gracefully

? 5. Output File

• File naming convention

• Example:
  IT_Weekly_Report_<date>.docx

Hands-On Demonstration

In this lecture, you will:

? Create a Custom Skill

• Build an IT Weekly Report Generator

• Define structured instructions in SKILL.md

⚙️ Upload and Register the Skill

• Add skill to Claude Co-Work

• Enable/disable skill usage

? Execute the Skill

? Without Explicit Activation

• Claude automatically detects and uses the skill

? With Explicit Activation

/skill → IT Weekly Report

• Forces Claude to use the specific skill

Real-World Use Cases

• Weekly project status reports

• Automated documentation generation

• Business report templates

• DevOps and IT reporting workflows

• Standardized enterprise processes

Why This Lecture Matters

This lecture introduces one of the most important concepts in AI workflows:
? Turning prompts into reusable systems

Instead of asking AI again and again, you build a skill once and scale infinitely.

Who This Lecture Is For

• Developers building AI automation systems

• Professionals creating repeatable workflows

• Project managers generating reports

• Anyone looking to standardize AI outputs

In this lecture, you will learn how to customize Claude Co-Work Plugins to match your organization’s specific workflows, coding standards, and business requirements.

Instead of relying on generic plugin behavior, you will transform plugins into company-specific AI tools that follow your internal standards and processes.

What You’ll Learn

• Why default plugins may not match your company standards

• How to customize existing plugins with your own rules

• How to define organization-specific workflows

• How to enforce coding standards using AI

• How to test and validate customized plugin behavior

Core Concept Explained

? Default Plugin = Generic Industry Standard
? Custom Plugin = Your Company’s Standard

This lecture shows how to bridge that gap.

Hands-On Demonstration

⚙️ 1. Using Default Engineering Plugin

• Perform code review using built-in plugin

• Observe generic output based on standard practices

? 2. Customizing Plugin for Your Company

You will define custom rules such as:

• Minimum 85% test coverage

• Mandatory code review process (PR approval)

• Team-specific coding standards

• Tech stack-specific guidelines

? 3. Creating a Custom Plugin Version

• Generate a new plugin with modified instructions

• Retain original plugin for comparison

• Add company-specific logic inside skills

? 4. Testing the Custom Plugin

• Run the same code review task again

• Compare results:

  • Default Plugin → Generic feedback

  • Custom Plugin → Company-specific validation

Real-World Use Cases

• Enforcing coding standards in development teams

• Automated code reviews with company rules

• DevOps and deployment validation

• Enterprise-level workflow automation

• Compliance and governance automation

Why This Lecture Matters

This lecture introduces a powerful idea:
? AI should not just assist — it should adapt to your organization

Custom plugins turn Claude into a company-aligned AI assistant, not just a generic tool.

Who This Lecture Is For

• Software engineers and tech leads

• DevOps and QA teams

• Organizations implementing AI workflows

• Developers building enterprise AI solutions

In this lecture, you will learn how to create your own custom plugin in Claude Co-Work from scratch, enabling you to design AI tools tailored to your specific business needs.

You’ll go beyond using pre-built and customized plugins and build a fully functional plugin with multiple skills, transforming Claude into a domain-specific assistant for your workflows.

What You’ll Learn

• How to create a brand-new plugin using natural language prompts

• How Claude automatically generates plugin structure and skills

• How to define multiple skills within a plugin

• How to save, manage, and use your custom plugin

• How to apply your plugin to real-world tasks

Core Concept Explained

? Plugin = Collection of Skills
? Skills = Step-by-step instructions for tasks

In this lecture, you will build both together automatically using AI.

Hands-On Demonstration

?️ 1. Create a Custom Plugin

You will create a new plugin:

Plugin Name: IT Helpdesk
Purpose: Automate IT support workflows

⚙️ 2. Define Multiple Skills

The plugin includes 3 core skills:

• ? Ticket Triage

  • Categorize and prioritize support tickets

• ? IT Summary

  • Generate weekly IT reports

• ? Additional IT Operations Skill

  • Handle structured IT workflows

? 3. Auto-Generated Plugin Structure

Claude automatically creates:

• Plugin configuration

• Multiple SKILL.md files

• Structured instructions for each skill

• Ready-to-use workflow logic

? 4. Save and Activate Plugin

• Save the generated plugin

• Access it from the Customize → Plugins section

• Enable it for use in tasks

? 5. Use Your Plugin

Example use case:

/plugin → IT Helpdesk → Ticket Triage

• Analyze IT tickets

• Categorize and prioritize issues

• Automate support workflows

Real-World Use Cases

• IT helpdesk automation

• Customer support ticket management

• Internal workflow automation

• Business process automation

• Enterprise AI tool development

Why This Lecture Matters

This lecture demonstrates a major shift:
? From using AI tools → to building your own AI tools

You are no longer limited by existing plugins—you can create anything you need.

Who This Lecture Is For

• Developers building custom AI systems

• IT teams automating support workflows

• Business professionals creating AI tools

• Anyone looking to go beyond basic AI usage

In this lecture, you will learn how to use Claude AI directly inside Google Chrome using the Claude Chrome Extension, enabling you to automate real-world browser tasks with AI.

This powerful feature turns Claude into a browser automation agent that can interact with websites, fill forms, perform searches, and complete multi-step tasks—just like a human.

What You’ll Learn

• How to install and set up the Claude Chrome Extension

• How to connect your Claude account securely

• How Claude interacts with live web pages

• How to automate browser-based tasks using AI

• How to control AI actions (manual vs automatic execution)

Key Concept Explained

? Claude in Chrome = AI Agent + Browser Control

Instead of just answering questions, Claude can:

• Navigate websites

• Fill forms

• Click buttons

• Extract data

Hands-On Demonstration

? 1. Install Claude Chrome Extension

• Add extension from Chrome Web Store

• Authenticate with your Claude account

• Enable browser-side AI assistant

⚙️ 2. Understand How It Works

• Claude takes snapshots of the browser

• Uses them as context

• Executes actions step-by-step

✈️ 3. Real Use Case: Flight Booking Automation

You will see Claude:

• Navigate to flight search website

• Enter:

  • From: Mumbai

  • To: Bali

  • Travel dates

• Search for flights

• Extract:

  • Airline names

  • Prices

  • Travel time

? 4. Autonomous Task Execution

Claude performs:

• Multi-step navigation

• Error correction (fixing wrong selections)

• Data extraction

? All without manual input

Execution Modes

• ✅ Ask Before Acting (Safe mode)

• ⚡ Act Automatically (Full automation)

Important Notes

⚠️ This feature is in beta
⚠️ Avoid using on sensitive websites (banking, personal data)
⚠️ High token usage due to continuous screenshots

Real-World Use Cases

• Travel planning and booking

• Market research automation

• Form filling and data entry

• QA testing across websites

• Web scraping and analysis

Why This Lecture Matters

This lecture showcases the future of AI:
? From assistant → to autonomous digital agent

Claude is no longer just responding—it is acting on your behalf.

In this lecture, you will learn how to extend Claude Chrome Agent into a powerful multi-site web research system, enabling you to automate complex research workflows across multiple websites efficiently.

You’ll discover a structured strategy called Crawl → Walk → Run, designed to overcome context limitations, improve accuracy, and scale AI-powered browsing.

What You’ll Learn

• How to perform structured web research using Claude Chrome Agent

• How to overcome context window limitations in AI agents

• How to organize multi-site research using Chrome tab groups

• How to run parallel AI tasks across multiple websites

• How to extract structured data (tables, insights) from different sources

Core Problem Explained

When using AI for large-scale research:

❌ Context window gets overloaded
❌ Accuracy drops with too many instructions
❌ Errors break the entire workflow
❌ Different websites behave differently

? Solution: Break tasks into smaller, structured steps

The Strategy: Crawl → Walk → Run

? Crawl (Single Site Research)

• Focus on one website

• Perform one specific task

? Example:

• Search hotels in Kyoto on Booking.com

• Extract results in a structured table

? Walk (Multi-Site Research)

• Work across 2–3 websites

• Use Chrome Tab Groups

? Example:

• Kyoto tours (GetYourGuide)

• Tokyo tours (Viator)

? Run (Full-Scale Research)

• Combine multiple sources

• Perform large-scale research

? Example:

• Hotels + Tours + Products (Amazon + Agoda + Booking)

Hands-On Demonstration

? 1. Hotel Research (Crawl Phase)

• Website: Booking.com

• Task:

  • Search Kyoto hotels

  • Apply filters (dates, guests)

  • Output in markdown table

? 2. Tour Research (Walk Phase)

Using Chrome Tab Groups:

• GetYourGuide

  • Kyoto day tours

• Viator

  • Tokyo day tours

? Claude runs tasks across tabs

?️ 3. Product + Hotel Research (Run Phase)

• Agoda → Hotels in Tokyo

• Amazon → Travel backpacks

? Parallel research across multiple tabs

Real-World Use Cases

• Travel planning (hotels, tours, flights)

• Market research across platforms

• E-commerce product comparison

• Competitive analysis

• Multi-source data aggregation

Why This Lecture Matters

This lecture teaches you how to think like an AI workflow designer, not just a user.

? From single prompt usage → to multi-agent structured workflows

Who This Lecture Is For

• Developers working with AI agents

• Researchers and analysts

• Travel planners and consultants

• Anyone building scalable AI workflows

In this lecture, you will learn how to combine multi-site AI research into a single structured report using Claude Chrome Agent.

After performing parallel research across multiple websites, you’ll discover how to aggregate, organize, and synthesize data into a complete travel research report, while also understanding real-world limitations of AI agents.

What You’ll Learn

• How to combine results from multiple AI-powered browser tasks

• How to create a final structured research report

• How to handle incomplete or partial AI outputs

• How to manually assist AI when automation fails

• How to design end-to-end AI research workflows

Workflow Recap

In this lecture, you complete a full-scale AI research pipeline:

? Data Sources Used:

• Booking.com → Kyoto hotels

• Agoda → Tokyo hotels

• GetYourGuide → Kyoto tours

• Viator → Tokyo tours

• Amazon → Travel backpacks

Final Step: Data Compilation

? Master Prompt for Aggregation

You instruct Claude to:

• Combine all research

• Structure results into sections:

  • Accommodation comparison

  • Day tour comparison

  • Travel gear analysis

  • Budget summary

  • Final recommendations

Real Challenge Highlighted

⚠️ Claude could not fully access all previous tab data automatically

? This reveals a key limitation:

• AI agents may lose context across multiple tabs/sessions

• Not all extracted data is retained reliably

Solution Demonstrated

?️ Manual Data Injection

To solve this:

• Copy results from different tabs

• Paste them into a single prompt

• Ask Claude to compile everything

? Hybrid approach:
Automation + Manual Control = Best Results

Why This Lecture Matters

This lecture shows the real-world limitations and practical solutions when working with AI agents.

? You learn not just what works, but also what breaks—and how to fix it

Real-World Use Cases

• Travel planning and itinerary creation

• Market research report generation

• Product comparison analysis

• Multi-source data aggregation

• Business intelligence workflows

Who This Lecture Is For

• AI developers and automation enthusiasts

• Business analysts and researchers

• Travel planners and consultants

• Anyone building real-world AI workflows

In this lecture, you will learn how to perform intelligent data analysis and data cleaning directly inside Microsoft Excel using Claude AI.

You’ll discover how Claude can automatically detect data issues, suggest corrections, and even fix inconsistencies—transforming raw, messy datasets into clean, structured data with minimal effort.

What You’ll Learn

• How to install and set up Claude AI in Excel

• How to connect and authenticate your Claude account

• How to analyze large datasets using natural language

• How to detect data quality issues automatically

• How to clean and standardize data using AI

Hands-On Dataset Overview

You will work with a real-world dataset containing:

• Booking details (customers, hotels, dates, pricing)

• Agent commission data

• Destination metadata (country, season, currency, timezone)

Step-by-Step Learning

? 1. Analyze Raw Data with AI

You will ask Claude to:

• Scan the entire dataset

• Identify issues such as:

  • Duplicate records

  • Incorrect calculations

  • Missing values

  • Invalid date formats

  • Inconsistent capitalization

  • Data formatting errors

? 2. Intelligent Issue Detection

Claude automatically detects:

• Duplicate booking entries

• Incorrect total cost calculations

• Negative or invalid values

• Formatting inconsistencies

• Typographical errors

? All with exact cell references for easy fixing

? 3. Data Cleaning with AI Commands

You will use prompts to:

• Standardize names (Title Case)

• Fix capitalization issues

• Remove extra spaces

• Correct inconsistent labels

⚙️ 4. Automated Data Transformation

Claude performs:

• Bulk updates across columns

• Standardization of categories

• Structured corrections with permission control

? 5. Controlled Editing

• Claude asks for permission before modifying data

• You can:

  • Allow once

  • Allow always

  • Deny changes

? Ensures safe and controlled automation

Real-World Use Cases

• Data cleaning for analytics projects

• Financial data validation

• CRM and customer data standardization

• Travel and booking data processing

• Business reporting preparation

Why This Lecture Matters

This lecture demonstrates how AI is transforming Excel from a manual tool into an intelligent data assistant.

? From formulas and filters → to AI-driven automation

Who This Lecture Is For

• Data analysts and business professionals

• Excel users looking to automate workflows

• Developers working with data pipelines

• Anyone handling messy datasets

In this lecture, you will learn how to perform advanced data cleaning, validation, analysis, and dashboard creation in Excel using Claude AI.

Building on previous steps, you’ll go deeper into fixing numerical errors, standardizing dates, validating calculations, and generating automated reports and visual dashboards—all using natural language prompts.

What You’ll Learn

• How to fix numerical and calculation errors in Excel using AI

• How to standardize date formats across datasets

• How to validate formulas and correct incorrect values

• How to create automated summaries using Excel formulas

• How to build dashboards and charts using Claude AI

Step-by-Step Learning

? 1. Fix Numerical Data Issues

You will:

• Remove incorrect symbols (like $)

• Correct invalid values (e.g., negative nights)

• Fix inconsistent number formatting

? Example:

• Convert $890 → 890

• Fix incorrect calculations

? 2. Standardize Date Formats

You will instruct Claude to:

• Convert all dates into a consistent format
  ? DD MMM YYYY

• Handle incomplete dates intelligently

• Add comments where data is missing

? 3. Validate and Fix Calculations

Claude will:

• Verify formulas like:

  
  

  Total Cost = Nights × Price per Night

• Automatically correct incorrect values

• Highlight duplicate records

? 4. Intelligent Data Highlighting

• Duplicate rows are flagged visually

• Comments added for clarity

• Errors clearly marked

? 5. Generate Advanced Analysis

Claude creates a new Analysis Sheet with:

? Booking Summary:

• Total bookings

• Total revenue

• Average price

? Destination-Level Analysis:

• Bookings per destination

• Revenue breakdown

• Price insights

?‍? Agent-Level Analysis:

• Total bookings per agent

• Revenue contribution

• Commission insights

? 6. Build Dashboard & Charts

Claude automatically creates:

• ? Bar Chart → Revenue by destination

• ? Pie Chart → Distribution insights

• ? Additional visual comparisons

? Fully automated chart generation inside Excel

? 7. Customize Visualizations

• Modify chart colors

• Adjust formatting

• Enhance dashboard presentation

Real-World Use Cases

• Business reporting dashboards

• Financial data analysis

• Sales and booking analytics

• Data validation and auditing

• Executive summary generation

Why This Lecture Matters

This lecture shows how Excel evolves from a manual spreadsheet tool into a fully AI-powered analytics platform.

? From formulas & pivot tables → to AI-driven insights and dashboards

Who This Lecture Is For

• Data analysts and business professionals

• Excel users looking to automate workflows

• Developers working with analytics

• Anyone dealing with large datasets

In this lecture, you will learn how to create and customize professional PowerPoint presentations using Claude AI directly inside Microsoft PowerPoint.

You’ll discover how to transform raw business data into fully structured, visually appealing slides with charts, speaker notes, and formatting—completely automated using AI.

What You’ll Learn

• How to install and set up Claude AI in PowerPoint

• How to generate complete presentations using prompts

• How to convert raw data into structured slides

• How to customize slide content, design, and charts

• How to edit and enhance presentations using AI

Step-by-Step Learning

? 1. Install Claude in PowerPoint

• Add Claude via Office Add-ins

• Authenticate your account

• Open Claude sidebar inside PowerPoint

? 2. Set Presentation Style & Preferences

You will define:

• Slide design template

• Formatting rules (titles, bullets, colors)

• Presentation structure

? Example:

• Short bullet points

• Clean titles (≤ 6 words)

• Consistent theme

? 3. Generate Slides from Data

Using business data, Claude creates:

• ? 10-slide presentation

• Structured content per slide

• Speaker notes for each slide

• Tables and charts

? 4. Automated Chart Creation

Claude generates:

• Bar charts

• Pie charts

• Data tables

? Based on provided dataset

✏️ 5. Edit Slides Using Prompts

You can modify:

• Font styles (e.g., change to Verdana)

• Colors and themes

• Chart formatting (sorting, labeling)

• Slide-specific content

? 6. Advanced Chart Customization

You will:

• Sort charts (highest → lowest)

• Add data labels

• Highlight key values

• Improve readability

➕ 7. Add New Slides Dynamically

• Insert new slides using prompts

• Extend existing presentations

• Maintain consistent formatting

Real-World Use Cases

• Business presentations (QBR, reports)

• Client pitch decks

• Data storytelling and analytics reports

• Training and educational presentations

• Executive dashboards

Why This Lecture Matters

This lecture demonstrates how AI is transforming PowerPoint into a smart presentation builder.

? From manual slide design → to AI-generated professional decks

Who This Lecture Is For

• Business professionals and analysts

• Consultants and managers

• Students creating presentations

• Anyone looking to save time on PPT creation

In this lecture, you will learn how to connect an MCP (Model Context Protocol) server with Claude and use it to interact with external tools like Canva. Through a hands-on demonstration, you’ll see how Claude can directly create and modify designs using connected services.

What you’ll learn in this lecture:

• Understand what MCP (Model Context Protocol) is and why it matters

• Explore how Claude connects with external tools using MCP

• Connect a Canva account as an MCP server/connector

• Configure permissions (read, write, interactive actions) for connectors

• Create presentations directly from Claude chat using Canva

• Generate multi-slide presentations with simple prompts

• Customize and select design templates within Canva

• Open and edit generated designs directly on Canva

• Convert designs into different formats (Instagram, LinkedIn posts, etc.)

• Understand how Claude interacts with external services behind the scenes

• Learn how MCP acts as a bridge between AI models and external platforms

• Explore other available connectors (Google Drive, Zapier, Airtable, GitLab, etc.)

• Understand differences between web and desktop connector setups

• Handle common UI/connection issues during integration

By the end of this lecture, you will understand how to extend Claude’s capabilities beyond chat by integrating it with real-world tools using MCP, enabling powerful automation and productivity workflows.

In this lecture, you will learn how to configure and use MCP (Model Context Protocol) servers directly within the Claude desktop application. You will set up multiple MCP servers and test their functionality through real-world use cases like file access, GitHub automation, and web search.

What you’ll learn in this lecture:

• Understand how MCP servers work in the Claude desktop environment

• Set up prerequisites like Node.js, npm, and Claude Code

• Locate and modify the claude_desktop_config.json file

• Configure multiple MCP servers (File System, GitHub, DuckDuckGo)

• Define commands and parameters for each MCP server

• Set up file system access to specific local directories

• Generate and use GitHub Personal Access Tokens securely

• Integrate GitHub MCP server for repository operations

• Install and use tools like uvx for MCP server execution

• Restart and verify MCP server configuration in Claude Desktop

• Test File System MCP server (list and access local files)

• Test GitHub MCP server (fetch repositories, create issues)

• Understand permission handling and authentication flows

• Learn why MCP servers may not always trigger automatically

• Force MCP usage through prompt engineering techniques

• Test DuckDuckGo MCP server for real-time web search

• Understand practical limitations and behavior of MCP tools

By the end of this lecture, you will be able to configure and use multiple MCP servers locally, enabling Claude to interact with your file system, GitHub account, and external web data seamlessly.

In this lecture, you will learn how to configure MCP (Model Context Protocol) servers using the Claude CLI (Cloud Code). Building on previous desktop setup, this session focuses on setting up and managing MCP servers directly from the command line for more flexible and developer-friendly workflows.

What you’ll learn in this lecture:

• Understand the difference between MCP setup in Desktop vs CLI

• Verify Claude CLI (Cloud Code) installation and environment readiness

• Add MCP servers using CLI commands (claude mcp add)

• Configure File System MCP server with local directory access

• Use npx modules to run MCP server implementations

• Verify configured MCP servers using claude mcp list

• Add and configure DuckDuckGo MCP server for web search

• Set up GitHub MCP server with Personal Access Token

• Manage authentication requirements for different MCP servers

• View and manage all connected MCP servers via CLI

• Access MCP capabilities directly from Claude CLI chat

• Understand how CLI-based MCP enables automation workflows

• Learn how prompts trigger different MCP servers dynamically

By the end of this lecture, you will be able to configure and manage MCP servers entirely from the command line, enabling seamless integration of external tools like file systems, GitHub, and web search into your Claude CLI workflows.

In this lecture, you'll build your own custom MCP (Model Context Protocol) server from scratch using the FastMCP framework. Instead of relying on pre-built MCP servers, you'll learn how to create custom tools, expose functionality through MCP, test servers using the MCP Inspector, and interactively validate tool execution.

You'll also explore MCP resources and prompts, understand FastMCP development workflows, and learn how to inspect and debug MCP server implementations before integrating them with AI clients such as Claude Desktop.

What You'll Learn

• Understand the architecture of a custom MCP server

• Build an MCP server from scratch using FastMCP

• Generate MCP server code using Claude Code

• Create and register custom MCP tools

• Implement utility tools such as time retrieval and mathematical calculations

• Configure and run FastMCP servers locally

• Install and manage FastMCP dependencies

• Verify MCP server functionality using development mode

• Launch and use the MCP Inspector interface

• Explore MCP communication using Standard I/O transport

• Test custom tools directly from the MCP Inspector

• Execute and validate MCP tool calls interactively

• Understand MCP decorators for tools, resources, and prompts

• Create custom MCP resources for project configuration and documentation

• Build reusable MCP prompts for code review, debugging, and documentation tasks

• Monitor MCP server status and troubleshoot development issues

• Learn best practices for testing MCP servers before client integration

By the end of this lecture, you'll be able to create, test, inspect, and debug your own FastMCP-powered MCP servers, giving you complete control over the tools, prompts, and resources available to AI applications.

In this lecture, you'll learn how to connect a custom MCP (Model Context Protocol) server to Claude Desktop and enable Claude to access your own tools, resources, and prompts. You'll troubleshoot common MCP integration issues, configure server connections, and verify that Claude can successfully discover and invoke custom functionality.

Using a FastMCP-based server, you'll see how to expose tools, resources, and prompts to Claude, configure MCP servers within Claude Desktop, and validate end-to-end communication between your local server and the AI assistant.

What You'll Learn

• Debug and troubleshoot MCP server implementation issues

• Understand MCP tools, resources, and prompts architecture

• Test MCP servers locally using FastMCP

• Verify MCP server functionality before integration

• Explore MCP resources and prompt definitions

• Configure custom MCP servers inside Claude Desktop

• Edit and manage Claude Desktop MCP configuration files

• Register Python-based MCP servers in Claude Desktop

• Resolve common configuration issues such as path and slash formatting errors

• Monitor MCP server logs for debugging and troubleshooting

• Restart and validate MCP server connections

• Verify successful MCP server discovery within Claude Desktop

• Force Claude to invoke custom MCP tools when required

• Test custom MCP functions through natural language prompts

• Understand how Claude decides when to use MCP tools versus native capabilities

• Inspect available tools, resources, and prompts exposed by an MCP server

• Build a complete workflow connecting local MCP servers to Claude Desktop

By the end of this lecture, you'll be able to build, configure, debug, and integrate custom MCP servers with Claude Desktop, allowing Claude to access and utilize your own tools and workflows seamlessly.

In this lecture, you will set up your complete Claude AI development environment from scratch. We will start by creating your free Claude.ai account and then head over to the Anthropic Console to generate your very own API key — which you will use throughout this course for building Python-based AI projects.

Next, you will install Python and Visual Studio Code (VS Code) on your local machine. After that, we will download and set up the Claude Desktop application, which gives you access to Claude Chat, Claude Code, and Claude CoWork — all in one place.

Finally, you will install the Claude CLI (Command Line Interface) directly from your terminal, so you are ready to interact with Claude right from the command line.

By the end of this lecture, your entire workspace will be configured and ready to go — so you can fully focus on building, automating, and creating AI agents in the upcoming lectures.

What you will set up in this lecture:

• Claude.ai account creation and login

• API key generation from the Anthropic Console

• Python installation and verification

• Visual Studio Code (VS Code) installation

• Claude Desktop app (Chat, Code, CoWork)

• Claude CLI installation via terminal

In this lecture, you will make your very first API call to Claude using Python. We will start by creating a dedicated workspace folder and setting up a Python virtual environment to keep all your Anthropic-related libraries organized and isolated.

Next, you will create a .env file to securely store your Anthropic API key and a requirements.txt file to manage your project dependencies — including the Anthropic SDK and python-dotenv packages. You will install everything using pip right inside your virtual environment.

Once the setup is complete, you will write and execute a simple Python script that sends a prompt to the Claude Sonnet model using the Anthropic client library. You will see the response come back live — including the model name, token usage, SDK version, and API key verification — confirming that your environment is fully working.

By the end of this lecture, you will have a fully functional Python environment connected to the Claude API — ready for building more advanced projects in the upcoming sections.

What you will learn in this lecture:

• Creating a Python virtual environment for your Claude projects

• Storing your API key securely using a .env file

• Setting up requirements.txt with Anthropic and python-dotenv

• Writing your first Python script to call the Claude API

• Running and verifying a successful API response

• Troubleshooting common setup issues (API key, billing, credits)

In this lecture, you will learn how to make your first API call to Claude AI using Python, and understand how to interact programmatically with large language models.

This session marks the transition from theory to hands-on AI development, where you’ll start building real applications using the Claude API.

You’ll begin by setting up your environment:

• Configuring a Python virtual environment

• Managing dependencies using requirements.txt

• Securing your API key using a .env file

Once the setup is complete, you’ll create your first API request using the Anthropic Python SDK. You’ll learn how to:

• Initialize the Claude client

• Select different models (Haiku, Sonnet, Opus)

• Configure parameters like max_tokens

• Send prompts programmatically

But this lecture goes beyond just sending a request.

You’ll also explore the response structure in detail, including:

• Extracting generated text output

• Understanding message metadata (ID, role, model)

• Inspecting stop reasons and sequences

• Tracking token usage (input, output, total tokens)

By the end of this lecture, you’ll have a clear understanding of how to:

• Build Python scripts that interact with Claude

• Debug API issues (like incorrect model names)

• Analyze responses for deeper insights

This is a foundational step toward building AI-powered applications, automation tools, and intelligent workflows.

What You’ll Learn

• Setting up Python environment for Claude API

• Using .env for secure API key management

• Writing your first Claude API call in Python

• Understanding model selection (Haiku, Sonnet, Opus)

• Extracting and parsing API responses

• Tracking token usage and metadata

• Debugging common API errors

Who This Lecture Is For

• Python developers

• AI engineers and enthusiasts

• Beginners learning AI API integration

• Developers building AI-powered apps

• Anyone exploring Claude API

In this lecture, you will learn how to use the Claude Streaming API with Python to build real-time, interactive AI applications.

Moving beyond basic API calls, this session introduces streaming responses, where outputs are received chunk-by-chunk in real time instead of waiting for the complete response.

You’ll start by modifying your existing Claude API code to implement streaming using the Anthropic Python SDK. Instead of a single response object, you’ll:

• Use the stream() method

• Iterate over response chunks dynamically

• Display output in real-time using a streaming loop

This approach is essential for building chatbots, live assistants, and responsive AI interfaces.

You’ll also explore how streaming works under the hood by analyzing:

• Event types (message start, content block, delta, stop events)

• How responses are broken into chunks

• How to reconstruct the full response from streamed data

• Measuring response timing and performance

Additionally, you’ll implement logic to:

• Capture the final message output

• Track token usage and metadata

• Calculate elapsed time for streaming responses

To bring everything together, the lecture concludes with a CLI-based AI chat application, where you’ll:

• Interact with Claude in real time

• Send prompts and receive streamed responses instantly

• Simulate a ChatGPT-like experience directly in the terminal

What You’ll Learn

• Difference between standard API calls and streaming API

• How to implement streaming with Claude using Python

• Handling chunk-based responses in real time

• Understanding event-driven streaming architecture

• Extracting full responses from stream data

• Measuring performance and response time

• Building a CLI-based real-time AI chatbot

Why This Matters

Streaming APIs are critical for:

• Chat applications

• Real-time assistants

• Low-latency AI systems

• Better user experience in AI products

This lecture equips you with the skills to build production-ready, real-time AI applications.

Who This Lecture Is For

• Python developers building AI apps

• Developers working with Claude or LLM APIs

• Anyone interested in real-time AI systems

• Beginners transitioning from basic API calls to advanced usage

In this lecture, you will learn how to build multimodal AI applications using Claude, where you can send both text and images as input and receive intelligent responses.

This session takes your AI development skills to the next level by introducing image-based prompting using Python and the Claude API.

You’ll start by preparing your environment:

• Installing required libraries (requests, image handling dependencies)

• Downloading sample images programmatically

• Organizing image datasets for testing

Next, you’ll implement the core logic to work with images:

• Reading images from local storage

• Converting images into Base64 encoding

• Detecting image formats (JPEG, PNG, GIF, WebP)

• Preparing image data for API requests

Once the image is ready, you’ll integrate it with Claude by:

• Sending both image + text prompt in a single API request

• Asking contextual questions about the image

• Receiving detailed AI-generated descriptions

You’ll also explore how Claude processes multimodal inputs by analyzing:

• Input and output token usage

• Encoded image size and structure

• Response interpretation and accuracy

By the end of this lecture, you’ll be able to build applications where users can:

• Upload images

• Ask questions about visuals

• Generate intelligent descriptions and insights

What You’ll Learn

• How to use Claude for multimodal (image + text) AI tasks

• Converting images to Base64 for API compatibility

• Sending image-based prompts using Python

• Understanding media types and encoding

• Building AI systems that analyze images

• Tracking token usage in multimodal requests

Real-World Applications

• Image captioning tools

• Visual search systems

• AI-powered assistants for photos

• Content moderation and analysis

• Travel and landmark recognition apps

Who This Lecture Is For

• Python developers working with AI APIs

• Developers building multimodal AI apps

• Beginners exploring image-based AI

• Anyone interested in combining vision + language models

In this lecture, you will learn how to build powerful document processing pipelines using Claude AI and Python, enabling you to extract, analyze, and structure data from PDF and CSV files.

This session focuses on real-world automation use cases such as invoice processing, business analytics, and structured data extraction using LLMs.

You’ll begin by generating a sample PDF (travel invoice) and preparing a CSV dataset. Then, step-by-step, you’ll learn how to:

PDF Processing with Claude

• Convert PDF files into Base64 format

• Send documents as input to Claude API

• Ask intelligent questions about invoices

• Extract key details such as:

  • Customer name

  • Travel destination

  • Invoice amount

  • Payment status

CSV Data Analysis

• Load structured CSV data (travel bookings)

• Query business insights using natural language

• Generate summaries like:

  • Total bookings

  • Revenue from paid invoices

  • Outstanding unpaid amounts

Building an Invoice Processing Pipeline

You’ll take it further by creating an end-to-end AI pipeline that:

• Processes both PDF and CSV files

• Extracts structured data automatically

• Converts outputs into JSON format

• Saves extracted results into files for downstream use

You’ll also learn how to:

• Design system prompts for structured outputs

• Define JSON schemas for consistent extraction

• Handle token usage and optimize performance

What You’ll Learn

• Processing PDF documents using Claude API

• Extracting structured data from invoices

• Analyzing CSV files with natural language queries

• Building AI-powered data pipelines

• Converting unstructured data into JSON

• Combining multiple data sources (PDF + CSV)

• Automating business workflows with LLMs

Real-World Applications

• Invoice automation systems

• Financial data extraction tools

• Business intelligence dashboards

• Travel booking analytics

• Document digitization and processing

Who This Lecture Is For

• Python developers building AI automation tools

• Data engineers and analysts

• Developers working with documents (PDF/CSV)

• Anyone interested in LLM-powered data pipelines

In this lecture, you will learn how to generate structured outputs using Claude AI and understand the challenges of extracting reliable data from unstructured inputs like emails.

This session focuses on converting natural language emails into clean, structured JSON data, which is essential for building real-world AI applications such as CRMs, automation tools, and data pipelines.

You’ll start by working with sample travel inquiry emails and designing a custom prompt that instructs Claude to extract key information in a predefined JSON format.

What You’ll Implement

• Define a strict JSON schema for output

• Extract fields such as:

  • Full name

  • Email & phone number

  • Travel destination

  • Travel dates

  • Budget

  • Travel type & priority

• Build a Python function to:

  • Send prompts to Claude

  • Receive structured responses

  • Parse JSON output programmatically

Key Learning Focus

While Claude can generate valid JSON, you’ll discover real-world issues such as:

• Incorrect data types (string vs number)

• Wrong enum values (e.g., “high priority” vs “high”)

• Improper formatting (arrays vs strings)

• Inconsistent field values

These challenges highlight why structured output alone is not enough without validation.

What You’ll Learn

• Extracting structured JSON from unstructured text

• Designing prompts for consistent AI outputs

• Handling JSON parsing in Python

• Understanding limitations of LLM-generated structured data

• Identifying common data quality issues in AI responses

Why This Matters

Structured output is critical for:

• CRM automation systems

• Lead extraction from emails

• AI-powered data pipelines

• Business workflow automation

This lecture prepares you for building systems where AI outputs must be reliable, consistent, and machine-readable.

What’s Next

In the next lecture, you will learn how to solve these issues using schema validation (Pydantic) to enforce:

• Type safety

• Data consistency

• Reliable structured outputs

Who This Lecture Is For

• Python developers working with AI APIs

• Developers building automation or CRM tools

• Data engineers handling unstructured data

• Anyone interested in structured AI outputs

In this lecture, you will learn how to enforce strict structured output validation using Pydantic with Claude AI, ensuring that all AI-generated responses are reliable, consistent, and production-ready.

Building on the previous lecture, where you extracted JSON from emails, this session focuses on solving real-world issues like incorrect data types, inconsistent formats, and unreliable outputs.

You’ll integrate Pydantic models into your AI pipeline to define and enforce a strict schema for all responses generated by Claude.

What You’ll Implement

✅ Schema-Driven AI Output

• Define structured data models using Pydantic

• Automatically generate JSON schema from Python classes

• Pass schema as part of the prompt to guide Claude

✅ Validation & Type Safety

• Enforce correct data types (string, float, list, etc.)

• Restrict values using enums (e.g., priority, travel type)

• Ensure required fields are present

• Handle missing values using null

✅ Custom Validators

• Validate email format

• Ensure numeric fields are correct

• Apply business logic (e.g., minimum number of travelers)

• Guarantee consistent output across multiple inputs

Key Learning Outcome

Unlike basic structured output, this approach ensures:

• Guaranteed schema compliance

• No incorrect data types

• Consistent and clean JSON output

• Production-ready AI pipelines

You’ll also learn how to:

• Compare raw AI output vs validated output

• Debug inconsistencies in AI responses

• Build robust data extraction systems

What You’ll Learn

• Using Pydantic with AI APIs

• Generating JSON schema dynamically

• Validating LLM outputs programmatically

• Enforcing enum constraints and field rules

• Building reliable AI-driven data pipelines

Real-World Applications

• AI-powered CRM systems

• Email lead extraction automation

• Data validation pipelines

• AI-based form processing

• Enterprise-grade AI workflows

Who This Lecture Is For

• Python developers building AI applications

• Data engineers working with LLM outputs

• Developers needing reliable structured data

• Anyone building production-ready AI systems

In this lecture, you will learn how to optimize cost and performance when using Claude AI models by selecting the right model for the right task.

Choosing between models like Haiku, Sonnet, and Opus can significantly impact your API cost, response time, and output quality—and this lecture shows you exactly how to make that decision intelligently.

What You’ll Learn

✅ Understanding Claude Model Differences

• Haiku (4.5): Fastest and most cost-effective

• Sonnet (4.6): Balanced performance and cost

• Opus (4.6): Most powerful for complex reasoning

✅ Token-Based Pricing Explained

• Input vs Output token costs

• Cost per million tokens

• Why newer models are more cost-efficient

✅ Hands-On Cost Comparison

You’ll build a Python script to:

• Send the same prompt to all three models

• Measure:

  • Input tokens

  • Output tokens

  • Response time

• Calculate actual cost per API call

Key Insights You’ll Discover

• How much each model costs for the same task

• Why Opus is slower but more powerful

• Why Haiku is ideal for lightweight tasks

• When Sonnet is the best practical choice

You’ll also generate a comparison table showing:

• Token usage

• Execution time

• Cost per request

Best Practices for Model Selection

• Use Haiku for:

  • Simple queries

  • Classification tasks

  • High-volume applications

• Use Sonnet for:

  • Writing

  • Coding

  • General AI tasks

• Use Opus for:

  • Deep reasoning

  • Complex analysis

  • High-accuracy requirements

Real-World Applications

• Cost-optimized AI SaaS products

• Scalable AI APIs

• Budget-aware AI automation systems

• Production-grade AI pipelines

Who This Lecture Is For

• Developers building AI applications at scale

• Engineers optimizing API costs

• Startups working with limited AI budgets

• Anyone using Claude API in production

In this lecture, you will learn how to implement token management and cost estimation using Claude AI, enabling you to optimize your AI applications before even making an API call.

Token usage directly impacts your API cost and performance, and this session shows you how to predict, control, and optimize token consumption effectively.

What You’ll Learn

✅ Understanding Tokens

• What tokens are and how they are calculated

• Difference between input tokens vs output tokens

• Approximate token-to-text relationship

✅ Pre-Call Token Estimation (FREE API)

• Use count_tokens API to estimate token usage

• Calculate input tokens before sending a request

• Compare short vs long prompts

✅ Impact of System Prompts

• How system prompts increase token usage

• Measuring additional tokens added by instructions

• Optimizing prompt design for cost efficiency

Hands-On Implementation

You’ll build a Python script to:

• Estimate token usage for different prompts

• Compare token counts with and without system prompts

• Predict output token usage

• Calculate estimated cost before API call

Cost Estimation & Optimization

You’ll learn how to:

• Calculate cost using token pricing (input + output)

• Compare estimated vs actual API cost

• Understand why estimates closely match real usage

• Build a monthly cost calculator

Example insights:

• Cost per request using different models

• Monthly cost for high-scale apps (e.g., 500 requests/day)

• Why cheaper models can be more efficient

Key Takeaways

• Always estimate tokens before sending requests

• System prompts significantly increase cost

• Optimize prompts to reduce unnecessary tokens

• Choose the cheapest model that meets your needs

• Plan your monthly AI budget in advance

Real-World Applications

• AI SaaS cost optimization

• Chatbot budget planning

• Enterprise AI usage forecasting

• Scalable AI system design

Who This Lecture Is For

• Developers building AI applications at scale

• Engineers optimizing API costs

• Startups managing AI budgets

• Anyone using Claude API in production

In this lecture, you will learn how to implement prompt caching with Claude AI to significantly reduce API costs and improve response performance.

Prompt caching is a powerful optimization technique that allows you to reuse previously processed prompts, avoiding redundant computation and saving both time and money.

What You’ll Learn

✅ What is Prompt Caching?

• How Claude stores and reuses responses

• Difference between:

  • Cache Write (first request)

  • Cache Read (subsequent requests)

✅ Cost Optimization with Caching

• First request: ~1.25x cost (cache write)

• Subsequent requests: ~90% cheaper (cache read)

• Optional 1-hour cache with higher initial cost

Hands-On Implementation

You’ll build a Python application that:

• Loads a large knowledge base file

• Sends multiple related queries to Claude

• Uses caching to avoid repeated processing

• Measures:

  • Token usage

  • Response time

  • Cost savings

Key Insights You’ll Discover

• How caching reduces repeated computation

• Why static prompts should be cached

• How to structure prompts for maximum efficiency

• Real cost comparison:

  • With caching vs without caching

• Savings at scale (e.g., thousands of API calls)

Performance & Cost Comparison

You’ll analyze:

• Token usage for cache write vs cache read

• Time improvement in repeated queries

• Real-world cost savings (up to ~90% per repeated request)

Best Practices for Prompt Caching

• Cache large, static content (e.g., documents, knowledge base)

• Keep dynamic queries separate from cached content

• Use caching for repeated workflows

• Understand cache duration (5 minutes or 1 hour options)

• Optimize for minimum token threshold

Real-World Applications

• AI chatbots with memory

• Knowledge base assistants

• Document-based Q&A systems

• Enterprise AI tools with repeated queries

Who This Lecture Is For

• Developers building scalable AI applications

• Engineers optimizing API performance and cost

• Startups working with high-volume AI usage

• Anyone using Claude API in production

In this lecture, you will learn how to implement Batch API Requests using Claude (Anthropic) API to process multiple tasks efficiently while significantly reducing API costs.

Instead of sending requests one by one, you’ll discover how to bundle multiple prompts into a single batch request, improving scalability and optimizing performance for real-world AI applications.

What You’ll Learn

✅ Sequential vs Batch Processing

• Traditional one-by-one API calls (sequential approach)

• Sending multiple requests together using Batch API

• Key differences in:

  • Execution time

  • Cost

  • Efficiency

Hands-On Implementation

You’ll build a Python-based system that:

• Processes multiple support tickets

• Classifies each ticket using Claude AI

• Returns structured JSON output:

  • Category (flight, hotel, refund, etc.)

  • Priority (low, medium, high, urgent)

  • Summary

Batch API Workflow

You’ll learn how to:

• Create structured request objects

• Send multiple prompts in a single API call

• Use polling to retrieve results

• Handle batch responses efficiently

Performance & Cost Comparison

? Sequential Processing:

• Multiple API calls (one per request)

• Faster response per request

• Higher total cost

? Batch Processing:

• Single API call for multiple requests

• Slight delay due to processing & polling

• Up to ~50% cost savings

Key Insights

• Batch API reduces cost significantly at scale

• Ideal for bulk processing tasks

• Same output quality as sequential approach

• Trade-off: latency vs cost efficiency

Real-World Applications

• Customer support ticket classification

• Bulk data processing pipelines

• AI-powered analytics systems

• Large-scale automation workflows

Best Practices

• Use batch API for non-real-time tasks

• Combine similar requests for efficiency

• Monitor token usage and cost

• Use polling strategy effectively

Who This Lecture Is For

• Developers building scalable AI systems

• Engineers optimizing API cost at scale

• Startups handling bulk AI workloads

• Anyone working with Claude API

In this lecture, you will learn how to use Extended Thinking in Claude AI to solve complex, multi-step problems with improved accuracy and reasoning depth.

Extended Thinking allows the model to spend more time reasoning, making it ideal for tasks that require logical analysis, step-by-step calculations, and deeper insights.

What You’ll Learn

✅ What is Extended Thinking?

• How Claude performs deeper reasoning before answering

• Difference between:

  • Standard response mode

  • Extended thinking mode

✅ How to Enable Extended Thinking

• Using the thinking parameter in Python SDK

• Setting thinking type and token budget

• Controlling how much the model “thinks” before responding

Hands-On Implementation

You’ll build a Python program that:

• Solves a multi-country travel cost problem

• Compares:

  • Standard mode vs Extended Thinking

• Measures:

  • Input tokens

  • Output tokens

  • Response time

  • Cost

Key Insights & Comparison

? Standard Mode:

• Faster response

• Lower token usage

• Lower cost

• Limited reasoning depth

? Extended Thinking Mode:

• More detailed, step-by-step reasoning

• Higher token usage

• Longer response time

• Increased cost

Thinking Budget Optimization

You’ll explore how to:

• Define thinking budgets (small, medium, large)

• Control token usage for reasoning

• Balance:

  • Accuracy vs Cost

  • Speed vs Depth

Real Observations

• Extended thinking can double or triple token usage

• Execution time increases significantly

• Cost increases proportionally

• Output quality improves for complex problems

When to Use Extended Thinking

• Complex mathematical problems

• Multi-step logical reasoning

• Business analysis with multiple variables

• Decision-making systems requiring justification

Best Practices

• Use extended thinking only for complex tasks

• Set appropriate token budgets

• Monitor cost vs performance trade-offs

• Avoid overusing for simple queries

Real-World Applications

• Financial and cost analysis systems

• AI-powered decision engines

• Advanced analytics workflows

• Intelligent planning systems

Who This Lecture Is For

• Developers building advanced AI systems

• Engineers working on reasoning-heavy applications

• AI practitioners optimizing model performance

• Anyone using Claude for complex problem-solving

In this lecture, you will learn how to effectively use the chat feature in Claude AI by mastering three essential prompting techniques: Zero-Shot Prompting, Few-Shot Prompting, and Chain-of-Thought Prompting.

We begin with a practical, real-world scenario where you act as a travel consultant and use AI to classify customer queries, estimate budgets, and recommend destinations. Through this hands-on example, you will clearly understand how different prompting strategies impact the quality, structure, and reliability of AI responses.

First, we explore Zero-Shot Prompting, where no examples are provided and the AI generates responses based solely on instructions. You’ll observe how outputs can vary in format and consistency.

Next, we move to Few-Shot Prompting, where you provide sample inputs and outputs. This ensures that the AI follows a structured and predictable response format, making it highly useful for real-world applications.

Finally, we dive into Chain-of-Thought Prompting, where you guide the AI step-by-step in its reasoning process. This technique allows you to:

• Improve accuracy

• Control how the model thinks

• Generate more logical and detailed outputs

By comparing all three approaches side by side, you’ll gain a clear understanding of when and why to use each prompting technique to get the best results from AI models like Claude.

What You’ll Learn

• Introduction to Claude AI chat interface

• What is Zero-Shot Prompting and when to use it

• How Few-Shot Prompting improves output consistency

• Chain-of-Thought Prompting for step-by-step reasoning

• Controlling AI output format and logic

• Real-world example using travel planning use case

• Comparing prompting techniques for better results

• Best practices for writing effective AI prompts

Who This Lecture Is For

• Beginners learning AI prompting techniques

• Developers working with LLMs like Claude, GPT, or Gemini

• AI enthusiasts exploring prompt engineering

• Professionals using AI for automation and decision-making

• Students preparing for AI or Generative AI certifications

In this lecture, you will learn how to use System Prompts in Claude AI to control the behavior, personality, and response style of your AI assistant.

Instead of relying on default, generic responses, you’ll discover how to program Claude like a custom AI agent by defining clear instructions, communication rules, and boundaries.

We begin by understanding the difference between:

• Without system prompts → Generic, unpredictable responses

• With system prompts → Structured, role-based, and consistent outputs

Using a practical example, you will build a custom AI assistant called a Python Support Agent (PyBot) inside a Claude project. You’ll define:

• AI identity and role

• Communication style and tone

• Response format and structure

• Behavioral rules and limitations

Through hands-on demonstrations, you’ll see how system prompts influence:

• Friendly and structured responses

• Error explanations and debugging support

• Handling frustrated users with empathy

• Rejecting off-topic or unethical requests

• Maintaining strict role boundaries

You’ll also explore how Claude enforces system instructions even when users try to override them—ensuring your AI assistant remains consistent, safe, and aligned with its purpose.

By the end of this lecture, you’ll be able to design your own custom AI personas for real-world use cases such as support agents, tutors, assistants, and automation tools.

What You’ll Learn

• What are system prompts in Claude AI

• Difference between normal prompts and system instructions

• How to create AI personas with defined roles and behavior

• Designing communication style, tone, and boundaries

• Using Claude Projects to apply persistent system prompts

• Handling edge cases: frustration, off-topic, and unethical queries

• Ensuring consistency and control in AI responses

• Best practices for prompt engineering with system instructions

Who This Lecture Is For

• Beginners learning prompt engineering

• Developers building AI assistants or chatbots

• AI enthusiasts exploring Claude AI capabilities

• Educators creating AI tutors or support systems

• Professionals automating workflows with AI

In this lecture, you will explore advanced prompt engineering techniques using XML tags, delimiters, and structured input/output formats to gain better control over AI responses.

Instead of writing simple, unstructured prompts, you’ll learn how to design highly structured prompts that guide the model more precisely—resulting in consistent, predictable, and production-ready outputs.

We begin by comparing unstructured prompts vs structured prompts, showing how adding XML-style tags (like <role>, <customer_message>, and <instruction>) helps the model clearly understand:

• Who it is

• What the input is

• What the expected output should be

Next, you’ll learn how to use delimiters to separate multiple inputs (such as customer reviews or messages), making it easier for the AI to process each item independently and generate organized responses.

We then move into one of the most powerful concepts: controlling output formats directly from the prompt. You’ll see how to:

• Generate structured JSON outputs for programmatic use

• Create Markdown-formatted responses for readability

• Design detailed, multi-step outputs like travel itineraries

Through real-world examples (travel planning, customer reviews, and data extraction), you’ll understand how structured prompting improves:

• Accuracy

• Clarity

• Automation readiness

• Integration with code and APIs

By the end of this lecture, you’ll be able to design prompts that not only guide the AI’s thinking but also ensure the output is in the exact format required for real-world applications and automation workflows.

What You’ll Learn

• What are XML tags in prompt engineering

• Difference between structured and unstructured prompts

• Using delimiters to organize multiple inputs

• Designing prompts with clear roles, instructions, and data

• Controlling AI output format (JSON, Markdown, structured text)

• Extracting structured data from natural language inputs

• Creating automation-ready AI responses

• Best practices for advanced prompt design

Who This Lecture Is For

• Developers integrating AI into applications

• AI/ML engineers working with LLMs

• Data engineers and automation professionals

• Prompt engineering learners

• Anyone looking to generate structured AI outputs

In this lecture, you will learn one of the most powerful prompt engineering techniques for complex tasks: Prompt Chaining.

Instead of trying to solve everything in a single, overloaded prompt, you’ll discover how to break down large problems into manageable, step-by-step prompts—leading to more accurate, structured, and high-quality outputs.

We begin by analyzing a common mistake: asking AI to build a complete production-level application in one prompt. You’ll see why this approach often leads to incomplete, shallow, or inconsistent results.

To solve this, we introduce Prompt Chaining, where a complex task is divided into multiple stages:

1. Research Phase – Define requirements, constraints, architecture, and risks

2. Validation Phase – Review and refine the plan using a checklist

3. Implementation Phase – Generate code based on a well-defined plan

Using a real-world example of building a Python CLI Personal Expense Tracker, you’ll learn how to:

• Guide the AI to perform structured technical research

• Design architecture and data models before coding

• Validate outputs like a tech lead reviewing a project

• Iteratively refine results for better accuracy

This approach ensures better control, higher reliability, and production-ready outputs, making it essential for developers and AI practitioners working on complex workflows.

By the end of this lecture, you’ll understand how to think like an architect when prompting AI, rather than just asking for instant answers.

What You’ll Learn

• What is Prompt Chaining in AI

• Why single large prompts fail for complex tasks

• Breaking problems into multi-step workflows

• Designing research-first prompts

• Validating AI outputs using structured checklists

• Building scalable and maintainable AI-driven solutions

• Applying prompt chaining for coding and development tasks

• Best practices for complex prompt engineering

Who This Lecture Is For

• Developers building applications with AI

• AI/ML engineers working with LLM workflows

• Prompt engineering learners

• Software architects and technical leads

• Anyone solving complex problems using AI

In this lecture, we continue our journey into Prompt Chaining by moving from research to actual implementation and validation of code using AI.

Building on the previous lecture, you’ll learn how to transform a well-structured research plan into a fully functional Python application using step-by-step prompting techniques.

Instead of generating code blindly, you’ll see how to:

• Use validated research outputs as input for code generation

• Provide clear coding requirements and constraints

• Ensure the AI produces complete, production-ready code without placeholders

Using a real-world example of a Python CLI Expense Tracker, this lecture demonstrates how to:

1. Generate a complete working Python file from structured research

2. Apply strict instructions like type hints, docstrings, and error handling

3. Maintain architectural consistency with earlier planning

But the learning doesn’t stop at code generation.

You’ll also explore a critical step often missed by beginners: Code Validation using AI.
By applying a completeness checklist, you’ll learn how to:

• Verify if all required features are implemented

• Identify missing or partially implemented functionality

• Automatically refine and improve the generated code

This lecture highlights how prompt chaining evolves into a full development workflow—from planning → implementation → validation—making AI a powerful partner in real-world software development.

What You’ll Learn

• Converting research outputs into working code

• Writing structured prompts for full code generation

• Enforcing coding standards (docstrings, type hints, error handling)

• Generating production-ready Python applications with AI

• Validating AI-generated code using checklists

• Identifying gaps and refining outputs automatically

• Building a complete AI-driven development workflow