Przejdź do treści
Biblioteka skilli
Marketing i treści · Pisanie

thread-writer

/thread-writer

Pisze wątek na X lub Threads: spójną serię postów opowiadających jedną historię lub argument, z mocnym otwarciem.

Repozytorium
skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
15.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
6
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 15.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Pisze wątek na X lub Threads: spójną serię postów opowiadających jedną historię lub argument, z mocnym otwarciem.

Wyzwalacze z opisu

write a thread,turn this into a thread,X thread,Twitter thread,thread about X,write a thread
Oryginalny opis (EN)

Use to write a thread — a connected sequence of posts on X/Twitter or Threads that tells one story or makes one argument across multiple posts. Run when the user says "write a thread," "turn this into a thread," "X thread," "Twitter thread," "thread about X," or has a multi-beat idea that won't fit one post. Reads brand-profile and voice first, uses hook-writer for the opening post (which must hook AND promise the payoff), builds one cohesive idea where every post earns the next, and lands a close with one CTA. Knows when a single post beats a thread. Naming trap: "write a thread" means this m

Jak działa

  1. Step 0 — Read the foundation first
  2. Step 1 — Lock one idea, the payoff, and check it should be a thread
  3. Step 2 — Write the opener (hook + promise)
  4. Step 3 — Architect the thread
  5. Step 4 — Write the body posts
  6. Step 5 — Land the close and one CTA
  7. Step 6 — Format for the platform
  8. Quality bar — self-check
  9. Edge cases
  10. Related skills
Sekcje z nagłówków SKILL.md, w oryginale · 105 linii, 887 słów
Podgląd SKILL.md
---
name: thread-writer
description: >-
  Use to write a thread — a connected sequence of posts on X/Twitter or Threads that tells one
  story or makes one argument across multiple posts. Run when the user says "write a thread,"
  "turn this into a thread," "X thread," "Twitter thread," "thread about X," or has a multi-beat
  idea that won't fit one post. Reads brand-profile and voice first, uses hook-writer for the
  opening post (which must hook AND promise the payoff), builds one cohesive idea where every
  post earns the next, and lands a close with one CTA. Knows when a single post beats a thread.
  Naming trap: "write a thread" means this multi-post chain; "post on/to Threads" means a single
  post on Meta's Threads app — use threads-post for that. For a single caption use caption-writer;
  for just the opening hook use hook-writer.
metadata:
  version: 1.0.0
license: MIT
---

# Thread Writer

A thread is a retention machine in text: a sequence of posts where each one has to earn the next,
or the reader drops off. Done well it's one of the best formats for depth, saves, and follower
growth on X. Done lazily — a blog chopped into arbitrary chunks — it's worse than a single post.

Three principles run through it:

1. **The opener is the whole game.** Post 1 must *hook* (stop the scroll) **and** *promise the
   payoff* (give a reason to read all the way down). It's also the post that gets reshared, so
   the thread's reach lives or dies here.
2. **One idea per thread, one idea per post.** A thread makes a single cohesive point; each post
   advances it by exactly one beat. Cramming kills it.
3. **Every post earns the next.** Momentum is the metric. A post that doesn't pull the reader
   forward — or doesn't deserve its place — gets cut.

## Step 0 — Read the foundation first

Load `brand-profile.md` and `voice.md`. Voice carries across every post; the X/Threads register is
usually more conversational (use the voice tone-map). Carry guardrails throughout.

## Step 1 — Lock one idea, the payoff, and check it should be a thread

- **One idea** — the single point or story. If there are several, pick one or plan separate
  threads.
- **The payoff** — what the reader gets by the end (the lesson, the list, the result).
- **Thread or single post?** Thread *only* if the idea genuinely needs multiple beats. If it fits
  one post, a single punchy post almost always beats a forced thread. See
  `references/platform-and-when.md`.

## Step 2 — Write the opener (hook + promise)

Use `hook-writer` for post 1. It must do two jobs at once: hook with a real mechanism, and promise
the payoff ("here's how we did it," "7 lessons," "the story of how it broke"). The opener must
also stand alone as a strong post, since it's what gets reshared. No slow wind-up. See
`references/post-craft.md`.

## Step 3 — Architect the thread

Pick the structure that fits the idea — listicle, story, argument, how-to, or breakdown — and
outline the **spine**: the opener's promise and the ordered posts that deliver it. The spine is
what makes a thread cohesive instead of a chopped article. One idea per post. See
`references/architecture.md`.

