# Thread Generator

> How to generate Twitter/X threads. Use this skill whenever the user asks for a "thread", "Twitter thread", "X thread", "tweet storm", or wants to explain something across multiple connected tweets. Also use when user says "break this down", "make a tutorial thread", or wants to share knowledge in a multi-tweet format. Make sure to read the user profile first to match their voice.

- Skill: `learn-with-santosh/thread-generator` (Agent Skill)
- Install (CLI): `npx skillmds@latest add learn-with-santosh/thread-generator`
- Raw SKILL.md: https://api.skillmd.com/api/skills/learn-with-santosh/thread-generator/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: learn-with-santosh (https://skillmd.com/u/learn-with-santosh)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/learn-with-santosh/thread-generator

---


# Twitter Thread Generator

## Purpose

Generate multi-tweet threads that:

- Teach something valuable across 5-10 tweets
- Feel like a human explaining to a friend over chai
- Get saved, shared, and bookmarked
- Build authority through real experience

Threads are not just long tweets. They're mini-articles with teeth.

---

## Core Philosophy

**Threads should feel like:**

- A senior dev pulling you aside
- Someone who's been through it
- Sharing the actual path, not the highlight reel

**Threads should NOT feel like:**

- A university lecture
- Corporate documentation
- AI-generated listicles

---

## My Signature Tone

### Voice

- Casual, human, slightly imperfect
- Simple English — like explaining to a friend
- No corporate tone, no buzzwords
- Slight frustration when things are unnecessarily complex

### Mental Models

- "If it works in real life, it's valuable. If not, it's noise."
- Build → Test → Share → Improve
- Simple fixes > complex solutions

### Phrases That Sound Like You

- "I was wasting 3 hours daily. So I built this."
- "Turns out the fix was stupid simple."
- "Don't overthink this."
- "Here's what actually worked..."
- "I stopped using X. Here's why."

---

## Thread Structure (8-Tweet Framework)

### Tweet 1: The Hook

This determines if anyone reads the rest.

**Formula:**

```
[Contrarian statement / Big promise / Vulnerable admission]

[What they'll learn]

[Social proof or stakes]

Thread ↓
```

**Examples:**

```
I was a junior dev for 2 years before I learned #3.

These 7 debugging tricks will save you hours:

1. The rubber duck upgrade
2. Git blame on yourself
3. The console.table() flex
...

Thread ↓
```

```
Unpopular opinion:

Your README is lying.

"Easy setup in 5 minutes"

*3 days later*
*still on step 2*

Here's what every README should actually include:

Thread ↓
```

---

### Tweets 2-7: The Meat

Each tweet should:

- Stand alone (people scroll back)
- Build on the previous
- Have a clear point
- End with a micro-payoff

**Formats that work:**

#### The "Problem → Solution" Tweet

```
The problem:
[Specific pain point]

What I tried:
[Common approach that failed]

What worked:
[Simple fix]
```

#### The "Before/After" Tweet

```
Before:
[How you did it wrong]

After:
[How you do it right]

Why it matters:
[One-line benefit]
```

#### The "Code Snippet" Tweet

````
Stop doing this:
```code
[Wrong way]
````

Do this:

```code
[Right way]
```

Reason:
[One-line explanation]

```

#### The "Story" Tweet
```

Last week:
[Setup — what you were doing]

Then:
[The thing that went wrong / discovery]

Result:
[What you learned / how it changed]

```

---

### Tweet 8: The Wrap

**Never end with "Thanks for reading."**

**Good endings:**

#### The "Call to Action"
```

If you got value from this:

1. Follow me for more [topic] content
2. RT the first tweet to help others
3. Reply with your biggest [topic] struggle

I read every comment.

```

#### The "Summary"
```

Recap:

• [Key point 1]
• [Key point 2]
• [Key point 3]
• [Key point 4]

Bookmark this for later.
You'll need it.

```

#### The "Open Loop"
```

This is just the start.

Next week I'm breaking down:
[Related topic that builds on this]

Turn on notifications.
You don't want to miss it.

```

#### The "Resource Drop"
```

Want the actual code/templates?

I've put everything in a repo:
[Link]

No email capture.
No upsell.
Just copy and use.

```

---

## Thread Archetypes

### 1. The "How I Fixed X" Thread
**Best for:** Technical tutorials, debugging stories

**Structure:**
1. Hook: The problem that almost broke you
2. Context: What you were trying to do
3. The rabbit hole: What went wrong
4. The discovery: What you found
5. The fix: Step-by-step solution
6. The result: Time saved / bugs fixed
7. Generalization: How to apply this elsewhere
8. Wrap: Summary + CTA

---

### 2. The "7 Things I Wish I Knew" Thread
**Best for:** Listicles with actual value

**Structure:**
1. Hook: Vulnerable admission + promise
2-7. Each item gets one tweet with:
   - The thing
   - Why it matters
   - How to apply it
8. Wrap: Recap + save prompt

---

### 3. The "Stop Doing This" Thread
**Best for:** Contrarian takes, myth-busting

**Structure:**
1. Hook: Controversial statement
2. The common mistake (with empathy)
3. Why people do it (understand their reasoning)
4. Why it's wrong (evidence/logic)
5. The right way (clear alternative)
6. Example (code/screenshot)
7. Edge cases (show nuance)
8. Wrap: Challenge + CTA

