Skip to main content

YouTube Capstone - Intelligence Acceleration in Action

You've completed the full SDD-RI workflow across Lessons 1-10. You've written specifications, built a video generation system, and created reusable intelligence (the generate-video and upload-youtube skills).

Now comes the proof: Can you complete a second project faster using the intelligence you've built?

This capstone answers that question decisively. You'll upload your video to YouTube—completing a real feature—using the skills you created in Lesson 9. This demonstrates the core principle of SDD-RI: accumulated intelligence compounds.

By the end of this capstone, you'll have:

  • A video published on YouTube (portfolio-ready)
  • Evidence that your skills accelerated the work
  • Understanding of why intelligence accumulation matters more than code libraries
  • The ability to tackle future projects with exponentially less effort

The Acceleration Principle​

Before diving into the capstone, let's measure what's about to happen.

Project Timeline: Video Generation (Lessons 1-8)​

Lessons 1-8 took you from nothing to a working video generation system:

PhaseLessonTime EstimateWhat You Did
Constitution0330 minDefined video quality standards
Specification0445 minWrote product demo video spec
Clarify0530 minRefined spec with edge cases
Plan0645 minDesigned implementation strategy
Tasks0730 minBroke down into atomic work units
Implement0860 minGenerated and validated video
Total~3.5 hoursBuilt from scratch

You had to:

  • Learn Playwright MCP (browser automation)
  • Discover Gemini.google.com UI patterns
  • Troubleshoot session persistence
  • Validate video file quality
  • Write entire implementation plan

Project Timeline: YouTube Upload (Lesson 11 - This Capstone)​

This lesson takes you from video to YouTube publication using the skills you created:

PhaseWhat You'll DoTime Estimate
SpecificationWrite YouTube upload spec15 min
ImplementExecute with skills30 min
ValidationVerify YouTube accessibility15 min
ReflectionDocument acceleration10 min
Total~70 minutes

The difference: You're reusing intelligence.

Why This Is Faster​

Compare the effort:

Without skills (hypothetical):

  • Discover YouTube upload UI
  • Learn authentication flow
  • Handle file upload edge cases
  • Troubleshoot metadata sync
  • Estimate: 2-3 hours (almost as long as video generation)

With skills (your reality):

  • Reference your upload-youtube skill
  • Let /sp.implement invoke that skill
  • Validate output
  • Done in 70 minutes

The math:

  • Lesson 1-8: 3.5 hours to build video generation intelligence
  • Lesson 11: 70 minutes using that intelligence
  • Savings: 2 hours 20 minutes (65% time reduction)
  • But here's the key: The next YouTube video upload will take 45 minutes. The third will take 40 minutes. Intelligence compounds exponentially.

Step 1: Write Your YouTube Upload Specification​

Your specification for YouTube upload is intentionally shorter than your video generation specification (Lesson 4). This demonstrates specification complexity reduction through skill composition.

Why This Spec Is Simpler​

Lesson 4 (Video Generation) spec required:

  • Gemini prompt structure (what to ask the AI)
  • Output validation (file integrity, format)
  • Download process (browser automation details)
  • Multiple decision points (all handled by you)

Lesson 11 (YouTube Upload) spec requires:

  • Intent (get video on YouTube)
  • Constraints (platform rules)
  • Success Criteria (URL exists, plays)

The upstream complexity is encapsulated in your skill. Your specification just needs to say what success looks like, not how the skill works internally.

Create Your YouTube Upload Specification​

Create a file at specs/video-publication/youtube-upload.md with this structure:

# Specification: YouTube Video Upload

## Intent

Upload the product demo video (generated in Lesson 8) to YouTube.

**Success means**: Video is accessible at a public YouTube URL, plays without errors, and can be embedded in portfolio.

**Target platform**: YouTube (studio.youtube.com)

**Video source**: `./video-output/product-demo.mp4` (from Lesson 8)

## Constraints

- **Authentication**: Use your Google account (same as Gemini.google.com)
- **Visibility**: Public (anyone with link can watch)
- **Metadata**: Title, description, and tags populated automatically from video spec
- **Format**: Keep as MP4 (no re-encoding required)

## Success Evals

