01-foundation-setup.md

Section 1: Foundation & Setup (10 min)

---

Slide: What is Claude Code?

Key Points:

• Anthropic's official CLI tool for Claude
• AI pair programmer that lives in your terminal
• Can read, write, and execute code in your environment

Talking Points:

• Unlike the web interface, Claude Code has direct access to your filesystem, git, terminal
• It's agentic - can take multi-step actions, run commands, iterate on errors
• Think of it as having a senior developer sitting next to you

Visual: Terminal screenshot showing Claude Code in action

---

Slide: Why CLI Over Web?

Key Points:

• Direct filesystem access - reads/writes files in place
• Git integration - commits, branches, PRs
• Tool execution - runs tests, builds, linters
• Persistent context - continues conversations across sessions

Talking Points:

• Web interface: copy-paste back and forth
• CLI: "Fix the failing tests" → it reads the errors, edits files, runs again
• The difference is night and day for real coding work

Visual: Split comparison - Web (copy/paste) vs CLI (direct action)

---

Slide: Configuration Architecture

Key Points:

~/.claude/
├── CLAUDE.md          # Your global preferences
├── settings.json      # Permissions, MCP servers
└── .env               # Credentials (NEVER commit)

<project>/.claude/
├── CLAUDE.md          # Project-specific instructions
└── settings.json      # Project settings

Talking Points:

• Two levels: global (all projects) vs project-specific
• CLAUDE.md = natural language instructions Claude follows
• settings.json = technical config (MCP servers, permissions)
• .env = secrets (API keys, tokens) - keep out of git!

Visual: Diagram showing config file hierarchy with arrows

---

Slide: Config File Priority

Key Points:

• Project CLAUDE.md > User CLAUDE.md > Defaults
• Project settings can override global settings
• Both are read - project adds specificity

Talking Points:

• Global: "I use Conventional Commits, I like pytest"
• Project: "This repo uses Airflow, DAGs need these tags"
• Claude reads both and combines them

Visual: Layered diagram showing override priority

---

Slide: The Credentials File

Key Points:

• Location: ~/.claude/.env
• Never committed to git
• Loaded by Claude for API access

Talking Points:

• Store API keys, tokens, passwords here
• Reference in CLAUDE.md: "Load credentials from ~/.claude/.env"
• Works with python-dotenv or similar libraries
• Keep it simple: JIRA_TOKEN=xxx, SLACK_TOKEN=yyy

Visual: Example .env file (with redacted values)

---

Slide: Session Management

Key Points:

Command	Description
claude	Start fresh session
claude -c	Continue last session
claude --resume	Pick from recent sessions

Talking Points:

• Fresh session: clean slate, no prior context
• Continue: picks up exactly where you left off
• Resume: shows list of recent sessions to choose from
• Pro tip: Most of my work uses -c to continue

Visual: Terminal showing --resume session picker

---

Slide: Shell Aliases (Pro Tip)

Key Points:

# Add to ~/.zshrc or ~/.bashrc
alias cc="claude -c"
alias cr="claude --resume"
alias cs="claude --model sonnet"

Talking Points:

• cc is my most-used alias - quickly continue where I left off
• cs for quick tasks where you want speed over depth
• Save keystrokes, reduce friction

Visual: Terminal showing alias in action

---

Slide: Working Across Directories

Key Points:

claude --add-dir ../other-repo
claude --add-dir ../backend --add-dir ../shared-libs

Talking Points:

• By default, Claude only sees current directory
• --add-dir expands its view to sibling repos
• Perfect for: frontend calling backend APIs, shared type definitions
• Combine with -c: claude -c --add-dir ../related-project

Visual: Diagram showing multiple repos being accessible

---

Slide: Golden Rule

Key Points:

• Always use Claude to edit Claude config files

Talking Points:

• Want to add a preference? Tell Claude: "Remember that I prefer..."
• Claude understands its own config format perfectly
• Avoids syntax errors, puts things in the right place
• Meta but powerful: Claude maintaining its own instructions

Visual: Screenshot of asking Claude to update CLAUDE.md

---

Slide: Demo Time

Demo: Config Files & Edit

1. Show ~/.claude/CLAUDE.md
2. Show project .claude/CLAUDE.md
3. Ask Claude to add a new preference
4. Watch it update the file

Key Takeaway: Configuration is just markdown - readable, versionable, shareable

---

Section 1 Summary

• Claude Code = AI in your terminal with full filesystem access
• Two config levels: global (~/.claude/) and project (.claude/)
• Session commands: claude, -c, --resume
• --add-dir for multi-repo work
• Let Claude edit its own config files

02-remember-pattern.md

Section 2: The "Remember" Pattern (5 min)

---

Slide: Teaching Claude to Remember

Key Points:

• Say "Remember that I prefer..." and Claude updates its config
• Preferences persist across all future sessions
• No manual file editing required

Talking Points:

• This is one of the most powerful patterns
• You're training YOUR Claude over time
• The more you use it, the more it knows your style

Visual: Before/after of CLAUDE.md with new preference added

---

Slide: What to Remember

Key Points:

• Coding style preferences
• Commit message format
• Testing frameworks
• Documentation standards
• Communication tone

Talking Points:

• Examples:
  • "Remember I use Conventional Commits"
  • "Remember I prefer pytest over unittest"
  • "Remember I like Simpsons GIFs in my PRs"
  • "Remember my GitHub username is ronco"

Visual: List with checkmarks

---

Slide: Global vs Project

Key Points:

Global (~/.claude/CLAUDE.md)	Project (.claude/CLAUDE.md)
Commit message format	Project-specific standards
Testing preferences	Team conventions
Your name/username	Framework patterns
Communication style	File naming rules

Talking Points:

• Global = things that apply everywhere you code
• Project = things specific to this codebase or team
• Project CLAUDE.md can be committed - share with team!
• Global stays private to you

Visual: Two-column comparison

---

Slide: Building Your Personal Claude

Key Points:

• Start simple, add over time
• Notice patterns in your corrections
• "I keep telling Claude to..." → add a Remember

Talking Points:

• After a few weeks, you'll have a well-trained assistant
• Review your CLAUDE.md occasionally - remove outdated stuff
• It's iterative - no need to get it perfect on day one
• Think of it as onboarding a new team member

Visual: Growth chart showing CLAUDE.md evolving

---

Slide: Real Example

Key Points:

# From my actual CLAUDE.md

