# 🎬 Crafted Skills - Video Demo Script

**Title**: "Crafted Skills: AI-Powered Development with Claude Code"

**Duration**: 8-10 minutes

**Target Audience**: Developers using Crafted SaaS

---

## 📋 Video Structure

```
0:00 - 0:30   Introduction & Hook
0:30 - 2:00   What are Crafted Skills?
2:00 - 4:00   Demo 1: Building a Feature (Balanced)
4:00 - 5:30   Demo 2: Fixing a Bug
5:30 - 7:00   Demo 3: Quick Validations
7:00 - 8:00   Advanced Features & Agent Skills
8:00 - 8:30   Conclusion & Call to Action
```

---

## 🎬 Scene-by-Scene Script

### Scene 1: Introduction & Hook (0:00 - 0:30)

**Visual**: Screen recording of VS Code with Crafted project open

**Narration**:
```
"What if you could build production-ready features just by describing what you want?

No configuration. No manual steps. Just describe your feature, and get:
- Clean architecture
- Comprehensive tests
- Proper validation
- All following your project's quality level

This is Crafted Skills for Claude Code."
```

**On Screen**:
- Show quick 5-second clips:
  - User typing: "Add user authentication"
  - Code appearing automatically
  - Tests running (all passing)
  - Architecture validation (all green checkmarks)

**Music**: Upbeat, modern tech music (low volume)

---

### Scene 2: What are Crafted Skills? (0:30 - 2:00)

**Visual**: Split screen - concept diagram on left, VS Code on right

**Narration**:
```
"Crafted Skills are specialized AI modes that transform Claude Code
into a context-aware development partner.

They work in three layers:

First, Level Skills detect your project's quality level:
- Rapid for MVPs (ship fast)
- Balanced for growing products (pragmatic quality)
- Crafted for enterprise (software craftsmanship)

Second, Workflow Skills orchestrate complete development cycles:
- Feature development
- Bug fixing
- Refactoring
- Security reviews

Third, Agent Skills give you specialized expertise on-demand:
- Architect for system design
- Developer for implementation
- Tester for comprehensive testing
- Reviewer for quality assurance

The magic? They auto-detect your project and adapt automatically."
```

**On Screen**:
- Show skill categories diagram
- Show auto-detection flow:
  ```
  User request → Detect level (balanced) → Apply rules → Execute workflow
  ```
- Highlight numbers:
  - "3 levels"
  - "4 workflows"
  - "4 agents"
  - "3 utilities"

**Graphics**: Animated diagram showing the skill architecture

---

### Scene 3: Demo 1 - Building a Feature (2:00 - 4:00)

**Setup**: Balanced level project, clean slate

**Visual**: Full screen VS Code with Claude Code panel

**Narration**:
```
"Let's build a real feature: a product catalog with filtering and pagination.

Watch how Crafted Skills handles this from start to finish."
```

#### Part 1: User Request (2:00 - 2:10)

**On Screen**:
```
User in Claude Code:
"I want to add a product catalog feature with filtering by category
and pagination"
```

**Narration**:
```
"I just describe what I want in plain English."
```

#### Part 2: Auto-Detection (2:10 - 2:20)

**On Screen**:
```
🔍 Detecting project context...
  Level: balanced ⚖️
  Platform: web

Activating /feature workflow...
```

**Narration**:
```
"Skills automatically detect this is a Balanced-level project
and activate the feature workflow."
```

#### Part 3: Architecture Phase (2:20 - 2:40)

**On Screen**:
```
🏗️  Architect Mode Activated

Designing 3-layer architecture for Balanced level:

Router Layer (< 20 lines):
  packages/api/routers/product.ts

Service Layer (< 50 lines):
  packages/services/product.service.ts
  - Filtering logic
  - Pagination logic

Repository Layer:
  packages/database/repositories/product.repository.ts
  - Prisma queries

Creating ADR-042: Use cursor pagination for scalability
```

**Narration**:
```
"First, the Architect designs a clean 3-layer architecture.
Notice it creates an ADR - Architecture Decision Record -
documenting why cursor pagination was chosen."
```