- ✅ Video uploaded to YouTube
- ✅ Video is accessible at public URL
- ✅ Video plays correctly (no buffering, full duration)
- ✅ Metadata visible (title, description visible on YouTube page)
- ✅ Portfolio-ready (can be shared in professional context)

## Non-Goals

- No custom thumbnail design
- No editing or post-processing
- No channel optimization (no playlists, no custom layout)
- No audience engagement metrics (no analytics review)
- No video monetization setup

## Edge Cases Handled by Skill

The `upload-youtube` skill from Lesson 9 handles these:
- Session timeout during upload (auto-retry)
- Network interruption (resume upload)
- Metadata encoding (special characters in title/description)
- YouTube API rate limiting

Stop and verify: Your specification is complete when:

  • ✅ Intent is clear (what's being uploaded, where, why)
  • ✅ Constraints are explicit (authentication, visibility, format)
  • ✅ Success criteria are measurable (URL exists, video plays)
  • ✅ Non-goals prevent scope creep (no editing, no thumbnails)

Step 2: Reference Your Skills in Implementation​

Now comes the leverage: you're going to invoke /sp.implement with explicit skill references. This tells the AI assistant: "Use the intelligence I've already built."

Understanding Skill Composition​

Your /sp.implement command will look like this:

/sp.implement --feature youtube-upload \
  --skills generate-video,upload-youtube \
  --spec specs/video-publication/youtube-upload.md

What this means:

  • --feature youtube-upload — This is the feature being implemented
  • --skills generate-video,upload-youtube — These pre-built skills encapsulate the necessary knowledge
  • --spec — Reference your specification written in Step 1

The AI assistant will:

  1. Read your specification
  2. Load your upload-youtube skill (Persona + Questions + Principles)
  3. Invoke the skill using Playwright MCP to authenticate and upload
  4. Report success/failure against your success criteria

What you're NOT doing:

  • ❌ Writing YouTube upload code from scratch
  • ❌ Discovering YouTube authentication flow
  • ❌ Troubleshooting Playwright MCP for video upload
  • ❌ Learning studio.youtube.com UI patterns

Your skill has already encoded this knowledge.

Why Skill Composition Works​

The upload-youtube skill from Lesson 9 contains:

# Skill: YouTube Upload

## Persona
You are a YouTube publication engineer who understands:
- Studio.youtube.com navigation and UI
- Google OAuth authentication flow
- Video metadata best practices
- Rate limiting and retry logic

## Questions
1. Is the video file valid and accessible?
2. What metadata should be extracted from specification?
3. How do we handle authentication securely?
4. What validation confirms successful upload?

## Principles
1. Specification Primacy: Upload order defined by spec, not implementation preference
2. Security First: Never log credentials; use OAuth
3. Validation Before Completion: Verify video plays before marking complete
4. Transparent Logging: Document each upload step for troubleshooting

When you reference this skill in /sp.implement, the AI assistant doesn't start from scratch—it applies this reasoning framework, which accelerates the entire implementation.

Step 3: Execute with /sp.implement and Skills​

When you're ready (your specification complete, your video from Lesson 8 available locally), run this command:

/sp.implement --feature youtube-upload \
  --skills generate-video,upload-youtube \
  --spec specs/video-publication/youtube-upload.md

What Happens During Execution​

The AI assistant will:

  1. Load Your Specification

    • Read intent, constraints, success criteria
    • Identify video source (./video-output/product-demo.mp4)
    • Extract metadata (title, description from original video spec)

  2. Invoke Your Skills

    • Apply upload-youtube skill reasoning (Persona + Questions + Principles)
    • Use Playwright MCP to navigate studio.youtube.com
    • Authenticate with your Google account
    • Upload video file
    • Fill metadata fields
    • Set visibility to public

  3. Execute Safely

    • Before uploading: Verify video file is valid
    • Confirm Google authentication works
    • Preview upload settings
    • Get your approval before publishing

  4. Validate Success

    • Check that YouTube provides a public URL
    • Verify video is accessible (not processing)
    • Test that video plays without errors
    • Confirm metadata is visible

Your Role During Implementation​

You don't watch passively. You're part of the execution:

  1. Approve Before Publishing — The assistant will show you the upload settings and ask: "Ready to publish?" You verify metadata is correct and approve.

  2. Troubleshoot If Needed — If something goes wrong (authentication fails, file too large), the assistant will show you options and ask for guidance.

  3. Validate The Outcome — Once published, you click the YouTube URL and verify the video plays.

Step 4: Validate Your YouTube Upload​

Once the video is published, run this validation checklist:

Pre-Upload Checklist (Before You Hit Publish)​

  • Video file exists — ./video-output/product-demo.mp4 is present and plays locally
  • Specification is complete — All required sections filled (Intent, Constraints, Success Evals, Non-Goals)
  • Skills are referenced — /sp.implement command includes --skills generate-video,upload-youtube
  • Google authentication ready — You can log into studio.youtube.com
  • Metadata is accurate — Title, description match your intention from Lesson 4

Post-Upload Validation (After Publishing)​

  • Video has public URL — YouTube provides a link like youtube.com/watch?v=...
  • Video is accessible — You can visit the URL (not stuck in "Processing")
  • Video plays completely — Click play, watch at least 30 seconds, verify no buffering
  • Metadata is visible — Title and description appear correctly on YouTube page
  • Portfolio-ready — You would show this link to a potential employer or client

Success Criteria Verification​

Map your YouTube upload to the specification success evals:

Success EvalEvidenceStatus
Video uploaded to YouTubeYouTube URL in browser✅ / ❌
Video accessible at public URLLink accessible without sign-in✅ / ❌
Video plays correctlyFull playback with no errors✅ / ❌
Metadata visibleTitle, description on page✅ / ❌
Portfolio-readyShareable with confidence✅ / ❌

Success condition: All evals marked ✅

Step 5: Reflection - Why Was This Faster?​

Now comes the insight: pause and measure what just happened.

Comparing Two Experiences​

Lesson 1-8 (Video Generation from Scratch)

You had to:

  1. Learn Playwright MCP concept (automation)
  2. Discover Gemini.google.com interface
  3. Write specification (45 min)
  4. Plan implementation (45 min)
  5. Execute tasks (60 min)
  6. Troubleshoot and validate (30+ min)
  7. Iterate when first attempt failed

Result: Comprehensive understanding of video generation, but time-consuming.

Lesson 11 (YouTube Upload with Skills)

You only had to:

  1. Write specification (15 min)
  2. Reference existing skills
  3. Run /sp.implement (30 min)
  4. Validate output (15 min)

Result: Video on YouTube, faster, using intelligence you built.

The Acceleration Hypothesis​

Why was this faster? Document your observations:

## Intelligence Acceleration - Reflection

### Time Comparison
- **Lesson 8 (video from scratch)**: ~3.5 hours
- **Lesson 11 (upload with skills)**: ~70 minutes
- **Time savings**: ~2 hours 20 minutes (65% reduction)

### Why It Was Faster
1. **Specification was simpler** — Upstream complexity handled by skills
2. **Skills encoded patterns** — No discovery needed (Gemini workflow, authentication, validation)
3. **Composition worked** — Reused intelligence instead of reinventing
4. **Fewer decisions** — Skill Persona + Questions meant fewer "what now?" moments

### What Came from Skills vs from Scratch
- **From `upload-youtube` skill**: Authentication flow, YouTube metadata mapping, upload error handling
- **From scratch** (minimal): Only how this specific video specification maps to YouTube

### Next Project (Hypothetical)
If you uploaded a second video tomorrow:
- **Without skills**: 2+ hours (similar to first time)
- **With skills**: 45 minutes (skills refined, patterns known)

### The Compounding Effect
- **Project 1**: 3.5 hours (build intelligence)
- **Project 2**: 1 hour (use intelligence)
- **Project 3**: 45 min (intelligence refined)
- **Project 10**: 20 min (mastered, automated)

**The math of intelligence accumulation**: Each new project takes progressively less time because you're not rediscovering patterns—you're applying known solutions at increasing velocity.

### Skills as Portfolio
- **Code library**: Developers inherit technical solutions
- **Intelligence skills**: Developers inherit reasoning frameworks and domain knowledge
- **Your advantage**: You're building a library of *thinking*, not just code

Stop here and reflect: What surprised you about the time difference? What did the skills actually buy you? Write 2-3 sentences in your own reflection document.

Chapter 14 Complete Validation Checklist​

You've completed Chapter 14. Verify you have:

✅ Projects Completed​

  • Video generation file — ./video-output/product-demo.mp4 exists and plays
  • Video published on YouTube — Public URL accessible and playable
  • Both skills created — generate-video and upload-youtube skills in your skill library

✅ Documentation Complete​

  • Constitution file — specs/video-project-constitution.md defines quality standards
  • Video generation spec — specs/video-generation/product-demo.md completed in Lesson 4
  • YouTube upload spec — specs/video-publication/youtube-upload.md completed in this lesson
  • Specifications refined — Both specs passed /sp.clarify validation
  • Implementation plan — specs/video-generation/plan.md detailed approach
  • Task breakdown — specs/video-generation/tasks.md atomic work units

✅ Skills Documented​

  • generate-video skill — Persona + Questions + Principles for video generation
  • upload-youtube skill — Persona + Questions + Principles for YouTube publication
  • Skill metadata — Both skills documented with proficiency levels and decision frameworks

✅ Intelligence Demonstrated​

  • Acceleration measured — Lesson 8 timeline (3.5 hours) vs Lesson 11 (70 minutes) documented
  • Skill reuse applied — /sp.implement explicitly referenced skills
  • Composition proven — YouTube upload used video generation skill output without modification
  • Compounding recognized — Reflection on how Project 2 would be faster than Project 1

✅ Portfolio-Ready Project​

  • Video on YouTube — Public URL you can share
  • Skills documented — Could explain them to another developer
  • Specification files — Show your thinking (specification primacy)
  • Timeline evidence — Can demonstrate intelligence acceleration to others

All boxes checked? You've completed the full SDD-RI cycle. You have:

  • Theory (Chapter 13)
  • Practice (Chapter 14, Lessons 1-10)
  • Application (Chapter 14, Lesson 11 - this capstone)
  • Reusable Intelligence (Two documented skills)
  • Portfolio Project (Video on YouTube)

You're now positioned to approach any new project with composition-first thinking instead of build-from-scratch thinking.

Try With AI​

Setup: Open your AI companion (Claude Code, Gemini, or ChatGPT). You're going to prepare your YouTube upload by having a reflection conversation about intelligence acceleration.

Prompt Set:

Prompt 1 (Understand Your Skills):
"I built two skills in Chapter 14:
1. generate-video — Creates product demo videos using Playwright MCP + Gemini
2. upload-youtube — Publishes videos to YouTube

In plain language, what kinds of future projects could I tackle faster using these two skills?
What new projects could I automate if I combined these skills with a third skill (like 'generate-thumbnail')?
How does having these skills change my development velocity?"

Prompt 2 (Measure Acceleration):
"I spent 3.5 hours generating my first video (Lessons 1-8).
I'm about to upload that video to YouTube using the skills I built (Lesson 11).
I estimate this will take ~70 minutes.

What should I be measuring about this time difference to prove that intelligence accumulation is real?
What should I track for the next project to show compound benefits?"

Prompt 3 (Projection):
"If I followed the SDD-RI approach for 5 more projects over the next year:
- What would my skill library look like?
- How would my development velocity improve?
- What's the long-term ROI of building reusable intelligence vs writing one-off code?"

Expected Outcomes:

  • Prompt 1: AI should help you envision future projects (marketing video automation, portfolio projects, client deliverables) where your skills provide leverage
  • Prompt 2: AI should highlight what makes intelligence valuable (pattern reuse, decision framework sharing, composability)
  • Prompt 3: AI should demonstrate exponential returns from intelligence accumulation (skills compound across projects)

Safety Note: When you share your YouTube URL or discuss future client work, remember that you're sharing your own work—you've built this. Credit yourself. You didn't use AI to generate the entire project—you used AI to accelerate building it with specifications and skills as the foundation.

Optional Stretch: Once your video is published, find a real SaaS product (not your own). Write a specification for a product demo video for that product. Estimate how long it would take you to execute it using your skills. Then, using your skills, actually generate and upload that demo video. This is how developers monetize their intelligence accumulation: by solving client problems faster than competitors.

Chapter 14 is now complete. You've demonstrated full SDD-RI mastery—from specification to implementation to reusable intelligence to accelerated execution.

You're ready for more complex projects. Your skills compound. Your intelligence library grows. Your development velocity increases exponentially.

This is the power of SDD-RI.