## Git Workflow Preferences

### Branch Creation
Always create new branches from `origin/main`
Use: `git checkout origin/main -b <branch-name>`

### Commit Messages
Always use Conventional Commits syntax
Format: `<type>(<scope>): <description>`

Talking Points:

• This is from my real config
• Now every branch starts from main, every commit is conventional
• I didn't write this by hand - I told Claude to remember it
• Saved hours of corrections over time

Visual: Screenshot of actual CLAUDE.md section

---

Slide: Demo Time

Demo: The Remember Pattern

1. "Remember that I prefer tests written with pytest"
2. Watch Claude update ~/.claude/CLAUDE.md
3. Show the change in the file
4. Start a new session - Claude now knows

Key Takeaway: Your preferences accumulate into a personalized AI assistant

---

Section 2 Summary

• "Remember..." triggers CLAUDE.md updates
• Global = your universal preferences
• Project = team/codebase conventions
• Build up over time - iterate, don't perfect
• Check in project CLAUDE.md - share knowledge with team

03-git-github.md

Section 3: Git & GitHub Workflows (15 min)

---

Slide: Claude + Git = Power

Key Points:

• Claude understands git natively
• Reads diffs, history, branch structure
• Creates commits with meaningful messages
• Handles the git workflow you teach it

Talking Points:

• "Create a commit for these changes" → smart message
• "What changed in the last 5 commits?" → summarizes
• "Create a branch for this feature" → follows your conventions
• Git is where Claude Code really shines

Visual: Terminal showing git operations

---

Slide: Commit Message Magic

Key Points:

• Claude analyzes staged changes
• Generates contextual commit messages
• Follows your format (Conventional Commits, etc.)

Talking Points:

• Example workflow:
  1. Make your changes
  2. "Create a commit"
  3. Claude: stages, analyzes, writes message, commits
• Taught mine to use Conventional Commits via CLAUDE.md
• No more "fixed stuff" commits

Visual: Example of generated commit message

---

Slide: Branch Management

Key Points:

• "Create a branch for adding user authentication"
• Follows naming conventions from CLAUDE.md
• Starts from correct base (origin/main)

Talking Points:

• In my config: "Always create branches from origin/main"
• Claude knows to fetch first, then branch
• Consistent naming: feat/add-user-auth, fix/login-bug
• No more "wait, what branch am I on?"

Visual: Git graph showing clean branching

---

Slide: Why gh CLI is Essential

Key Points:

• GitHub's official CLI tool
• Claude uses it for GitHub operations
• PRs, issues, reviews, API access

Talking Points:

• Without gh: Claude can only do local git
• With gh: Claude can create PRs, read issues, comment
• Install: brew install gh then gh auth login
• This unlocks the full GitHub workflow

Visual: gh logo + key commands

---

Slide: What gh Enables

Key Points:

Command	What Claude Can Do
gh pr create	Create pull requests
gh pr view	Read PR details
gh issue list	See open issues
gh api	Access any GitHub API

Talking Points:

• "Create a PR for this branch" → uses gh pr create
• "What's in PR #123?" → gh pr view
• "Find issues labeled 'bug'" → gh issue list
• The API access is powerful for custom workflows

Visual: Table with examples

---

Slide: Custom PR Templates

Key Points:

• Define PR format in CLAUDE.md
• Consistent structure every time
• Include your team's requirements

Talking Points:

• My PR format:
  • Summary (bullet points)
  • Changes (what was modified)
  • Test plan (how to verify)
  • GIF (because why not)
• Claude follows this template automatically

Visual: Example PR with clear sections

---

Slide: The Simpsons GIF Trick

Key Points:

• PRs are more fun with GIFs
• "Include a relevant Simpsons GIF" in CLAUDE.md
• Custom /pr skill handles the workflow

Talking Points:

• Started as a joke, now it's team culture
• Claude picks contextually appropriate GIFs
• Makes code review more enjoyable
• Shows personality in async communication

Visual: Example PR with Homer GIF

---

Slide: My PR Workflow (CLAUDE.md)

Key Points:

## Pull Request Creation
Always use the `/pr` command when creating PRs.
Include a relevant GIF (Simpsons preferred).

**PR Description Structure:**
- Summary → Changes → Test plan → GIF
- Use checkboxes for test plans
- Be concise but complete

Talking Points:

• This is from my actual CLAUDE.md
• Claude reads this every time
• PRs come out consistent
• Team knows what to expect

Visual: CLAUDE.md snippet

---

Slide: Custom Skills for Workflows

Key Points:

• Skills = reusable slash commands
• /pr - Create PR with your format
• /commit - Commit with conventions
• Define once, use everywhere

Talking Points:

• Skills live in ~/.claude/skills/
• Just markdown files with prompts
• Example: /pr triggers full PR workflow
• We'll cover skills more in the advanced section (see cheatsheet)

Visual: Skills directory structure

---

Slide: Demo Time

Demo: Full Git Workflow

1. Create branch from origin/main
2. Make a small change
3. Create commit (watch the message)
4. Create PR with /pr
5. Show the GIF in the PR!

Key Takeaway: End-to-end workflow in one conversation

---

Section 3 Summary

• Claude handles git operations natively
• Install gh CLI to unlock GitHub features
• Define PR templates in CLAUDE.md
• Custom skills (like /pr) streamline workflows
• Add personality - GIFs make PRs fun

04-mcp-jira.md

Section 4: MCP + Jira Workflow (15 min)

---

Slide: What is MCP?

Key Points:

• Model Context Protocol
• Standard for connecting AI to external tools
• Claude Code supports MCP servers out of the box

Talking Points:

• Think of it as plugins for Claude
• Servers provide new capabilities: Jira, Slack, databases
• One config, multiple integrations
• Open standard - growing ecosystem

Visual: Diagram: Claude ↔ MCP ↔ External Services

---

Slide: Why MCP Matters

Key Points:

• Claude stays in your terminal
• No context switching to browser
• AI understands your tools together

Talking Points:

• Before: Copy Jira ticket → paste to Claude → copy solution → update Jira
• After: "Implement PROJ-123" → Claude reads, codes, comments
• Slack: "Summarize #alerts from today" → instant summary
• The integration is the productivity multiplier

Visual: Before/After comparison

---

Slide: Setting Up MCP Servers

Key Points:

// ~/.claude/settings.json
{
  "mcpServers": {
    "atlassian": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-atlassian"]
    },
    "slack": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-slack"]
    }
  }
}

Talking Points:

• Add to settings.json (not CLAUDE.md)
• Uses npx - no global install needed
• First run: will prompt for authentication
• Servers start on demand

Visual: settings.json snippet

---

Slide: Available MCP Servers

Key Points:

Server	What It Does
Atlassian	Jira + Confluence access
Slack	Read/post messages
GitHub	Extended GitHub features
Filesystem	Additional file ops

Talking Points:

• Atlassian = Jira issues + Confluence pages
• Slack = channels, messages, threads
• More servers being added regularly
• Can also build custom servers

Visual: Icon grid of integrations

---

Slide: Jira Workflow - Reading Tickets

Key Points:

• "What's in PROJ-123?"
• "Show me my assigned tickets"
• "Find tickets labeled 'tech-debt'"

Talking Points:

• Claude reads full ticket: description, comments, attachments
• Understands acceptance criteria
• Can search with JQL
• Confluence links? It can read those too

Visual: Terminal showing Jira ticket read

---

Slide: Writing Tickets with Codebase Context

Key Points:

• "Create a Jira ticket for the bug in login.py:45"
• Claude includes:
  • Code snippets
  • File paths
  • Related context
  • Suggested fix approach

Talking Points:

• This is where it gets powerful
• Claude writes tickets WITH code understanding
• No more "see line 45" - actual code included
• Technical debt? Claude can document it properly

Visual: Example Jira ticket created by Claude

---

Slide: Implementing Tickets

Key Points:

1. "Read PROJ-123"
2. Claude understands requirements
3. "Implement this ticket"
4. Claude codes the solution
5. "Create a PR and link it"

Talking Points:

• Full loop: ticket → code → PR → ticket update
• Claude comments on the ticket with PR link
• Transitions ticket status if you want
• Async work becomes seamless

Visual: Flow diagram: Ticket → Code → PR → Done

---

Slide: The Full Loop

Key Points:

You: "Implement PROJ-123"

Claude:
1. Reads ticket from Jira
2. Explores relevant code
3. Makes changes
4. Runs tests
5. Creates commit
6. Creates PR
7. Links PR to ticket
8. Adds comment to ticket

Talking Points:

• This is the dream workflow
• You're the architect, Claude is the builder
• Review the PR, not every keystroke
• Works for bugs, features, refactors

Visual: Numbered flow

---

Slide: Slack Integration

Key Points:

• "What's happening in #alerts today?"
• "Summarize the discussion in #architecture"
• "Post a message to #team-updates"

Talking Points:

• Read channels you have access to
• Summarize threads (great for catching up)
• Post updates (status, announcements)
• Thread replies too

Visual: Slack message examples

---

Slide: Demo Time

Demo: MCP + Jira

Option A - Create ticket:

1. Find a code issue
2. "Create a Jira ticket for this"
3. Show the created ticket

Option B - Implement ticket:

1. "Read PROJ-XXX"
2. "Implement this ticket"
3. Watch Claude work
4. Show the PR

Key Takeaway: Code and project management in one flow

---

Section 4 Summary

• MCP = plugins for Claude Code
• Atlassian server: Jira + Confluence access
• Slack server: channel reading/posting
• Write tickets WITH codebase context
• Implement tickets end-to-end
• Full loop: ticket → code → PR → done

05-codebase-exploration.md

Section 5: Codebase Exploration (10 min)

---

Slide: The Exploration Superpower

Key Points:

• Claude can read and understand entire codebases
• Uses specialized "Explore" agents
• Answers architectural questions in minutes

Talking Points:

• New to a codebase? Claude reads it for you
• "How does authentication work?" → traces the flow
• No more grep-ing through thousands of files
• This is honestly magical

Visual: Mind map of codebase structure

---

Slide: The Explore Agent

Key Points:

• Specialized sub-agent for research
• Searches files, reads code, traces connections
• Reports back findings
• Runs in parallel while you work

Talking Points:

• Different from normal Claude - optimized for exploration
• "Explore how the API handles errors"
• Goes deep, follows imports, reads docs
• Comes back with a summary

Visual: Agent diagram with arrows

---

Slide: Strategic Questions to Ask

Key Points:

• "What's the overall architecture?"
• "How does X feature work?"
• "Where is Y handled?"
• "What calls this function?"
• "How do I add a new Z?"

Talking Points:

• Open-ended questions work great
• Start broad, then narrow down
• "How do I..." questions are powerful
• Claude will read code to answer

Visual: Question cards

---

Slide: Exploration Patterns

Key Points:

Question Type	Example
Architecture	"What's the directory structure?"
Data flow	"How does a request go from API to DB?"
Feature location	"Where is user auth implemented?"
Pattern matching	"How do other endpoints handle validation?"

Talking Points:

• Architecture: get the big picture first
• Data flow: trace through the system
• Feature location: find the starting point
• Pattern matching: learn from existing code

Visual: Table with examples

---

Slide: Reverse Engineering

Key Points:

• Clone an unfamiliar repo
• Ask Claude to explain it
• Build mental model in minutes

Talking Points:

• New team? New project? OSS contribution?
• "Give me an overview of this codebase"
• "What's the main entry point?"
• "How would I add a new feature?"
• Faster than reading docs (if they even exist)

Visual: Before (confused) → After (understanding)

---

Slide: Context Management

Key Points:

Command	When to Use
/compact	Context getting long, still relevant
claude (fresh)	Switching topics, confused state

Talking Points:

• /compact: compresses but keeps knowledge
• Fresh session: clean slate
• Signs you need fresh: referencing deleted code, confusion, slow
• Don't be afraid to start over

Visual: Decision tree

---

Slide: When Context Goes Bad

Key Points:

• Referencing code you already changed
• Repeating previous mistakes
• Slower responses
• Contradicting itself

Talking Points:

• Context can get "polluted"
• Too much old information
• Starting fresh is often faster
• Think of it as rebooting

Visual: Warning signs list

---

Slide: Demo Time

Demo: Codebase Exploration

Using: httpx (Python HTTP client)

1. Clone/open the repo
2. "What's the architecture of this project?"
3. "How does connection pooling work?"
4. "Where would I add a new transport?"

Key Takeaway: Minutes to understand, hours saved

---

Section 5 Summary

