Build a Self-Improving YouTube Engine

Introduction

30 Second Summary

You have 20 years of expertise that nobody outside your company knows about. Engineers half your age are building audiences on YouTube, turning their knowledge into consulting leads, course revenue, and speaking gigs.

In this project, you will build a complete AI-powered YouTube content engine that scrapes trending topics, generates scripts and thumbnails, produces three content formats, and improves itself every week.

What You'll Build

A 7-component content pipeline orchestrated through Claude Desktop MCP servers, with live trend intelligence from Firecrawl and a self-improving agent that patches its own prompts after every production cycle.

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

• A Channel vault with 9 directories, identity files, and a 52-week business plan informed by live trend data from your niche.
• A 7-component pipeline covering capture, scripting, production, audience-RAG, evaluation, council governance, and trend intelligence.
• Three content artifacts (long-form script, shorts hooks, demo-live brief) benchmarked against real trending data in your niche.
• Secret Mission: Ship your first YouTube video and run your first trend-analysis cycle to plan video #2.

Are there any prerequisites?

You need a Windows 10/11 machine, a Claude Desktop Max plan (20x), and basic command-line familiarity. You should also have a topic area where you have deep expertise to share.

Bootstrap Your MCP Stack

You know what you want to share with the world. Now you need the infrastructure to make it happen.

This step provisions your entire tool stack in one shot: four command-line tools, two MCP servers, nine Python packages, and a 9-directory content vault. A single PowerShell script handles the heavy lifting while you grab your free Firecrawl API key in parallel.

In this step, get ready to:

• Install Node.js, Python, Git, ffmpeg, and Obsidian via a bootstrap script.
• Configure Claude Desktop with 4 MCP servers (filesystem, git, sqlite, firecrawl).
• Open your Channel vault in Obsidian and test the full stack.

Run the bootstrap script and get your Firecrawl API key

The bootstrap script checks whether Node.js, Python, Git, and ffmpeg are installed on your machine. If any tool is missing, it installs it via winget. It also creates your entire Channel vault directory structure and installs all required packages.

• Press the Windows key to open your search bar.
• Type PowerShell, right-click Windows PowerShell, and select Run as administrator.

Why run as administrator?

The winget install commands inside the script install system-level software. Windows requires administrator privileges for these operations.

• Allow PowerShell to run local scripts by running this command:

Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

What does this command do?

Windows blocks all PowerShell scripts by default. RemoteSigned allows scripts you create locally to run while still blocking unsigned scripts downloaded from the internet.

PowerShell will ask you to confirm the change. Type Y and press Enter.

• Move to your Desktop by running this command:

cd ~/Desktop

• Create the bootstrap script file by running this command:

notepad bootstrap.ps1

• Notepad will ask if you want to create a new file. Click Yes.
• Paste the following code into Notepad:

# Zero to Creator - Windows Bootstrap Script
# Run as Administrator: Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

Write-Host "=== Zero to Creator: Bootstrap ===" -ForegroundColor Cyan
Write-Host "Building your AI content engine..." -ForegroundColor Yellow

# Check Node.js
if (!(Get-Command node -ErrorAction SilentlyContinue)) {
    Write-Host "Installing Node.js 20 LTS..." -ForegroundColor Green
    winget install OpenJS.NodeJS.LTS --accept-package-agreements --accept-source-agreements
} else {
    Write-Host "Node.js found: $(node --version)" -ForegroundColor Green
}

# Check Python
if (!(Get-Command python -ErrorAction SilentlyContinue)) {
    Write-Host "Installing Python 3.11..." -ForegroundColor Green
    winget install Python.Python.3.11 --accept-package-agreements --accept-source-agreements
} else {
    Write-Host "Python found: $(python --version)" -ForegroundColor Green
}

# Check Git
if (!(Get-Command git -ErrorAction SilentlyContinue)) {
    Write-Host "Installing Git..." -ForegroundColor Green
    winget install Git.Git --accept-package-agreements --accept-source-agreements
} else {
    Write-Host "Git found: $(git --version)" -ForegroundColor Green
}

# Check ffmpeg
if (!(Get-Command ffmpeg -ErrorAction SilentlyContinue)) {
    Write-Host "Installing ffmpeg..." -ForegroundColor Green
    winget install Gyan.FFmpeg --accept-package-agreements --accept-source-agreements
} else {
    Write-Host "ffmpeg found: $(ffmpeg -version | Select-Object -First 1)" -ForegroundColor Green
}

# Check Obsidian (your vault interface)
if (!(Get-Command obsidian -ErrorAction SilentlyContinue)) {
    Write-Host "Installing Obsidian..." -ForegroundColor Green
    winget install Obsidian.Obsidian --accept-package-agreements --accept-source-agreements
} else {
    Write-Host "Obsidian found." -ForegroundColor Green
}

# Install MCP servers globally
Write-Host "Installing MCP servers..." -ForegroundColor Yellow
npm install -g @modelcontextprotocol/server-filesystem
npm install -g firecrawl-mcp

# Install Python dependencies
Write-Host "Installing Python packages..." -ForegroundColor Yellow
pip install openai-whisper whisperx arize-phoenix dspy-ai ragas pydantic fastapi uvicorn sqlalchemy

# Create Channel vault structure (9 directories)
$channelRoot = "$env:USERPROFILE\Channel"
Write-Host "Creating Channel vault at $channelRoot..." -ForegroundColor Yellow

$directories = @(
    "$channelRoot\00-Raw-Recordings",
    "$channelRoot\01-Staging",
    "$channelRoot\02-Ingest",
    "$channelRoot\03-Published",
    "$channelRoot\Council",
    "$channelRoot\Operations\reviews",
    "$channelRoot\Trends",
    "$channelRoot\System",
    "$channelRoot\eval\goldset-v0"
)

foreach ($dir in $directories) {
    New-Item -ItemType Directory -Force -Path $dir | Out-Null
}

# Initialize git repo
Set-Location $channelRoot
git init
git add .
git commit -m "Zero to Creator: initial vault scaffold"

Write-Host ""
Write-Host "=== Bootstrap Complete ===" -ForegroundColor Cyan
Write-Host "Next steps:" -ForegroundColor Yellow
Write-Host "  1. Get free Firecrawl API key: https://www.firecrawl.dev/app/api-keys" -ForegroundColor White
Write-Host "  2. Open Obsidian and select $channelRoot as your vault" -ForegroundColor White
Write-Host "  3. Edit: %APPDATA%\Claude\claude_desktop_config.json" -ForegroundColor White
Write-Host "  4. Restart Claude Desktop, verify 4 MCP servers connected" -ForegroundColor White
Write-Host "Vault: $channelRoot" -ForegroundColor Green

What does this script do?

• Checks for Node.js, Python, Git, ffmpeg, and Obsidian. Installs any that are missing via winget.
• Installs two MCP server packages globally: @modelcontextprotocol/server-filesystem and firecrawl-mcp.
• Installs nine Python packages for transcription, evaluation, and API serving.
• Creates your Channel/ vault at C:\Users\USERNAME\Channel with 9 directories for raw recordings, staging, publishing, and more.
• Initializes a Git repository inside the vault with your first commit.

• Save the file by pressing Ctrl+S, then close Notepad.
• Run the bootstrap script by running this command:

.\bootstrap.ps1

The script takes about 5 minutes to finish. While it runs, use that time to get your Firecrawl API key.

• Open your browser and go to https://www.firecrawl.dev/app/api-keys.
• Sign up for a free account. No credit card is required. The free tier gives you 1,000 credits per month.
• Copy your API key. It starts with fc-. Save it somewhere safe (a text file or password manager).

What is Firecrawl?

Firecrawl is a web scraping API that extracts structured data from websites. You will use it through Claude Desktop's MCP integration to scrape trending YouTube topics, analyze competitor channels, and find content gaps in your niche.

Once the script finishes, you should see === Bootstrap Complete === in cyan text in your terminal.

• Verify your Node.js version by running this command:

node --version

✔️ I see v20 or higher

Node.js is ready. Move on to the Python version check below.

ⓧ I see a version lower than v20

You have an older version installed. The bootstrap script only installs Node.js if it is completely absent.

• Upgrade to Node.js 20 LTS by running this command:

winget install OpenJS.NodeJS.LTS --accept-package-agreements --accept-source-agreements

• Close and reopen PowerShell as administrator, then run node --version again to confirm v20 or higher.

ⓧ Command not found

Node.js was installed by the script but your current PowerShell session does not see it yet.

• Close PowerShell completely and reopen it as administrator.
• Run node --version again. You should now see v20 or higher.

• Verify your Python version by running this command:

python --version

✔️ I see Python 3.11 or higher

Python is ready. You are all set to move on.

ⓧ I see a version lower than 3.11

You have an older version installed. The bootstrap script only installs Python if it is completely absent.

• Install Python 3.11 alongside your existing version by running:

winget install Python.Python.3.11 --accept-package-agreements --accept-source-agreements

• Close and reopen PowerShell as administrator.
• Run python --version again. If it still shows the old version, try python3.11 --version or use the full path at C:\Users\USERNAME\AppData\Local\Programs\Python\Python311\python.exe.

ⓧ Command not found

Python was installed by the script but your current session does not see it yet.

• Close PowerShell completely and reopen it as administrator.
• Run python --version again. You should see Python 3.11 or higher.

Script failed partway through?

• If you see a permission error, make sure you opened PowerShell with Run as administrator.
• If winget is not recognized, you may be on an older Windows 10 build. Update Windows via Settings > Windows Update, then try again.
• If npm install -g fails, close and reopen PowerShell so it picks up the newly installed Node.js, then re-run .\bootstrap.ps1.

Help me troubleshoot my bootstrap script failing on Windows

✔️ Awesome, I've got everything!

Great. Make sure your Firecrawl API key is saved somewhere accessible. You will need it in the next substep.

ⓧ I'd like to double check the full code

Here is the full bootstrap.ps1 script for comparison:

# Zero to Creator - Windows Bootstrap Script
# Run as Administrator: Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

Write-Host "=== Zero to Creator: Bootstrap ===" -ForegroundColor Cyan
Write-Host "Building your AI content engine..." -ForegroundColor Yellow