## Step 4 — Write the body posts

Each post: front-load the point, deliver one beat, stay within the platform's limit, and **pull
forward** to the next (a mini-hook, a numbered step, "but here's the thing"). Cut any post that's
filler or throat-clearing. Keep every post in the brand voice. See `references/post-craft.md`.

## Step 5 — Land the close and one CTA

The final post delivers/summarizes the payoff, then makes **one** ask — matched to the goal and
in voice. On X, the native growth move is asking people to reshare the opener ("If this was
useful, RT the first post") and/or follow. One CTA only; a link, if any, goes here or in a reply.

## Step 6 — Format for the platform

Apply X vs Threads mechanics (limits, numbering, links, hashtags) from
`references/platform-and-when.md`. Number posts where it aids orientation; never split mid-thought
awkwardly; use line breaks within posts for readability.

## Quality bar — self-check

- Does the **opener hook AND promise**, and stand alone as a reshareable post?
- Is it **one idea**, with a clear spine — not a chopped article?
- Does **every post earn the next** (momentum, no filler)?
- Does each post **front-load the point** and respect the platform limit?
- Does the **close land the payoff** with exactly **one** CTA?
- Is it in the **brand voice**, at the right register?
- Should this even be a thread — or is a single post stronger?

If any post doesn't pull the reader forward, cut or rewrite it before delivering.

## Edge cases

- **Should be a single post** → say so and write the strong single post instead of padding a
  thread.
- **Multiple ideas** → one idea per thread; propose a series.
- **Chopped long-form** (a blog "made into a thread" by splitting) → don't. Atomize the idea and
  rebuild it as a native thread (see `cross-platform-repurposing` for the source→thread flow).
- **Threads (Meta) vs X** → adapt: Threads is more casual, less thread-culture, 500/post; X has
  strong thread culture and the reshare-opener mechanic. A *single* conversational Threads post →
  `threads-post`.
- **No genuine payoff** → if the idea has no real takeaway, it's not a thread; sharpen the idea
  first.
- **Sensitive/regulated** → carry compliance guardrails into every post; no overstated claims.

## Related skills

- `brand-profile`, `voice-builder` — voice + register + guardrails.
- `hook-writer` — the opener (and re-hooks).
- `caption-writer` — single posts/captions; `threads-post` — a single Meta Threads post (not a
  chain); `cross-platform-repurposing` — turn long-form into a thread.
- `scheduling-and-queue` — schedule via WoopSocial. Note: WoopSocial publishes **single posts only**
  (no native multi-post chain), so schedule the opener and post the chain natively/manually.

## References

- `references/architecture.md` — thread structures, the spine, one-idea-per-post, length.
- `references/post-craft.md` — the opener formula, post-as-unit, transitions, the close + CTA.
- `references/platform-and-when.md` — X vs Threads mechanics, and when NOT to thread.
- `references/examples.md` — full worked threads (listicle and story), on-voice.
Pliki w paczce (6)
  • SKILL.md 6 KB
  • evals/evals.json 3 KB
  • references/architecture.md 3 KB
  • references/examples.md 3 KB
  • references/platform-and-when.md 3 KB
  • references/post-craft.md 3 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · social-media-skills/skills100MIT
fabiensalles/claude-marketplace100MIT

Migawka bazy z 13.11.2026 · wersja paczki 49b345f23bb6 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100x-thread
    Pisze wątek na X z 2 do 15 wpisów, z hookiem, łańcuchem wartości i zakończeniem z wezwaniem do działania.
  • 100social-thread-writer
    Pisze wątek w wielu częściach dla X, LinkedIn i innych platform z długiego pomysłu.
  • 100social-thread
    Buduje wielopostowy wątek na X lub LinkedIn z hookiem, jedną ideą na post i wezwaniem do działania.
  • 100threads-post-writer
    Pisze post lub krótki wątek na Threads, który zaczyna rozmowę: dobiera hak pod wybraną reakcję i trzyma limit 500 znaków.
  • 100arabic-x-thread
    Pisze arabski wątek na X lub Threads z pomysłu, wideo lub artykułu, z jednym punktem na wpis i limitem znaków w każdym.
  • 100tweet-thread-builder
    Zamienia jeden pomysł w zwarty wątek na X: hak, jedna myśl na wpis i prowadzenie do jednego wezwania do działania.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.