• Explore agent does codebase research
• Ask strategic questions: architecture, flow, location
• Great for onboarding to new codebases
• /compact to compress, fresh session to reset
• Know the signs of polluted context

06-wrapup.md

Section 6: Wrap-Up & Extra Credit (5 min)

---

Slide: Top 5 Power User Habits

Key Points:

1. Use claude -c constantly - Continue sessions, build context
2. Teach with "Remember" - Build your personalized assistant
3. Install gh CLI - Unlock full GitHub integration
4. Set up MCP servers - Jira, Slack, and more
5. Explore first, code second - Let Claude map the codebase

Talking Points:

• Start with these five
• Each compounds over time
• Your Claude gets better the more you use it
• These are the highest-leverage habits

Visual: Numbered list with icons

---

Slide: Quick Wins for Today

Key Points:

• Install gh and run gh auth login
• Add one "Remember" preference
• Set up an alias: alias cc="claude -c"
• Try exploring a codebase you're curious about

Talking Points:

• You can do all of these in 10 minutes
• Pick one, do it today
• The habits build from there
• Small friction reduction = big productivity gains

Visual: Checklist

---

Slide: Your Cheatsheet

Key Points:

• All commands and patterns on one page
• Advanced topics we didn't cover:
  • Hooks
  • Custom skills
  • Multi-agent parallelism
  • Model selection
  • Headless mode

Talking Points:

• Take this with you
• Reference when you forget a command
• Deep dive into advanced topics when ready
• Share with your team

Visual: Preview of cheatsheet

---

Slide: Extra Credit Resources

Key Points:

Resource	Link
Community Tips	github.com/ykdojo/claude-code-tips
Official Docs	anthropic.com/claude-code
Report Issues	github.com/anthropics/claude-code
In-app Help	/help command

Talking Points:

• ykdojo's repo: community curated tips (highly recommended)
• Official docs: authoritative reference
• Found a bug? Report it
• /help is always available

Visual: QR codes or clickable links

---

Slide: What We Covered

Key Points:

1. Foundation & Setup - Config files, sessions, credentials
2. The Remember Pattern - Teaching Claude your preferences
3. Git & GitHub - Commits, PRs, the GIF trick
4. MCP + Jira - External integrations, ticket workflows
5. Codebase Exploration - Reverse engineering, context management

Talking Points:

• These are the core power user skills
• Each builds on the others
• You now know more than most users
• Go practice!

Visual: Section recap icons

---

Slide: Q&A

Key Points:

• Questions?
• What would you like to see demoed?
• What's your biggest Claude Code challenge?

Talking Points:

• Open floor
• Happy to demo anything again
• Share your use cases
• Let's discuss

Visual: Q&A graphic

---

Slide: Thank You!

Key Points:

• Grab the cheatsheet
• Check out the extra credit links
• Connect: [Your contact info]
• Happy coding!

Talking Points:

• Thanks for your time
• Start with one habit today
• Feel free to reach out
• Go build something cool

Visual: Thank you + contact info + Simpsons GIF

claude-code-cheatsheet.md

Claude Code Cheatsheet

Quick Reference Commands

Session Management

Command	Description
claude	Start fresh session
claude -c	Continue last session
claude --resume	Pick from recent sessions
claude -p "prompt"	Headless mode (for scripts/CI)
claude --add-dir ../path	Add directories to context
claude --model sonnet	Use faster/cheaper model

Shell Aliases (add to ~/.zshrc or ~/.bashrc)

alias cc="claude -c"
alias cr="claude --resume"
alias cs="claude --model sonnet"

In-Session Commands

Command	Description
/help	Show all commands
/compact	Compress context (keeps working, saves tokens)
/clear	Clear conversation entirely
/cost	Show token usage
Esc	Cancel current operation
Ctrl+C	Interrupt / exit

---

Configuration Files

Locations

~/.claude/
├── CLAUDE.md          # Your global preferences
├── settings.json      # Permissions, MCP servers
└── .env               # Credentials (NEVER commit)

<project>/
└── .claude/
    ├── CLAUDE.md      # Project-specific instructions
    └── settings.json  # Project settings

Priority Order

Project CLAUDE.md > User CLAUDE.md > Defaults

---

Model Selection

Model	Best For	Flag
Opus	Complex reasoning, large refactors	(default)
Sonnet	Quick tasks, simple edits, cost savings	--model sonnet

---

Hooks

Pre/post execution scripts. Add to ~/.claude/settings.json:

{
  "hooks": {
    "post-tool-use": {
      "edit": "npm run lint --fix"
    }
  }
}

---

Custom Skills (Slash Commands)

Create ~/.claude/skills/<skill-name>.md:

---
name: commit
description: Create a conventional commit
---

Create a git commit following Conventional Commits format.
Include a descriptive message based on staged changes.

Usage: /commit in session

---

MCP Server Setup

Add to ~/.claude/settings.json:

{
  "mcpServers": {
    "atlassian": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-atlassian"]
    },
    "slack": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-slack"]
    }
  }
}

---

Effective Prompting Patterns

Be Specific

# Vague (avoid)
"Fix the bug"

# Specific (better)
"Investigate why login fails when email contains '+' character"

Provide Context

# Good pattern
"In the UserService class, add a method to validate email
addresses. Follow the existing validation pattern used
for phone numbers."

Iterative Refinement

1. "Run the tests"
2. "Fix the failing test in auth.test.ts"
3. "Run tests again to verify"

---

Context Management

When to /compact

• Context getting long but still relevant
• Want to continue same task with less token usage

When to Start Fresh (claude)

• Switching to unrelated task
• Claude seems confused or stuck
• Accumulated context is polluting responses

Signs of Context Pollution

• Referencing old/deleted code
• Repeating previous mistakes
• Slower responses
• Inconsistent behavior

---

Plan Mode

For complex tasks, use plan mode:

"Enter plan mode and save the plan to PLAN.md"

Claude will:

1. Explore the codebase
2. Write a plan to the file
3. Wait for your approval
4. Execute after approval

---

Multi-Agent Parallelism

Claude can spawn background agents:

• Explore agent - Codebase research
• Plan agent - Architecture design

These run concurrently while you continue working.

---

Ad-Hoc Scripting

Great for one-off tasks:

"Write a Python script that scrapes attendee names
from this conference page: [URL]"

"Summarize the last 50 messages in #alerts Slack channel"

"Parse this CSV and generate SQL insert statements"

---

Test-Driven Debugging Loop

