This module focuses on the practical Python skills analysts use every day: understanding and being able to read code generated by AI, making simple modifications, working with notebooks, automating repetitive tasks, and communicating effectively with technical teams.

Participants will learn how Python code is structured, how to work with common data structures, understand simple logic and functions, use Jupyter Notebooks, and troubleshoot common issues using AI. Includes full exercise sets and worked solutions.

This part covers how to steer an agent effectively, and then introduces Git and GitHub as the safety net that makes AI-assisted work reversible. When an agent edits your files, version control stops being a nice-to-have.

Building Your First AI-Assisted Project

• Installing Claude Code and authenticating
• Running Claude Code in the terminal and in VS Code
• First interaction: exploring a project, asking questions about files

Git Fundamentals

• What is version control and why it matters for data work
• Core concepts: repositories, commits, branches, and the staging area
• Essential commands: init, add, commit, status, log, diff

GitHub & Collaboration

• Creating and managing repositories on GitHub
• Branching, merging, and resolving merge conflicts
• Pull Requests: proposing, reviewing, and merging changes
• Git as a safety net: checkpoints, rollback, and diff reviews

This part covers how to give Claude durable project memory, structure what enters the context window, manage permissions deliberately, and control how it plans before it acts.

CLAUDE.md – Project Memory

• What CLAUDE.md is and why it dramatically improves output quality
• What to write and what not to – the rule: if Claude already does it right, delete it
• Three levels: project shared, project local, user global
• Writing an effective CLAUDE.md for a data analysis project
• Defining coding conventions, preferred libraries, and project structure

CLAUDE.md as Strategy