**Highlight**: Show the generated ADR file briefly

#### Part 4: Implementation Phase (2:40 - 3:10)

**On Screen**:
```
👨‍💻 Developer Mode Activated

Implementing feature following Balanced rules:
  ✅ Router < 20 lines
  ✅ Service < 50 lines per function
  ✅ Max 3 parameters per function
  ✅ No inline comments
  ✅ Self-documenting code

Files created:
  ✅ packages/api/routers/product.ts (15 lines)
  ✅ packages/services/product.service.ts (45 lines)
  ✅ packages/database/repositories/product.repository.ts (38 lines)

Validating code quality...
  ✅ No violations detected
```

**Narration**:
```
"The Developer implements the feature, automatically following
Balanced-level rules: thin routers, services under 50 lines,
max 3 parameters, self-documenting code.

Every file is validated against quality rules in real-time."
```

**Show**: Quick peek at generated code (scroll through one file)

#### Part 5: Testing Phase (3:10 - 3:35)

**On Screen**:
```
🧪 Tester Mode Activated

Writing tests for Balanced level (70% coverage):

Unit tests:
  ✅ ProductService.list() - happy path
  ✅ ProductService.list() - with filters
  ✅ ProductService.list() - pagination edge cases
  ✅ Error handling

Integration tests:
  ✅ Router → Service → Repository flow

Running tests...
  ✅ 12 tests passing
  ✅ Coverage: 75% (required: 70%)
```

**Narration**:
```
"The Tester writes comprehensive tests - not just for coverage,
but for real quality. Happy paths, edge cases, error handling.

For Balanced level, 70% coverage is required. We got 75%."
```

**Show**: Test output in terminal (green checkmarks)

#### Part 6: Review Phase (3:35 - 4:00)

**On Screen**:
```
👀 Reviewer Mode Activated

Validating implementation:
  ✅ Code quality (no violations)
  ✅ Architecture (3-layer separation)
  ✅ Tests (75% coverage)
  ✅ Type safety (all functions typed)
  ✅ Security (input validation present)

Feature ready! 🎉

Summary:
  📊 3 files created
  📝 1 ADR documented
  🧪 12 tests written
  ✅ All validation passed
```

**Narration**:
```
"Finally, the Reviewer validates everything: code quality,
architecture boundaries, test coverage, type safety.

And we're done! Production-ready code in under 2 minutes."
```

---

### Scene 4: Demo 2 - Fixing a Bug (4:00 - 5:30)

**Setup**: Same project, introduce a bug scenario

**Visual**: VS Code with Claude Code

**Narration**:
```
"Now let's fix a real bug: users can't update their email
if it contains a plus sign."
```

#### Part 1: Report Bug (4:00 - 4:10)

**On Screen**:
```
User: "Bug: Users can't update their email when it contains a + sign"
```

#### Part 2: Reproduce (4:10 - 4:30)

**On Screen**:
```
🔍 Step 1: Reproduce

Writing failing test to confirm bug...

it('should update email with plus sign', async () => {
  const result = await userService.updateEmail(
    'user-123',
    'user+test@email.com'
  );
  expect(result.isSuccess).toBe(true);
});

Running test...
  ❌ Test fails (bug confirmed)
```

**Narration**:
```
"First, it writes a test that fails - proving the bug exists.
This becomes our regression test."
```

#### Part 3: Diagnose (4:30 - 4:50)

**On Screen**:
```
🔬 Step 2: Diagnose

Searching for updateEmail implementation...

Found issue in packages/domain/value-objects/Email.ts:
  Line 8: Email validation regex too strict
  Current: /^[a-zA-Z0-9@.]+$/
  Issue: Rejects + sign in email addresses

Root cause: Regex doesn't allow + character
```

**Narration**:
```
"It searches the codebase, finds the Email value object,
and identifies the root cause: the regex is too strict."
```

#### Part 4: Fix & Test (4:50 - 5:20)