Powerful pattern for fixing issues:

1. "Run the test suite"
2. Claude sees failures
3. "Fix the failing tests"
4. Claude makes changes
5. "Run tests again"
6. Repeat until green

---

Code Review Workflow

"Review the changes in this PR: [URL]"

"What are the potential issues with the code
in src/auth/login.ts?"

"Review my staged changes before I commit"

---

Cost Awareness Tips

1. Use sonnet for simple tasks
2. /compact to reduce context size
3. Start fresh sessions for new topics
4. Be specific to avoid back-and-forth
5. Use /cost to monitor usage

---

Keyboard Shortcuts

Key	Action
Esc	Cancel current operation
Ctrl+C	Interrupt
Up Arrow	Previous command
Tab	Autocomplete

---

Extra Credit Resources

• Community Tips: https://github.com/ykdojo/claude-code-tips
• Official Docs: Run /help or visit anthropic.com
• Report Issues: https://github.com/anthropics/claude-code/issues

---

Generated for Claude Code Power User Tutorial

claude-code-tutorial-plan.md

Claude Code Power User Tutorial - Plan

Status: Dry Runs Complete - Ready for Presentation

Last Updated: 2025-01-13

---

Overview

Creating a Google Slides tutorial on Claude Code with hands-on demo opportunities. Target Duration: ~1 hour (condensed from original 2-hour plan)

---

Deliverables

1. Slide Deck (~60 min presentation with demos)
2. Cheatsheet (1-2 page PDF - commands, tips, patterns)
3. Extra Credit Resources (links for self-study)

---

Tutorial Structure (1-Hour Version)

Section 1: Foundation & Setup (10 min)

• What is Claude Code? Why CLI?
• Config file hierarchy:
  • ~/.claude/CLAUDE.md - User global
  • <project>/.claude/CLAUDE.md - Project-specific
  • ~/.claude/.env - Credentials
• Session management: claude vs -c vs --resume
• --add-dir for multi-repo work
• Key principle: Use Claude to edit Claude config files

Demo: Show config files, quick edit via Claude

---

Section 2: The "Remember" Pattern (5 min)

• Teaching Claude persistent preferences
• Global vs project instructions
• Iterative refinement over time

Demo: "Remember that I prefer..." → watch CLAUDE.md update

---

Section 3: Git & GitHub Workflows (15 min)

• Git interactions: commits, branches, diffs
• Why gh CLI is essential
• Custom PR templates & conventions
• The Simpsons GIF trick

Demo: Full flow - branch → changes → PR with GIF

---

Section 4: MCP + Jira Workflow (15 min)

• What is MCP? (30 sec explainer)
• Setting up Atlassian + Slack servers
• Writing Jira tickets with codebase context
• Implementing tickets end-to-end
• Linking PRs back to issues

Demo: Create Jira ticket from code analysis OR implement existing ticket

---

Section 5: Codebase Exploration (10 min)

• The Explore agent
• Strategic questions: "How does X work?"
• Reverse engineering unfamiliar codebases
• When to use /compact vs fresh start

Demo: Drop into unfamiliar repo, understand architecture in minutes

---

Section 6: Wrap-Up & Extra Credit (5 min)

• Key takeaways (top 3-5 power user habits)
• Cheatsheet handout
• Extra credit resources:
  • https://github.com/ykdojo/claude-code-tips
  • Official Claude Code docs
• Q&A

---

Topics Moved to Cheatsheet

These are valuable but better as reference material:

• Hooks (pre/post tool execution)
• Custom Skills (slash commands)
• Multi-agent parallelism
• Model selection (sonnet vs opus)
• Headless/CI mode (claude -p)
• Test-driven debugging loops
• Keyboard shortcuts
• Context management (/compact, /clear)
• Cost awareness tips
• Web search & fetch
• Effective prompting patterns
• Permission management

---

Cheatsheet Content

See: claude-code-cheatsheet.md

---

Extra Credit Resources

Resource	Description
ykdojo/claude-code-tips	Community power tips collection
Official Claude Code docs	/help in CLI or online docs
Ron's CLAUDE.md template	Example of a well-configured setup

---

Demo Preparation

Section 1 Demo: Config Files

• Show ~/.claude/CLAUDE.md
• Show project .claude/CLAUDE.md
• Have Claude add a new preference

Section 2 Demo: Remember Pattern

• "Remember that I like tests written with pytest"
• Show the file update

Section 3 Demo: Git Workflow

• Create branch from origin/main
• Make a small change
• Create PR with Simpsons GIF using /pr

Section 4 Demo: MCP + Jira

• Option A: Query existing Jira tickets, pick one, implement
• Option B: Analyze code issue, create Jira ticket with context

Section 5 Demo: Codebase Exploration

• Use an unfamiliar OSS repo
• Ask: "What's the architecture?" / "How does X work?"
• Show the Explore agent in action

---

Original Topics Checklist

Covered in Presentation

• Claude config files and locations (user vs project)
• Always use Claude to edit Claude config files
• Using Claude .env file for credentials
• claude vs claude -c vs claude --resume + aliases
• --add-dir for multi-directory work
• Teaching Claude to "Remember"
• Reverse engineering codebases
• Connecting MCP servers (Atlassian, Slack)
• Writing Jira tickets with codebase context
• Implementing Jira tickets
• Custom PR templates (Simpsons GIF trick)
• Git interactions and shortcuts
• Benefit of gh CLI

Moved to Cheatsheet

• Plan mode with saving to file
• Ad-hoc scripts (conference scraping, Slack alerts)
• Hooks
• Custom Skills (slash commands)
• Todo system
• Keyboard shortcuts
• /compact and context management
• Code review workflows
• Test-driven debugging
• Multi-agent parallelism
• Model selection
• Headless/CI mode
• Web search + fetch
• Effective prompting
• When to start fresh
• Cost awareness

---

Next Steps

1. Restructure for 1-hour format
2. Create cheatsheet content
3. Draft detailed slide content for each section
4. Create demo scripts with exact steps
5. Prepare demo environments (httpx cloned to ~/demo/httpx)
6. Create Gamma input file (copied to clipboard)
7. Generate slides in Gamma (paste gamma-input.md)
8. Review and refine generated slides
9. Test run demos

---

Files Created