• Rules files (.claude/rules/*.md) with lazy loading for large projects
• Anti-patterns: CLAUDE.md too long, contradicting instructions, unnecessary repetition

Permissions & Control

• Permission Modes: Ask Before Edits, Auto Accept, Bypass, Plan
• Overriding permissions with settings.json at three levels (local, project, global)
• The .claude directory: configuration files, permissions, and structure
• Choosing permissions deliberately when the agent can reach real data

Planning, Thinking & Context Management

• Plan Mode: pre-execution planning for complex tasks
• Advanced planning strategies that don't require Plan Mode
• Extended Thinking: effort levels and adaptive thinking
• Difference between planning and thinking – and when to use each
• Cost implications of context size and strategies to keep it lean

This part covers the two open standards that turn repeated work into reusable capability, and connect an agent to the systems where your data actually lives. 

Skills

• What are Skills and how they differ from CLAUDE.md (on-demand vs always-on)
• Creating, running, and iterating on Skills
• Frontmatter: name, description, allowed-tools, disable-model-invocation
• Arguments: passing parameters to skills for flexible workflows
• Advanced skills: reference files, templates, scripts, and multi-file skill structure
• Agent Skills as an open standard: portability across tools that support the spec

MCP Servers – Connecting to External Tools

• What is the Model Context Protocol (MCP) 
• Local vs remote MCP servers and security considerations
• Adding servers: claude mcp add, scope configuration, environment variables
• Anthropic Connectors: one-click connection to Gmail, Google Drive, Slack, and more
• Querying a database directly through Claude Code

A single general-purpose agent is no longer the default design. Production teams now run several specialized agents that divide the work, and the orchestration pattern chosen has a direct effect on both quality and cost. This part covers how to decompose analytical work across agents, and how model selection per step becomes a cost decision.

Understanding Cost Management

• Understanding token usage: what consumes context and what doesn't
• Budget and turn limits as circuit breakers
• Token-based cost breakouts and the /cost command
• Reducing cost strategies

Subagents: Protecting the Main Context

• What subagents are and why they protect the main agent's context window
• Built-in subagents and when each one earns its place
• Creating custom subagents with restricted tools, specific models, and their own instructions
• When a subagent is the wrong answer

Orchestration Patterns

• Orchestrator and workers: a capable model plans, cheaper models execute
• Sequential pipelines: each stage consumes the previous stage's output
• Parallel fan-out: independent subtasks running concurrently, then aggregated
• Choosing a pattern: what the task's dependency structure tells you

Multi-Agent Workflows for Data Work

• Decomposing an analysis across specialized agents
• A review pattern: one agent produces, another independently verifies
• Cost control through model selection per step
• Where multi-agent adds real value, and where it just adds complexity and spend

An agent connected to real data raises two questions that no feature tutorial answers: what should it do when it is not sure, and what should it never be able to do at all. This part builds both answers, drawing on architectural patterns used in production data agents.

Confidence Gates: Teaching an Agent to Say "I Don't Know"

• Scoring answer confidence and setting a calibrated threshold
• Routing low-confidence questions to a human instead of guessing
• Stricter thresholds for sensitive domains such as finance and management reporting

Security by Design: Prompt Injection & Layered Defense

• Prompt injection: the top-ranked vulnerability for LLM applications, and why an agent with database access raises the stakes
• Layered defense: screening the question, restricting the data, screening the answer
• Handling PII and sensitive fields by role
• Designing for multiple points of failure before anything reaches the user

Hooks – Deterministic Control

• What Hooks are and why they differ from CLAUDE.md (guaranteed execution vs advisory)
• Hook events: PreToolUse, PostToolUse, UserPromptSubmit, Stop
• Safety gate: blocking destructive SQL and dangerous commands before they run
• Proving a guard works: testing the forbidden action instead of assuming

The semantic layer stopped being a BI accessory. Once an agent answers business questions directly, it needs governed metric definitions rather than raw tables, and this has made the semantic layer a prerequisite for analytical agents rather than an optional refinement.

This part covers both halves: teaching AI what your data means, and then proving it worked. Measuring answer quality against a known answer key is now a production requirement, not a nice-to-have.

The Semantic Layer: Teaching AI Your Data Domain

• Building context files that explain what your data means
• Grain, join keys, metric definitions, status vocabulary, and the gotchas that break queries
• Mapping tribal knowledge: what a field does, what breaks, what is buried in comments

Text-to-SQL & Database Integration

• Text-to-SQL: translating natural language questions into validated SQL queries
• MCP for databases: direct connection to PostgreSQL/BigQuery/Snowflake via MCP

AI Evals: Measuring Agent Accuracy

• Evals vs observability: structured tests before release, quality signals from live traffic
• Why "it looked right" is not a quality standard
• Building an evaluation set: questions, a golden answer key, and a grader
• Running the eval and reading the scorecard
• Diagnosing failures: which rule was missing from the layer
• Consistency testing

Semantic Layer Drift Detection

• Why a semantic layer silently goes stale as the database changes
• A scheduled job that compares the layer against the real tables
• Reporting what broke, what changed, and which columns are new
• Connecting three capabilities: semantic layer, headless, and scheduling

A semantic layer explains what the data means. It does not hold what the team learned, and it does not stretch to a knowledge base too large to load. This part covers the two layers that take over: an organizational memory that outlives any single session, and retrieval. Both answer the same question – how an agent reaches knowledge it cannot hold in context.

Building a Team Second Brain

• Tribal knowledge: the conditional, historically contingent rules that have no column, no metric definition, and no schema to live in
• The token ceiling, context rot, and the access model you inherit by accident
• Hooks that capture learnings 
• From manual rules to an evolving organizational memory

RAG & Vector Databases

• Embeddings and semantic search: how a machine finds "related" rather than "matching", and why the two terms are not the same thing
• Chunking strategy: why a chunk covering two topics retrieves worse than one covering a single topic
• The 2026 baseline: hybrid search (semantic plus keyword) and context-aware chunking
• Agentic retrieval: search as a tool the agent calls in a loop, not a fixed preprocessing step
• Vector databases in practice, and connecting one to Claude Code through MCP
• Choosing between three options: context file, semantic layer, or retrieval

This part gives participants enough Pandas fluency to supervise Claude Code rather than trust it. This module also teaches how to use Claude API calls from Python

Pandas for Analysts

• Data types, DataFrame, reading files (CSV, Excel, JSON)
• Selecting columns, filtering, sorting, retrieving distinct values
• Aggregation and groupby() for targeted analysis
• JOIN operations: inner, outer left, outer right, full
• Pivot and melt for data reshaping
• Handling missing values (NaNs) and data type conversions

Data Visualization

• Introduction to Matplotlib and Seaborn
• Chart types: line, bar, scatter, pie, histogram, boxplot
• Customizations: titles, labels, legends, subplots, color maps, annotations

Shipping the Result: Data Apps with Streamlit

• From a script only you can run to an app your manager can open
• Building a Streamlit app with Claude Code: turning an analysis into an interface
• Wiring the app to live data: the semantic layer and the agent behind a UI
• Practical delivery: what to expose, what to keep read-only, what never to surface

Claude as a Function: Calling the API from Python

• Calling Claude from Python: wrapping a model call in an ordinary function
• Turning model output into a DataFrame column, so it becomes data you can filter, group, chart and save
• Tool calling and structured outputs: getting back a shape you can rely on instead of prose you have to parse
• Subscription vs API billing: two separate things, and what each one actually charges for

Reading & Reviewing AI-Generated Code

• Claude Code + Pandas in action: Claude writes the analysis, you supervise and steer