Skip to content

lennoxsaint/Threadify-workflows / plugins/claude/skills/threadify-whats-working

threadify-whats-working

Verified

Check every Threads post you published this year against your own median views, show which kinds of posts Threads is killing and the one kind it still pushes 100x, then have Threadify write three posts in that winning pattern with tracked Auto Plugs and schedule them only after one exact approval. Use when someone asks "is Threads dead", "what's actually working on Threads", why their views dropped, or which of their posts get pushed.

What's Working

Threads isn't dead. Most of your posts are. This workflow reads every post you published this year, labels each one against your own median views (dead, stuck or alive), answers "is Threads dead for me?" month by month, names what the dead posts share and the one kind of post Threads still pushes hardest, then asks Threadify to write three new posts in that pattern, each with a tracked Auto Plug, and schedules them only after one "yes". It works the same in Claude Code, Codex and ChatGPT.

Follow Threadify-001: setup and first-loop video before the first connected call. A connection never authorizes scheduling. Only the owner's "yes" to the exact approval packet does.

Rules

  • Follow the demo feedback rules at the end of this file for the whole run. If ~/.threadify/owner-overlay.md exists, read it too and follow it; it is private, so never quote it into posts, files you publish or receipts.
  • Every number comes from the tools or the script. Missing data stays unknown: say "unknown", never 0. Describe what happened, never what will happen: no post or pattern "will" go viral.
  • Say "this year" only when the read starts on 1 January. Otherwise say the real window: "read N posts, to ".
  • Threadify writes every post and every plug with generate_content. Preserve generated wording by default; the agent edits only when the owner explicitly asks. Record the request and original copy. Never use edit_draft.
  • Without an editing request, the only permitted change is lowercasing, keeping proper nouns, and only when the owner asks for it. Prove it for every post and plug with scripts/casing-guard.mjs (Node 18+, JSON on stdin): lower(original) == lower(final) must be true and the result PASS. If the guard fails, show the original unchanged.
  • Never publish now. Never schedule without the owner's "yes" to the exact packet. Never move or overwrite a post already on the calendar.
  • Never print credentials, tokens, account ids, other people's handles from replies, or customer details. Show the owner's own posts and numbers; they are the point.

Steps

  1. Connect. Call get_connection_defaults. Confirm the account by saying only the @handle and timezone, for example "@handle · Australia/Perth". Note link_tracking and the plan for Auto Plug. Say in one line what the owner gets: "I'll check every post you published this year against your own median, show you what Threads is killing and the one kind it still pushes, then Threadify writes 3 of those for you."
  2. Read the year. Call search_posts with query: "*", from / to set to one calendar month at a time from 1 January to today (to is exclusive: use the first day of the next month, and tomorrow for the current month, or the last day of every month goes missing), sort_by: "recent" and a limit above that month's total_matched; if a month returns fewer rows than total_matched, split it into halves and read again. Keep every page, and check that the months' row counts add up to the total before you diagnose. (read_post_performance with a long window can fail with artifact-write-failed; use it only for a window it returns in full.) If the account's history doesn't reach 1 January, keep what it returns and say the real window. Save the raw pages locally (never in a public repo).
  3. Diagnose. Pipe {"performance": <every search_posts page>, "from": "<YYYY>-01-01", "handle": "@handle"} into node scripts/whats-working.mjs --html whats-working.html. Say the coverage line first ("Read N posts, date to date. Counted M; K too new to judge; U with unknown views."), then the median, the best post and its multiple, and never_broke_out_percent. Labels are relative to the median: dead under 1x, stuck 1x to under 3x, alive 3x or more; posts under 3 days old are left out because they are still collecting views. Then answer "is Threads dead for you?" from monthly: compare the first and last full months' median views and alive share, in numbers, with no verdict the numbers don't show.
  4. Name the patterns. Read the posts (top 30 by views, the 30 lowest, and every alive post) and give each counted post one short pattern label that joins its hook and format, for example "news reaction", "i got AI to do a huge task", "hot take", "how-to list", "personal story", "question", "promo". Use the owner's own words for topics. Use 6-10 labels in total so groups are big enough. Re-run the script with "tags": {"<post_id>": {"pattern": "<label>"}}. Patterns with fewer than 5 posts are marked small_sample and are not ranked; say so if one looks big.
  5. Show what's working. Open the report page and keep it on screen: serve its folder on this computer only (for example python3 -m http.server 8047 --bind 127.0.0.1 --directory <report folder> in the background) and open http://127.0.0.1:8047/whats-working.html in the browser, because some hosts' browsers refuse file:// pages. Stop the server when the run ends. In chat, keep it short and phone-readable (no wide tables):
    • What Threads killed: up to 3 most_dead patterns, each with its median multiple and one real post (first line + views).
    • What it still pushes: most_alive, ending on #1 (number_one): its median multiple, alive share and its 3 real example posts.
    • One line: what the #1 posts share that the dead ones don't (first line, subject, format), tied to the examples. Describe, don't predict.
  6. Threadify writes 3 in the #1 pattern. Make one generate_content call per post with strict_facts: true, inputText describing the #1 pattern as a shape (never a past post's copy to paste) plus a fresh subject from the owner's own recent topics, and selectedModel from generation models (Claude Opus 5.5 when the plan allows it, Gemini as fallback; record the requested and reported model). Ask for concise copy, a first line that opens a loop, short paragraphs and a strong closing point in the owner's voice. Give numbers as whole numbers, and keep the analysis caveats (association, sample size) in the report, not in the post. No offer and no link in the post itself. Keep Threadify's exact text and draft_id. If the owner wants lowercase, run casing-guard.mjs lowercase with the proper nouns to keep, then check on every post; show "guard: lower(original) == lower(final) PASS" per post.
  7. One Auto Plug each. Call list_offers and let the owner pick one offer if more than one fits. For each post, make one more generate_content call with that offer_id, asking for a one-post plug reply that continues that exact post. Run the guard on each plug the same way. Promote the selected offer, and claim only what its destination provides. The plug's link is the offer's saved destination; Threadify links on Threads are auto-tracked, so add no UTM tags. If link_tracking is off or unknown, say clicks may not be measured. If the plan has no Auto Plug, say so and ask whether to schedule without plugs or stop.
  8. Review and pick 3 slots. Follow review and editing and run node scripts/review-packet.mjs < review.json as described there. Call best_time_to_post (owner's timezone) and list_scheduled_posts; a truncated response is not an empty calendar. Pick one slot on each of the next three days at the best measured time with no scheduled post within 90 minutes and at least 60 minutes from now. Call validate_post on every post and plug; if one fails, say why and ask Threadify once for a replacement through steps 6-7.
  9. One approval packet. Send one message:
What's Working · @handle · <timezone>
#1 pattern: <label> · <median multiple>x your median
1) <weekday date, local time> · <unchanged | casing guard PASS | owner-requested edit>
<exact final post text>
Auto Plug (15 min after): <exact plug text>
Destination: <exact offer destination>
2) ...
3) ...
Action: schedule these 3 posts with their Auto Plugs exactly as shown. Nothing publishes now.
Reply "yes" to schedule all 3, or "no" to schedule nothing.