# Check Node.js
if (!(Get-Command node -ErrorAction SilentlyContinue)) {
    Write-Host "Installing Node.js 20 LTS..." -ForegroundColor Green
    winget install OpenJS.NodeJS.LTS --accept-package-agreements --accept-source-agreements
} else {
    Write-Host "Node.js found: $(node --version)" -ForegroundColor Green
}

# Check Python
if (!(Get-Command python -ErrorAction SilentlyContinue)) {
    Write-Host "Installing Python 3.11..." -ForegroundColor Green
    winget install Python.Python.3.11 --accept-package-agreements --accept-source-agreements
} else {
    Write-Host "Python found: $(python --version)" -ForegroundColor Green
}

# Check Git
if (!(Get-Command git -ErrorAction SilentlyContinue)) {
    Write-Host "Installing Git..." -ForegroundColor Green
    winget install Git.Git --accept-package-agreements --accept-source-agreements
} else {
    Write-Host "Git found: $(git --version)" -ForegroundColor Green
}

# Check ffmpeg
if (!(Get-Command ffmpeg -ErrorAction SilentlyContinue)) {
    Write-Host "Installing ffmpeg..." -ForegroundColor Green
    winget install Gyan.FFmpeg --accept-package-agreements --accept-source-agreements
} else {
    Write-Host "ffmpeg found: $(ffmpeg -version | Select-Object -First 1)" -ForegroundColor Green
}

# Check Obsidian (your vault interface)
if (!(Get-Command obsidian -ErrorAction SilentlyContinue)) {
    Write-Host "Installing Obsidian..." -ForegroundColor Green
    winget install Obsidian.Obsidian --accept-package-agreements --accept-source-agreements
} else {
    Write-Host "Obsidian found." -ForegroundColor Green
}

# Install MCP servers globally
Write-Host "Installing MCP servers..." -ForegroundColor Yellow
npm install -g @modelcontextprotocol/server-filesystem
npm install -g firecrawl-mcp

# Install Python dependencies
Write-Host "Installing Python packages..." -ForegroundColor Yellow
pip install openai-whisper whisperx arize-phoenix dspy-ai ragas pydantic fastapi uvicorn sqlalchemy

# Create Channel vault structure (9 directories)
$channelRoot = "$env:USERPROFILE\Channel"
Write-Host "Creating Channel vault at $channelRoot..." -ForegroundColor Yellow

$directories = @(
    "$channelRoot\00-Raw-Recordings",
    "$channelRoot\01-Staging",
    "$channelRoot\02-Ingest",
    "$channelRoot\03-Published",
    "$channelRoot\Council",
    "$channelRoot\Operations\reviews",
    "$channelRoot\Trends",
    "$channelRoot\System",
    "$channelRoot\eval\goldset-v0"
)

foreach ($dir in $directories) {
    New-Item -ItemType Directory -Force -Path $dir | Out-Null
}

# Initialize git repo
Set-Location $channelRoot
git init
git add .
git commit -m "Zero to Creator: initial vault scaffold"

Write-Host ""
Write-Host "=== Bootstrap Complete ===" -ForegroundColor Cyan
Write-Host "Next steps:" -ForegroundColor Yellow
Write-Host "  1. Get free Firecrawl API key: https://www.firecrawl.dev/app/api-keys" -ForegroundColor White
Write-Host "  2. Open Obsidian and select $channelRoot as your vault" -ForegroundColor White
Write-Host "  3. Edit: %APPDATA%\Claude\claude_desktop_config.json" -ForegroundColor White
Write-Host "  4. Restart Claude Desktop, verify 4 MCP servers connected" -ForegroundColor White
Write-Host "Vault: $channelRoot" -ForegroundColor Green

Configure Claude Desktop MCP

Claude Desktop uses a JSON config file to know which MCP servers to launch. You will wire it to your Channel vault (filesystem), your Git repo, a SQLite database for provenance tracking, and Firecrawl for live web intelligence.

• Open the MCP configuration file by running this command:

notepad $env:APPDATA\Claude\claude_desktop_config.json

• If the file does not exist yet, Notepad will ask to create it. Click Yes.
• Replace the entire contents of the file with the following configuration:

{
  "mcpServers": {
    "filesystem": {
      "command": "C:\\Program Files\\nodejs\\npx.cmd",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "C:\\Users\\[[WIN_USERNAME=\"your Windows username\"]]\\Channel"
      ]
    },
    "git": {
      "command": "C:\\Program Files\\nodejs\\npx.cmd",
      "args": [
        "-y",
        "@modelcontextprotocol/server-git",
        "--repository",
        "C:\\Users\\[[WIN_USERNAME=\"your Windows username\"]]\\Channel"
      ]
    },
    "sqlite": {
      "command": "C:\\Program Files\\nodejs\\npx.cmd",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sqlite",
        "--db-path",
        "C:\\Users\\[[WIN_USERNAME=\"your Windows username\"]]\\Channel\\provenance.db"
      ]
    },
    "firecrawl": {
      "command": "C:\\Program Files\\nodejs\\npx.cmd",
      "args": [
        "-y",
        "firecrawl-mcp"
      ],
      "env": {
        "FIRECRAWL_API_KEY": "fc-YOUR_API_KEY_HERE"
      }
    }
  }
}

What does this config do?

• Each entry under mcpServers tells Claude Desktop to launch an MCP server as a child process.
• The C:\\Program Files\\nodejs\\npx.cmd path is the full path to npx on Windows. Using the full path prevents "command not found" errors.
• The -y flag auto-confirms any install prompts so the server starts without hanging.
• The filesystem server gives Claude read/write access to your Channel/ vault.
• The firecrawl server gives Claude live web scraping capabilities using your API key.

• Replace fc-YOUR_API_KEY_HERE with the Firecrawl API key you copied earlier.
• Save the file by pressing Ctrl+S and close Notepad.
• Fully quit Claude Desktop. Right-click the Claude icon in your system tray and select Quit. Closing the window is not enough.
• Reopen Claude Desktop.
• Look for the hammer icon (or the MCP tools indicator) in the chat input area. Click it to confirm all 4 servers are listed as connected.

✔️ I see all 4 servers connected

Your MCP stack is wired up. Claude Desktop can now access your vault, Git history, SQLite database, and live web data.

ⓧ Hammer icon missing or servers not showing

• Open claude_desktop_config.json and check for JSON syntax errors. A missing comma or bracket will silently break the config.
• Verify that the path C:\Program Files\nodejs\npx.cmd exists on your machine. If Node.js installed to a different location, update the command paths accordingly.
• Make sure you replaced all instances of your Windows username in the file paths.
• Quit Claude Desktop completely from the system tray (not just close the window) and reopen it.
• Check the logs at %APPDATA%\Claude\logs for specific error messages.

Help me debug my MCP server connection in Claude Desktop on Windows

✔️ Awesome, I've got everything!

Great. Double check you saved claude_desktop_config.json and that Claude Desktop restarted cleanly.

ⓧ I'd like to double check the full code

Here is the full claude_desktop_config.json for comparison:

{
  "mcpServers": {
    "filesystem": {
      "command": "C:\\Program Files\\nodejs\\npx.cmd",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "C:\\Users\\USERNAME\\Channel"
      ]
    },
    "git": {
      "command": "C:\\Program Files\\nodejs\\npx.cmd",
      "args": [
        "-y",
        "@modelcontextprotocol/server-git",
        "--repository",
        "C:\\Users\\USERNAME\\Channel"
      ]
    },
    "sqlite": {
      "command": "C:\\Program Files\\nodejs\\npx.cmd",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sqlite",
        "--db-path",
        "C:\\Users\\USERNAME\\Channel\\provenance.db"
      ]
    },
    "firecrawl": {
      "command": "C:\\Program Files\\nodejs\\npx.cmd",
      "args": [
        "-y",
        "firecrawl-mcp"
      ],
      "env": {
        "FIRECRAWL_API_KEY": "fc-YOUR_API_KEY_HERE"
      }
    }
  }
}

Test the full MCP stack

The config is in place. Now you will confirm that Claude Desktop can actually reach your vault and the live web through the MCP servers.

• Open a new conversation in Claude Desktop.
• Type the following message and send it:

Create a file called test.txt in my Channel folder with the content "MCP filesystem is working" and then read it back to confirm.

• Claude will ask for permission to use the filesystem tool. Click Allow.
• Confirm Claude reports the file was created and read back successfully.

Why does Claude ask for permission?

MCP tools require your explicit approval before taking any action. This keeps you in control. Every file write, database query, or web scrape goes through you first.

• Now test Firecrawl by sending this message:

Search the web for "YouTube [your niche] trending 2026" using Firecrawl and summarize the top 3 results.

• Allow the Firecrawl tool when Claude asks for permission.
• Confirm Claude returns real search results with titles and summaries from current web pages.

Both tests passed. You now have live web intelligence and local vault access in one Claude session.

• Clean up by sending this final message:

Delete the test.txt file you just created in my Channel folder.

• Allow the deletion when prompted.

Firecrawl search returning an error?

• Double-check that your FIRECRAWL_API_KEY in claude_desktop_config.json matches the key from your Firecrawl dashboard. It should start with fc-.
• Make sure you fully quit and restarted Claude Desktop after editing the config.
• Verify your Firecrawl account is active by logging into firecrawl.dev and checking your credit balance.

Help me fix my Firecrawl MCP connection in Claude Desktop

Open your Channel vault in Obsidian

Every file Claude creates through MCP lands in the Channel/ folder. Obsidian turns that folder into a linked, searchable knowledge base. From this point on, Obsidian is your source of truth for everything the system produces.

• Press the Windows key to open your search bar.
• Type Obsidian and press Enter to open it.
• On the first launch, Obsidian asks you to create or open a vault. Click Open folder as vault.
• Navigate to C:\Users\USERNAME\Channel (replace USERNAME with your Windows username) and click Select Folder.

Obsidian creates a .obsidian/ config folder inside your vault. You should see all 9 directories from the bootstrap script listed in the left sidebar.

Why Obsidian as the vault?

Obsidian stores everything as plain markdown files on your local disk. Claude writes markdown through the filesystem MCP server, and Obsidian renders it instantly. No syncing, no cloud dependency, no format conversion.

As your channel grows, you get backlinks between notes, graph views of how ideas connect, and full-text search across every file the system produces.