~/dev/claud-tutorial/
├── claude-code-tutorial-plan.md     # This file
├── claude-code-cheatsheet.md        # 1-page reference handout
└── tutorial-content/
    ├── 01-foundation-setup.md       # Section 1 speaker notes
    ├── 02-remember-pattern.md       # Section 2 speaker notes
    ├── 03-git-github.md             # Section 3 speaker notes
    ├── 04-mcp-jira.md               # Section 4 speaker notes
    ├── 05-codebase-exploration.md   # Section 5 speaker notes
    ├── 06-wrapup.md                 # Section 6 speaker notes
    ├── demo-01-config.md            # Demo script: Config files
    ├── demo-02-remember.md          # Demo script: Remember pattern
    ├── demo-03-pr.md                # Demo script: Git/PR workflow
    ├── demo-04-jira.md              # Demo script: MCP/Jira
    ├── demo-05-explore.md           # Demo script: Codebase exploration
    └── gamma-input.md               # Consolidated outline for Gamma

Demo repo: ~/demo/httpx (cloned for exploration demo)

---

To Resume

cd ~/dev/claud-tutorial
claude

Then say: "Let's continue working on the Claude Code tutorial - see claude-code-tutorial-plan.md"

demo-01-config.md

Demo 1: Config Files

Section: 1 - Foundation & Setup Duration: ~1 minute Repo: Any project with a .claude/ directory

---

Setup (Before Presentation)

• Terminal open with clear screen
• Have a second terminal or editor ready to show file changes
• Verify ~/.claude/CLAUDE.md exists and has content
• Verify project .claude/CLAUDE.md exists
• Optional: Have the files open in VS Code side panel

---

Live Steps

Step 1: Show Global Config

Action: Open/display global CLAUDE.md

cat ~/.claude/CLAUDE.md

What to point out:

• "This is my global config - applies to all projects"
• "Written in plain markdown - human readable"
• "See my preferences here: commit format, git workflow, etc."

---

Step 2: Show Project Config

Action: Open/display project CLAUDE.md

cat .claude/CLAUDE.md

What to point out:

• "This is project-specific - checked into git"
• "Team can share these conventions"
• "Notice how it adds to global, doesn't replace"

---

Fallback

If something goes wrong:

• If file doesn't exist: explain where it would be, show global only

---

Key Takeaways to Verbalize

1. "Two levels of config: global and project"
2. "Plain markdown - you can read and version control it"
3. "Project config is checked into git - team shares conventions"
4. "Next, I'll show you how Claude edits these files itself"

demo-02-remember.md

Demo 2: The "Remember" Pattern

Section: 2 - Teaching Claude Your Preferences Duration: ~2 minutes Repo: Any (using global config)

---

Setup (Before Presentation)

• Fresh terminal with Claude not running
• Know what preference you'll add (suggest: testing framework)
• Open ~/.claude/CLAUDE.md in VS Code: open ~/.claude/CLAUDE.md
• Position VS Code and terminal side-by-side so audience sees both

---

Live Steps

Step 1: Start Claude

Action: Start a fresh session

claude

What to say:

• "Let's teach Claude a new preference"

---

Step 2: Tell Claude to Remember

Action: Give the remember instruction

Say to Claude:

"Remember that I prefer pytest over unittest for all Python testing"

What to point out:

• Watch it process the request
• "It understands this is a configuration change"
• "Asking permission to edit CLAUDE.md"

---

Step 3: Approve the Edit

Action: Approve when prompted

What to point out:

• "I approve, and watch the file update"
• VS Code auto-reloads - audience sees the change appear live
• "There it is - added to my global preferences"

---

Step 4: Verify Persistence (Optional)

Action: Start new session, test the preference

# Exit current session
# Start new one
claude

Say to Claude:

"What testing framework do I prefer?"

What to point out:

• "New session, but it remembers"
• "This is how your Claude learns over time"

---

Fallback

If VS Code doesn't auto-reload:

• Manually refresh VS Code (Cmd+R) or cat ~/.claude/CLAUDE.md in terminal
• Explain the mechanism works even if display lagged

Backup option:

• Show your existing CLAUDE.md and point out things you've already remembered
• "Here are preferences I've built up over months"

---

Key Takeaways to Verbalize

1. "Just say 'remember' and describe your preference"
2. "Claude updates its own config file"
3. "Persists across all future sessions"
4. "Build this up over time - your Claude gets smarter"

demo-03-pr.md

Demo 3: Git Workflow + PR with GIF

Section: 3 - Git & GitHub Workflows Duration: ~5 minutes Repo: Any project repository

---

Setup (Before Presentation)

• Clean git status (no uncommitted changes)
• On main branch, up to date with origin
• gh CLI installed and authenticated (gh auth status)
• Change to make: add a nonsense comment to any DAG file (demo purposes only)
• Have GitHub PR page ready to show result
• Ensure /pr skill is configured (or be ready to use gh pr create directly)

---

Pre-Demo Check

git status          # Should be clean
git branch          # Should be on main
gh auth status      # Should be authenticated

---

Live Steps

Step 1: Start Claude and Create Branch

Action: Start Claude and ask for a branch

claude

Say to Claude:

"Create a new branch for adding a demo comment"

What to point out:

• "Watch it create from origin/main - that's in my CLAUDE.md"
• "Follows my naming convention"

---

Step 2: Make a Small Change

Action: Ask Claude to make the change

Say to Claude:

"Add a nonsense comment to any DAG file - this is just for demo purposes"

What to point out:

• "Simple change, but let's see the full workflow"

---

Step 3: Create Commit

Action: Ask for a commit

Say to Claude:

"Create a commit for this change"

What to point out:

• "Watch the commit message - Conventional Commits format"
• "It analyzed the change and wrote a meaningful message"
• "No more 'fixed stuff' commits"

---

Step 4: Create PR with GIF

Action: Use the /pr skill or ask directly

Say to Claude:

"/pr"

or if no skill:

"Create a pull request with a summary and include a Simpsons GIF"

What to point out:

• "There's my PR template - summary, changes, test plan"
• "And there's the GIF - this is the fun part"
• "Watch it push and create the PR"

---

Step 5: Show the PR

Action: Open GitHub in browser

What to point out:

• Show the PR description
• Point out the GIF
• "Consistent format every time"
• "This makes code review more enjoyable"

---

Fallback

If PR creation fails:

• Show the branch and commit locally
• Explain: "The PR would follow my template in CLAUDE.md"
• Open a previous PR to show the format

