The 4 Secret Content
Weapons

You are going to bootstrap a Claude Code skill called `hook-writer` for me. This skill is going to write data-grounded short-form hooks for me on demand.

The whole thing has to follow this principle: **I am not inventing hooks from nothing. I am mining proven frameworks from creators who have already won, and remixing them onto my topics.** Every hook the skill produces must be traceable back to a real framework from a real high-performing post. No invented content. No generic templates.

You are going to do this in five phases. Stop and check in with me after Phase 2 and Phase 4. Don't skip ahead.

---

## Phase 1: Set up the skill folder

Create the following structure inside my Claude Code skills folder (`~/.claude/skills/hook-writer/`):

```
hook-writer/
├── SKILL.md
├── frameworks/
│   ├── kallaway-3-step.md
│   ├── hormozi-hooks.md
│   ├── isenberg-patterns.md
│   ├── kane-stop-the-scroll.md
│   └── _frameworks-index.md
├── transcripts/
│   └── (raw YouTube transcripts go here for reference)
└── examples/
    └── proven-hooks.md
```

If `~/.claude/skills/` doesn't exist yet, create it. If `hook-writer/` already exists, ask me before overwriting.

---

## Phase 2: Ingest the framework knowledge

You're going to populate the `frameworks/` folder by pulling the actual teaching content from creators who teach hooks for a living. Don't write the frameworks from your training data. Pull them from real source material so the skill is grounded in what these creators actually said.

Use the `/last30days` skill (or any web fetch tool you have) to find and transcribe video content from these specific creators. Search YouTube and the open web for their hook-teaching videos:

1. **Brendan Kane**, author of "One Million Followers." Search "Brendan Kane hook formula" and "Brendan Kane stop the scroll." He has a structured hook taxonomy. Capture it.
2. **Alex Hormozi**. Search "Alex Hormozi hooks", "Alex Hormozi short form content", "Hormozi attention." He talks about the value-density of the first three seconds. Capture his specific phrasings.
3. **Greg Isenberg**. Search "Greg Isenberg viral hooks", "Greg Isenberg short form playbook." Capture his hook patterns.
4. **Kallaway (Connor Kallaway)**. Search "Kallaway hook formula" and "Kallaway 3-step hook." His architecture is: context lean, then scroll-stop interjection, then contrarian snapback. This is the spine. Capture every nuance you can find.
5. **Codie Sanchez**. Search "Codie Sanchez content hooks." She's strong on identity-validation hooks. Capture them.
6. **MrBeast**. Search "MrBeast retention hooks" and "MrBeast first 30 seconds." He doesn't teach hooks directly but his openers are reverse-engineerable.

For each creator:
- Fetch the top 2-3 videos where they explicitly teach hooks
- Save the raw transcript to `transcripts/[creator-name].md`
- Synthesize their teaching into a clean framework file at `frameworks/[creator-name].md`. Each framework file should contain:
  - A one-line summary of their philosophy
  - The named patterns they teach (e.g., "The Curiosity Gap," "The Specificity Hook")
  - The exact swappable mad-lib structure for each pattern (e.g., `"{Tool} just killed {Role}"` or `"Most {identity} have never heard of {thing}"`)
  - 2-3 examples of the pattern in the wild

After all six are populated, create `frameworks/_frameworks-index.md` that lists every named pattern across all creators with a one-line tag (e.g., `news-fomo`, `cold-data-drop`, `assumption-subvert`, `tool-killed-role`, `cult-hop`). This is the menu the skill will pull from.

**Stop here. Show me the index and ask if I want to add more creators or edit any patterns before continuing.**

---

## Phase 3: Encode the architecture and enhancers

Create two more files inside `frameworks/`:

### `frameworks/_architecture.md`

Encode Kallaway's 3-step formula compressed for short-form:

1. **Context lean.** Reference a truth or pain the viewer already believes. They lean in.
2. **Scroll-stop interjection.** A single stunning line that interrupts ("but," "except," "however").
3. **Contrarian snapback.** Go opposite direction of the lean. Leaves the loop open.

In short-form (under 3 seconds spoken), all three steps compress into one to two sentences. Note that explicitly.

### `frameworks/_enhancers.md`

Encode the five enhancers that get layered on top of any hook:

1. **Visual hook.** What's on screen must reinforce the spoken hook. Mute test: if sound is off, would the visual still stop the scroll?
2. **Identity validation.** Make the viewer think "that's me," not "this might apply to me." Recognition over consideration.
3. **Cult hopping.** Reference a name, brand, or community with a dedicated following (e.g., "If you're already in the Claude ecosystem"). One per hook max.
4. **Compress speed to value.** Every word between hook and first a-ha point must earn its slot. Cut "in this video I'll show you" filler.
5. **Staccato rhythm.** Short. Punchy. Mountain range of sentence lengths, not a wall of text.