🙋‍♀️ Obsidian not showing your folders?

• Make sure you selected the Channel folder itself, not a subfolder inside it.
• If the sidebar is empty, click the folder icon at the top-left to expand the file explorer panel.
• If Obsidian opened with a different vault, click the vault icon (bottom-left) and select Open another vault, then choose your Channel folder.

Help me connect my Channel folder as an Obsidian vault

Your entire infrastructure is live. Claude Desktop can read and write files in your Obsidian vault, track changes with Git, store provenance data in SQLite, and scrape live web data through Firecrawl. Next up, you will use this stack to define your channel identity and pull real trend intelligence.

Define Your Identity and Business Plan

Your MCP stack is live and your Obsidian vault is open. Claude Desktop can read and write markdown files directly into your vault, and you see every change instantly in Obsidian's sidebar.

Now you need to answer the most important question: who are you as a creator, and what does the market actually want? In this step, Claude conducts a deep identity interview while simultaneously scraping YouTube trends for your niche. The intersection of your expertise and real search demand becomes your content strategy.

In this step, get ready to:

• Complete a 10-question identity interview with simultaneous trend scanning.
• Generate a 52-week business plan with 100x growth targets.
• Create 4 Mermaid diagrams for your GitHub README.

Run the identity interview and trend scan

This is the most important prompt you will paste in the entire project. It tells Claude to do two things at once: interview you about your expertise (10 questions) and scrape live YouTube data for your niche using Firecrawl. While you answer identity questions, Claude gathers market intelligence in the background.

• Open Claude Desktop (it should already be running with 4 MCP servers connected from Step 1).
• Start a new conversation.
• Paste the following prompt to kick off the identity interview and parallel trend scan:

You are my channel strategist. We're building a YouTube channel from zero. I need you to do TWO things in parallel:

## Part 1: Identity Interview (ask me these 10 questions one at a time)
1. What do you do for a living, and how long have you been doing it?
2. What's the one problem you solve better than anyone you know?
3. Who specifically needs to hear what you know? (age, role, situation)
4. What 5 themes could you talk about every single week without getting bored?
5. What's your teaching style - formal, casual, story-driven, evidence-first?
6. What do you believe that most people in your field disagree with?
7. What will you NEVER do on your channel? (anti-positions)
8. What does success look like at 12 months?
9. What's your weekly time budget for content creation?
10. Name 12 questions you're obsessed with solving (your "twelve favorite problems").

## Part 2: Trend Scan (do this WHILE waiting for my answers)
Using Firecrawl, search for:
- "YouTube [[NICHE="your niche topic, e.g. cloud engineering"]] trending 2026" - find what topics are getting views right now
- Top 5 channels in [[NICHE="your niche topic"]] - note their titles, view counts, posting frequency
- "[[NICHE="your niche topic"]] tutorial keyword difficulty" - find gaps

Save trend results to Channel/Trends/ as a markdown file named with today's date.

## After all 10 answers:
Generate these markdown files using filesystem MCP (all .md so they render in Obsidian):
1. Channel/channel-identity.md (structured with YAML frontmatter containing: channel_name, tagline, origin_story, 5 themes, voice settings, virtue_signals, declared_positions, anti_positions, content_formats, sustainability)
2. Channel/System/twelve-favorite-problems.md (the 12 questions from Q10, one per heading)
3. Channel/02-Ingest/audience-pain-points.md (v0 - derived from my answers + trend data)

Start with Question 1. Run the Firecrawl searches immediately - don't wait for my answers.

What happens when you paste this prompt?

Claude will ask you Question 1 immediately. At the same time, it uses the Firecrawl MCP server to search the web for trending YouTube content in your niche. You will see tool-use indicators as Claude calls firecrawl_search between questions.

Answer each question thoughtfully. Your answers directly shape the channel-identity.md file that drives every future output from the system. Spend 8-10 minutes on this interview. When Claude saves files, they appear instantly in your Obsidian sidebar.

• Answer all 10 questions as Claude asks them.
• After you finish Question 10, Claude generates the three YAML files and saves the trend scan results.
• Confirm Claude created the files by asking it to list what it saved.

Check your Obsidian sidebar. You should see channel-identity.md, twelve-favorite-problems.md, audience-pain-points.md, and a trend scan file in Channel/Trends/. Click any file to preview it in Obsidian's editor.

Claude not using Firecrawl?

If Claude says it cannot search the web or does not show Firecrawl tool calls, verify that the hammer icon in the bottom-left of Claude Desktop shows 4 connected servers. If Firecrawl is missing, restart Claude Desktop.

help me troubleshoot why Claude Desktop is not connecting to my Firecrawl MCP server

💡 Why run identity and trends in parallel?

Most creator programs tell you to pick a niche based on what you like. That is half the equation. The other half is what people are actively searching for. By running both simultaneously, you get a content strategy built on the intersection of your deep expertise and proven market demand.

Generate your 52-week business plan

Your identity is defined and your trend data is fresh. Now Claude synthesizes both into a concrete business plan with measurable growth targets.

• In the same Claude Desktop conversation, paste this follow-up prompt to generate the business plan:

Now generate my 52-week business plan. Save it to Channel/business-plan.md.

Incorporate the trend data you just gathered. The plan must include:

1. **Content pillars** - map my 5 themes to the trending topics you found. Which of my themes has the most market demand right now?

2. **Publishing cadence** - 1 video/week (Sunday publish), 2-3 shorts per video, 1 demo-live per month starting Day-60.