If GIF doesn't appear:

• "Sometimes it picks a GIF that doesn't embed - the pattern still works"
• Show a previous PR with a good GIF

---

Key Takeaways to Verbalize

1. "Branch from origin/main - configured in CLAUDE.md"
2. "Commit messages follow Conventional Commits"
3. "PR template is consistent every time"
4. "The GIF makes PRs memorable - small touches matter"
5. "End-to-end workflow without leaving the terminal"

demo-04-jira.md

Demo 4: MCP + Jira Workflow

Section: 4 - MCP + Jira Workflow Duration: ~5 minutes Repo: Any project repository

---

Setup (Before Presentation)

• Atlassian MCP server configured in ~/.claude/settings.json
• Authenticated with Atlassian (first run prompts for auth)
• Know your Jira project key (e.g., PROJ, DATA, etc.)
• Have either:
  • Option A: A piece of code with an obvious issue to create ticket for
  • Option B: An existing simple ticket to implement
• Have Jira open in browser to show results

---

Pre-Demo Check

# Verify MCP server is configured
cat ~/.claude/settings.json | grep atlassian

---

Option A: Create Ticket from Code

Step 1: Start Claude

Action: Start fresh session

claude

---

Step 2: Find or Point to Code Issue

Action: Navigate to code with an issue

Say to Claude:

"Look at [file.py] - there's a potential issue with [describe briefly]. Can you create a Jira ticket for this?"

or simpler:

"There's a TODO comment in [file.py] line 50. Create a Jira ticket to address it."

What to point out:

• "Watch Claude read the code"
• "It understands the context"

---

Step 3: Watch Ticket Creation

Action: Let Claude create the ticket

What to point out:

• "See it using the Atlassian MCP server"
• "The ticket will include code context"
• "File paths, line numbers, relevant snippets"

---

Step 4: Show the Ticket

Action: Open Jira in browser

What to point out:

• "Look at the description - actual code included"
• "Not just 'fix the thing' - real context"
• "Anyone can pick this up and understand it"

---

Option B: Implement Existing Ticket

Step 1: Start Claude

Action: Start fresh session

claude

---

Step 2: Read the Ticket

Action: Ask Claude to read a ticket

Say to Claude:

"Read PROJ-123 and tell me what it needs"

What to point out:

• "Claude reads directly from Jira"
• "No copy-paste needed"
• "It understands the requirements"

---

Step 3: Implement (Abbreviated)

Action: Start implementation

Say to Claude:

"Implement this ticket"

What to point out:

• "It's working on the solution"
• "In a real scenario, this continues to PR"
• "The full loop: ticket → code → PR → ticket update"

(For time, you may stop here and explain the rest)

---

Step 4: Show Linking (Optional)

Action: If time permits

Say to Claude:

"Add a comment to the ticket with the PR link"

What to point out:

• "Claude updates the ticket"
• "Everything linked together"

---

Fallback

If Jira connection fails:

• Show the settings.json config
• Explain: "When connected, Claude can read/write tickets"
• Show a screenshot of a ticket Claude created previously

If ticket creation fails:

• Show the prompt Claude would use
• "The ticket would include: [describe format]"

---

Key Takeaways to Verbalize

1. "MCP servers connect Claude to external tools"
2. "Atlassian server = Jira + Confluence access"
3. "Tickets include real code context"
4. "Full workflow: ticket ↔ code ↔ PR"
5. "No context switching to browser"

demo-05-explore.md

Demo 5: Codebase Exploration