Schedule only on an explicit "yes". Any change to text, plug, destination, account or time needs a new packet and a new "yes". On "yes", re-check list_scheduled_posts, then call schedule_post three times with a stable idempotency_key per post (account, slot, final post and plug hashes) and auto_plug: {content: <exact plug text>, trigger: "time", delay_minutes: 15}. Unchanged text: pass draft_id and content_type. Lowercased or owner-edited text: pass the exact final text without draft_id, because Threadify schedules a draft's stored text when given a draft_id. Omit platforms and auto_repost. Read back each one with get_schedule_status: text, local time and the auto_plug echo must match the packet; a failed or cancelled record is a mismatch. If an outcome is unclear, read back before retrying, and retry only that post with the same key. On "no", schedule nothing; originals stay as Threadify drafts. 10. 7-day check. Offer to re-run What's Working 7 days after the last of the 3 posts goes out, to see where they landed against the median. If the host supports a reminder or scheduled run, offer to create one and create it only after the owner agrees. Otherwise give a dated note: "Run What's Working on to see where these 3 landed."

When something is missing

Without a Threadify connection or generation access, stop and say exactly what is missing and the manual next step. Never write posts yourself instead. A scheduled post is not a published post.

Demo feedback rules (full text)

Corrections creators gave Threadify workflows while running them live, turned into rules so nobody has to give the same feedback twice. Every workflow follows these; a workflow's own rules win where they are stricter. A private overlay at ~/.threadify/owner-overlay.md, when present, adds the owner's personal preferences; read it, follow it, and never publish, quote or upload it.

Pace and confirmations

  • Keep going until the agreed scope is finished. Never stop just to report progress.
  • At each checkpoint, state what is done, what remains and an honest time estimate, without being asked.
  • Make routine choices yourself (titles, posting times, picks between close options) and state the choice in one line.
  • Ask for one confirmation per irreversible action. Never ask the same confirmation twice.
  • Put every action of a run into one approval packet that says what each does. After the single yes, run to the end and read each result back. Never ask again for anything already inside the packet.
  • The owner's "yes" in chat is the approval. If the host (an approval queue, a hook or a gate) still holds the call, say where to approve it in one line and wait. Never route around it or retry another way. If the rule holding it looks stale (it asks for something the owner has since changed), say so and offer to fix the rule itself, with its own yes, then retry once.
  • Build for whoever runs the workflow: find or ask what actually makes them money, confirm it, and never hardcode one creator's offer, handle, tools or data.
  • Plan for the owner's setup, not a developer's: no-code actions first. Say "here's what I'll do, in this order, and why. OK?", then work most important first. Start slow work, ship the quick win, then finish it.
  • Look it up before you ask. Never ask the owner something their connected account, files or past posts can answer, and never offer an action the product cannot do.
  • Ask questions in batches of at most three, each with your recommended answer. Use the host's native question tool when it has one.
  • Run commands yourself. Never hand the user a terminal command you could run.
  • In step-by-step demo mode, do exactly one step, then wait for "next".