3. **100x Growth targets** (I'm starting from zero):
   - Day-30: 4 videos published, 100 subscribers
   - Day-90: 12 videos, 500 subscribers
   - Day-180: 24 videos, 2,000 subscribers, YouTube Partner Program achieved
   - Day-365: 52 videos, 10,000 subscribers, $500/mo revenue

4. **Time allocation** - 7-14 hrs/week broken into: Record, Edit, Publish+SEO, Engage, System Review, Learning, Trend Scan.

5. **Monetization runway** - when each revenue stream becomes viable:
   - YPP (1,000 subs + 4,000 watch hours)
   - Super Thanks
   - Channel Memberships
   - Sponsorships
   - Consulting leads

Make it specific to MY themes and the competitive landscape you found.

What does this business plan give you?

This is not a generic template. Claude maps YOUR themes against REAL trending data to recommend which content pillar to prioritize first. The growth targets are concrete checkpoints. If you hit Day-30 with 4 videos and 100 subscribers, the system is working.

If you miss a target, the self-improving agent (built in Step 5) captures why and patches the pipeline. You never fly blind.

• Wait for Claude to finish generating and saving business-plan.md.
• Ask Claude to show you the first content pillar recommendation. Confirm it maps one of your themes to a real trending topic.

You should see a specific recommendation like "Your theme X maps to trending topic Y, which has Z views and low keyword difficulty."

Business plan seems generic?

If the plan does not reference specific trending data or competitor channels, Claude may not have successfully completed the Firecrawl searches in the previous step. Ask Claude: "Did the Firecrawl trend scan succeed? Show me the data you found." If it failed, re-run the trend scan portion separately.

help me get Claude to incorporate real trend data into my business plan

Generate Mermaid diagrams for your README

Your system architecture deserves visual documentation. GitHub renders Mermaid diagrams natively inside markdown files. You will generate 4 diagrams that make your README a visual map of how the whole system works.

• Paste this prompt to generate the README with all 4 diagrams:

Generate Channel/README.md with a complete project overview and 4 Mermaid diagrams that render natively on GitHub.

The README structure:

# Zero to Creator
> 20-year corporate engineer builds an AI-powered YouTube channel from zero.
> If I can do it, anyone can. 100x in Year 1.

## The Thesis
You do not need connections, a team, or $5,000/quarter coaching. You need a system that eliminates friction, learns from failure, and compounds your expertise into an audience.

## 100x Growth Targets
(Table with Day-30, Day-90, Day-180, Day-365 milestones from the business plan)

## System Architecture (7 Components)
```mermaid
flowchart TB diagram showing: Capture + Transcript -> Organize (Script + Hook Builder) -> Distill (Production Pipeline) -> Express (Audience-RAG) -> Evaluate (Eval + Self-Improvement) -> Council (Council + Future-Proofing). Plus a separate Trend Intelligence component feeding into Organize.
```

## Weekly Cadence
```mermaid
sequenceDiagram showing the Sunday session flow: You <-> Claude+MCP <-> Firecrawl <-> YouTube. Show: trend scan, topic recommendation, recording, transcription, content generation, publishing, and the self-improvement loop.
```

## Content Pipeline
```mermaid
flowchart LR showing time-per-stage: Record (2hr) -> Transcribe (5min) -> Extract Claims (10min) -> Generate Package (15min) -> Edit (2hr) -> Publish (30min) -> Evaluate (15min)
```

## 52-Week Growth
```mermaid
gantt chart showing growth milestones across the year: first video, YPP milestone, 10K subscribers, revenue targets.
```

## Budget: $0/mo Additional
(Table showing all tools and their costs - all free or already owned)

Save this to Channel/README.md using filesystem MCP.

Why Mermaid diagrams in your README?

GitHub renders Mermaid diagrams directly in markdown files, issues, discussions, and pull requests. No image files to maintain. No external tools to install. You write the diagram as text, and GitHub renders it as a visual flowchart, sequence diagram, or Gantt chart.

When you push this repo to GitHub, anyone visiting sees a professional architecture overview without you ever opening a design tool.

• Wait for Claude to confirm it saved Channel/README.md.
• Ask Claude to read back the first Mermaid diagram to confirm it uses valid syntax.

You should see a flowchart TB block showing your 7 system components connected with arrows.

Mermaid diagram not rendering on GitHub?

Mermaid blocks must be wrapped in a fenced code block with the mermaid language identifier. Ask Claude to verify each diagram starts with a triple-backtick line followed by mermaid and ends with a triple-backtick line.

help me fix my Mermaid diagrams so they render on GitHub

✔️ Everything looks good

Your identity, trends, business plan, and README are all saved in the vault and visible in Obsidian.

ⓧ I'd like to double check my files

Open your Obsidian sidebar and expand each folder. You should see these files:

• Channel/channel-identity.md with your 5 themes, voice settings, positions, and sustainability config in YAML frontmatter.
• Channel/System/twelve-favorite-problems.md with 12 questions.
• Channel/02-Ingest/audience-pain-points.md v0.
• Channel/Trends/YYYY-MM-DD_initial-scan.md with trend data (today's date).
• Channel/business-plan.md with 100x targets and monetization runway.
• Channel/README.md with 4 Mermaid diagrams.

If any file is missing, ask Claude to generate it. Reference the specific prompt from this step. Files created by Claude appear in Obsidian immediately without needing to refresh.

Your channel identity is locked, your market is scanned, and your 52-week plan has concrete targets backed by real data. Everything lives in your Obsidian vault as markdown. Next up, you will record your first video on a topic chosen by the intersection of your expertise and live trend intelligence.

Record, Capture, and Transcribe Your First Video

You have a channel identity, a business plan, and live trend data. Now it is time to create the raw material that feeds your entire content pipeline.

In this step, you will record your first 12-minute video on a topic informed by real data. Then you will run it through an automated capture pipeline that transcribes, timestamps, and extracts the core intellectual property from your recording.

In this step, get ready to:

• Record a 12-minute video on a Claude-recommended topic using OBS Studio.
• Transcribe your recording with word-level timestamps using Whisper and WhisperX.
• Extract scored atomic claims that become your content building blocks.

Get your first video topic from Claude

Your trend scan and twelve-favorite-problems already contain the data Claude needs to pick a winning topic. The best first video sits at the intersection of what you know deeply and what people are actively searching for.

• Open Claude Desktop and paste the following prompt:

Read my Channel/System/twelve-favorite-problems.yaml and Channel/Trends/ initial scan file via filesystem MCP. Find the topic with the highest overlap between my intellectual obsessions and current trending search demand. Recommend my first video topic with:
1. A working title
2. Why this topic has high potential (trend data evidence)
3. Which of my 12 problems it maps to
4. A 2-sentence angle that differentiates me from competitors in the trend scan

What does this prompt do?

Claude reads both your personal interests (twelve-favorite-problems) and real market data (trend scan) via filesystem MCP. It finds the topic where your expertise and audience demand overlap most. This means you are not guessing what to talk about.

• Review Claude's recommendation. If the topic resonates, proceed. If not, ask Claude for two alternative angles from the same data.
• Note down the recommended topic title for your recording.

Now you need OBS Studio to capture your screen and webcam.

• Install OBS Studio by running this command:

winget install OBSProject.OBSStudio --accept-package-agreements --accept-source-agreements

What is OBS Studio?

OBS Studio is a free, open-source screen recorder and live streaming tool. It captures your screen, webcam, and microphone simultaneously into a single video file.

• Press the Windows key to open your search bar.
• Type OBS Studio and press Enter to open it.
• On first launch, OBS will ask you to run the Auto-Configuration Wizard. Select Optimize just for recording and click Next.
• Set Base (Canvas) Resolution to 1920x1080.
• Set FPS to 30.
• Click Apply Settings.

Now configure the recording format and audio settings.

• Click Settings in the bottom-right panel.
• Select Output in the left sidebar.
• Set Recording Format to mkv.
• Set Recording Path to C:\Users\USERNAME\Channel\00-Raw-Recordings.
• Select Audio in the left sidebar.
• Set Sample Rate to 48 kHz.
• Click OK to save.

Why MKV format?

MKV is crash-resistant. If OBS or your machine crashes mid-recording, an MKV file is still recoverable. MP4 files become corrupted and unplayable if the recording is interrupted.

• In the Sources panel at the bottom, click the + button.
• Add a Display Capture source for your screen.
• Click + again and add a Video Capture Device source for your webcam.
• Resize and position your webcam overlay in the corner of the preview.

You are ready to record. Take a breath, open the material for your topic, and hit record.

• Click Start Recording in the bottom-right panel.
• Record for approximately 12 minutes on your Claude-recommended topic.
• Click Stop Recording when finished.

Your first recording will feel awkward

Every creator's first recording feels stilted. That is normal. The pipeline does not need perfection from you. It needs raw material. Speak as if you are explaining the topic to a colleague over coffee.

• Verify your recording exists by running:

ls $env:USERPROFILE\Channel\00-Raw-Recordings\

You should see an .mkv file in the output.

Don't see your recording?

Check the Recording Path in OBS Settings > Output. It must point to C:\Users\USERNAME\Channel\00-Raw-Recordings. If you left the default path, your file is in the OBS default recording folder instead.

Still stuck? Ask for help.

Run the capture pipeline to transcribe your recording

Your raw recording needs to be converted into text before the system can work with it. The pipeline has three stages: audio extraction, transcription, and word-level timestamp alignment.

• Extract audio from your recording as a 16kHz mono WAV by running this command (replace the filename with your actual .mkv filename):

ffmpeg -i $env:USERPROFILE\Channel\00-Raw-Recordings\[[RECORDING_FILE="your-recording-filename.mkv"]] -vn -acodec pcm_s16le -ar 16000 -ac 1 $env:USERPROFILE\Channel\01-Staging\transcript-audio.wav

What does this command do?

`-vn` strips the video track so only audio remains. `-ar 16000` resamples to 16kHz, which is the sample rate Whisper expects. `-ac 1` converts to mono. The result is a lightweight WAV file optimized for speech recognition.

• Verify the WAV file was created:

ls $env:USERPROFILE\Channel\01-Staging\transcript-audio.wav

You should see transcript-audio.wav listed.

• Transcribe the audio using Whisper large-v3 by running:

whisper $env:USERPROFILE\Channel\01-Staging\transcript-audio.wav --model large-v3 --output_format json --output_dir $env:USERPROFILE\Channel\01-Staging\

What is Whisper?

Whisper is OpenAI's open-source speech recognition model. The large-v3 variant is the highest-accuracy version, trained on over 1 million hours of audio. It runs locally on your machine, so no data leaves your computer.

This step may take 5-15 minutes depending on your hardware. If you have a CUDA-compatible GPU, Whisper will use it automatically for faster processing.

🙋‍♀️ Whisper running very slowly?

If transcription is taking more than 20 minutes, your machine may be running Whisper on CPU. You can use the turbo model instead, which is 8x faster with only slightly lower accuracy:

whisper $env:USERPROFILE\Channel\01-Staging\transcript-audio.wav --model turbo --output_format json --output_dir $env:USERPROFILE\Channel\01-Staging\

Help me speed up Whisper transcription on my machine.

• Now align word-level timestamps using WhisperX:

whisperx $env:USERPROFILE\Channel\01-Staging\transcript-audio.wav --model large-v3 --output_format json --output_dir $env:USERPROFILE\Channel\01-Staging\

Why use WhisperX after Whisper?

Whisper gives you segment-level timestamps (when each sentence starts and ends). WhisperX adds word-level timestamps using a phoneme alignment model (wav2vec2). This precision is what lets the system later identify exactly which seconds contain your strongest hooks.

• Store the transcript with a provenance hash in SQLite. Paste this prompt into Claude Desktop:

Read the transcript JSON from Channel/01-Staging/ via filesystem MCP. Then use sqlite MCP to:
1. Create a 'recordings' table if it doesn't exist (columns: id, filename, sha256_hash, transcript_path, created_at)
2. Compute the SHA-256 hash of the transcript JSON file content
3. Insert a record with the filename, hash, and path
4. Save the transcript to Channel/01-Staging/ with word-level timestamps preserved

Confirm the record was inserted by querying the recordings table.

Why store a SHA-256 hash?

The hash creates a tamper-proof provenance record. If anyone ever questions whether your content was AI-generated from scratch or based on your actual spoken words, you have cryptographic proof linking your published content back to the original recording.

Claude will confirm the record was inserted and show you the SHA-256 hash. Your transcript is now stored in Channel/01-Staging/ with provenance tracked in Channel/provenance.db.

• Verify the WER (Word Error Rate) target of <=8% by asking Claude:

Read the transcript from Channel/01-Staging/ via filesystem MCP. Sample 5 random segments (each 30 seconds of audio). For each segment, show me the transcribed text so I can spot-check against what I actually said. Estimate the WER based on any obvious errors you can identify in the transcript (repeated words, hallucinated phrases, missing words). Is the quality at or below 8% WER?

Spot-checking is sufficient for v0

Formal WER measurement requires a ground-truth transcript you manually type. For your first video, Claude's spot-check against the audio context is enough. You will build a proper goldset for automated evaluation in Step 5.

🙋‍♀️ Transcript quality seems poor?

If you see many errors, check your audio quality. Background noise and low microphone volume are the most common causes. Re-record a 2-minute test clip in a quieter space, run it through the same pipeline, and compare.

Help me improve my transcript quality.

Extract atomic claims from your transcript

Your transcript is a stream of spoken words. To turn it into reusable content, you need to break it into discrete, scorable pieces of intellectual property.

• Ask Claude to extract and score atomic claims by pasting this prompt:

Read my transcript from Channel/01-Staging/ via filesystem MCP. Extract every atomic claim (a single, self-contained insight or statement of fact). For each claim, assign three scores from 0 to 1:

1. confidence: How certain am I that this claim is accurate and defensible?
2. hook_potential: How likely is this claim to stop a viewer from scrolling if used as an opening line?
3. thumbnail_potential: How well could this claim be visualized as a compelling thumbnail concept?

Output as structured JSON with this schema:
{
  "source_file": "transcript filename",
  "extraction_date": "YYYY-MM-DD",
  "claims": [
    {
      "id": 1,
      "text": "the atomic claim",
      "timestamp_start": "MM:SS",
      "timestamp_end": "MM:SS",
      "confidence": 0.0,
      "hook_potential": 0.0,
      "thumbnail_potential": 0.0,
      "tags": []
    }
  ]
}

After generating the JSON:
- Auto-promote claims where ANY score >= 0.75 to Channel/02-Ingest/ (save as atomic-claims-promoted.json)
- For claims where ALL scores < 0.75, save to Channel/02-Ingest/atomic-claims-below-threshold.json with a "clarifying_question" field added to each (a question that, if answered, would strengthen the claim)
- Report: total claims extracted, number promoted, number below threshold

What are atomic claims?

An atomic claim is a single, self-contained insight that can stand alone. "React Server Components reduce bundle size by 30%" is atomic. "React is great and also fast and has good tooling" is not. Atomic claims are the building blocks that get recombined into hooks, thumbnails, scripts, and shorts.

The three scores let the system automatically route your best material to the content pipeline without you manually reviewing every sentence.

Claude will report how many claims were extracted, promoted, and queued for clarification.

• Verify the promoted claims exist by running:

ls $env:USERPROFILE\Channel\02-Ingest\

You should see atomic-claims-promoted.json (and possibly atomic-claims-below-threshold.json) alongside your existing audience-pain-points.yaml.

Claude didn't save the files?

Make sure Claude confirms it used filesystem MCP to write the files. If it only showed you the JSON in the chat without saving, ask it explicitly: "Save this JSON to Channel/02-Ingest/atomic-claims-promoted.json using filesystem MCP."

Help me get Claude to save files via MCP.

Your raw 12-minute recording is now structured intellectual property. The promoted claims in Channel/02-Ingest/ are the building blocks for your first content package. Next, you will turn these claims into three content formats: a long-form script, shorts hooks, and a demo-live brief.

Generate Your Full Content Package

You have a vault full of extracted atomic claims, each scored for hook potential and thumbnail potential. Now it is time to turn that raw intellectual property into publishable content across all three YouTube formats.

In this step, Claude generates a complete content package: a long-form script outline benchmarked against real trending data, shorts with pattern-interrupt hooks, thumbnails rendered by Nano Banana 2, and a demo-live brief. Every artifact traces back to your source claims so you always know which ideas drove which content.

In this step, get ready to:

• Generate a long-form script outline with hooks benchmarked against trending videos.
• Create shorts hooks, thumbnail prompts, and render one thumbnail with AI disclosure.
• Save all artifacts with provenance links and self-assessment quality scores.

Generate your long-form script outline

A long-form video (8-15 minutes) is your primary authority-builder on YouTube. It targets search traffic and builds watch time. Claude will write a structured script outline using your high-confidence atomic claims and benchmark the hooks against what is currently performing in your niche.

• In Claude Desktop, send the following prompt to generate your long-form script outline:

Generate a long-form video script outline for my first video.

Context:
1. Read my atomic claims from Channel/02-Ingest/ (use only claims with confidence >= 0.75)
2. Read my channel identity from Channel/channel-identity.yaml
3. Read my trend scan from Channel/Trends/ (the most recent scan file)

Output requirements:
- 200-word script outline
- Clear thesis statement (one sentence)
- 3-act structure: Hook (0:00-0:30), Body (0:30-10:00), CTA (10:00-12:00)
- B-roll suggestions for each section
- Chapter timestamps
- Target length: 8-15 minutes

Hook benchmarking:
- Use Firecrawl to search for the top 5 performing videos in my niche from the past 30 days
- Extract their hook patterns (first 30 seconds structure)
- Benchmark my hook against those patterns
- Note which pattern you are using and why it fits my voice

Save the complete outline to:
Channel/03-Published/YYYY-MM-DD_first-video/long_form/script-outline.md

(Replace YYYY-MM-DD with today's date)

Include at the bottom:
- Provenance: link each section to the source atomic claim ID it draws from
- Hook benchmark: show the 5 trending hooks you compared against

What does this prompt do?

Claude reads your high-confidence atomic claims (the ideas extracted from your recording that scored 0.75 or above), your channel identity (so it matches your voice), and your trend scan data. It then writes a structured script outline using a proven 3-act format.

The hook benchmarking step uses Firecrawl MCP to search for current top-performing videos in your niche. Claude extracts their hook structures and patterns, then designs your hook to match what is working right now. You are not guessing what makes a good opening.

• Wait for Claude to finish generating. It will use both the filesystem MCP (to read your vault files) and the Firecrawl MCP (to scrape trending videos).
• Confirm Claude created the file at Channel/03-Published/YYYY-MM-DD_first-video/long_form/script-outline.md by asking Claude to read it back.

You should see a complete script outline with a thesis, three acts, timestamps, and a list of trending hooks Claude compared against.

Claude did not create the file?

If Claude responds with content but does not save it to the filesystem, explicitly ask: "Please save that outline to Channel/03-Published/YYYY-MM-DD_first-video/long_form/script-outline.md using the filesystem MCP." The filesystem server must be connected (check the hammer icon in Claude Desktop).

If the Firecrawl search fails, Claude may note it could not benchmark hooks. Ask Claude to retry: "Please use firecrawl_search to find top performing YouTube videos about [your topic] from the past 30 days."

help me debug why Claude is not saving files via filesystem MCP

Generate shorts, thumbnails, and demo-live brief

Shorts drive discovery on YouTube. They surface your content to viewers who have never seen your channel. The pattern-interrupt opener (starting with something unexpected in the first 2 seconds) is what stops the scroll.

• Send this prompt to Claude Desktop to generate your shorts hooks and thumbnail concepts:

Generate shorts hooks and thumbnail concepts for my first video.

Context:
1. Read the script outline you just saved in Channel/03-Published/YYYY-MM-DD_first-video/long_form/
2. Read my atomic claims from Channel/02-Ingest/ (focus on claims with high hook-potential scores)
3. Read my channel identity from Channel/channel-identity.yaml

Shorts (save to Channel/03-Published/YYYY-MM-DD_first-video/shorts/hooks.md):
- Generate 3-5 hook variants, each 45-60 seconds
- Every hook MUST have a pattern-interrupt opener (first 2 seconds break expectation)
- Optimize for 15-second retention (the critical drop-off point)
- Each hook targets a single atomic claim
- Include: opening line, key visual moment, closing CTA
- Add provenance: link each hook to its source atomic claim ID

Thumbnails (save to Channel/03-Published/YYYY-MM-DD_first-video/thumbnails/prompts.md):
- Generate exactly 3 thumbnail concepts as Nano Banana 2 prompts
- Each prompt must specify: composition, text overlay (5 characters MAX), color palette, target emotion
- Format each as a ready-to-paste prompt for the Gemini app
- Text overlay examples: "WHY?", "STOP", "THIS.", "WAIT"

Demo-live brief (save to Channel/03-Published/YYYY-MM-DD_first-video/demo_live/brief.md):
- Topic angle derived from the long-form script
- Real-time IP extraction plan (which new insights to develop live)
- Audience interaction checkpoints every 10 minutes
- Post-stream plan: OpusClip VOD cut plan for 3-5 shorts from the recording
- Target length: 30-60 minutes
- Add provenance links to source atomic claims

Include provenance links in all three files.

Why three content formats?

Each format targets a different YouTube recommendation surface. Long-form targets search (people looking for answers). Shorts target the Shorts feed (discovery by new viewers). Demo-live targets notifications and community (deepening relationships with existing subscribers).

One recording session produces content for all three surfaces. This is how solo creators compete with teams.

• Wait for Claude to generate all three files. This may take 1-2 minutes as it reads multiple vault files.
• Once Claude confirms the files are saved, pick your favorite thumbnail prompt from the three concepts in thumbnails/prompts.md.
• Open the Gemini app in your browser at gemini.google.com.
• Paste your chosen thumbnail prompt into the Gemini chat.
• Download the generated image to Channel/03-Published/YYYY-MM-DD_first-video/thumbnails/.

What is Nano Banana 2?

Nano Banana 2 is Google's image generation model (Gemini 3.1 Flash Image). It generates up to 4K images with accurate text rendering and supports up to 5 characters of text overlay and 14-object subject consistency. It is free in the Gemini app with a daily soft cap.

Every image generated by Nano Banana 2 includes an invisible SynthID watermark embedded in the pixels. This watermark is machine-readable and provides AI provenance. For EU AI Act Art 50 compliance (effective 2 August 2026), you must also disclose that thumbnails are AI-generated in your video description or channel about page.

• Add an AI disclosure note to your thumbnail file. In your video description (when you publish), include a line such as: "Thumbnail generated with AI (Nano Banana 2)."

Why disclose AI-generated thumbnails?

EU AI Act Regulation (EU) 2024/1689, Article 50, requires that deployers of AI systems which generate synthetic content must disclose that content is artificially generated. This applies from 2 August 2026. The fine for non-compliance is up to EUR 15,000,000 or 3% of worldwide annual turnover.

Beyond compliance, transparency builds trust. Your channel identity declares "No undisclosed AI-generated content" as an anti-position. Living that value from Day 1 is part of your brand.

You should now have three files in your 03-Published directory: a hooks file, a thumbnail prompts file with one rendered image, and a demo-live brief.

Gemini did not generate an image?

If the Gemini app responds with text but no image, make sure your prompt starts with an action like "Create an image of" or "Generate a YouTube thumbnail showing". Nano Banana 2 activates when the prompt clearly requests image generation.

If you hit the daily soft cap (a message saying images cannot be generated right now), wait a few hours or try again tomorrow. You can proceed with the rest of this step and come back to render the thumbnail later.

help me troubleshoot Nano Banana 2 image generation in Gemini

Score your content with a quality self-assessment

Before you publish anything, the system evaluates its own output. This self-assessment becomes the baseline your self-improving agent uses to track quality over time. Every week, these scores get compared against actual performance data.

• Send this prompt to Claude Desktop to generate quality scores for all your content artifacts:

Generate a content-quality self-assessment for all artifacts in Channel/03-Published/YYYY-MM-DD_first-video/.

Read:
1. All files in the long_form/, shorts/, demo_live/, and thumbnails/ subdirectories
2. My channel identity from Channel/channel-identity.yaml
3. My trend scan from Channel/Trends/ (most recent)

For EACH artifact (script outline, each hook variant, demo-live brief, each thumbnail concept), score on 4 axes:
- Brand alignment (0-1): How well does this match my channel voice, themes, and declared positions?
- Hook strength (0-1): How likely is this to stop a scroll or earn a click in the first 3 seconds?
- SEO potential (0-1): Does this target terms people are actively searching for?
- Uniqueness vs competitors (0-1): How differentiated is this from what the top 5 competitors published this month?

Format: Table with artifact name, 4 scores, and a one-line justification for each score.

Append the assessment table to the bottom of each artifact file (long_form/script-outline.md, shorts/hooks.md, demo_live/brief.md, thumbnails/prompts.md).

Also save a consolidated assessment to:
Channel/03-Published/YYYY-MM-DD_first-video/quality-assessment.md

What do these scores mean?

• Brand alignment measures whether the content sounds like YOU, not a generic creator.
• Hook strength predicts click-through rate by checking your opener against proven patterns.
• SEO potential checks whether the title and framing target active search demand from your trend data.
• Uniqueness vs competitors ensures you are not producing content that already exists from larger channels.

After you publish and get real metrics (CTR, average view duration), the self-improving agent in Step 5 compares predicted scores against actual performance. This feedback loop is what makes the system get better every week.

• Confirm Claude saved the consolidated assessment to Channel/03-Published/YYYY-MM-DD_first-video/quality-assessment.md.
• Ask Claude to list all files in your Channel/03-Published/YYYY-MM-DD_first-video/ directory to verify the full structure exists.

You should see 4 subdirectories (long_form/, shorts/, demo_live/, thumbnails/) plus the consolidated quality-assessment.md at the root of the dated folder.

Missing subdirectories or files?

If Claude created the files but in the wrong location, ask it to move them: "Move [filename] to Channel/03-Published/YYYY-MM-DD_first-video/[correct-subdirectory]/ using filesystem MCP."

If the quality-assessment scores are all very high (above 0.9), that is likely Claude being overly generous with its own work. Ask Claude to re-score with stricter criteria: "Re-score with a critical eye. Anything above 0.8 needs strong justification. Compare honestly against the trending competitors you scraped."

help me verify my content package file structure is correct

Your content package is complete. You now have publishable artifacts for all three YouTube surfaces, each traced back to your original ideas and scored for quality. Next up, you will wire this into a self-improving system that learns from every output and gets smarter every week.

Activate Audience-RAG and the Self-Improving Agent

Your content package is ready. You have scripts, hooks, thumbnails, and a demo-live brief. But a static pipeline that produces the same quality forever is not a system. It is a script.

What separates this from a weekend hack is the feedback loop. In this step, you will wire up Audience-RAG so Claude can reason over your entire vault when recommending topics. Then you will build the self-improving agent that learns from every production cycle and a future-proofing watchlist that detects shifts before they blindside you. Finally, you will install Arize Phoenix for continuous evaluation so you have hard numbers, not vibes.

In this step, get ready to:

• Verify Audience-RAG by testing /next-video and /trend-check commands with citation grounding.
• Create the self-improving agent memory and future-proofing watchlist.
• Launch Phoenix, seed your evaluation goldset, and generate the Master Prompt.

Verify Audience-RAG with live commands

Your vault now contains identity files, trend scans, atomic claims, and a full content package. Claude can read ALL of this in a single session because Opus 4.7 has a 1M token context window at flat pricing. That means no chunking, no retrieval tricks. Just the entire vault loaded directly.

• Open Claude Desktop and start a new conversation.
• Type this prompt to test the /next-video command:

Read my entire Channel/ vault via filesystem MCP. Then recommend my next video topic by cross-referencing:
1. My twelve-favorite-problems.yaml
2. My audience-pain-points.yaml
3. My latest trend scan in Trends/

Rank the top 3 angles by overlap score (problems x pain-points x trends). For each angle, cite the specific source file and line that supports it.

What does this prompt do?

This is your /next-video command in action. Claude reads your vault via the filesystem MCP server, cross-references three data sources, and returns ranked topic recommendations with citations back to your own files.

The citation grounding is critical. Every recommendation should trace back to a specific line in your vault. If Claude cannot cite a source, the recommendation is hallucinated.

• Verify that Claude returns 3 ranked angles, each with a citation pointing to a specific file in your vault.
• Now test the /trend-check command by typing this prompt:

Run a Firecrawl search for current trending YouTube videos in my niche (use the themes from my channel-identity.yaml). Compare what's trending against my business-plan.md content calendar. Flag any gaps where trending topics are NOT covered in my plan. Save results to Channel/Trends/ with today's date.

What does this prompt do?

This is your /trend-check command. Claude uses the Firecrawl MCP server to scrape live trending data, then compares it against your content calendar to find gaps you are missing.

The gap analysis is what makes this system proactive instead of reactive. You do not wait to fall behind. The system tells you where the market moved before you miss it.

• Verify that Claude creates a new file in Channel/Trends/ with today's date and a gap analysis section.
• Confirm both outputs include citation grounding (specific file references, not vague claims).

Claude not reading your vault files?

Check that the filesystem MCP server is still connected (hammer icon in Claude Desktop). If it disconnected, restart Claude Desktop.

If Firecrawl returns an error, verify your API key is still valid at firecrawl.dev. Free tier allows 1,000 credits per month.

help me debug why Claude cannot read my Channel vault files via filesystem MCP

Build the self-improving agent and future-proofing watchlist

Most AI pipelines produce the same quality forever. This one gets smarter every week. The self-improving agent records what worked, what failed, and what to change. Then it patches its own prompts based on evidence.

• Ask Claude to create the self-improving agent memory file by typing this prompt:

Create Channel/System/lessons-learned.yaml with this exact schema:
- version: 0
- last_updated: today's date in YYYY-MM-DD format
- Sections: proven_patterns (empty list), anti_patterns (empty list), experiments (empty list)
- prompt_patches: one template entry with patch_id 0, today's date, component "hook_generation", change "TEMPLATE - first patch goes here after video #1 review", reason "TEMPLATE", result "pending"
- model_notes: opus_4_7 for weekly strategy, sonnet_4_6 for daily content, haiku_4_5 for utility tasks, nano_banana_2 for thumbnails
- platform_changes (empty list), failure_log (empty list)
- next_review: today's date

Include comments explaining that this file is the brain of the system, read at session start, and updated after every production cycle.

Claude creates the file via filesystem MCP. The result should match this structure:

# Self-Improving Agent Memory
# This file is the brain of your system. Claude reads it at session start.
# Updated automatically after every production cycle.
# The system gets smarter every week because of this file.

version: 0
last_updated: "YYYY-MM-DD"

# What consistently works (promoted after 4+ videos confirm the pattern)
proven_patterns: []

# What consistently fails (killed after 2+ videos confirm the anti-pattern)
anti_patterns: []

# Active experiments (test for 4 videos before promoting or killing)
experiments: []

# Prompt adjustments that feed back into Master Prompt automatically
prompt_patches:
  - patch_id: 0
    date: "YYYY-MM-DD"
    component: "hook_generation"
    change: "TEMPLATE - first patch goes here after video #1 review"
    reason: "TEMPLATE"
    result: "pending"

# Model performance observations
model_notes:
  opus_4_7: "Weekly strategy + quarterly identity refresh"
  sonnet_4_6: "Daily content generation + script drafts"
  haiku_4_5: "Utility tasks + quick classifications"
  nano_banana_2: "Thumbnails + B-roll images"

# Platform shifts detected via Firecrawl scans
platform_changes: []

# Failures and what they taught (the gold - this is how you grow)
failure_log: []

# Next scheduled review
next_review: "YYYY-MM-DD"

Why is this file the core innovation?

After every weekly production cycle, Claude reviews what you published versus what performed. It extracts lessons, compiles adjustments into this YAML, and updates the Master Prompt memory section with new instructions.

The prompt_patches section is where the magic happens. Each patch records a specific change to how Claude generates content, the reason for the change, and whether it worked. After 4+ videos confirm a pattern, it gets promoted to proven_patterns. After 2+ failures, it gets killed in anti_patterns.

• Verify that Channel/System/lessons-learned.yaml exists by asking Claude to read it back to you.
• Now ask Claude to create the future-proofing watchlist:

Create Channel/System/future-proofing.yaml with a watchlist covering 5 categories:
1. new_models - quarterly scan, trigger on new frontier models, evaluate against goldset, adopt if >=5% lift + zero regression + <=10% cost increase, rollback within 24 hours. Include current_stack listing Opus 4.7/Sonnet 4.6/Haiku 4.5, Gemini for council, Nano Banana 2 for images.
2. platform_changes - monthly, trigger on YouTube algorithm/policy/feature/monetization changes, adopt if >10% metric impact within 2 weeks. Sources: blog.youtube, Creator Insider channel, YouTube Help community updates.
3. tool_shifts - quarterly, trigger on tools claiming >30% improvement, adopt after 2-week trial, churn budget <=2 per quarter.
4. industry_shifts - monthly, trigger on new 10K+ sub competitors or niche reversals, adopt if 3+ signals in 30 days.
5. content_format_evolution - monthly, trigger on new YouTube formats, adopt after testing with 2 videos.

Each category needs: scan_frequency, detection_trigger, evaluation_criteria, adoption_threshold, rollback_plan. Include comments explaining this keeps you ahead of every shift.

The result should match this structure:

# Future-Proofing Watchlist
# Scanned quarterly by Council + Brand Strategist persona
# This file keeps you ahead of every shift in models, platforms, and tools
# Without this, your system becomes outdated within 6 months

version: 0
last_scan: "YYYY-MM-DD"

watchlist:
  new_models:
    scan_frequency: quarterly
    detection_trigger: "New frontier model from Anthropic, Google, OpenAI, or Meta"
    evaluation_criteria: "Run against goldset; must beat current by >=5%"
    adoption_threshold: ">=5% lift + zero regression + <=10% cost increase"
    rollback_plan: "Revert within 24 hours if regression detected"
    current_stack:
      primary: "Claude Opus 4.7 / Sonnet 4.6 / Haiku 4.5"
      council: "Gemini (different family for independence)"
      image: "Nano Banana 2 (Gemini 3.1 Flash Image)"
    last_evaluated: "YYYY-MM-DD"

  platform_changes:
    scan_frequency: monthly
    detection_trigger: "YouTube algorithm update, policy change, new feature, monetization shift"
    evaluation_criteria: "Does change affect CTR, APV, AVD, or monetization?"
    adoption_threshold: "If >10% metric impact, adapt within 2 weeks"
    rollback_plan: "Strategy pivot documented in Council report"
    sources_to_scan:
      - "https://blog.youtube/"
      - "Creator Insider channel"
      - "YouTube Help community updates"
    last_scanned: "YYYY-MM-DD"

  tool_shifts:
    scan_frequency: quarterly
    detection_trigger: "New tool claims >30% improvement in our pipeline"
    evaluation_criteria: "Saves >30 min/week OR measurable quality improvement"
    adoption_threshold: "2-week trial + maintain budget ceiling"
    rollback_plan: "Previous config in git; revert if trial fails"
    churn_budget: "<=2 tool changes per quarter (stability over novelty)"
    last_evaluated: "YYYY-MM-DD"

  industry_shifts:
    scan_frequency: monthly
    detection_trigger: "New competitor >10K subs, niche trend reversal, demographic shift"
    evaluation_criteria: "Does shift require content pivot or new pillar?"
    adoption_threshold: "3+ signals in same direction within 30 days"
    rollback_plan: "Maintain core identity; adjust tactics not mission"
    last_scanned: "YYYY-MM-DD"

  content_format_evolution:
    scan_frequency: monthly
    detection_trigger: "New YouTube format, aspect ratio, or feature"
    evaluation_criteria: ">20% engagement lift in early adopter data"
    adoption_threshold: "Test with 2 videos before committing"
    rollback_plan: "Return to proven format if underperforms by >20%"
    last_scanned: "YYYY-MM-DD"

What does each watchlist category protect against?

• new_models prevents you from missing a better AI model that could improve output quality.
• platform_changes catches YouTube algorithm shifts before your views tank.
• tool_shifts evaluates new tools without destabilizing your workflow (max 2 changes per quarter).
• industry_shifts detects when your niche moves and you need to pivot tactics.
• content_format_evolution catches new YouTube formats early so you can test them before competitors saturate.

• Verify that Channel/System/future-proofing.yaml exists by asking Claude to read it back.
• Confirm both files have today's date in their date fields.

Claude created the file but the structure looks different?

Claude may reformat the YAML slightly. The key things to check: the prompt_patches section in lessons-learned has a patch_id: 0 template entry, and future-proofing has all 5 watchlist categories with rollback_plan in each.

If a section is missing, ask Claude to re-read the file and add the missing section. The filesystem MCP lets Claude edit files directly.

help me fix my lessons-learned.yaml or future-proofing.yaml structure

Install Phoenix, seed your goldset, and generate the Master Prompt

The self-improving agent needs measurement to know if its patches actually improve output. Arize Phoenix gives you OpenTelemetry-based tracing so you can see exactly how Claude processes your prompts and where quality drifts.

• Phoenix was already installed by the bootstrap script. Start the Phoenix server by running this command in a new PowerShell window:

phoenix serve

• Open your browser and navigate to http://localhost:6006 to verify the Phoenix dashboard loads.

What is Phoenix doing here?

Phoenix collects traces from your AI calls so you can measure retrieval quality, response accuracy, and prompt performance over time. Combined with RAGAS metrics, it gives you hard numbers on whether the self-improving agent is actually improving.

You will not run a full evaluation cycle today. But you need the infrastructure in place so that Day-30 evaluation has historical data to compare against.

🙋‍♀️ Phoenix not starting or port already in use?

If you see a port conflict, another process is using port 6006. Close any Jupyter or TensorBoard instances that might occupy that port.

If phoenix is not recognized as a command, the bootstrap may not have added it to your PATH. Close and reopen PowerShell, then try again.

help me troubleshoot Phoenix not starting on my Windows machine

• Now seed your evaluation goldset. Ask Claude to create the test data:

Create an evaluation goldset in Channel/eval/goldset-v0/ with three files:
1. chunks.json - 10 transcript chunks from my 01-Staging/ transcript (pick representative segments covering different topics)
2. queries.json - 5 test queries that a viewer might ask based on my content (mix of factual, opinion, and how-to)
3. contradictions.json - 3 deliberately contradictory pairs where one claim conflicts with another (these test whether the system detects inconsistencies)

This goldset will be used with RAGAS metrics to evaluate retrieval quality at Day-30.

Why seed a goldset now?

A goldset is a curated test dataset you run evaluations against. By seeding it now with 10 chunks, 5 queries, and 3 contradictions, you have a baseline. When DSPy compiles at Day-30 (after 50+ decisions), it optimizes prompts against this goldset and measures real improvement.

The contradictions are especially important. They test whether your system catches conflicting advice across videos. A viewer should never get contradictory recommendations.

• Verify the goldset files exist by asking Claude to list the contents of Channel/eval/goldset-v0/.
• Finally, ask Claude to generate the Master Prompt that ties everything together:

Generate my Master Prompt for this YouTube content system. It must include:

1. Five personas: Content Strategist (Opus 4.7 for weekly strategy), Script Writer (Sonnet 4.6 for daily content), Utility Worker (Haiku 4.5 for quick tasks), Visual Designer (Nano Banana 2 for thumbnails), Trend Analyst (Firecrawl for web intelligence)

2. Self-improvement loop: At the start of every session, read Channel/System/lessons-learned.yaml. At the end of every production cycle, update it with what worked, what failed, and prompt patches.

3. Firecrawl commands:
   - /next-video: Cross-reference twelve-favorite-problems x audience-pain-points x latest trend scan. Return top 3 ranked angles with citation grounding.
   - /trend-check: Scrape current trending via Firecrawl, compare against content calendar, flag gaps.

4. Future-proofing scan schedule: Reference Channel/System/future-proofing.yaml. Monthly scans for platform_changes, industry_shifts, content_format_evolution. Quarterly scans for new_models, tool_shifts.

5. Governance: All AI-generated images must include EU AI Act Art 50 disclosure. All recommendations must cite source files.

Save to Channel/System/master-prompt.md and also commit the DSPy wrapper module stubs to Channel/System/dspy-wrappers/ (compile deferred to Day-30 when we have 50+ goldset decisions).

What are the DSPy wrapper modules?

DSPy is a framework for optimizing AI prompts programmatically. The wrapper modules define the shape of your prompts (inputs, outputs, constraints) so that MIPRO can automatically optimize them later.

Compile is deferred to Day-30 because DSPy needs at least 50 goldset decisions to optimize meaningfully. The documented lifts are significant: ReAct accuracy from 24% to 51%, and RAG pipelines from 66% to 87% on specific benchmarks.

• Verify Claude created Channel/System/master-prompt.md with all 5 personas listed.
• Verify Channel/System/dspy-wrappers/ contains module stub files.
• Commit everything to git by asking Claude:

Use git MCP to stage and commit all new files in Channel/ with the message: "Add self-improving agent, future-proofing watchlist, goldset-v0, and Master Prompt"

• Confirm the commit succeeds by asking Claude to show the git log.

Git commit failing?

If git MCP reports an error, it may be a file path issue. Ask Claude to run git status first to see which files are untracked. Then stage them explicitly.

If the git MCP server disconnected, restart Claude Desktop and try the commit again.

help me commit my self-improving agent files to git via MCP

Your system now has a brain that learns from every output. Next up, you will lock the weekly cadence and build the council that ensures quality never slips.

Lock Your Weekly Cadence and Ship

Your system can produce content, evaluate it, and learn from it. But none of that matters without a locked cadence that keeps you consistent week after week.

In this step, you close the feedback loop. Every Sunday, the system produces output AND learns from the previous week. You will generate the cadence runbook, scaffold governance templates, commit everything to GitHub, and lock your Day-30 targets.

In this step, get ready to:

• Generate your Sunday cadence runbook with time allocations and a self-improvement trigger.
• Scaffold governance templates including the council, DSPy checklist, and future-proofing review.
• Commit everything to GitHub and lock your 30-day growth targets.

Generate the Sunday cadence runbook

Consistency beats virality. The cadence runbook is a structured schedule that tells you exactly how to spend your 7-14 hours each week. It also includes a lessons-learned capture step that feeds the self-improving agent.

• In Claude Desktop, ask Claude to generate your weekly cadence runbook by pasting this prompt:

Create the file Channel/Operations/weekly-cadence.md with a Sunday cadence runbook.

Structure it with these exact time allocations (7-14 hrs/week total):
- Record: 2 hrs (one video per week)
- Edit: 2 hrs (DaVinci Resolve, cut dead air, color, intro/outro)
- Publish + SEO: 1 hr (upload, title, description, tags, end screens, cards)
- Engage: 1 hr (respond to comments, community posts, collaboration outreach)
- System Review: 1 hr (check analytics, review council report, update experiments)
- Learning/Growth: 1-2 hrs (study niche leaders, skill development)
- Trend Scan: 30 min via Firecrawl (/trend-check command)

At the END of the runbook, add a "Lessons-Learned Capture" section that:
1. Reviews what was published this week vs what performed
2. Extracts lessons (what worked, what failed, what to change)
3. Compiles adjustments into Channel/System/lessons-learned.yaml
4. Updates the Master Prompt memory section if needed

Include a sustainability gate: if weekly hours exceed 14, flag burnout risk and suggest what to cut.

Format as a clean markdown checklist the operator can follow every Sunday.

What does this runbook do?

The runbook is your operating manual. It ensures you never wonder "what should I do this week?" again.

The lessons-learned capture at the end is what makes the system self-improving. Every Sunday, your failures feed back into the pipeline and patch it for next week.

• Verify that Claude created Channel/Operations/weekly-cadence.md via filesystem MCP.
• Confirm the file includes all 7 time-allocation blocks and the lessons-learned capture section at the end.

Now set a weekly reminder so the system nudges you every Sunday at 8pm.

• Open PowerShell and create a Windows Task Scheduler entry by running this command:

schtasks /create /tn "ZeroToCreator-WeeklyCadence" /tr "cmd /c echo Zero to Creator: Sunday session time" /sc weekly /d SUN /st 20:00

What does this command do?

• /tn sets the task name you will see in Task Scheduler.
• /sc weekly /d SUN /st 20:00 schedules it for every Sunday at 8:00 PM.
• The /tr is a placeholder trigger. You can later change it to open Claude Desktop or your browser.

• Verify the task was created by running:

schtasks /query /tn "ZeroToCreator-WeeklyCadence"

• You should see the task listed with Next Run Time showing the upcoming Sunday at 20:00.

Access denied error?

If you see a permissions error, close PowerShell and reopen it as Administrator. Right-click the PowerShell icon and select Run as administrator, then retry the command.

help me fix a permissions error when creating a scheduled task in Windows

Scaffold the council and governance templates

The council is your quality gate. It evaluates every piece of content against 8 axes before you ship. The 8th axis is trend-drift: "are you creating content the market has moved away from?"

• In Claude Desktop, ask Claude to scaffold your governance templates by pasting this prompt:

Scaffold the Channel/Council/ directory with 4 template files:

1. council-template.md - An 8-axis evaluation template with these axes:
   - Brand alignment (does this match channel-identity.yaml?)
   - Hook strength (pattern-interrupt potential, first 5 seconds)
   - SEO potential (keyword density, search volume from trends)
   - Uniqueness vs competitors (differentiation from trend scan)
   - Production quality (audio, visual, pacing)
   - Audience value (does this solve a pain point?)
   - Sustainability (can I maintain this quality weekly?)
   - Trend-drift ("are you creating content the market has moved away from?")
   Each axis gets a 0-1 score. Ship threshold: average >= 0.7, no single axis below 0.5.

2. quarterly-dspy-compile.md - A checklist for quarterly DSPy MIPRO compilation:
   - Confirm goldset has 50+ decisions
   - Run MIPRO compile against current prompt
   - Compare new vs old on holdout set
   - Accept if >=5% lift, zero regression
   - Document in lessons-learned.yaml

3. nist-ai-rmf-template.md - NIST AI Risk Management Framework template:
   - Map: identify AI risks in content pipeline
   - Measure: define metrics for each risk
   - Manage: document mitigations
   - Govern: assign review cadence
   Focus on: hallucination risk, bias in recommendations, over-reliance on AI judgment.

4. future-proofing-quarterly-review.md - A structured review template that checks:
   (a) Any new models worth evaluating against goldset?
   (b) Any YouTube algorithm changes detected via Firecrawl?
   (c) Any tool improvements saving >30 min/week?
   (d) Any niche shifts requiring content pivot?
   Link each check to the corresponding section in Channel/System/future-proofing.yaml.

Why 8 axes instead of 7?

The original council evaluates content quality. But quality content on a dead topic still gets zero views.

The trend-drift axis uses your Firecrawl scan data to check whether your chosen topic still has active search demand. This is what separates data-driven creators from those who wonder why a "great" video got 12 views.

• Verify that Claude created all 4 files in Channel/Council/ by asking Claude to list the directory contents.
• Confirm the council template includes all 8 axes with the trend-drift axis as the 8th.
• Confirm the future-proofing quarterly review references Channel/System/future-proofing.yaml for each check.

Missing files in Council directory?

If Claude only created some files, ask it to list what exists in Channel/Council/ and then create only the missing ones. MCP filesystem sometimes needs explicit confirmation for each write.

help me troubleshoot Claude not creating all files via filesystem MCP

Commit to GitHub and lock your Day-30 targets

Everything you have built lives locally. Pushing to GitHub gives you version history, a rendered README with Mermaid diagrams, and proof of work for your "building in public" content.

• Create a new repository on GitHub called zero-to-creator (public or private, your choice).
• Do not initialize it with a README (you already have one).
• Copy the repository URL that GitHub provides.

• In PowerShell, navigate to your Channel vault and push to GitHub by running these commands:

# Move to Channel vault
cd $env:USERPROFILE\Channel

# Stage all new files from Steps 2-6
git add .

# Commit with a meaningful message
git commit -m "Complete system: cadence, council, governance, content package"

# Connect to your GitHub repository
git remote add origin [[YOUR_REPO_URL="https://github.com/YOUR_USERNAME/zero-to-creator.git"]]

# Rename branch to main (if needed) and push
git branch -M main
git push -u origin main

What does this do?

• git add . stages all files created across Steps 2-6 (identity, trends, content, system, council).
• git remote add origin links your local repo to GitHub.
• git push -u origin main uploads everything. Your README with Mermaid diagrams renders immediately on GitHub.

• Open your repository on GitHub in your browser.
• Verify the README displays with the Mermaid architecture diagram rendered as a visual flowchart (not raw code).

Mermaid diagrams showing as raw text?

GitHub renders Mermaid natively in fenced code blocks tagged with mermaid. If you see raw text, check that your README uses triple backticks with mermaid as the language identifier. Also try a hard refresh of the page.

help me fix Mermaid diagrams not rendering on GitHub

Now lock your commitment with a WOOP statement. WOOP stands for Wish, Outcome, Obstacle, Plan.

• Ask Claude to generate your WOOP commitment with Day-30 targets by pasting this prompt:

Create Channel/Operations/woop-commitment.md with my WOOP commitment.

Wish: Build a self-improving YouTube channel that hits 100x growth in Year 1.

Outcome (Day-30 targets - lock these exactly):
- 4 videos published
- 100+ subscribers
- First trend-to-content cycle completed (Firecrawl scan -> topic selection -> publish)
- First lessons-learned compilation run (after video #1 review)
- First monthly analytics review (Day-30 check-in)

Obstacle: Ask me what I think my biggest obstacle will be in the first 30 days. Wait for my answer, then write it into the WOOP.

Plan: For my specific obstacle, write an if-then plan:
"If [obstacle occurs], then I will [specific action using the system]."

End with: "The system is self-improving from Day 1. Every failure feeds the pipeline. Show up on Sunday. That is the only rule."

Why WOOP instead of a vague goal?

WOOP forces you to name the obstacle before it arrives. When "I do not have time this week" hits (and it will), you already have a pre-committed response written down. This is what separates people who ship 52 videos from people who quit at video 3.

• Answer Claude's question about your biggest obstacle honestly.
• Verify that Channel/Operations/woop-commitment.md was created with all 5 Day-30 targets listed.
• Do a final commit to push your WOOP commitment to GitHub by running:

cd $env:USERPROFILE\Channel
git add .
git commit -m "Lock Day-30 targets and WOOP commitment"
git push

• Refresh your GitHub repository page. You should see your full project with all files committed.

Git push rejected?

If GitHub rejects the push, you may need to authenticate. Run git push and follow the browser prompt to sign in. If you initialized the GitHub repo with a README, you will need to pull first with git pull origin main --allow-unrelated-histories before pushing.

help me fix a git push rejection to GitHub

Your system is now live, committed, and self-improving from Day 1. Every Sunday at 8pm, Windows will remind you to sit down and run the cadence. Every cycle makes the system smarter. Next up: the Secret Mission, where you ship video #1 and run your first full trend-to-content loop.

Secret mission

Ship Video #1 + Run First Trend Cycle for Video #2

You have a complete production pipeline. Now prove it works. Ship your first YouTube video within 48 hours, then run your first trend-analysis cycle to let the system recommend video #2. This is where the pipeline stops being theoretical and starts compounding.

Clean Up Your Resources

Clean Up Your Resources

This project runs entirely on local tools and free-tier services. There are no ongoing costs beyond the Claude Desktop Max subscription you already pay for.

Decide whether to keep your resources running, pause them to come back later, or delete them entirely.

Resources you used:

• Channel/ Obsidian vault (local directory with all content, recordings, and config files).
• Global npm packages (@modelcontextprotocol/server-filesystem and firecrawl-mcp).
• Python packages installed via pip (whisper, whisperx, arize-phoenix, dspy-ai, ragas, and others).
• Claude Desktop MCP configuration (claude_desktop_config.json).
• Firecrawl API key (free tier, 1,000 credits/month).
• GitHub repository (free tier).

Keep everything running

No action needed. Choose this if you plan to start your weekly content cadence and let the self-improving system run every Sunday.

• Your Channel/ vault stays on disk, ready for Claude Desktop to read via MCP.
• Firecrawl free tier renews monthly at 1,000 credits with no action on your part.
• Phoenix runs only when you start it manually with phoenix serve. It does not consume resources when stopped.
• Note that Node.js, Python, Git, and ffmpeg remain installed on your machine. These are general-purpose tools you may use for other projects.

Pause - I'll come back to this later

Shut down running processes to free up memory. Your files and configuration stay intact for when you return.

• If Phoenix is running, press Ctrl+C in its terminal window to stop the server.
• Close Claude Desktop if you want to free memory. Your MCP configuration persists in claude_desktop_config.json and reconnects automatically next time you open Claude Desktop.
• Your Channel/ vault, Git history, and all YAML config files remain on disk.
• Firecrawl free tier stays active with no intervention. Credits reset monthly.

Delete - I don't want to use this again

Remove all project resources and start fresh. Follow each step below to fully clean up.

• Delete the Channel/ vault by running this command in PowerShell:
• Remove-Item -Recurse -Force "$env:USERPROFILE\Channel"
• Uninstall the global npm MCP packages by running:

npm uninstall -g @modelcontextprotocol/server-filesystem firecrawl-mcp

• Uninstall the Python packages by running:

pip uninstall openai-whisper whisperx arize-phoenix dspy-ai ragas pydantic fastapi uvicorn sqlalchemy -y

• Reset your Claude Desktop MCP configuration. Open %APPDATA%\Claude\claude_desktop_config.json and remove the four server entries (filesystem, git, sqlite, firecrawl). Save the file.
• Revoke your Firecrawl API key. Go to firecrawl.dev/app/api-keys, create a new key (at least one must remain active), then click the revoke option on your old key. If you want to remove the account entirely, go to Settings then Advanced and delete the team.
• Delete your GitHub repository. Open your repo on GitHub, go to Settings, scroll to the Danger Zone section, and click Delete this repository.

That's a Wrap!

That's a Wrap!

You just built what creator coaches sell for $5,000-50,000/quarter. For $0 additional cost beyond what you already pay for Claude Desktop.

You've learned how to:

• Build a 7-component self-improving AI pipeline with Claude Desktop MCP orchestration, Firecrawl trend intelligence, and a lessons-learned agent that patches its own prompts after every production cycle.
• Define a 100x growth plan with concrete checkpoints (52 videos, 10K subs, $500/mo in Year 1) informed by live trend data scraped from YouTube via Firecrawl MCP.
• Produce a complete 3-format content package (long-form script, shorts hooks, demo-live brief) with continuous evaluation via Arize Phoenix and a future-proofing watchlist that keeps you ahead of model, platform, and industry shifts.
• Secret Mission: Ship your first YouTube video within 48 hours and run a full trend-analysis cycle to plan video #2 using the complete system loop.

Ready to quiz yourself?