**On Screen**:
```
🔧 Step 3: Fix

Updating Email validation:
  - Old: /^[a-zA-Z0-9@.]+$/
  + New: /^[^\s@]+@[^\s@]+\.[^\s@]+$/

🧪 Step 4: Test

Adding regression tests...
  ✅ Should accept email with plus sign
  ✅ Should accept email with dots
  ✅ Should reject invalid formats

Running all tests...
  ✅ All 14 tests pass

✅ Step 5: Validate
  ✅ No side effects
  ✅ Coverage maintained (75%)

Bug fixed! 🎉
```

**Narration**:
```
"It fixes the regex, adds comprehensive regression tests,
runs the full suite, and validates no side effects.

Bug fixed, with tests to prevent it from coming back."
```

---

### Scene 5: Demo 3 - Quick Validations (5:30 - 7:00)

**Setup**: Same project, some code changes

**Visual**: VS Code with Claude Code

**Narration**:
```
"During development, you can use utility skills for quick checks."
```

#### Validation 1: Code Quality (5:30 - 5:50)

**On Screen**:
```
User: /validate

Claude:
✅ Code validates for BALANCED level

Checks:
  ✅ Function length: All < 50 lines
  ✅ Parameters: All ≤ 3 params
  ✅ Type safety: All functions typed
  ⚠️  Duplication: 2 places (acceptable for Balanced)

No blocking issues!
```

**Narration**:
```
"Type /validate to instantly check code quality:
function length, parameters, type safety, duplication."
```

#### Validation 2: Architecture (5:50 - 6:10)

**On Screen**:
```
User: /guard

Claude:
✅ Architecture boundaries OK for BALANCED level

Checks:
  ✅ 3-layer separation (Router → Service → Repository)
  ✅ No circular dependencies
  ✅ Services don't import from routers
  ✅ Repositories don't import from services

Architecture is clean!
```

**Narration**:
```
"/guard checks architecture boundaries: are services importing routers?
Any circular dependencies? All clean!"
```

#### Validation 3: Coverage (6:10 - 6:30)

**On Screen**:
```
User: /coverage

Claude:
✅ Test coverage OK for BALANCED level

Coverage: 75% (required: 70%)

Breakdown:
  ✅ Services: 82%
  ✅ Repositories: 68%
  ✅ Routers: 75%

All requirements met!
```

**Narration**:
```
"And /coverage validates test coverage against your level's requirements.
For Balanced, that's 70% minimum. We're at 75%."
```

#### Show Different Levels (6:30 - 7:00)

**On Screen**: Side-by-side comparison

```
📊 Rules by Level:

Rapid:
  • Functions: < 100 lines
  • Coverage: None
  • Architecture: Flat

Balanced:
  • Functions: < 50 lines
  • Coverage: 70%
  • Architecture: 3-layer

Crafted:
  • Functions: < 20 lines
  • Coverage: 100% domain
  • Architecture: Hexagonal
```

**Narration**:
```
"The beauty of Skills? They adapt to your level.
Same commands, different rules based on your project's needs."
```

---

### Scene 6: Advanced Features (7:00 - 8:00)

#### Agent Skills (7:00 - 7:20)

**On Screen**:
```
User: /architect "Design a notification system"

Claude (Architect Mode):
🏗️  Architect Mode Activated

Designing multi-channel notification system...

Strategy Pattern for extensibility:
  - Email (Resend)
  - SMS (Twilio)
  - Push (Expo Notifications)

Creating ADR-051: Multi-Channel Notification Architecture
```

**Narration**:
```
"Need just architecture? Use /architect.
Need just review? Use /reviewer.
Each agent is a specialist."
```

#### Level Switching (7:20 - 7:40)

**On Screen**:
```
User: "What if I want to see Crafted-level version?"

Claude: "I can show you how this would look at Crafted level..."

Crafted version:
  • Domain entities (pure business logic)
  • Use-cases (orchestration)
  • Repository interfaces
  • 100% domain coverage
  • Result pattern (no exceptions)
```

**Narration**:
```
"Skills can show you how code would look at different levels,
helping you decide when to level up."
```

#### MCP Integration (7:40 - 8:00)

**On Screen**: Show MCP tools being called