Output on screen

  • Show generated posts and their Auto Plugs in full, in chat, as plain text. Never show only a file path, a summary, or text inside a card, box or next-step prompt.
  • Show Threadify's generated drafts exactly as returned. Don't audit, polish or rewrite them unless the user asks.
  • After any correction, print the whole set again (every post and every Auto Plug) with the change applied. Never show only the changed item or a diff.
  • Make only the edit the owner asked for. Keep everything else exactly as it was, keep what they praised, and say what you removed.
  • When a workflow writes posts, offer an edit-in-place step (editable text with a Done button) that keeps the originals for comparison. Skip it when the owner says they won't edit.
  • Narrate each step in plain, viewer-facing language, as if the audience is watching the screen.
  • Open what you produced (page, tab or file) and confirm it opened before saying it is ready.
  • Review pages and videos must load and play quickly on a phone.
  • Work in the background or the in-app browser. Don't take over the presenter's screen.
  • Keep tables and visuals phone-readable: few columns and short cells.

Truth and numbers

  • Use real, current account numbers, refreshed at run time. Never use stale or estimated figures.
  • Drop metrics that prove nothing (zero or unknown outcomes) instead of padding with them.
  • Show real screenshots of what you describe. For a fix, show before and after.
  • Hide only real secrets (keys, tokens, IDs, emails). Never blur the evidence the viewer needs.
  • Label any hook without performance evidence as unproven. Never call it proven.
  • Keep each claim exactly as strong as the data: "one of my most viewed" stays "one of", a median is not an average, and a rough rate stays rough.

Copy

  • Start from the owner's own material before writing from scratch: past posts and threads, testimonials, receipts, screenshots and notes. Use the real story or proof you find there.
  • Base each post on a real outlier post turned into a template with placeholders: copy its whole structure (hook, line breaks, list shape, length and ending), not just its hook. Make the first 3 to 5 words the strongest.
  • The hook carries a benefit for as many readers as possible. Use specific numbers, but never so specific that they shut most readers out.
  • Never lead with numbers that kill social proof (a weak count like "1 signup" or "0 paid"). Frame them as the discovery or the win.
  • Write with diary energy: what just happened, told like you just found out.
  • Never reuse a hook, template or proof point within one batch.
  • Listicles go from the hook straight into the numbered list: no analogy, setup paragraph or "here are N things" bridge.
  • Short post: a one-sentence hook that opens a loop. Long thread: a three-sentence hook with two loops that ends in a colon.
  • Be concise: short posts under about 350 characters (unless the workflow asks for a long thread), CTAs about 100 to 250 characters, and cut anything that does not earn its place.
  • End each post with a grand, bold, emotional "so what" line for the reader that flows from the sentence before.
  • Copy follows the channel's casing: lowercase on Threads (proper nouns kept), the site's own casing on the site and in offers.
  • CTAs must be relevant, specific and seamlessly integrated. Point to the product, not the workflow name, and include a real number or social proof. Model each Auto Plug on the plugs that got the most clicks. A proven plug shape: one line from the post's subject to the product, one line of pain, the product as the fix, a free-to-try or social-proof line, then the offer's plain link (Threadify tracks clicks itself, so no tracking tags).
  • Reuse the offer the account already has for the product. Never create, rename or duplicate an offer per run, episode or rehearsal; the Auto Plug carries the run's specific message.
  • Remove AI tells and hedging ("not because X, but because Y", vague abstractions, qualifiers).
  • Use plain words and no internal jargon a viewer would not know.

Failure handling

  • If a dependency stalls, switch to the fallback or the files already provided and say so. Never wait silently.
  • On failure, report the exact error in one line, then retry the way the workflow was meant to run.
  • After a rehearsal the user asked for, cancel only the test schedules and drafts that rehearsal created, and read back the result.
  • When a redo replaces a draft or a scheduled post the run created, delete the replaced draft and cancel its schedule, then read the list back.
  • When the user corrects output during a run, apply the correction to every remaining item, keep a visible running list of corrections, and at the end remind them to write that list back into the workflow so it is never needed again.
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 196kUpdated Claude CodeCodexVerifiedInstall