Section: 5 - Codebase Exploration Duration: ~3-4 minutes Repo: httpx (https://github.com/encode/httpx)

---

Setup (Before Presentation)

• Ensure ~/demo directory exists (or create it)
• Remove httpx if previously cloned: rm -rf ~/demo/httpx
• Terminal ready
• Have NOT explored httpx before (or pretend you haven't)

---

Live Steps

Step 1: Start Claude in Demo Directory

Action: Start fresh session

cd ~/demo
claude

Talking point:

• "I've never looked at this codebase before"
• "Let's see how fast Claude can help me understand it"

---

Step 2: Clone the Repo

Action: Ask Claude to clone

Say to Claude:

"Clone the httpx repo from encode/httpx so we can explore it"

What to point out:

• "Claude handles git operations too"
• "No need to leave the session"

---

Step 3: Ask for Architecture Overview

Action: Big picture question

Say to Claude:

"What's the overall architecture of this project? Give me the high-level structure."

What to point out:

• "Watch it explore - reading files, following imports"
• "It's building a mental model"
• Wait for response
• "In 30 seconds, I have what would take an hour to figure out"

---

Step 4: Dive Deeper

Action: Follow-up question

Say to Claude:

"How does connection pooling work in this library?"

or

"How does a request flow from client.get() to actually sending bytes?"

What to point out:

• "Now it's tracing specific functionality"
• "Following the code path"
• "This is reverse engineering in real-time"

---

Step 5: Ask a "How Would I" Question

Action: Practical contribution question

Say to Claude:

"If I wanted to add support for a new transport protocol, where would I start?"

What to point out:

• "This is the question you ask before contributing"
• "Claude shows you the extension points"
• "You'd know where to look without reading everything"

---

Fallback

If clone fails:

• Use any unfamiliar repo on the machine
• Or explore a part of airflow-dags you don't usually work with

If responses are slow:

• "The Explore agent is thorough - it's reading multiple files"
• "This is faster than doing it manually"

---

Alternative Quick Demo

If time is short, clone + one powerful question:

cd ~/demo
claude

"Clone httpx from encode/httpx, then give me a 2-minute overview of how it's structured and what the main components are."

This single prompt demonstrates the power.

---

Key Takeaways to Verbalize

1. "Minutes to understand what takes hours manually"
2. "Ask strategic questions: architecture, flow, 'how would I'"
3. "Great for onboarding to new projects"
4. "Claude reads the code so you don't have to read everything"
5. "This changes how you approach unfamiliar code"

gamma-input.md

Claude Code Power User Tutorial

Presentation Overview

A 1-hour hands-on tutorial on becoming a Claude Code power user. Covers configuration, git workflows, Jira integration, and codebase exploration.

---

Section 1: Foundation & Setup (10 min)

What is Claude Code?

• Anthropic's official CLI tool for Claude
• AI pair programmer that lives in your terminal
• Direct filesystem access - reads and writes files in place
• Git integration - commits, branches, PRs without copy-paste
• Think of it as a senior developer sitting next to you

Configuration Architecture

Two levels of config files:

Global (~/.claude/)

• CLAUDE.md - Your preferences (all projects)
• settings.json - MCP servers, permissions
• .env - Credentials (never commit!)

Project (.claude/)

• CLAUDE.md - Project-specific instructions
• settings.json - Project settings

Priority: Project > Global > Defaults

Session Management

Command	Purpose
claude	Start fresh session
claude -c	Continue last session
claude --resume	Pick from recent sessions

Pro tip: Add shell aliases

alias cc="claude -c"
alias cr="claude --resume"

Working Across Directories

claude --add-dir ../other-repo

Access multiple repos in one session - perfect for frontend + backend work.

Golden Rule

Always use Claude to edit Claude config files

Say "Remember that I prefer..." and Claude updates its own config correctly.

DEMO: Config Files

Show global and project CLAUDE.md, have Claude add a new preference.

---

Section 2: The "Remember" Pattern (5 min)

Teaching Claude to Remember

Just say "Remember that I prefer..." and Claude:

1. Understands your preference
2. Updates CLAUDE.md
3. Persists across all future sessions

What to Remember

• Coding style preferences
• Commit message format (Conventional Commits)
• Testing frameworks
• Documentation standards
• Your name and GitHub username

Global vs Project Preferences

Global	Project
Commit format	Team conventions
Testing framework	File naming rules
Communication style	Framework patterns

Building Your Personal Claude

• Start simple, add over time
• Notice when you keep correcting Claude
• "I keep telling Claude to..." → add a Remember
• Your Claude gets better over time

DEMO: Remember Pattern

Tell Claude to remember a preference, watch the file update.

---

Section 3: Git & GitHub Workflows (15 min)

Claude + Git = Power

• Reads diffs, history, branch structure
• Creates commits with meaningful messages
• Follows your conventions automatically

Commit Message Magic

Claude analyzes staged changes and generates contextual messages. Teach it Conventional Commits in CLAUDE.md - no more "fixed stuff" commits.

Why gh CLI is Essential

GitHub's official CLI tool enables:

• gh pr create - Create pull requests
• gh pr view - Read PR details
• gh issue list - See open issues
• Full GitHub workflow from terminal

Install: brew install gh then gh auth login

Custom PR Templates

Define your PR format in CLAUDE.md:

• Summary (bullet points)
• Changes (what was modified)
• Test plan (how to verify)
• GIF (because why not!)

The Simpsons GIF Trick

PRs are more fun with GIFs. Add to CLAUDE.md: "Include a relevant Simpsons GIF in PRs"

Makes code review more enjoyable and memorable.

Custom Skills

Create reusable workflows like /pr and /commit. Skills live in ~/.claude/skills/ as markdown files.

DEMO: Full Git Workflow

Create branch → Make change → Commit → Create PR with GIF

---

Section 4: MCP + Jira Workflow (15 min)

What is MCP?

Model Context Protocol - standard for connecting AI to external tools. Think of it as plugins for Claude.

Setting Up MCP Servers

Add to ~/.claude/settings.json:

{
  "mcpServers": {
    "atlassian": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-atlassian"]
    }
  }
}

Available Integrations

• Atlassian: Jira + Confluence access
• Slack: Read and post messages
• GitHub: Extended features
• More being added

Jira Workflow - Reading

• "What's in PROJ-123?"
• "Show me my assigned tickets"
• Claude reads full ticket details, comments, attachments

Writing Tickets with Code Context

"Create a Jira ticket for the bug in login.py:45"

Claude includes:

• Code snippets
• File paths
• Related context
• Suggested fix approach

The Full Implementation Loop

1. Read ticket from Jira
2. Explore relevant code
3. Make changes
4. Run tests
5. Create commit and PR
6. Link PR to ticket
7. Update ticket status

DEMO: MCP + Jira

Either create a ticket from code analysis, or implement an existing ticket.

---

Section 5: Codebase Exploration (10 min)

The Exploration Superpower

Claude can read and understand entire codebases. Uses specialized "Explore" agents. Answers architectural questions in minutes.

Strategic Questions to Ask

• "What's the overall architecture?"
• "How does X feature work?"
• "Where is Y handled?"
• "How do I add a new Z?"

Exploration Patterns

Question Type	Example
Architecture	"What's the directory structure?"
Data flow	"How does a request go from API to DB?"
Feature location	"Where is user auth implemented?"
Pattern matching	"How do other endpoints handle validation?"

Reverse Engineering

Clone any unfamiliar repo, ask Claude to explain it. Build a mental model in minutes instead of hours.

Context Management

Command	When to Use
/compact	Context getting long, still relevant
claude (fresh)	Switching topics, context polluted

Signs you need fresh: referencing deleted code, contradictions, slowness.

DEMO: Codebase Exploration

Explore httpx library - ask about architecture and how features work.

---

Section 6: Wrap-Up (5 min)

Top 5 Power User Habits

1. Use claude -c constantly - continue sessions
2. Teach with "Remember" - build your assistant
3. Install gh CLI - unlock GitHub integration
4. Set up MCP servers - Jira, Slack, more
5. Explore first, code second - let Claude map codebases

Quick Wins for Today

• Install gh and run gh auth login
• Add one "Remember" preference
• Set up alias: alias cc="claude -c"
• Try exploring a codebase you're curious about

Extra Credit Resources

Resource	Link
Community Tips	github.com/ykdojo/claude-code-tips
Official Docs	anthropic.com/claude-code
Report Issues	github.com/anthropics/claude-code

Cheatsheet

All commands, patterns, and advanced topics on one page. Take it with you!

Thank You!

• Grab the cheatsheet
• Check out extra credit links
• Start with one habit today
• Happy coding!

---

Visual Suggestions for Slides

• Section 1: Terminal screenshots, config file diagrams
• Section 2: Before/after CLAUDE.md, growth chart
• Section 3: Git graph, PR screenshot with GIF
• Section 4: Flow diagram (ticket → code → PR), Jira screenshot
• Section 5: Mind map of codebase, exploration animation
• Section 6: Checklist, QR codes for resources

Notes for Gamma

• Theme: Modern, developer-focused, dark mode preferred
• Include code blocks where shown
• Embed Simpsons GIF in Git section if possible
• Keep slides scannable - not too text-heavy
• Add icons for quick visual recognition