```
Behind the scenes, Skills orchestrate MCP tools:

  mcp__crafted-context__get_architecture_info()
  mcp__rules-validator__validate_code()
  mcp__architecture-guard__check_layer_boundaries()
  mcp__vitest__check_coverage()

You don't see this complexity. You just get results.
```

**Narration**:
```
"Under the hood, Skills orchestrate multiple MCP tools,
but you never see this complexity. Just results."
```

---

### Scene 7: Conclusion (8:00 - 8:30)

**Visual**: Back to talking head or summary screen

**On Screen**: Key benefits list

**Narration**:
```
"Crafted Skills transforms Claude Code into a context-aware
development partner that:

✅ Auto-detects your project level
✅ Applies appropriate architecture and rules
✅ Generates production-ready code
✅ Writes comprehensive tests
✅ Validates everything automatically

No configuration. No manual steps.
Just describe what you want.

Get started in 5 minutes:
```

**On Screen**:
```bash
crafted clone              # Create project
# Select template, enable AI System
# Skills are installed automatically!

# Then just start building:
"Add user authentication"
"Add payment processing"
"Add email notifications"

Skills do the rest!
```

**Narration**:
```
"Skills are included in all Crafted projects.
Just run crafted clone, enable the AI System,
and start building.

Links in description.
Happy coding!"
```

**End Screen**:
```
🔗 Links:
   • Crafted SaaS: craftedsaas.com
   • Documentation: docs.craftedsaas.com
   • GitHub: github.com/crafted-saas
   • Discord: discord.gg/crafted-saas

⭐ Star us on GitHub!
💬 Join our Discord community!
```

---

## 🎥 Production Notes

### Equipment Needed

- **Screen Recording**: OBS Studio or ScreenFlow
  - 1080p minimum (1440p preferred)
  - 60fps for smooth scrolling
  - Record audio separately

- **Microphone**: Good quality USB mic
  - Blue Yeti
  - Rode NT-USB
  - Or similar

- **Video Editing**: DaVinci Resolve or Final Cut Pro
  - Add callouts and highlights
  - Add smooth transitions
  - Add background music

### Recording Tips

1. **Prepare the environment**:
   - Clean VS Code workspace
   - Hide personal info
   - Use light theme for visibility
   - Increase font size (16-18pt)

2. **Recording workflow**:
   - Record each demo separately
   - Multiple takes OK
   - Pause between steps
   - Clear narration

3. **Screen captures**:
   - Highlight mouse clicks
   - Use zoom for code details
   - Slow scrolling (easier to follow)
   - Add callout boxes for key points

### Post-Production

1. **Editing**:
   - Cut dead air
   - Add transitions (subtle!)
   - Add text overlays for key points
   - Add music (low volume, 15-20%)

2. **Graphics**:
   - Skill architecture diagram
   - Level comparison table
   - Feature workflow animation

3. **Captions**:
   - Auto-generate with YouTube
   - Manual review for accuracy
   - Add for accessibility

### Publishing

1. **YouTube**:
   - Title: "Crafted Skills: Build Production-Ready Features with AI | Claude Code Tutorial"
   - Description: Full links + timestamps
   - Tags: crafted-saas, claude-code, ai-development, typescript, react
   - Thumbnail: Clean, high-contrast, text overlay

2. **Twitter**:
   - Thread with key clips
   - 30-second teaser
   - Link to full video

3. **Discord/Community**:
   - Announce to community
   - Gather feedback
   - Iterate on skills based on usage

---

## 📊 Metrics to Track

- **Views**
- **Engagement** (likes, comments, shares)
- **Click-through to docs**
- **New project creations** (with AI System enabled)
- **Skill usage** (via telemetry if available)

---

## 🎬 Alternative Cuts

### Short Version (3 minutes)
- Intro (30s)
- One feature demo (1:30)
- Quick validations (30s)
- Outro (30s)

### Social Media Clips (30-60 seconds each)
- "Watch AI build a complete feature in 60 seconds"
- "Fix bugs with AI in 30 seconds"
- "Validate code quality instantly"

---

**Status**: Ready for production

**Next Steps**:
1. Set up recording environment
2. Practice narration
3. Record demos
4. Edit and publish
5. Promote across channels