---

## Phase 4: Build the SKILL.md

Now create the main skill file at `~/.claude/skills/hook-writer/SKILL.md`. Use this exact structure:

```markdown
---
name: hook-writer
description: Generates data-grounded short-form hook variants by pulling proven frameworks from a curated knowledge base of top creators (Kallaway, Hormozi, Isenberg, Kane, Sanchez, MrBeast) and adapting them to the user's topic. Triggered by "write me hooks", "hook for [topic]", or "/hook-writer".
allowed-tools: Read, Bash, Glob, Grep
---

# Hook Writer

You write short-form hooks the way Noe writes them: mine winning frameworks from the framework library, adapt them to the user's topic, never invent from nothing.

## Step 1: Gather the query

Ask (or infer):
1. **TOPIC.** What is the video about? Specific. "Claude Code for cold email" beats "AI stuff."
2. **PLATFORM.** TikTok, Reels, or both?
3. **AUDIENCE / IDENTITY.** Who is the viewer? ("AI-curious creators," "non-technical founders," etc.)

If the user gave you enough, skip the question. Don't bog down.

## Step 2: Load the frameworks

Read every file in `frameworks/` (this folder). The `_frameworks-index.md` is your menu. The named pattern files are the source of truth.

## Step 3: Pull from competitor data (if available)

If a Supabase MCP is connected and a `competitors` or `posts` table exists, query for:
- The top 10 posts in the same topic area sorted by `outlier_score` or `view_count`
- The first-line hooks from those posts
- The hook category for each (if classified)

Use these as ADDITIONAL reference material. They beat library frameworks when available because they're real-time and niche-specific.

If no Supabase data is available, work entirely from the framework library. That is fine.

## Step 4: Write 5 variants

For each variant:

```
VARIANT [N]: [Pattern Name]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Framework: [the swappable mad-lib, e.g. "{Tool} just killed {Role}"]
Adapted hook: [the actual line for this topic]
Text overlay: [what appears on screen]
Visual: [what's on camera during the hook]
Enhancers used: [list which of the 5 enhancers this hook layers in]

Source: [creator name, framework file]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
```

Cover at least 4 different pattern types across the 5 variants. Don't ship 5 variants of the same pattern.

## Step 5: Voicing pass

Before delivering, check each adapted hook against:
1. Kallaway 3-step (compressed). Does it lean, interrupt, snap back?
2. Mute test. Would the visual stop the scroll on its own?
3. Staccato. Read it out loud. Does it have a heartbeat?

Fix any variant that fails. Don't deliver a weak one to fill the slot.

## Step 6: Deliver

Output the 5 variants. After delivery, ask:
- Which one do you want to record?
- Want me to also write the script body? (Hand off to /short-form-script-writer if it exists.)

## Guardrails

- **Never invent a source.** Every variant must trace to a framework file or a real database row. If you can't cite it, don't ship it.
- **Cross-niche frameworks get remixed, not copy-pasted.** "I gave $1M to a stranger" doesn't land for AI content. The pattern "{I gave {extreme thing} to {unlikely subject}}" remixed as "{I gave my entire job to a Claude agent}" does.
- **Prefer outlier score over similarity.** A 5x outlier from a slightly different topic beats a 1.2x outlier on the exact topic. Proven performance trumps topical closeness.
```

After you write SKILL.md, show it to me and let me review before continuing.

---

## Phase 5: Test the skill end-to-end

Once SKILL.md is approved, run a test.

Trigger the skill with a sample query: **"Write me 5 hooks for a video about using Claude Code to automate cold email outreach. Audience: founders who hate selling."**

Walk through the steps. Show me the output. If any variant fails the voicing pass, regenerate just that one.

Then ask me what to refine in the framework files based on the test output. Iteration here is the difference between a skill I'll use daily and one that sits in the folder unused.

---

## Notes for you (Claude)

- This skill becomes more powerful the more frameworks live in `frameworks/`. Treat it as a living library. Anytime I find a new hook breakdown video I want added, I'll tell you "add this to my hook frameworks" and you'll fetch the transcript, synthesize the patterns, and update the index.
- If I have a Supabase database of competitor content (from a separate scraping pipeline), wire the skill to query it. The skill should work with OR without that database. The framework library alone is enough to ship Day 1.
- The whole point of this skill is to never sit down to record and have to think of a hook from scratch. The hook is always already mined. I just press record.