---

### 4. The "Build in Public" Thread
**Best for:** Showing your work, building authority

**Structure:**
1. Hook: What you built + why
2. The problem you're solving
3. Your approach (high-level)
4. Technical deep dive 1
5. Technical deep dive 2
6. What broke along the way
7. What you'd do differently
8. Wrap: Link to project + invite feedback

---

### 5. The "Concept Explainer" Thread
**Best for:** Making complex things simple

**Structure:**
1. Hook: "X is simpler than you think" or "X is more important than you realize"
2. What it is (one sentence)
3. Why it matters (real-world impact)
4. Analogy (compare to something familiar)
5. How it works (simplified)
6. Code example
7. Common mistakes
8. Wrap: Summary + "follow for more"

---

## Writing Rules (Non-Negotiable)

### Formatting
- Max 2-3 lines per paragraph
- White space is your friend
- Use bullet points (•) for lists
- Number threads clearly (1/8, 2/8, etc.)
- No walls of text

### Language
**Avoid:**
- "Leverage", "optimize", "utilize"
- "In today's world"
- "It's worth noting that"
- Corporate speak

**Use:**
- "just", "honestly", "basically"
- "turns out"
- "I was wrong about this"
- Simple, direct language

### Tone
- Slightly frustrated when things are complex
- Honest about mistakes
- Never condescending
- Always actionable

---

## Hook Formulas That Work

### The "Time Investment" Hook
```

Took me [X years/days/hours] to realize this:

[Insight]

Here's what I learned:

```

### The "Mistake" Hook
```

I wasted [time] on [thing].

Don't make the same mistake.

Here's the faster way:

```

### The "Contrarian" Hook
```

Unpopular opinion:

[Common practice] is overrated.

Here's why:

```

### The "Secret" Hook
```

Nobody talks about [thing].

But it's a superpower.

Let me explain:

```

### The "Before/After" Hook
```

Before: [struggle]
After: [ease]

The one change that fixed everything:

```

---

## Engagement Triggers

### For Saves
- Numbered lists
- Step-by-step tutorials
- Code snippets
- Templates

### For Shares
- Contrarian takes
- Relatable struggles
- "This should be common knowledge" content

### For Comments
- End with a question
- Ask about their experience
- Challenge a common belief

### For Follows
- Consistent value across tweets
- Clear niche/expertise
- Personality that comes through

---

## Thread Checklist (Before Posting)

**Content:**
- [ ] Does tweet 1 make people stop scrolling?
- [ ] Does each tweet deliver value?
- [ ] Is the thread skimmable?
- [ ] Are there any filler tweets? (delete them)
- [ ] Does the ending feel earned?

**Format:**
- [ ] Are line breaks clean?
- [ ] Is there enough white space?
- [ ] Are code snippets readable?
- [ ] Are tweets numbered correctly?

**Tone:**
- [ ] Does it sound human?
- [ ] Would you actually say this to a friend?
- [ ] Is there any corporate speak? (remove it)
- [ ] Does it feel like lived experience?

---

## Common Mistakes to Avoid

### 1. The "Thread Tax"
Don't add fluff to hit a certain number of tweets.
If it's 5 tweets, it's 5 tweets.

### 2. The "Bait and Switch"
Your hook promises X, your thread delivers Y.
Make sure the content matches the promise.

### 3. The "Wall of Text"
If a tweet needs more than 2-3 scrolls to read, it's too long.
Break it up.

### 4. The "Weak Ending"
"Thanks for reading!" adds no value.
End with: summary, CTA, or open loop.

### 5. The "Theory Trap"
Threads heavy on explanation, light on application.
Show, don't just tell.

---

## Output Format (MANDATORY)

When generating a thread, always output:

### Thread Topic
[What the thread is about]

### Target Length
[X tweets]

### The Thread

**Tweet 1/X (Hook)**
[Tweet text]

**Tweet 2/X**
[Tweet text]

...

**Tweet X/X (Wrap)**
[Tweet text]

---

### Why This Thread Works

[Brief explanation of hook choice, flow, and engagement strategy]

### Suggested Visuals

[Which tweets should have images/screenshots and what they should show]

### Posting Tips

[Any specific advice for this thread: best time to post, who to tag, follow-up strategy]

---

## Quick Reference: Topic → Thread Type

| Topic | Best Thread Type |
|-------|------------------|
| Debugging a specific bug | How I Fixed X |
| Learning a new technology | 7 Things I Wish I Knew |
| Common misconception | Stop Doing This |
| Building a project | Build in Public |
| Explaining a concept | Concept Explainer |
| Sharing a workflow | How I Fixed X / 7 Things |
| Reviewing a tool | Stop Doing This / Build in Public |

---

## Final Rule

If the thread feels like:
- A tutorial nobody asked for
- Something you'd skip while scrolling
- Generic advice from a blog post

Delete it.

Rewrite until it feels like:
- Something you'd save
- Something you'd send to a friend
- Something that could only come from your actual experience

---

## Bonus: Thread → Content Multiplier

After writing a thread, consider:
1. Can this become a Medium article? (expand each tweet)
2. Can this become a carousel? (one slide per tweet)
3. Can this become a video script? (narrate the thread)
4. Can this become a LinkedIn post? (condense to long-form)

One thread = four pieces of content.
Work smarter.
```