Skip to content

Eleven free Claude skills that run a LinkedIn account: posts off 21 hook formulas, comments, replies, profile score, weekly plan, and a humanizer that strips the AI fingerprint and scores the draft before it goes out.

The LinkedIn agent skill: 11 Claude skills, v1.0

Jake Schincarioladd2c23882fe
diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json
new file mode 100644
index 0000000..4b181c9
--- /dev/null
+++ b/.claude-plugin/marketplace.json
@@ -0,0 +1,18 @@
+{
+ "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
+ "name": "linkedin-agent-skill",
+ "description": "The LinkedIn agent skill pack for Claude",
+ "owner": {
+ "name": "Jake Schincariol",
+ "url": "https://opusjake.ai"
+ },
+ "plugins": [
+ {
+ "name": "linkedin-agent",
+ "description": "Eleven Claude skills that run a LinkedIn account, including a humanizer that strips the AI fingerprint and scores the draft on a five-check panel.",
+ "source": "./",
+ "category": "productivity",
+ "homepage": "https://opusjake.ai/r/linkedin-agent"
+ }
+ ]
+}
diff --git a/.claude-plugin/plugin.json b/.claude-plugin/plugin.json
new file mode 100644
index 0000000..3414e31
--- /dev/null
+++ b/.claude-plugin/plugin.json
@@ -0,0 +1,13 @@
+{
+ "name": "linkedin-agent",
+ "description": "Eleven Claude skills that run a LinkedIn account: posts off 21 hook formulas, comments, replies, profile score, weekly plan, DMs, inbox triage, carousels, repurposing, audits, and a humanizer that strips the AI fingerprint and scores the draft before it goes out.",
+ "version": "1.0.0",
+ "author": {
+ "name": "Jake Schincariol",
+ "url": "https://opusjake.ai"
+ },
+ "homepage": "https://opusjake.ai/r/linkedin-agent",
+ "repository": "https://github.com/Jakeschincariol/linkedin-agent-skill",
+ "license": "MIT",
+ "keywords": ["linkedin", "content", "writing", "humanizer", "social", "marketing"]
+}
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..4b0e230
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,5 @@
+.DS_Store
+__pycache__/
+*.pyc
+.venv/
+*.tmp
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..ac31f09
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jake Schincariol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..07e4943
--- /dev/null
+++ b/README.md
@@ -0,0 +1,177 @@
+# The LinkedIn agent skill
+
+Eleven Claude skills that run a LinkedIn account. Free, MIT, no signup, no API
+key, nothing to connect.
+
+One of them writes your posts off 21 hook formulas. One comments on other
+people's posts. One handles the replies under yours. One scores your profile
+out of 100 and rewrites what lost points. One plans the week: what to post,
+when, and who to engage with.
+
+And one is the humanizer, which is the reason the rest are usable. It strips
+the em dashes, the slop vocabulary and the invisible watermark characters out
+of a draft, then scores what is left against a five-check detection panel
+before you ever see it.
+
+**Nothing gets posted until you say yes.** These skills write. You post.
+
+## Install
+
+Paste this into Claude:
+
+```
+https://github.com/Jakeschincariol/linkedin-agent-skill
+
+Install this skill, then confirm /li-post works.
+```
+
+Or do it yourself, in Claude Code:
+
+```bash
+git clone https://github.com/Jakeschincariol/linkedin-agent-skill.git
+cp -r linkedin-agent-skill/skills/li-* ~/.claude/skills/
+```
+
+Or as a plugin:
+
+```
+/plugin marketplace add Jakeschincariol/linkedin-agent-skill
+/plugin install linkedin-agent
+```
+
+Project-local instead of global: copy the same folders into your repo's
+`.claude/skills/`. No Claude Code at all? Paste any single `SKILL.md` at the
+top of a chat and it runs as a mode - you lose the two Python tools, which is
+most of the point of `/li-human`, but the rest works.
+
+Then spend ten minutes on `templates/voice.md`. Copy it to
+`~/.claude/linkedin/voice.md` and fill it in, or paste three of your own posts
+into Claude and say "write my voice.md from these". Every skill reads that
+file. Skip it and everything comes out sounding like everyone else.
+
+## The eleven
+
+| command | what it does |
+| --- | --- |
+| `/li-post` | One idea into a post. Three hook options from [21 formulas](skills/li-post/hooks.json), one full draft, humanized before you see it. |
+| `/li-comment` | Comments on other people's posts. Nine types, picked by what the post actually is. Never "Great post!". |
+| `/li-reply` | The thread under your own post. Sorts every comment into lead / substance / peer / support / noise, then writes in that order. |
+| `/li-profile` | Scores your profile against a [12-part rubric](skills/li-profile/rubric.json) out of 100, then rewrites in fix-first order. |
+| `/li-plan` | The week. What to post, when to post it, and the 10 people to engage with. Writes `~/.claude/linkedin/plan.md`. |
+| `/li-human` | The humanizer. Two scripts that actually run. See below. |
+| `/li-carousel` | Document posts. Slide-by-slide copy, the cover that earns the swipe, and the PDF to upload. |
+| `/li-repurpose` | One video, newsletter or transcript into a week of posts that each stand alone. |
+| `/li-dm` | The 200-character invite note, the first message, and the two follow-ups. Two. |
+| `/li-inbox` | Triages the inbox into lead / recruiter / peer / ask / spam, and tells you which tell gave the sequence away. |
+| `/li-audit` | Post-mortem on what you have already published. Ranks by engagement rate and reach multiple, not impressions. |
+
+## The humanizer
+
+`/li-human` ships two Python scripts with no dependencies. They run on your
+machine, on your text, and nothing is uploaded.
+
+```bash
+python3 humanize.py draft.txt --report # clean it, show every change
+python3 detect.py draft.txt # score it, five checks
+python3 detect.py before.txt after.txt # prove the delta
+```
+
+**What comes out automatically:**
+
+- **Invisible characters.** Zero-width spaces and joiners, word joiners, soft
+ hyphens, byte-order marks, Unicode tag characters, non-breaking and narrow
+ spaces. Your keyboard does not make these. They survive copy-paste and they
+ are invisible in every editor you own.
+- **Typography.** Em dash to comma, en dash to hyphen, curly quotes to
+ straight, ellipsis to three dots.
+- **The lexicon.** 113 stock words and phrases with plain-English
+ replacements - delve, leverage, robust, seamless, crucial, testament to, "in
+ today's fast-paced world", "let that sink in" - with capitalisation preserved
+ and URLs untouched. It lives in
+ [`slop.json`](skills/li-human/slop.json) and it is meant to be edited.
+
+**What gets flagged instead of fixed:** "It's not just X, it's Y", rule-of-three
+triads, one-word rhetorical questions, hashtag walls, reflex engagement bait,
+uniform sentence length. Changing the shape of a sentence needs judgement, so
+those are handed back for a rewrite rather than mangled by a regex.
+
+**The five checks**, scored 0-100, higher is more human:
+
+| check | what it measures |
+| --- | --- |
+| BURSTINESS | sentence-length variation. Models write even. |
+| SPECIFICITY | numbers, names and concrete markers per 100 words |
+| SLOP DENSITY | lexicon hits per 100 words |
+| FINGERPRINT | invisible characters, em dashes, curly quotes per 1,000 |
+| VOICE | contractions, person, structural tells |
+
+The verdict weights the mean at 60% and the **weakest single check** at 40%,
+because a detector only needs one signal to fire.
+
+Run against a deliberately terrible draft:
+
+```
+ BURSTINESS ##################...... 73.0
+ SPECIFICITY ######################## 100.0
+ SLOP DENSITY ........................ 0.0 19 stock terms, 24.1 per 100 words
+ FINGERPRINT ........................ 0.0 1 invisible, 1 em dash, 3 curly quote
+ VOICE ########................ 33.3 3 structural tells
+ ------------------------------------------------------------
+ HUMAN SCORE ######.................. 24.8 FLAGGED
+```
+
+After `humanize.py`, with the flagged structures still unrewritten:
+
+```
+ HUMAN SCORE #################....... 69.7 REVIEW (+44.9)
+```
+
+The last stretch to PASS is the part the script deliberately leaves to you.
+
+## The fine print, which is the honest part
+
+**These skills do not post to LinkedIn, and they should not.** There is no
+official API for posting to a personal profile without an approved partner
+app, and automating the site with a browser or a third-party tool violates
+[LinkedIn's User Agreement](https://www.linkedin.com/legal/user-agreement) and
+gets accounts restricted. So every skill here ends the same way: a copy-ready
+block, and you paste it. That is not a limitation bolted on afterwards, it is
+the design. It is also why the approval gate is real rather than a setting.
+
+**The five checks are local heuristics, not detector APIs.** They are modelled
+on the signals public detectors key on, and they run entirely on your machine.
+They are not GPTZero, Originality, Copyleaks, Winston or Turnitin, they do not
+call those services, and they cannot promise those verdicts. Fixing what they
+measure tends to move those numbers, because they are measuring the same
+underlying things. That is the whole claim. Nobody can honestly sell you
+"undetectable", and anybody who does is selling you something.
+
+**The invisible-character pass is real and it is narrow.** It removes the
+zero-width and format characters that end up in generated text and survive a
+copy-paste. That is a genuine, checkable fingerprint. It is not a claim about
+defeating a cryptographic watermarking scheme, and this repo does not make
+one.
+
+**Nothing here fabricates.** No invented metrics, clients or outcomes go under
+your name. If a draft needs a number you have not given, it comes back with
+`{{your number}}` in it and a flag, every time.
+
+## Files
+
+```
+skills/li-post/hooks.json 21 hook formulas: template, example, what it is for, how it gets ruined
+skills/li-human/slop.json the lexicon: 113 terms, 17 invisible classes, 11 structural tells
+skills/li-human/humanize.py the three cleaning passes
+skills/li-human/detect.py the five-check panel
+skills/li-profile/rubric.json the 100-point profile score
+templates/voice.md your voice profile. Fill this in first.
+```
+
+## Credit
+
+Made by Jake Schincariol, [opusjake.ai](https://opusjake.ai).
+The full write-up is at [opusjake.ai/r/linkedin-agent](https://opusjake.ai/r/linkedin-agent).
+
+## License
+
+MIT. Take it, change it, ship it.
diff --git a/skills/li-audit/SKILL.md b/skills/li-audit/SKILL.md
new file mode 100644
index 0000000..7b57a54
--- /dev/null
+++ b/skills/li-audit/SKILL.md
@@ -0,0 +1,88 @@
+---
+name: li-audit
+description: >-
+ Post-mortem on what the user has already published - which posts actually
+ worked, why, and what to stop doing. Use when the user pastes their LinkedIn
+ analytics or past posts and asks "what's working", "why did this flop", "read
+ my analytics", "audit my content", or wants to know what to double down on.
+---
+
+# li-audit
+
+The only honest source of what works for an account is that account. Every
+rule in every LinkedIn guide, including the ones in this pack, is a prior. The
+user's own last 30 posts are the evidence.
+
+## Input
+
+Ask for whichever the user has:
+
+- The post analytics export (LinkedIn: Analytics -> Content -> Export). CSV.
+- Or a screenshot per post with impressions, reactions, comments, reposts.
+- Or just the posts and their reaction counts, which is enough for a first
+ pass.
+
+Also read `~/.claude/linkedin/log.md` if it exists, since it records which
+hook formula each post used.
+
+## What to actually measure
+
+Raw impressions are the least useful number on the page, because they are
+mostly a function of how many people already follow the user. Compute these
+instead, and show the working:
+
+| metric | how | what it tells you |
+| --- | --- | --- |
+| **Engagement rate** | (reactions + comments + reposts) / impressions | whether the post earned its reach |
+| **Comment ratio** | comments / reactions | whether it started something or just got a nod |
+| **Reach multiple** | impressions / follower count | whether it travelled past the existing audience |
+| **Save/send rate** | if available | the strongest single predictor of future reach |
+
+Rank by engagement rate and reach multiple, not impressions. A post with 900
+impressions and 40 comments beat the one with 12,000 impressions and 6.
+
+## Then find the pattern
+
+With the top 5 and bottom 5 side by side, look for what actually separates
+them, and be willing to conclude something the user will not like:
+
+- Hook formula. Which numbers from `hooks.json` are in the top 5?
+- Format. Text, document, image, video.
+- Length.
+- Theme.
+- Day and time - check this **last**, and only if the other four show nothing.
+ It is almost never the cause, and it is where people want it to be.
+- First-hour comments. Posts the user replied to inside an hour versus not.
+
+State the finding as a claim with the evidence attached, and say how confident
+it is. With 30 posts you can see a pattern; with 6 you cannot, and you should
+say that instead of inventing one.
+
+## Output
+
+```
+AUDIT · 31 posts · Jun 12 - Sep 5
+
+TOP 5 BY ENGAGEMENT RATE
+ 8.1% #3 Mistake "$18,000 is what no contract cost me" 1,940 imp
+ 6.4% #20 Walk-Away "I fired my highest-paying client" 2,210 imp
+ ...
+
+BOTTOM 5
+ 0.4% #5 List "7 tools every founder needs" 11,400 imp
+ ...
+
+WHAT THE DATA SAYS
+1. Posts where you were the one who looked bad: mean 6.2% vs 1.1% for
+ everything else. n=6. This is your strongest signal and it is not close.
+2. Tool listicles get impressions and nothing else. High reach, no comments,
+ no leads. Three of your bottom five.
+3. Day of week shows nothing. Your Tuesday mean and your Friday mean are
+ inside the noise. Stop optimising it.
+
+STOP: listicles about tools.
+DO MORE: the ones with a cost you paid, and a number.
+```
+
+Then hand the conclusions to `/li-plan` so next week's plan is built on the
+user's own evidence rather than on defaults.
diff --git a/skills/li-carousel/SKILL.md b/skills/li-carousel/SKILL.md
new file mode 100644
index 0000000..c204f52
--- /dev/null
+++ b/skills/li-carousel/SKILL.md
@@ -0,0 +1,71 @@
+---
+name: li-carousel
+description: >-
+ Build a LinkedIn document post (carousel) - slide-by-slide copy, the cover
+ that earns the swipe, and the PDF to upload. Use when the user says
+ "carousel", "document post", "slides for LinkedIn", "turn this into a
+ carousel", or has a list-shaped idea that would die as a text post.
+---
+
+# li-carousel
+
+Document posts are the highest-dwell format on LinkedIn, because a swipe is
+counted and a scroll is not. The format rewards one idea broken into steps.
+It punishes a text post cut into pieces.
+
+## When to use it instead of a text post
+
+Use a carousel when the idea has **sequence** - steps, a countdown, a
+before/after progression, a framework with parts. Use a text post when the
+idea is one claim. Splitting one claim across eight slides is the most common
+way carousels fail, and if that is what the user has, say so and hand them to
+`/li-post`.
+
+## Structure
+
+8-12 slides. Under 8 is a text post. Over 12 and the completion rate falls off
+a cliff.
+
+```
+1 COVER the hook, 6 words or fewer, plus one line of promise
+2 THE STAKE why this matters, in one sentence
+3-N ONE IDEA PER SLIDE. A headline of 3-7 words, and at most 25 words
+ under it. If a slide needs a paragraph, it is two slides.
+N+1 RECAP the whole thing as a list, so the screenshot is useful
+LAST CTA one action. Follow, comment a keyword, or the link. One.
+```
+
+## Slide copy rules
+
+- **Slide 1 is 80% of the result.** Six words. Big. The rest of the deck
+ cannot save a cover nobody swipes.
+- **Number every slide** (3/10). Completion goes up when people can see the
+ end.
+- **No slide is a paragraph.** If you cannot say it in 25 words, split it.
+- **The recap slide is the one people screenshot.** Make it standalone.
+- **The user's handle on every slide**, small, bottom corner. Screenshots
+ travel without you.
+
+## Making the PDF
+
+LinkedIn wants a PDF, 1080x1350 (4:5) for maximum feed real estate, under
+100MB, under 300 pages. Build it as HTML and print to PDF:
+
+```bash
+# one page per slide, 1080x1350, no margins
+# then: Chrome headless --print-to-pdf, or any HTML-to-PDF you already use
+```
+
+Write the HTML with one `<section>` per slide, `width:1080px; height:1350px;
+page-break-after:always`, a single accent colour, and type no smaller than
+28px - people read these on a phone at thumbnail size. If the user has a brand
+skill or design system in this project, use it and do not invent a palette.
+
+## Output
+
+The slide-by-slide copy first, as a numbered list the user can read in ten
+seconds. Then the accompanying **post text** - a carousel still needs 2-3
+lines above it, which is the actual hook in the feed. Run both through
+`/li-human`. Then build the PDF only if the user approves the copy.
+
+Nothing is uploaded to LinkedIn. The user posts the PDF themselves.
diff --git a/skills/li-comment/SKILL.md b/skills/li-comment/SKILL.md
new file mode 100644
index 0000000..14f1b99
--- /dev/null
+++ b/skills/li-comment/SKILL.md
@@ -0,0 +1,91 @@
+---
+name: li-comment
+description: >-
+ Write comments on other people's LinkedIn posts that read as a person with an
+ opinion, not a bot. Use when the user pastes a post and wants a comment, says
+ "comment on this", "engage with this", "what do I say here", or wants a batch
+ of comments for their engagement round.
+---
+
+# li-comment
+
+Commenting is the highest-leverage thing on LinkedIn and the easiest to do
+badly. A comment on a post with 400 reactions gets seen by more people than
+most of your own posts. A generic one gets seen by nobody and costs you
+credibility with the author.
+
+## Input
+
+The user pastes the post text (and the author's name and role if they have
+it). If they paste a screenshot, read it. If they give you a URL you cannot
+open, ask them to paste the text - do not guess what the post said, and do not
+use browser automation to scrape the feed.
+
+## The nine comment types
+
+Pick by what the post actually is. Never default to type 1.
+
+| # | type | when | shape |
+| --- | --- | --- | --- |
+| 1 | **Add a datum** | post makes a claim you can support with a number | "We saw the same thing: 40% of our..." |
+| 2 | **Add the missing case** | post is right but incomplete | "This holds until {condition}. Then..." |
+| 3 | **Respectful disagree** | you genuinely think it is wrong | name the agreement first, then the fork |
+| 4 | **Extend one line** | one sentence in the post is the good one | quote it, then build on it |
+| 5 | **Ask the real question** | post skipped the hard part | one question, specific, no "curious to hear" |
+| 6 | **The receipt** | you have done the thing they described | what happened, in two sentences |
+| 7 | **The correction** | there is a factual error | be right, be brief, be kind, be sure |
+| 8 | **The reframe** | the post has the right facts and the wrong frame | "Another way to read this:" |
+| 9 | **The one-liner** | the post needs nothing, you want presence | under 12 words, must be funny or true |
+
+## Rules
+
+- **2 to 4 sentences.** Longer reads as a hijack. Shorter reads as filler.
+- **Never open with "Great post"**, "Love this", "So true", "Couldn't agree
+ more", "This resonates", or the author's first name followed by an
+ exclamation mark. All six are invisible.
+- **No emoji openers.** No 🔥 or 👏 as a first character.
+- **Never restate the post.** The author knows what they wrote and so does
+ everyone reading.
+- **One idea.** A comment with two points reads as a blog attempt.
+- **Say the specific thing.** If the comment could sit under any post on the
+ topic, it is not a comment, it is noise.
+- **Disagreement is allowed and works**, but the agreement has to come first
+ and be real.
+
+## Output
+
+Give **two options of different types**, labelled, plus a one-line reason for
+the one you would post. Run both through `/li-human` first - a comment with an
+em dash in it is more obviously machine-written than a post, because comments
+are short and people read them closely.
+
+```
+COMMENT OPTIONS (on @author's post about hiring)
+
+[6 · Receipt]
+We tried the no-resume version of this for 3 hires last year. Two were the
+best hires we made. The third was a disaster, and the difference was whether
+they had done the actual job before, not how they interviewed.
+
+[3 · Respectful disagree]
+Agree on the signal problem. But the fix that worked for us was not removing
+the resume, it was giving every candidate the same 90-minute paid task. Same
+outcome, far less argument internally.
+
+Post the first. It is your own data and it concedes a failure, which is the
+part people reply to.
+```
+
+## Batch mode
+
+If the user wants an engagement round, ask for the 5-10 posts as pasted text
+in one message, return one comment each in a single block, and keep a running
+note of who they have already commented on this week in
+`~/.claude/linkedin/log.md`. Commenting on the same three people every day is
+visible and it looks like what it is.
+
+## Never
+
+Do not auto-post. Do not use a browser tool to publish comments on the user's
+behalf. Automated posting and scraping both violate LinkedIn's User Agreement
+and put the account at risk. This skill writes the comment. The user posts it.
diff --git a/skills/li-dm/SKILL.md b/skills/li-dm/SKILL.md
new file mode 100644
index 0000000..7d11b2f
--- /dev/null
+++ b/skills/li-dm/SKILL.md
@@ -0,0 +1,83 @@
+---
+name: li-dm
+description: >-
+ Write connection notes and DM follow-ups that get replies - the 200-character
+ invite, the first message, and the two follow-ups. Use when the user says
+ "write a connection request", "DM this person", "outreach message", "how do I
+ follow up", or is reaching out to someone specific on LinkedIn.
+---
+
+# li-dm
+
+The invite note is 200 characters. The first DM decides whether there is a
+second one. Neither is a pitch.
+
+## Before writing, get the specifics
+
+Ask for, in one batched question:
+
+1. **Who** - name, role, company.
+2. **The hook** - the actual reason to reach out now. A post they wrote, a
+ thing their company shipped, a mutual connection, a talk they gave. Not
+ "they fit my ICP".
+3. **What the user wants** - a conversation, a referral, a job, a sale. Be
+ honest internally, even if the message does not lead with it.
+
+If there is no specific reason to message this person today, say so. A message
+with no reason is what everyone else sends, and it is why their reply rate is
+2%.
+
+## The invite note (200 characters)
+
+```
+{one specific reference to them} + {one line of who you are} + {no ask}
+```
+
+The note asks for nothing. It exists to make the accept obvious. Under 200
+characters including spaces - count them and show the count.
+
+```
+Saw your post on killing the discovery call - we did the same thing in March
+and it worked. I run ops at a 12-person studio. Would like to follow along.
+ [187/200]
+```
+
+## The first message, after they accept
+
+Wait a day. Then:
+
+- **Two to four sentences.** A screen of text is a delete.
+- **Reference the specific thing** from the note - continuity is the whole
+ reason the note was specific.
+- **Give something before asking.** A number, a template, a name, an answer.
+- **One ask, and make it small.** "Worth a 15-minute call?" beats "let me walk
+ you through our platform".
+- **No calendar link in message one.** It reads as a funnel, because it is.
+
+## Follow-ups
+
+Two. That is the number.
+
+- **+4 days** - add something new. Never "just bumping this" or "following up
+ on my last message". If you have nothing new, you have no follow-up.
+- **+10 days** - the close-the-loop message. Say you will stop, and mean it.
+ This one gets a surprising share of the total replies, because it removes
+ the pressure.
+
+Then stop. A third follow-up converts nobody and costs the relationship.
+
+## Never
+
+- Never send an automated connection or message sequence. Automated outreach
+ tools violate LinkedIn's User Agreement and get accounts restricted.
+- Never fabricate a mutual connection, a shared school, or having read
+ something the user has not read.
+- Never write the message that opens "I hope this message finds you well".
+- Never send more than 20 invites a day. Beyond that, LinkedIn throttles the
+ account, and a throttled account is a dead one.
+
+## Output
+
+The invite note with its character count, the first message, and both
+follow-ups with the day they go out. All humanized through `/li-human`. The
+user sends every one of them by hand.
diff --git a/skills/li-human/SKILL.md b/skills/li-human/SKILL.md
new file mode 100644
index 0000000..deb7779
--- /dev/null
+++ b/skills/li-human/SKILL.md
@@ -0,0 +1,98 @@
+---
+name: li-human
+description: >-
+ Strip the machine fingerprint out of any draft - em dashes, AI slop words,
+ invisible watermark characters - and score it against a five-check detection
+ panel before it goes out. Use whenever text needs to sound human, when the
+ user says humanize, "does this sound like AI", "remove the em dashes", "de-slop
+ this", "will this get flagged", or before any LinkedIn post, comment, reply
+ or DM is shown to the user.
+---
+
+# li-human
+
+Two tools live in this folder and they both actually run. Use them. Do not
+eyeball this.
+
+```bash
+python3 humanize.py draft.txt --report # clean it, show what changed
+python3 detect.py draft.txt # score it, five checks
+python3 detect.py before.txt after.txt # prove the delta
+```
+
+Both read `slop.json`, which is the lexicon: 100+ stock words and phrases with
+plain-English replacements, 17 invisible character classes, 11 typographic
+substitutions, and 11 structural tells. It is meant to be edited. If the user
+has a word they always use that the lexicon strips, remove it from the file.
+
+## What gets fixed automatically
+
+**1. Invisible characters.** Zero-width spaces and joiners, word joiners,
+soft hyphens, byte-order marks, Unicode tag characters, non-breaking and
+narrow spaces. A keyboard does not produce these. They survive copy-paste,
+they are invisible in every editor, and they are the single most mechanical
+thing in generated text. `humanize.py` deletes every one, including any
+remaining Unicode format character it does not have a name for.
+
+**2. Typography.** Em dash to comma, en dash to hyphen, curly quotes to
+straight, ellipsis to three dots, bullet character to hyphen. The em dash pass
+is the one that matters: it collapses ` — ` to `, ` and then cleans up the
+double punctuation that leaves behind.
+
+**3. The slop lexicon.** delve, leverage, robust, seamless, crucial, tapestry,
+testament to, moreover, "in today's fast-paced world", "let that sink in" and
+the rest, each swapped for a plain word, with capitalisation preserved and
+URLs left untouched.
+
+## What does NOT get fixed automatically
+
+Structural tells get **flagged, not rewritten**, because changing the shape of
+a sentence needs judgement:
+
+- "It's not just X, it's Y" and "not only X but also Y"
+- Rule-of-three triads
+- Rhetorical one-word question lines: "The result?"
+- Rocket, fire, bulb, sparkle and dart emoji
+- Hashtag walls
+- Reflex engagement bait: "Thoughts?", "Agree?", "Who else?"
+- Uniform sentence length and uniform bullet length
+
+That list is your job. Rewrite each flagged line by hand, keeping the meaning,
+then re-run `detect.py`. This is the part that moves the score from REVIEW to
+PASS, and it is the part a script cannot do.
+
+## The five checks
+
+`detect.py` scores five signals 0-100, higher is more human:
+
+| check | what it measures | machine looks like |
+| --- | --- | --- |
+| BURSTINESS | sentence-length variation | every sentence the same length |
+| SPECIFICITY | numbers, names, concrete markers per 100 words | abstract nouns, no figures |
+| SLOP DENSITY | lexicon hits per 100 words | stock vocabulary |
+| FINGERPRINT | invisible chars, em dashes, curly quotes per 1k chars | typographically perfect |
+| VOICE | contractions, person, structural tells | no contractions, staged reveals |
+
+The verdict weights the mean at 60% and the **weakest single check** at 40%,
+because a detector only needs one signal to fire. PASS needs an overall of 70+
+with no check below 55.
+
+## Say this honestly
+
+These are five local heuristics modelled on the signals public detectors key
+on. They run entirely on the user's machine and nothing is uploaded. They are
+**not** GPTZero, Originality, Copyleaks, Winston or Turnitin, they do not call
+those APIs, and they cannot promise those verdicts. Fixing what they measure
+does tend to move those numbers, because they are measuring the same
+underlying things. That is the claim. Do not make a bigger one on the user's
+behalf, and do not tell a user their text is undetectable.
+
+## Order of operations
+
+1. `humanize.py draft.txt -o clean.txt --report`
+2. Read the structural flags. Rewrite those lines yourself.
+3. `detect.py draft.txt clean.txt` to show the before and after.
+4. If the verdict is not PASS, fix the weakest check named in the output and
+ go again. Two rounds is normal. Five means the draft was written by
+ formula, and the fix is a different draft, not more passes.
+5. Show the user the cleaned text and the score. Never the score alone.
diff --git a/skills/li-human/detect.py b/skills/li-human/detect.py
new file mode 100755
index 0000000..bd306ab
--- /dev/null
+++ b/skills/li-human/detect.py
@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+"""
+detect.py - a five-check panel that scores how machine-written a draft looks.
+
+What this is: five local heuristics modelled on the signals public AI
+detectors actually measure - sentence-length variation, concreteness, stock
+vocabulary, typographic fingerprint, and voice. Every score is computed on
+your machine from the text alone. Nothing is uploaded.
+
+What this is NOT: GPTZero, Originality, Copyleaks, Winston or Turnitin.
+It does not call their APIs and it cannot promise their verdict. It catches
+the things they all key on, which is why fixing them tends to move their
+numbers too - but the only honest claim is the one on this line.
+
+Each check returns a HUMAN score from 0 to 100. Higher is better.
+
+Usage
+ python3 detect.py draft.txt
+ pbpaste | python3 detect.py -
+ python3 detect.py draft.txt --json
+ python3 detect.py before.txt after.txt # compare two drafts
+"""
+
+import argparse
+import json
+import os
+import re
+import statistics
+import sys
+import unicodedata
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+LEX = os.path.join(HERE, "slop.json")
+
+SENT_RE = re.compile(r"[^.!?\n]+[.!?]*")
+WORD_RE = re.compile(r"[A-Za-z']+")
+CONTRACTIONS = re.compile(r"\b\w+'(?:s|t|re|ve|ll|d|m)\b", re.IGNORECASE)
+PRONOUNS = re.compile(r"\b(i|me|my|mine|we|us|our|you|your)\b", re.IGNORECASE)
+NUMBERS = re.compile(r"\b\d[\d,.]*%?\b|\$\d")
+PROPER = re.compile(r"(?<![.!?]\s)(?<!^)\b[A-Z][a-z]{2,}\b", re.MULTILINE)
+
+
+def clamp(n):
+ return max(0.0, min(100.0, n))
+
+
+def scale(value, human, machine):
+ """Map value onto 0-100 where `human` -> 100 and `machine` -> 0."""
+ if human == machine:
+ return 50.0
+ return clamp((value - machine) / (human - machine) * 100)
+
+
+def sentences(text):
+ return [s.strip() for s in SENT_RE.findall(text) if len(s.split()) > 2]
+
+
+def words(text):
+ return WORD_RE.findall(text)
+
+
+def check_burstiness(text):
+ """Humans vary sentence length hard. Models write even."""
+ lens = [len(s.split()) for s in sentences(text)]
+ if len(lens) < 4:
+ return 50.0, "too short to judge"
+ mean = statistics.mean(lens)
+ cv = statistics.pstdev(lens) / mean if mean else 0
+ score = scale(cv, human=0.70, machine=0.22)
+ return score, f"variation {cv:.2f} across {len(lens)} sentences (want 0.55+)"
+
+
+def check_specificity(text):
+ """Numbers, names and concrete nouns. Slop is abstract."""
+ w = words(text)
+ if len(w) < 25:
+ return 50.0, "too short to judge"
+ per100 = 100 / len(w)
+ hits = len(NUMBERS.findall(text)) + len(set(PROPER.findall(text)))
+ density = hits * per100
+ score = scale(density, human=6.0, machine=0.5)
+ return score, f"{hits} concrete markers, {density:.1f} per 100 words (want 4+)"
+
+
+def check_slop(text, lex):
+ """Stock vocabulary density against the lexicon."""
+ w = words(text)
+ if not w:
+ return 50.0, "empty"
+ hits, found = 0, []
+ for entry in lex["words"] + lex["phrases"]:
+ pattern = re.compile(r"\b" + re.escape(entry["find"]).replace(r"\ ", r"\s+") + r"\b",
+ re.IGNORECASE)
+ n = len(pattern.findall(text))
+ if n:
+ hits += n
+ found.append(entry["find"])
+ density = hits * 100 / len(w)
+ score = scale(density, human=0.0, machine=4.0)
+ detail = f"{hits} stock terms, {density:.1f} per 100 words"
+ if found:
+ detail += " (" + ", ".join(sorted(found)[:4]) + (", ..." if len(found) > 4 else "") + ")"
+ return score, detail
+
+
+def check_fingerprint(text):
+ """Characters a phone keyboard does not produce."""
+ invisible = sum(1 for c in text if unicodedata.category(c) == "Cf")
+ em = text.count("—")
+ curly = sum(text.count(c) for c in "‘’“”")
+ ellip = text.count("…")
+ nbsp = sum(text.count(c) for c in "   ")
+ total = invisible * 4 + em * 2 + curly + ellip + nbsp
+ per1k = total * 1000 / max(len(text), 1)
+ score = scale(per1k, human=0.0, machine=12.0)
+ detail = (f"{invisible} invisible, {em} em dash, {curly} curly quote, "
+ f"{ellip} ellipsis, {nbsp} hard space")
+ return score, detail
+
+
+def check_voice(text, lex):
+ """Contractions, person, and the shapes models default to."""
+ w = words(text)
+ if len(w) < 25:
+ return 50.0, "too short to judge"
+ per100 = 100 / len(w)
+ contractions = len(CONTRACTIONS.findall(text)) * per100
+ person = len(PRONOUNS.findall(text)) * per100
+ tells = 0
+ names = []
+ for s in lex["structures"]:
+ try:
+ n = len(re.compile(s["regex"], re.MULTILINE).findall(text))
+ except re.error:
+ continue
+ if n:
+ tells += n
+ names.append(s["id"])
+ bullets = [len(b.split()) for b in re.findall(r"(?m)^\s*[-*•]\s+(.+)$", text)]
+ uniform = (len(bullets) >= 3 and statistics.pstdev(bullets) < 1.6)
+ score = (scale(contractions, human=3.0, machine=0.0) * 0.35
+ + scale(person, human=8.0, machine=1.0) * 0.35
+ + clamp(100 - tells * 22) * 0.30)
+ if uniform:
+ score -= 12
+ names.append("uniform-bullets")
+ detail = (f"{contractions:.1f} contractions, {person:.1f} personal pronouns "
+ f"per 100 words, {tells} structural tell(s)")
+ if names:
+ detail += " [" + ", ".join(names[:4]) + "]"
+ return clamp(score), detail
+
+
+CHECKS = ["BURSTINESS", "SPECIFICITY", "SLOP DENSITY", "FINGERPRINT", "VOICE"]
+
+
+def run(text, lex):
+ results = {}
+ results["BURSTINESS"] = check_burstiness(text)
+ results["SPECIFICITY"] = check_specificity(text)
+ results["SLOP DENSITY"] = check_slop(text, lex)
+ results["FINGERPRINT"] = check_fingerprint(text)
+ results["VOICE"] = check_voice(text, lex)
+ scores = [results[c][0] for c in CHECKS]
+ # The weakest check drags the verdict: a detector only needs one signal.
+ overall = statistics.mean(scores) * 0.6 + min(scores) * 0.4
+ verdict = "PASS" if overall >= 70 and min(scores) >= 55 else (
+ "REVIEW" if overall >= 50 else "FLAGGED")
+ return results, overall, verdict
+
+
+def bar(score, width=24):
+ filled = round(score / 100 * width)
+ return "#" * filled + "." * (width - filled)
+
+
+def render(results, overall, verdict, label=None, out=sys.stdout):
+ title = "AI DETECTION PANEL" + (f" - {label}" if label else "")
+ print("\n" + title, file=out)
+ print("=" * max(len(title), 62), file=out)
+ for name in CHECKS:
+ score, detail = results[name]
+ print(f" {name:<13} {bar(score)} {score:5.1f}", file=out)
+ print(f" {'':<13} {detail}", file=out)
+ print("-" * 62, file=out)
+ print(f" {'HUMAN SCORE':<13} {bar(overall)} {overall:5.1f} {verdict}", file=out)
+ if verdict != "PASS":
+ weakest = min(CHECKS, key=lambda c: results[c][0])
+ print(f"\n Weakest signal: {weakest}. Fix that first.", file=out)
+ print("", file=out)
+
+
+def main():
+ ap = argparse.ArgumentParser(description="Score how machine-written a draft looks.")
+ ap.add_argument("input", nargs="?", default="-", help="file, or - for stdin")
+ ap.add_argument("compare", nargs="?", help="second file, to show before/after")
+ ap.add_argument("--json", action="store_true")
+ ap.add_argument("--lexicon", default=LEX)
+ args = ap.parse_args()
+
+ lex = json.load(open(args.lexicon, encoding="utf-8"))
+ read = lambda p: sys.stdin.read() if p == "-" else open(p, encoding="utf-8").read()
+
+ targets = [(args.input, read(args.input))]
+ if args.compare:
+ targets.append((args.compare, read(args.compare)))
+
+ payload = []
+ for name, text in targets:
+ results, overall, verdict = run(text, lex)
+ payload.append({
+ "source": name,
+ "checks": {k: {"score": round(v[0], 1), "detail": v[1]} for k, v in results.items()},
+ "human_score": round(overall, 1),
+ "verdict": verdict,
+ })
+
+ if args.json:
+ print(json.dumps(payload if args.compare else payload[0], indent=2))
+ return
+
+ for (name, text), p in zip(targets, payload):
+ results, overall, verdict = run(text, lex)
+ render(results, overall, verdict, label=os.path.basename(name) if args.compare else None)
+ if args.compare:
+ a, b = payload
+ delta = b["human_score"] - a["human_score"]
+ print(f" {a['human_score']:.1f} {a['verdict']} -> "
+ f"{b['human_score']:.1f} {b['verdict']} ({delta:+.1f})\n")
+
+ sys.exit(0 if payload[-1]["verdict"] == "PASS" else 1)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/skills/li-human/humanize.py b/skills/li-human/humanize.py
new file mode 100755
index 0000000..415d2f4
--- /dev/null
+++ b/skills/li-human/humanize.py
@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+"""
+humanize.py - strip the machine fingerprint out of a draft.
+
+Three passes, in this order:
+
+ 1. INVISIBLE delete or normalise the characters a human keyboard never
+ produces: zero-width joiners, word joiners, soft hyphens,
+ BOMs, Unicode tag characters, non-breaking and narrow spaces.
+ These survive copy-paste and are the most mechanical tell in
+ any generated text.
+ 2. TYPOGRAPHIC em dash -> comma, en dash -> hyphen, curly quotes -> straight,
+ ellipsis -> three dots, bullet -> hyphen.
+ 3. LEXICAL replace the slop lexicon in slop.json with plain words,
+ preserving capitalisation and leaving URLs untouched.
+
+Structural tells (rule-of-three, "not just X, it's Y", hashtag walls) are
+REPORTED, never auto-rewritten - rewriting a sentence's shape needs judgement,
+so that is the model's job, not a regex's.
+
+Usage
+ python3 humanize.py draft.txt
+ python3 humanize.py draft.txt --report
+ pbpaste | python3 humanize.py - --report
+ python3 humanize.py draft.txt --json
+ python3 humanize.py draft.txt -o clean.txt
+"""
+
+import argparse
+import json
+import os
+import re
+import sys
+import unicodedata
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+LEX = os.path.join(HERE, "slop.json")
+
+URL_RE = re.compile(r"https?://\S+|www\.\S+|\S+@\S+\.\S+")
+SENT_RE = re.compile(r"[^.!?\n]+[.!?]*")
+
+
+def load_lexicon(path=LEX):
+ with open(path, encoding="utf-8") as fh:
+ return json.load(fh)
+
+
+def _cp(spec):
+ """'U+200B' -> '\\u200b'; 'U+E0000-U+E007F' -> (start, end)."""
+ if "-" in spec:
+ a, b = spec.split("-")
+ return (int(a[2:], 16), int(b[2:], 16))
+ return int(spec[2:], 16)
+
+
+def protect_urls(text):
+ """Swap URLs for placeholders so no pass rewrites inside a link."""
+ found = []
+
+ def stash(m):
+ found.append(m.group(0))
+ return f"\x00URL{len(found) - 1}\x00"
+
+ return URL_RE.sub(stash, text), found
+
+
+def restore_urls(text, found):
+ for i, url in enumerate(found):
+ text = text.replace(f"\x00URL{i}\x00", url)
+ return text
+
+
+def pass_invisible(text, lex):
+ """Delete or space-normalise invisible characters. Returns (text, hits)."""
+ hits = []
+ for entry in lex["invisible"]:
+ cp = _cp(entry["cp"])
+ if isinstance(cp, tuple):
+ pattern = "[" + re.escape(chr(cp[0])) + "-" + re.escape(chr(cp[1])) + "]"
+ else:
+ pattern = re.escape(chr(cp))
+ n = len(re.findall(pattern, text))
+ if n:
+ hits.append({"name": entry["cp"] + " " + entry["name"], "count": n,
+ "action": entry["action"]})
+ text = re.sub(pattern, "" if entry["action"] == "delete" else " ", text)
+ # Any remaining Cf (format) character is invisible by definition.
+ stray = [c for c in text if unicodedata.category(c) == "Cf"]
+ if stray:
+ hits.append({"name": "other invisible format chars", "count": len(stray),
+ "action": "delete"})
+ text = "".join(c for c in text if unicodedata.category(c) != "Cf")
+ return text, hits
+
+
+def pass_typographic(text, lex):
+ hits = []
+ for entry in lex["typographic"]:
+ ch = entry["from"]
+ n = text.count(ch)
+ if not n:
+ continue
+ hits.append({"name": f"{ch} {entry['name']}", "count": n, "to": entry["to"].strip() or "(space)"})
+ if ch == "—":
+ # " word — word " and "word—word" both collapse to a comma + space.
+ text = re.sub(r"\s*—\s*", ", ", text)
+ elif ch == "–":
+ text = re.sub(r"\s*–\s*(?=\d)", "-", text) # 5–10 -> 5-10
+ text = re.sub(r"\s+–\s+", ", ", text) # used as em dash
+ text = text.replace("–", "-")
+ else:
+ text = text.replace(ch, entry["to"])
+ # A comma inserted before existing punctuation reads wrong.
+ text = re.sub(r",\s*([,.;:!?])", r"\1", text)
+ text = re.sub(r",\s*\n", "\n", text)
+ return text, hits
+
+
+def _match_case(src, repl):
+ if not repl:
+ return repl
+ if src.isupper() and len(src) > 1:
+ return repl.upper()
+ if src[0].isupper():
+ return repl[0].upper() + repl[1:]
+ return repl
+
+
+def pass_lexical(text, lex):
+ """Replace slop words and phrases. Longest first so phrases win."""
+ hits = []
+ entries = sorted(lex["phrases"] + lex["words"],
+ key=lambda e: len(e["find"]), reverse=True)
+ for entry in entries:
+ find = entry["find"]
+ pattern = re.compile(r"\b" + re.escape(find).replace(r"\ ", r"\s+") + r"\b",
+ re.IGNORECASE)
+ found = pattern.findall(text)
+ if not found:
+ continue
+ hits.append({"find": find, "replace": entry["replace"] or "(deleted)",
+ "count": len(found), "family": entry["family"]})
+ text = pattern.sub(lambda m: _match_case(m.group(0), entry["replace"]), text)
+ # Clean up after deletions.
+ text = re.sub(r"[ \t]{2,}", " ", text)
+ text = re.sub(r"(?m)^[ \t]*([,.;:])\s*", "", text)
+ text = re.sub(r"\s+([,.;:!?])", r"\1", text)
+ text = re.sub(r"(?m)^[ \t]+$", "", text)
+ text = re.sub(r"\n{3,}", "\n\n", text)
+ # An em dash that became a comma, followed by a sentence connective, leaves
+ # a splice ("is important, also, it's proof"). Promote it to a full stop.
+ text = re.sub(r",\s*(also|so|still|basically|in the end)\s*,\s*",
+ lambda m: ". " + m.group(1)[0].upper() + m.group(1)[1:] + ", ", text)
+ return text, hits
+
+
+def scan_structures(text, lex):
+ flags = []
+ for s in lex["structures"]:
+ try:
+ pattern = re.compile(s["regex"], re.MULTILINE)
+ except re.error:
+ continue
+ found = pattern.findall(text)
+ if found:
+ flags.append({"name": s["name"], "count": len(found), "fix": s["fix"]})
+ # Sentence-length uniformity is structural too.
+ lens = [len(s.split()) for s in SENT_RE.findall(text) if len(s.split()) > 2]
+ if len(lens) >= 4:
+ mean = sum(lens) / len(lens)
+ var = sum((n - mean) ** 2 for n in lens) / len(lens)
+ cv = (var ** 0.5) / mean if mean else 0
+ if cv < 0.35:
+ flags.append({
+ "name": f"Uniform sentence length (variation {cv:.2f})",
+ "count": len(lens),
+ "fix": "Break one sentence in half. Let another run long. Machines write even.",
+ })
+ return flags
+
+
+def humanize(text, lex):
+ text, urls = protect_urls(text)
+ text, inv = pass_invisible(text, lex)
+ text, typo = pass_typographic(text, lex)
+ text, lexi = pass_lexical(text, lex)
+ text = restore_urls(text, urls)
+ return text.strip() + "\n", {
+ "invisible": inv,
+ "typographic": typo,
+ "lexical": lexi,
+ "structures": scan_structures(text, lex),
+ }
+
+
+def render_report(report, out=sys.stderr):
+ def head(title):
+ print(f"\n{title}\n" + "-" * len(title), file=out)
+
+ total = sum(h["count"] for h in report["invisible"]) \
+ + sum(h["count"] for h in report["typographic"]) \
+ + sum(h["count"] for h in report["lexical"])
+
+ head("HUMANIZE REPORT")
+ print(f"{total} machine artefacts removed, "
+ f"{len(report['structures'])} structural tells flagged for rewrite", file=out)
+
+ if report["invisible"]:
+ head("1. INVISIBLE CHARACTERS")
+ for h in report["invisible"]:
+ print(f" {h['count']:>3}x {h['name']} -> {h['action']}", file=out)
+ if report["typographic"]:
+ head("2. TYPOGRAPHY")
+ for h in report["typographic"]:
+ print(f" {h['count']:>3}x {h['name']} -> {h['to']}", file=out)
+ if report["lexical"]:
+ head("3. SLOP LEXICON")
+ for h in report["lexical"]:
+ print(f" {h['count']:>3}x {h['find']} -> {h['replace']} [{h['family']}]", file=out)
+ if report["structures"]:
+ head("4. STRUCTURAL TELLS (not auto-fixed - rewrite these yourself)")
+ for h in report["structures"]:
+ print(f" {h['count']:>3}x {h['name']}\n {h['fix']}", file=out)
+ if not any(report.values()):
+ head("CLEAN")
+ print(" Nothing to strip.", file=out)
+ print("", file=out)
+
+
+def main():
+ ap = argparse.ArgumentParser(description="Strip the machine fingerprint out of a draft.")
+ ap.add_argument("input", nargs="?", default="-", help="file, or - for stdin")
+ ap.add_argument("-o", "--out", help="write cleaned text here instead of stdout")
+ ap.add_argument("--report", action="store_true", help="print what changed, to stderr")
+ ap.add_argument("--json", action="store_true", help="emit {text, report} as JSON")
+ ap.add_argument("--lexicon", default=LEX, help="path to slop.json")
+ args = ap.parse_args()
+
+ raw = sys.stdin.read() if args.input == "-" else open(args.input, encoding="utf-8").read()
+ lex = load_lexicon(args.lexicon)
+ clean, report = humanize(raw, lex)
+
+ if args.json:
+ print(json.dumps({"text": clean, "report": report}, indent=2, ensure_ascii=False))
+ return
+ if args.out:
+ with open(args.out, "w", encoding="utf-8") as fh:
+ fh.write(clean)
+ print(f"wrote {args.out}", file=sys.stderr)
+ else:
+ sys.stdout.write(clean)
+ if args.report:
+ render_report(report)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/skills/li-human/slop.json b/skills/li-human/slop.json
new file mode 100644
index 0000000..cb7e6c4
--- /dev/null
+++ b/skills/li-human/slop.json
@@ -0,0 +1,785 @@
+{
+ "version": "1.0",
+ "note": "Lexicon used by humanize.py and detect.py. Replacements are plain-English and keep the sentence grammatical. Edit freely - it is meant to be yours.",
+ "invisible": [
+ {
+ "cp": "U+200B",
+ "name": "ZERO WIDTH SPACE",
+ "action": "delete"
+ },
+ {
+ "cp": "U+200C",
+ "name": "ZERO WIDTH NON-JOINER",
+ "action": "delete"
+ },
+ {
+ "cp": "U+200D",
+ "name": "ZERO WIDTH JOINER",
+ "action": "delete"
+ },
+ {
+ "cp": "U+2060",
+ "name": "WORD JOINER",
+ "action": "delete"
+ },
+ {
+ "cp": "U+FEFF",
+ "name": "ZERO WIDTH NO-BREAK SPACE / BOM",
+ "action": "delete"
+ },
+ {
+ "cp": "U+00AD",
+ "name": "SOFT HYPHEN",
+ "action": "delete"
+ },
+ {
+ "cp": "U+180E",
+ "name": "MONGOLIAN VOWEL SEPARATOR",
+ "action": "delete"
+ },
+ {
+ "cp": "U+061C",
+ "name": "ARABIC LETTER MARK",
+ "action": "delete"
+ },
+ {
+ "cp": "U+200E",
+ "name": "LEFT-TO-RIGHT MARK",
+ "action": "delete"
+ },
+ {
+ "cp": "U+200F",
+ "name": "RIGHT-TO-LEFT MARK",
+ "action": "delete"
+ },
+ {
+ "cp": "U+E0000-U+E007F",
+ "name": "TAG CHARACTERS (invisible ASCII smuggling)",
+ "action": "delete"
+ },
+ {
+ "cp": "U+00A0",
+ "name": "NO-BREAK SPACE",
+ "action": "space"
+ },
+ {
+ "cp": "U+202F",
+ "name": "NARROW NO-BREAK SPACE",
+ "action": "space"
+ },
+ {
+ "cp": "U+2009",
+ "name": "THIN SPACE",
+ "action": "space"
+ },
+ {
+ "cp": "U+2007",
+ "name": "FIGURE SPACE",
+ "action": "space"
+ },
+ {
+ "cp": "U+2003",
+ "name": "EM SPACE",
+ "action": "space"
+ },
+ {
+ "cp": "U+2002",
+ "name": "EN SPACE",
+ "action": "space"
+ }
+ ],
+ "typographic": [
+ {
+ "from": "—",
+ "name": "EM DASH",
+ "to": ", "
+ },
+ {
+ "from": "–",
+ "name": "EN DASH",
+ "to": "-"
+ },
+ {
+ "from": "‘",
+ "name": "LEFT SINGLE QUOTE",
+ "to": "'"
+ },
+ {
+ "from": "’",
+ "name": "RIGHT SINGLE QUOTE",
+ "to": "'"
+ },
+ {
+ "from": "“",
+ "name": "LEFT DOUBLE QUOTE",
+ "to": "\""
+ },
+ {
+ "from": "”",
+ "name": "RIGHT DOUBLE QUOTE",
+ "to": "\""
+ },
+ {
+ "from": "…",
+ "name": "HORIZONTAL ELLIPSIS",
+ "to": "..."
+ },
+ {
+ "from": "′",
+ "name": "PRIME",
+ "to": "'"
+ },
+ {
+ "from": "·",
+ "name": "MIDDLE DOT",
+ "to": "-"
+ },
+ {
+ "from": "•",
+ "name": "BULLET",
+ "to": "-"
+ },
+ {
+ "from": "→",
+ "name": "RIGHTWARDS ARROW",
+ "to": "->"
+ }
+ ],
+ "words": [
+ {
+ "find": "delve into",
+ "replace": "look at",
+ "family": "verbs"
+ },
+ {
+ "find": "delve",
+ "replace": "look",
+ "family": "verbs"
+ },
+ {
+ "find": "dive deep into",
+ "replace": "get into",
+ "family": "verbs"
+ },
+ {
+ "find": "deep dive",
+ "replace": "breakdown",
+ "family": "nouns"
+ },
+ {
+ "find": "leverage",
+ "replace": "use",
+ "family": "verbs"
+ },
+ {
+ "find": "leveraging",
+ "replace": "using",
+ "family": "verbs"
+ },
+ {
+ "find": "utilize",
+ "replace": "use",
+ "family": "verbs"
+ },
+ {
+ "find": "utilizing",
+ "replace": "using",
+ "family": "verbs"
+ },
+ {
+ "find": "harness",
+ "replace": "use",
+ "family": "verbs"
+ },
+ {
+ "find": "embark on",
+ "replace": "start",
+ "family": "verbs"
+ },
+ {
+ "find": "foster",
+ "replace": "build",
+ "family": "verbs"
+ },
+ {
+ "find": "facilitate",
+ "replace": "help",
+ "family": "verbs"
+ },
+ {
+ "find": "showcase",
+ "replace": "show",
+ "family": "verbs"
+ },
+ {
+ "find": "unlock",
+ "replace": "get",
+ "family": "verbs"
+ },
+ {
+ "find": "elevate",
+ "replace": "improve",
+ "family": "verbs"
+ },
+ {
+ "find": "streamline",
+ "replace": "simplify",
+ "family": "verbs"
+ },
+ {
+ "find": "spearhead",
+ "replace": "lead",
+ "family": "verbs"
+ },
+ {
+ "find": "underscore",
+ "replace": "show",
+ "family": "verbs"
+ },
+ {
+ "find": "underscores",
+ "replace": "shows",
+ "family": "verbs"
+ },
+ {
+ "find": "cultivate",
+ "replace": "build",
+ "family": "verbs"
+ },
+ {
+ "find": "amplify",
+ "replace": "boost",
+ "family": "verbs"
+ },
+ {
+ "find": "curate",
+ "replace": "pick",
+ "family": "verbs"
+ },
+ {
+ "find": "curated",
+ "replace": "picked",
+ "family": "verbs"
+ },
+ {
+ "find": "empower",
+ "replace": "let",
+ "family": "verbs"
+ },
+ {
+ "find": "revolutionize",
+ "replace": "change",
+ "family": "verbs"
+ },
+ {
+ "find": "transformative",
+ "replace": "big",
+ "family": "adjectives"
+ },
+ {
+ "find": "robust",
+ "replace": "solid",
+ "family": "adjectives"
+ },
+ {
+ "find": "seamless",
+ "replace": "clean",
+ "family": "adjectives"
+ },
+ {
+ "find": "seamlessly",
+ "replace": "cleanly",
+ "family": "adjectives"
+ },
+ {
+ "find": "pivotal",
+ "replace": "key",
+ "family": "adjectives"
+ },
+ {
+ "find": "crucial",
+ "replace": "important",
+ "family": "adjectives"
+ },
+ {
+ "find": "vital",
+ "replace": "important",
+ "family": "adjectives"
+ },
+ {
+ "find": "comprehensive",
+ "replace": "complete",
+ "family": "adjectives"
+ },
+ {
+ "find": "cutting-edge",
+ "replace": "new",
+ "family": "adjectives"
+ },
+ {
+ "find": "game-changing",
+ "replace": "big",
+ "family": "adjectives"
+ },
+ {
+ "find": "game-changer",
+ "replace": "big deal",
+ "family": "nouns"
+ },
+ {
+ "find": "groundbreaking",
+ "replace": "new",
+ "family": "adjectives"
+ },
+ {
+ "find": "unparalleled",
+ "replace": "unmatched",
+ "family": "adjectives"
+ },
+ {
+ "find": "invaluable",
+ "replace": "useful",
+ "family": "adjectives"
+ },
+ {
+ "find": "meticulous",
+ "replace": "careful",
+ "family": "adjectives"
+ },
+ {
+ "find": "meticulously",
+ "replace": "carefully",
+ "family": "adjectives"
+ },
+ {
+ "find": "myriad of",
+ "replace": "many",
+ "family": "adjectives"
+ },
+ {
+ "find": "myriad",
+ "replace": "many",
+ "family": "adjectives"
+ },
+ {
+ "find": "multifaceted",
+ "replace": "complicated",
+ "family": "adjectives"
+ },
+ {
+ "find": "holistic",
+ "replace": "whole",
+ "family": "adjectives"
+ },
+ {
+ "find": "bespoke",
+ "replace": "custom",
+ "family": "adjectives"
+ },
+ {
+ "find": "innovative",
+ "replace": "new",
+ "family": "adjectives"
+ },
+ {
+ "find": "profound",
+ "replace": "big",
+ "family": "adjectives"
+ },
+ {
+ "find": "remarkable",
+ "replace": "notable",
+ "family": "adjectives"
+ },
+ {
+ "find": "compelling",
+ "replace": "convincing",
+ "family": "adjectives"
+ },
+ {
+ "find": "tapestry",
+ "replace": "mix",
+ "family": "nouns"
+ },
+ {
+ "find": "realm",
+ "replace": "world",
+ "family": "nouns"
+ },
+ {
+ "find": "landscape",
+ "replace": "market",
+ "family": "nouns"
+ },
+ {
+ "find": "journey",
+ "replace": "process",
+ "family": "nouns"
+ },
+ {
+ "find": "testament to",
+ "replace": "proof of",
+ "family": "nouns"
+ },
+ {
+ "find": "cornerstone",
+ "replace": "base",
+ "family": "nouns"
+ },
+ {
+ "find": "beacon",
+ "replace": "signal",
+ "family": "nouns"
+ },
+ {
+ "find": "paradigm",
+ "replace": "model",
+ "family": "nouns"
+ },
+ {
+ "find": "synergy",
+ "replace": "overlap",
+ "family": "nouns"
+ },
+ {
+ "find": "ecosystem",
+ "replace": "system",
+ "family": "nouns"
+ },
+ {
+ "find": "treasure trove",
+ "replace": "pile",
+ "family": "nouns"
+ },
+ {
+ "find": "plethora of",
+ "replace": "lots of",
+ "family": "nouns"
+ },
+ {
+ "find": "plethora",
+ "replace": "lots",
+ "family": "nouns"
+ },
+ {
+ "find": "arsenal",
+ "replace": "set",
+ "family": "nouns"
+ },
+ {
+ "find": "north star",
+ "replace": "goal",
+ "family": "nouns"
+ },
+ {
+ "find": "moreover",
+ "replace": "also",
+ "family": "connectives"
+ },
+ {
+ "find": "furthermore",
+ "replace": "also",
+ "family": "connectives"
+ },
+ {
+ "find": "additionally",
+ "replace": "also",
+ "family": "connectives"
+ },
+ {
+ "find": "nevertheless",
+ "replace": "still",
+ "family": "connectives"
+ },
+ {
+ "find": "consequently",
+ "replace": "so",
+ "family": "connectives"
+ },
+ {
+ "find": "thus",
+ "replace": "so",
+ "family": "connectives"
+ },
+ {
+ "find": "hence",
+ "replace": "so",
+ "family": "connectives"
+ },
+ {
+ "find": "notably",
+ "replace": "",
+ "family": "connectives"
+ },
+ {
+ "find": "importantly",
+ "replace": "",
+ "family": "connectives"
+ },
+ {
+ "find": "ultimately",
+ "replace": "in the end",
+ "family": "connectives"
+ },
+ {
+ "find": "in essence",
+ "replace": "basically",
+ "family": "connectives"
+ },
+ {
+ "find": "in conclusion",
+ "replace": "so",
+ "family": "connectives"
+ },
+ {
+ "find": "when it comes to",
+ "replace": "with",
+ "family": "connectives"
+ },
+ {
+ "find": "in order to",
+ "replace": "to",
+ "family": "connectives"
+ },
+ {
+ "find": "a wide range of",
+ "replace": "many",
+ "family": "connectives"
+ },
+ {
+ "find": "it is worth noting that",
+ "replace": "note that",
+ "family": "connectives"
+ }
+ ],
+ "phrases": [
+ {
+ "find": "in today's fast-paced world",
+ "replace": "right now",
+ "family": "openers"
+ },
+ {
+ "find": "in today's digital age",
+ "replace": "right now",
+ "family": "openers"
+ },
+ {
+ "find": "in the ever-evolving landscape of",
+ "replace": "in",
+ "family": "openers"
+ },
+ {
+ "find": "in the ever-changing world of",
+ "replace": "in",
+ "family": "openers"
+ },
+ {
+ "find": "let's face it",
+ "replace": "",
+ "family": "openers"
+ },
+ {
+ "find": "here's the thing",
+ "replace": "",
+ "family": "openers"
+ },
+ {
+ "find": "picture this",
+ "replace": "",
+ "family": "openers"
+ },
+ {
+ "find": "imagine a world where",
+ "replace": "imagine if",
+ "family": "openers"
+ },
+ {
+ "find": "it's no secret that",
+ "replace": "",
+ "family": "openers"
+ },
+ {
+ "find": "we've all been there",
+ "replace": "",
+ "family": "openers"
+ },
+ {
+ "find": "let that sink in",
+ "replace": "",
+ "family": "closers"
+ },
+ {
+ "find": "the choice is yours",
+ "replace": "",
+ "family": "closers"
+ },
+ {
+ "find": "food for thought",
+ "replace": "",
+ "family": "closers"
+ },
+ {
+ "find": "the future is here",
+ "replace": "",
+ "family": "closers"
+ },
+ {
+ "find": "what are your thoughts?",
+ "replace": "",
+ "family": "closers"
+ },
+ {
+ "find": "drop a comment below",
+ "replace": "",
+ "family": "closers"
+ },
+ {
+ "find": "at the end of the day",
+ "replace": "",
+ "family": "closers"
+ },
+ {
+ "find": "needle-moving",
+ "replace": "useful",
+ "family": "closers"
+ },
+ {
+ "find": "move the needle",
+ "replace": "make a difference",
+ "family": "closers"
+ },
+ {
+ "find": "a testament to",
+ "replace": "proof of",
+ "family": "nouns"
+ },
+ {
+ "find": "had the opportunity to",
+ "replace": "got to",
+ "family": "connectives"
+ },
+ {
+ "find": "i am excited to announce",
+ "replace": "",
+ "family": "openers"
+ },
+ {
+ "find": "i'm thrilled to share",
+ "replace": "",
+ "family": "openers"
+ },
+ {
+ "find": "i am humbled to",
+ "replace": "",
+ "family": "openers"
+ },
+ {
+ "find": "without further ado",
+ "replace": "",
+ "family": "openers"
+ },
+ {
+ "find": "buckle up",
+ "replace": "",
+ "family": "openers"
+ },
+ {
+ "find": "the harsh truth is",
+ "replace": "",
+ "family": "openers"
+ },
+ {
+ "find": "spoiler alert",
+ "replace": "",
+ "family": "openers"
+ },
+ {
+ "find": "read that again",
+ "replace": "",
+ "family": "closers"
+ },
+ {
+ "find": "you're welcome",
+ "replace": "",
+ "family": "closers"
+ },
+ {
+ "find": "save this for later",
+ "replace": "",
+ "family": "closers"
+ },
+ {
+ "find": "who's with me",
+ "replace": "",
+ "family": "closers"
+ }
+ ],
+ "structures": [
+ {
+ "id": "not-just",
+ "regex": "(?i)\\bit'?s not (?:just|only) [^.!?\\n]{2,60}[,.] it'?s\\b",
+ "name": "\"It's not just X, it's Y\"",
+ "fix": "Say the one thing you actually mean. Delete the setup half."
+ },
+ {
+ "id": "not-only",
+ "regex": "(?i)\\bnot only\\b[^.!?\\n]{2,80}\\bbut also\\b",
+ "name": "\"Not only X but also Y\"",
+ "fix": "Split into two sentences, or drop the weaker half."
+ },
+ {
+ "id": "isnt-about",
+ "regex": "(?i)\\b(?:this|it) is(?:n'?t| not) about [^.!?\\n]{2,60}[.!] it'?s about\\b",
+ "name": "\"It isn't about X. It's about Y.\"",
+ "fix": "Lead with Y. The reversal is the tell."
+ },
+ {
+ "id": "the-result",
+ "regex": "(?i)^\\s*(?:the result|the best part|the kicker|the catch)\\?\\s*$",
+ "name": "One-word rhetorical question line",
+ "fix": "Answer it inline instead of staging a reveal."
+ },
+ {
+ "id": "heres-what",
+ "regex": "(?i)\\bhere'?s what (?:i|we) learned\\b",
+ "name": "\"Here's what I learned\"",
+ "fix": "State the lesson. Skip the announcement."
+ },
+ {
+ "id": "triad",
+ "regex": "(?i)\\b\\w+, \\w+, and \\w+\\.",
+ "name": "Rule-of-three triad",
+ "fix": "Two items or four. Three is the model's default rhythm."
+ },
+ {
+ "id": "rocket",
+ "regex": "[\\U0001F680\\U0001F525\\U0001F4A1\\u2728\\U0001F3AF]",
+ "name": "Rocket / fire / bulb / sparkle / dart emoji",
+ "fix": "One emoji max, and not one of these five."
+ },
+ {
+ "id": "hashtag-wall",
+ "regex": "(?:#\\w+[ \\t]*){5,}",
+ "name": "Hashtag wall (5+)",
+ "fix": "Three hashtags. LinkedIn stopped rewarding the wall."
+ },
+ {
+ "id": "as-an-ai",
+ "regex": "(?i)\\bas an ai\\b|\\bas a language model\\b",
+ "name": "Model self-reference",
+ "fix": "Delete the sentence."
+ },
+ {
+ "id": "in-summary",
+ "regex": "(?i)^\\s*(?:in summary|to summarize|in conclusion)\\b",
+ "name": "Essay-closer opener",
+ "fix": "A post does not need a conclusion paragraph."
+ },
+ {
+ "id": "engagement-bait",
+ "regex": "(?i)\\b(?:agree\\?|thoughts\\?|who else\\b|am i wrong\\?)\\s*$",
+ "name": "Reflex engagement bait",
+ "fix": "Ask a question only you could ask, about the specific thing above it."
+ }
+ ]
+}
\ No newline at end of file
diff --git a/skills/li-inbox/SKILL.md b/skills/li-inbox/SKILL.md
new file mode 100644
index 0000000..84cfad2
--- /dev/null
+++ b/skills/li-inbox/SKILL.md
@@ -0,0 +1,67 @@
+---
+name: li-inbox
+description: >-
+ Triage the LinkedIn inbox - sort connection requests and DMs into leads,
+ recruiters, peers and spam, and draft the replies worth sending. Use when the
+ user says "my inbox is a mess", "triage my DMs", "should I reply to this",
+ pastes a batch of LinkedIn messages, or is drowning in connection requests.
+---
+
+# li-inbox
+
+Most LinkedIn inboxes are 80% noise, and the cost of that noise is that the
+20% goes unanswered for a week. This skill separates them, then writes only
+what is worth writing.
+
+## Input
+
+The user pastes the messages. Screenshots are fine. Do not log into their
+account or read their inbox with a browser tool.
+
+## Sort into five
+
+| bucket | signal | action |
+| --- | --- | --- |
+| **LEAD** | describes a problem the user solves, or asks about working together | reply today, full answer |
+| **RECRUITER** | a role, a company, a salary band | reply if the role is real, one line if not |
+| **PEER** | someone in the same field with something to say | reply this week, keep it human |
+| **ASK** | wants advice, time, an intro, a favour | reply if it is cheap and specific, decline cleanly if not |
+| **SPAM** | agency pitch, lead-gen sequence, crypto, "quick question" with no question | archive, no reply |
+
+Print the counts first. Seeing "3 leads, 2 recruiters, 41 spam" is most of the
+value.
+
+## Detecting a sequence
+
+Automated outreach has a shape: an invite note with no specifics, a message
+that arrives within minutes of the accept, "quick question", "I noticed you're
+in {industry}", a calendar link in message one, then a bump exactly four days
+later. When you see it, mark it SPAM and say which tell gave it away. The user
+does not owe a reply to a script.
+
+## Replies
+
+- **LEAD** - answer the actual question in the message, in full, for free. If
+ it is a fit, the offer is one sentence at the end. If it is not, say so and
+ point them somewhere useful. Both outcomes are good.
+- **RECRUITER** - if the role is genuinely interesting, ask the three things
+ the message left out: comp band, level, and whether it is in-office. If it
+ is not, one line: not looking, happy to refer, and mean the refer.
+- **ASK** - if it costs under ten minutes and is specific, do it. If it is
+ "can I pick your brain", decline in one warm sentence and give them the one
+ answer you would have given on the call. That is the polite version and it
+ is also the more useful one.
+- **DECLINES** are short, warm and final. No "let's revisit in Q3" if there is
+ no Q3.
+
+## Output
+
+Grouped by bucket, counts first, drafts only for the buckets that get replies,
+each one humanized. Then the gate: the user sends them.
+
+```
+INBOX · 52 items · 3 LEAD, 2 RECRUITER, 4 PEER, 2 ASK, 41 SPAM
+
+SPAM (41) - archive. 38 are the same sequence: no-specifics invite,
+"quick question" within 4 minutes of accept, calendar link in message one.
+```
diff --git a/skills/li-plan/SKILL.md b/skills/li-plan/SKILL.md
new file mode 100644
index 0000000..b66afd7
--- /dev/null
+++ b/skills/li-plan/SKILL.md
@@ -0,0 +1,94 @@
+---
+name: li-plan
+description: >-
+ Build the week on LinkedIn - what to post, when to post it, and who to engage
+ with. Use when the user says "plan my week", "what should I post", "content
+ calendar", "I have nothing to post about", or wants a posting schedule and an
+ engagement list.
+---
+
+# li-plan
+
+The control room. Everything else in this pack executes; this decides what
+gets executed. Run it once a week, on the same day.
+
+## Input
+
+If `~/.claude/linkedin/voice.md` and `log.md` exist, read them - the plan
+should not repeat a theme from the last fortnight. If they do not exist, ask
+for four things and write them down:
+
+1. What the user sells, and to whom.
+2. The three or four themes they want to be known for.
+3. What actually happened this week - a client call, a number, a mistake, a
+ thing they built, an argument they had. This is where posts come from.
+4. Ten to twenty people or companies worth being visible to.
+
+## What to post
+
+Four posts a week beats seven. Consistency is a floor, not a target, and the
+fifth post of a week is almost always the weak one that drags the average.
+
+Mix across the week, never two of the same type back to back:
+
+| type | share | job |
+| --- | --- | --- |
+| **Proof** | 1 per week | something that happened, with a number |
+| **Opinion** | 1 per week | a position that could lose you followers |
+| **Teach** | 1 per week | one thing the reader can do today |
+| **Story** | 1 per fortnight | a scene with dialogue and a cost |
+| **Offer** | 1 per fortnight | what you sell, said plainly, no apology |
+
+For each slot give: the theme, the specific angle drawn from what actually
+happened this week, and the hook formula number from `li-post/hooks.json` that
+fits it. Not a topic - an angle. "AI" is not a plan. "The proposal we lost
+because our AI draft had an em dash in it" is a post.
+
+## When to post
+
+Post when the user's audience is at a desk. For a B2B audience in one
+timezone, Tuesday to Thursday, 7:30-9:30am local, is the working default, with
+Monday afternoon and Friday morning as the second tier. Weekends are for
+personal-story posts or nothing.
+
+But state this plainly: **the day and hour matter far less than whether the
+first line is good.** If the user is optimising posting times before their
+hooks work, they are polishing the wrong thing, and you should say so.
+
+Anchor the times to their audience's timezone, not the user's, if those
+differ.
+
+## Who to engage with
+
+Build a list of 10, split three ways:
+
+- **5 reach** - people with an audience the user wants, whose posts they can
+ genuinely add to. Comment before they have 20 comments or nobody sees it.
+- **3 peers** - same level, same field. This is the group that reciprocates.
+- **2 buyers** - people who could actually buy. Comment on their posts for
+ weeks before any DM, and never pitch in a comment.
+
+20 minutes a day, before posting, not after. Comments on other people's posts
+are what makes the user's own post land.
+
+## Output
+
+```
+WEEK OF SEP 8
+
+MON engage only (20 min, list below)
+TUE 8:15am PROOF #17 Time Anchor - the 5hr -> 20min proposal rebuild
+WED engage only
+THU 8:00am OPINION #1 Contrarian - why we killed the discovery call
+FRI 8:30am TEACH #21 Direct Value - the 4-line reopen email, given away
+SAT -
+SUN 4:00pm STORY #9 Cold Open - the "going with someone cheaper" email
+
+ENGAGE (5 reach / 3 peers / 2 buyers)
+ ...
+
+Say "write Tuesday" and I will draft it.
+```
+
+Write the plan to `~/.claude/linkedin/plan.md` so the other skills can read it.
+Nothing is scheduled or posted anywhere - this is a plan, and the user runs it.
diff --git a/skills/li-post/SKILL.md b/skills/li-post/SKILL.md
new file mode 100644
index 0000000..c6dd9be
--- /dev/null
+++ b/skills/li-post/SKILL.md
@@ -0,0 +1,105 @@
+---
+name: li-post
+description: >-
+ Write a LinkedIn post from a raw idea using 21 proven hook formulas, in the
+ user's own voice, humanized so it does not read as AI. Use whenever the user
+ wants a LinkedIn post, a hook, a draft for the feed, "post about X", "turn
+ this into a LinkedIn post", or asks for hook options. Produces three hook
+ options, one full draft, and a copy-ready block that is never published
+ without an explicit yes.
+---
+
+# li-post
+
+Turns one raw idea into a LinkedIn post that sounds like the person who
+posted it.
+
+## Before you write
+
+1. Read `~/.claude/linkedin/voice.md` if it exists. That file is the user's
+ voice profile: how they talk, what they never say, who they are talking to.
+ If it does not exist, ask for **three of their own past posts**, infer the
+ voice from those, and write the file. Do not skip this and do not invent a
+ voice. A post in the wrong voice is worse than no post.
+2. Read `hooks.json` in this folder. All 21 formulas, with templates, filled
+ examples, what each is for, and how each one usually gets ruined.
+3. If the idea is thin - "post about AI" - do not pad it. Ask one batched
+ question: what happened, to whom, and what did it cost or return. A post
+ needs one specific true thing. Get it before writing.
+
+## The shape
+
+LinkedIn rewards dwell time, saves and comments, in that order. So:
+
+```
+Line 1 the hook. Alone. It has to survive truncation at ~140 chars mobile.
+Line 2 the payoff of line 1, not setup for line 3.
+Body short paragraphs, 1-3 lines each, blank line between every one.
+ No wall. The white space is the format.
+The turn one line that reframes what came before.
+Close one specific question, or one instruction. Never both.
+```
+
+Length: 900-1,300 characters is the working range for a text post. Under 400
+reads as a thought, not a post. Over 2,000 needs to earn every line, and the
+"see more" tap has to be paid for by line 2.
+
+## The loop
+
+**1. Pick three hooks, not one.** Run the idea through `hooks.json` and choose
+the three formulas that genuinely fit it. Different formulas, not three
+variations of one. Show them as three numbered lines and say which you would
+ship and why, in one sentence.
+
+**2. Draft the full post** on the strongest hook.
+
+**3. Humanize it.** Run the draft through `/li-human` before showing it. Every
+post from this skill ships humanized. That is not an optional extra step, it
+is the reason the draft is worth reading.
+
+**4. Print the block.** Copy-ready, in a fenced block, exactly as it should be
+pasted. Then, underneath:
+
+```
+POST READY
+hook: #17 Time Anchor
+length: 1,140 characters
+humanizer: 6 artefacts stripped, human score 84 PASS
+post at: Tuesday 8:15am ET (from your plan)
+
+Reply "yes" to log it, or tell me what to change.
+```
+
+**5. Never publish.** This skill produces text. The user posts it. On "yes",
+append the post to `~/.claude/linkedin/log.md` with the date, the hook used
+and the first line, so `/li-audit` has a history to work from later.
+
+## Rules that make the difference
+
+- **One idea per post.** If the draft has two, you have two posts. Say so.
+- **Numbers over adjectives.** "$4,200" beats "a lot". If the user has not
+ given you a number, ask for one rather than writing around the hole.
+- **No engagement bait.** "Thoughts?" and "Agree?" are dead. The closing
+ question has to be one only this post could ask.
+- **Three hashtags maximum**, at the bottom, and only if they are real
+ categories someone follows.
+- **No links in the post body.** LinkedIn suppresses posts with outbound
+ links. Put the link in the first comment and say so in the receipt.
+- **Never fabricate.** No invented metrics, clients, revenue figures or
+ outcomes under the user's name, even as a placeholder. If a number is
+ needed and unknown, leave `{{your number}}` in the draft and flag it.
+
+## Example
+
+```
+/li-post we built an internal tool that cut proposal time from 5 hours to 20 min
+```
+
+```
+HOOKS
+1. #17 Time Anchor Writing a proposal used to take me 5 hours. It now takes 20 minutes.
+2. #12 Comparison A $12,000 proposal writer vs a weekend and a template. The weekend won.
+3. #3 Mistake For two years I charged clients for hours I was wasting on formatting.
+
+Shipping #17: the ratio is believable and the number is yours.
+```
diff --git a/skills/li-post/hooks.json b/skills/li-post/hooks.json
new file mode 100644
index 0000000..eaab5b4
--- /dev/null
+++ b/skills/li-post/hooks.json
@@ -0,0 +1,181 @@
+{
+ "version": "1.0",
+ "note": "21 hook formulas. Line 1 of a LinkedIn post is the whole game - the feed truncates at roughly 210 characters on desktop and 140 on mobile before 'see more', so the hook has to survive alone. Every formula here has a template, a filled example, what it is for, and the way it usually gets ruined.",
+ "rules": [
+ "One idea per hook. If it needs a comma splice, it needs two posts.",
+ "Line 2 is not a hook, it is the payoff of line 1. Never waste it on setup.",
+ "No question marks in line 1 unless the question is specific enough that only you could ask it.",
+ "Numbers beat adjectives. '$4,200' beats 'a lot of money' every time.",
+ "If the hook works with any other person's name on it, it is not your hook."
+ ],
+ "hooks": [
+ {
+ "id": 1,
+ "name": "Contrarian Take",
+ "template": "Everyone says {common advice}. After {specific experience}, I think that is wrong.",
+ "example": "Everyone says post daily. I posted 4x a week for a year and beat every daily poster in my niche.",
+ "best_for": "Establishing a point of view. Highest comment rate of any formula.",
+ "trap": "Being contrarian about something nobody believes. The belief has to be genuinely common."
+ },
+ {
+ "id": 2,
+ "name": "Number Reveal",
+ "template": "I {did thing} for {N} {days/weeks}. Here is what actually happened.",
+ "example": "I sent 400 cold DMs in 30 days. 11 replied. 2 became clients.",
+ "best_for": "Experiments, challenges, anything with a countable result.",
+ "trap": "Burying the number. Put it in line 1 or the formula does nothing."
+ },
+ {
+ "id": 3,
+ "name": "Mistake Confession",
+ "template": "{Specific cost} is what {one mistake} cost me.",
+ "example": "$18,000 is what not having a contract cost me last March.",
+ "best_for": "Trust. People forward the posts where you look bad.",
+ "trap": "A fake-humble mistake. 'I care too much' reads as a brag and kills the post."
+ },
+ {
+ "id": 4,
+ "name": "Before / After",
+ "template": "{Time ago} I was {low state}. Today I {high state}. The difference was {one thing}.",
+ "example": "18 months ago I was writing proposals at 2am. Today I send them in 6 minutes. One template did it.",
+ "best_for": "Proof you have travelled the distance your reader wants to travel.",
+ "trap": "Three-part transformations. Name one lever or the reader stops believing you."
+ },
+ {
+ "id": 5,
+ "name": "The List Promise",
+ "template": "{N} things I wish someone had told me before {milestone}.",
+ "example": "7 things I wish someone had told me before I hired my first employee.",
+ "best_for": "Saves. Highest save rate of the 21, which LinkedIn weights heavily.",
+ "trap": "N above 10. The reader does not believe you have 15 good ones, and you do not."
+ },
+ {
+ "id": 6,
+ "name": "Insider Secret",
+ "template": "After {N} years {doing thing}, here is the part nobody puts in the {job posting/course/pitch}.",
+ "example": "After 9 years in agency sales, here is the part nobody puts in the job posting.",
+ "best_for": "Credentialed takes. Works only if the years are real.",
+ "trap": "Promising a secret and delivering common knowledge. The comments will say so."
+ },
+ {
+ "id": 7,
+ "name": "The Callout",
+ "template": "If you are still {doing outdated thing}, stop.",
+ "example": "If you are still writing your LinkedIn posts in the LinkedIn composer, stop.",
+ "best_for": "Short posts with one instruction. Fastest to write of the 21.",
+ "trap": "Calling out something nobody does. Or worse, calling out your own audience with contempt."
+ },
+ {
+ "id": 8,
+ "name": "Question Trap",
+ "template": "{Specific scenario with a real cost}. What do you do?",
+ "example": "Your best client asks for a 40% discount and hints they will leave without it. What do you do?",
+ "best_for": "Comment volume. People answer scenarios, they ignore 'thoughts?'.",
+ "trap": "A question with an obvious right answer. There has to be a real fork."
+ },
+ {
+ "id": 9,
+ "name": "Story Cold Open",
+ "template": "\"{Line of dialogue}\"\\n\\n{Who said it, when, and why it mattered}.",
+ "example": "\"We are going with someone cheaper.\"\\n\\nThat email arrived 40 minutes after I sent my best proposal of the year.",
+ "best_for": "Long-form storytelling posts. Highest dwell time.",
+ "trap": "Dialogue nobody would actually say. Use the real line, including the ugly parts."
+ },
+ {
+ "id": 10,
+ "name": "The Receipt",
+ "template": "{Screenshot or hard number}. {One sentence of context}.",
+ "example": "3 clients, 11 days, zero calls booked. Here is the exact sequence that did it.",
+ "best_for": "Anything you can prove. Pair with an image and reach roughly doubles.",
+ "trap": "A receipt with no story attached. The number opens the door, the story is the room."
+ },
+ {
+ "id": 11,
+ "name": "Myth Bust",
+ "template": "{Popular explanation} is not why {bad outcome} is happening to you.",
+ "example": "The algorithm is not why your posts are dying.",
+ "best_for": "Reframing. Sets you up to deliver the real cause in line 3.",
+ "trap": "Busting the myth and never naming the replacement. Always name it."
+ },
+ {
+ "id": 12,
+ "name": "The Comparison",
+ "template": "{Expensive option} vs {cheap option}. {Surprising verdict}.",
+ "example": "A $12,000 brand agency vs a $20 tool and a weekend. The weekend won.",
+ "best_for": "Tool and process posts. Very high share rate.",
+ "trap": "An unfair comparison. Concede what the expensive option genuinely does better."
+ },
+ {
+ "id": 13,
+ "name": "Permission Slip",
+ "template": "You are allowed to {thing the reader feels guilty about}.",
+ "example": "You are allowed to turn down work that pays well and makes you miserable.",
+ "best_for": "Reach beyond your niche. These travel further than tactical posts.",
+ "trap": "Generic self-care. It has to be specific to the working life of your reader."
+ },
+ {
+ "id": 14,
+ "name": "Pattern Interrupt",
+ "template": "{One word or three-word line, full stop.}",
+ "example": "I got fired.",
+ "best_for": "Stopping the scroll cold. Whitespace does the work.",
+ "trap": "Overuse. Once a month. Every post starting this way reads as a tic."
+ },
+ {
+ "id": 15,
+ "name": "The Warning",
+ "template": "{Common practice} is quietly costing you {specific thing they care about}.",
+ "example": "Your 'quick call to align' is quietly costing you six hours a week.",
+ "best_for": "Problem-aware audiences who have not connected cause to cost.",
+ "trap": "Fear with no exit. Give the fix in the same post or you have just made someone anxious."
+ },
+ {
+ "id": 16,
+ "name": "Good vs Great",
+ "template": "Good {role} {do X}. Great {role} {do Y}.",
+ "example": "Good salespeople answer the question. Great salespeople ask why it was asked.",
+ "best_for": "Quotable one-liners. Screenshot bait.",
+ "trap": "A distinction that is really just 'try harder'. Y has to be a different action, not more effort."
+ },
+ {
+ "id": 17,
+ "name": "Time Anchor",
+ "template": "{Task} used to take me {long time}. It now takes {short time}.",
+ "example": "Writing a week of posts used to take me 5 hours. It now takes 20 minutes.",
+ "best_for": "Tool, system and automation posts. The strongest hook shape for a how-to.",
+ "trap": "An unbelievable ratio. 5 hours to 20 minutes lands. 5 hours to 8 seconds does not."
+ },
+ {
+ "id": 18,
+ "name": "The Unpopular Rule",
+ "template": "I do not {widely accepted practice}. Ever. Here is why.",
+ "example": "I do not take discovery calls. Ever.",
+ "best_for": "Positioning. Attracts the right clients by repelling the wrong ones.",
+ "trap": "A rule you break constantly. Someone in the comments will know."
+ },
+ {
+ "id": 19,
+ "name": "Curiosity Gap",
+ "template": "The {superlative} {thing} I ever {verb} {broke the obvious rule}.",
+ "example": "The best hire I ever made failed the interview.",
+ "best_for": "Openers that force the 'see more' tap.",
+ "trap": "A gap you never close. Pay it off by line 4 or you have written clickbait."
+ },
+ {
+ "id": 20,
+ "name": "The Walk-Away",
+ "template": "I {fired/quit/deleted/cancelled} {valuable thing}. {Result}.",
+ "example": "I fired my highest-paying client in January. Revenue is up 30%.",
+ "best_for": "Values posts with a business result attached. Very high engagement.",
+ "trap": "Walking away with no cost. Name what it actually cost you or it reads as theatre."
+ },
+ {
+ "id": 21,
+ "name": "The Direct Value",
+ "template": "Here is the exact {artifact} I used to {specific outcome}. Steal it.",
+ "example": "Here is the exact 4-line email I used to reopen 3 dead deals. Steal it.",
+ "best_for": "Lead magnets and comment-for-link posts. Highest conversion of the 21.",
+ "trap": "Making them ask for something you could have just posted. Give the artifact away in the post."
+ }
+ ]
+}
diff --git a/skills/li-profile/SKILL.md b/skills/li-profile/SKILL.md
new file mode 100644
index 0000000..515e179
--- /dev/null
+++ b/skills/li-profile/SKILL.md
@@ -0,0 +1,80 @@
+---
+name: li-profile
+description: >-
+ Score a LinkedIn profile out of 100 against a 12-part rubric and rewrite the
+ parts that lose points - headline, about, experience, featured, banner. Use
+ when the user says "optimize my profile", "score my LinkedIn", "rewrite my
+ headline", "fix my about section", or pastes their profile and asks how it
+ reads.
+---
+
+# li-profile
+
+A profile is not a resume. A resume answers "what have you done". A profile
+answers "should I message this person", and it answers it in about four
+seconds, from the headline and the first two lines of the about.
+
+## Input
+
+Ask the user to paste: headline, about section, current role and the last two
+experience entries, plus whether they have a banner and featured section. A
+screenshot of the top card is enough for the first pass. Do not log into
+LinkedIn on their behalf.
+
+## Score it
+
+Read `rubric.json` in this folder. Twelve items, 100 points, each with what
+full marks looks like. Score every item, show the table, and give the total.
+Be honest - most profiles land in the 30s and 40s on the first pass, and a
+generous score is useless.
+
+```
+PROFILE SCORE 41/100
+
+ headline 3/12 job title only, no outcome, no audience
+ about first 2 lines 2/10 opens with "passionate about"
+ about body 4/10 history, not offer
+ featured 0/8 empty
+ banner 0/6 default blue
+ ...
+```
+
+## Then rewrite, in this order
+
+Fix in descending order of points lost. Do not rewrite everything at once -
+the user has to actually paste each of these in.
+
+**1. Headline (220 characters).** The formula that works:
+`{what you do for whom} | {proof} | {how to start}`. Not your job title. Not
+"Helping X do Y" as the first three words, which every second profile now
+opens with. Give three options.
+
+**2. About, first two lines.** Everything after line 2 is behind "see more" on
+mobile, so those two lines are the whole about section for most readers. They
+must state who you help and what changes. No "passionate", no "results-driven",
+no third-person bio, no opening with your own name.
+
+**3. About body.** Written to one reader, in the second person. Structure:
+the problem they have, what you do about it, one piece of proof with a number,
+what to do next. Under 1,400 characters even though the limit is 2,600.
+
+**4. Featured.** Three items: the best post, the proof asset, the way to
+contact. An empty featured section is eight points and the only place on the
+profile you fully control.
+
+**5. Experience.** Each role gets one line of scope and two to three bullets
+that are outcomes with numbers, not duties. Cut anything older than ten years
+to a single line.
+
+**6. Banner.** One sentence of positioning and one way to reach you. The
+default blue gradient is the clearest signal on the page that nobody is home.
+
+## Output
+
+Score table, then the rewrites as copy-ready blocks in fix-first order, each
+one already run through `/li-human`. Re-score at the end and show the delta
+honestly - if the rewrite gets to 88 and not 98, say 88, and say what the
+remaining points need (usually recommendations, a real banner and posting
+history, none of which a rewrite can create).
+
+Nothing is saved to LinkedIn by this skill. The user pastes each section in.
diff --git a/skills/li-profile/rubric.json b/skills/li-profile/rubric.json
new file mode 100644
index 0000000..77320c0
--- /dev/null
+++ b/skills/li-profile/rubric.json
@@ -0,0 +1,67 @@
+{
+ "version": "1.0",
+ "total": 100,
+ "note": "Twelve items. Score each honestly - a generous score helps nobody. Most first-pass profiles land in the 30s and 40s.",
+ "items": [
+ {
+ "id": "headline",
+ "points": 12,
+ "full_marks": "States who you help and what changes for them, carries one piece of proof, and is not the job title. Uses the 220 characters, not 60."
+ },
+ {
+ "id": "about_open",
+ "points": 10,
+ "full_marks": "First two lines - everything visible before 'see more' - name the reader's problem. No 'passionate about', no third-person bio, no opening with your own name."
+ },
+ {
+ "id": "about_body",
+ "points": 10,
+ "full_marks": "Written to one person in second person: their problem, what you do, one number as proof, what to do next. Under 1,400 characters."
+ },
+ {
+ "id": "featured",
+ "points": 8,
+ "full_marks": "Three items: best-performing post, a proof asset, and the way to contact you. Nothing empty, nothing stale."
+ },
+ {
+ "id": "banner",
+ "points": 6,
+ "full_marks": "One line of positioning and one way to reach you. Not the default gradient, not a stock skyline."
+ },
+ {
+ "id": "photo",
+ "points": 6,
+ "full_marks": "Face fills roughly 60% of the frame, eyes visible, shot in the last two years, background not distracting."
+ },
+ {
+ "id": "current_role",
+ "points": 10,
+ "full_marks": "One line of scope, then two to three outcome bullets with numbers. Duties are not outcomes."
+ },
+ {
+ "id": "experience_depth",
+ "points": 8,
+ "full_marks": "Last two roles detailed, everything older than ten years compressed to a single line each."
+ },
+ {
+ "id": "skills",
+ "points": 6,
+ "full_marks": "Top three skills are the three you want to be hired for and are endorsed. The other 47 are noise."
+ },
+ {
+ "id": "recommendations",
+ "points": 8,
+ "full_marks": "At least three received in the last two years, each naming a specific outcome rather than character."
+ },
+ {
+ "id": "activity",
+ "points": 10,
+ "full_marks": "Posted or commented in the last seven days. An empty activity feed reads as an abandoned profile."
+ },
+ {
+ "id": "contact",
+ "points": 6,
+ "full_marks": "Custom URL, a working email or booking link in contact info, and the same handle as your other platforms."
+ }
+ ]
+}
\ No newline at end of file
diff --git a/skills/li-reply/SKILL.md b/skills/li-reply/SKILL.md
new file mode 100644
index 0000000..a740baf
--- /dev/null
+++ b/skills/li-reply/SKILL.md
@@ -0,0 +1,78 @@
+---
+name: li-reply
+description: >-
+ Handle the replies under the user's own LinkedIn posts - draft answers to
+ every comment, sorted by which ones are worth answering. Use when the user
+ pastes the comments on their post, says "reply to these", "handle my
+ comments", "someone said X on my post", or is dealing with a critic or a
+ lead in the comments.
+---
+
+# li-reply
+
+The reply thread under your own post is where reach is actually decided. Every
+reply is a second engagement event on the post, and the first hour of replies
+does most of the work. But the value is not equal across comments, so this
+skill sorts before it writes.
+
+## Input
+
+The user pastes the comments, ideally with names and roles. Screenshots are
+fine. Do not scrape the thread with a browser tool.
+
+## Triage first
+
+Sort every comment into one of five buckets and say the count out loud:
+
+| bucket | what it is | what it gets |
+| --- | --- | --- |
+| **LEAD** | someone describing the problem you solve | a real answer + a soft open door |
+| **SUBSTANCE** | adds data, disagrees, extends | the longest reply on the thread |
+| **PEER** | a name worth being seen next to | a reply that gives them something |
+| **SUPPORT** | "great post", 🔥, a tag | a like, and a 3-8 word reply at most |
+| **NOISE** | pitch, spam, bad faith | nothing, or one line and out |
+
+Then write in that order, and stop writing when the value stops.
+
+## How to reply
+
+- **Answer the actual question.** If someone asks how, tell them how, in the
+ reply. Do not send them to a DM to hear the answer they could have had.
+- **Use their name once**, at the start, and never with an exclamation mark.
+- **Match their length.** A two-line comment does not get a six-line reply.
+- **To a critic:** concede the true part first, in their words, then hold the
+ line on the part you believe. Never delete, never get defensive, never reply
+ twice on the same thread.
+- **To a lead:** answer fully in public. The open door is one sentence at the
+ end, and it is an offer of help, not a pitch. Public value is what makes the
+ next person DM you.
+- **To a pitch in your comments:** ignore it. Replying gives it reach.
+
+## Output
+
+One block, grouped by bucket, each reply copy-ready and already humanized:
+
+```
+REPLIES · 17 comments · 1 LEAD, 3 SUBSTANCE, 4 PEER, 8 SUPPORT, 1 NOISE
+
+LEAD
+@Sarah Chen - "we have the same problem with proposals"
+> The part that fixed it for us was pulling the pricing table out of the doc
+> entirely and sending it as its own page. Cut a whole review round. Happy to
+> send you the template if it is useful.
+
+SUBSTANCE
+@Marcus Webb - disagrees on cadence
+> Fair, and 4x a week only worked because I had 8 months of posts behind it.
+> From a standing start I would do what you said.
+
+SUPPORT (like these, reply to the first three)
+@... "This is great" -> Thanks Dan.
+...
+
+NOISE (1)
+Skipped: an agency pitch. Replying gives it reach.
+```
+
+Then the gate: **nothing is posted until the user says yes.** They paste the
+replies themselves.
diff --git a/skills/li-repurpose/SKILL.md b/skills/li-repurpose/SKILL.md
new file mode 100644
index 0000000..92815a3
--- /dev/null
+++ b/skills/li-repurpose/SKILL.md
@@ -0,0 +1,71 @@
+---
+name: li-repurpose
+description: >-
+ Turn one long asset - a YouTube video, podcast, newsletter, blog post,
+ transcript or client call - into a week of LinkedIn posts. Use when the user
+ says "repurpose this", "turn this into posts", "I have a video/newsletter/
+ transcript", or pastes a long piece of content and wants it on LinkedIn.
+---
+
+# li-repurpose
+
+One good long asset contains four to six posts. Most people extract one and
+throw the rest away.
+
+## Input
+
+A transcript, an article, a newsletter, a script, a call summary. If the user
+gives a YouTube URL and there is a transcript tool available in the session,
+use it; otherwise ask them to paste the text. Read the whole thing before
+extracting anything.
+
+## Extract, do not summarise
+
+A summary of a video is not a post. Nobody wants the summary. Go through the
+asset and pull out the things that stand alone:
+
+| pull | what it is |
+| --- | --- |
+| **Claims** | every sentence that would start an argument |
+| **Numbers** | every figure, cost, duration, percentage |
+| **Stories** | every moment with a person, a scene and a cost |
+| **Mechanisms** | every "the way this works is..." explanation |
+| **Mistakes** | every admission of something that went wrong |
+| **Lines** | every sentence that is already quotable as-is |
+
+List what you found, with counts, before writing anything. If the asset yields
+fewer than four items, it is thin, and four posts squeezed out of it will be
+thin too. Say that.
+
+## Then build the week
+
+Each extract becomes one post, and each post has to stand completely on its
+own - the reader has not seen the video and never will. Never write "as I
+mentioned in my latest video". The post is the thing.
+
+Assign a hook formula from `li-post/hooks.json` to each, and vary them: five
+posts from one source with the same hook shape reads as a content mill.
+
+Order them across the week so the strongest claim goes first, the story goes
+midweek, and the mechanism post goes last, when people who liked the earlier
+ones are watching for it.
+
+## Output
+
+```
+SOURCE: "Why we killed discovery calls" (18 min, 3,400 words)
+
+FOUND 4 claims, 6 numbers, 2 stories, 3 mechanisms, 1 mistake, 5 quotable lines
+
+WEEK
+TUE #1 Contrarian Discovery calls are a tax you pay for a bad website
+WED #17 Time Anchor We got 6 hours a week back by deleting one calendar link
+THU #9 Cold Open "Can we just hop on a quick call?"
+FRI #21 Direct Value The 4-question form that replaced the call. Steal it.
+
+Say "write Tuesday" and I will draft it.
+```
+
+Then draft on request, one at a time, each through `/li-post` and `/li-human`.
+Do not dump four finished posts at once - they will all sound the same, and
+the user will edit none of them.
diff --git a/templates/voice.md b/templates/voice.md
new file mode 100644
index 0000000..4553c06
--- /dev/null
+++ b/templates/voice.md
@@ -0,0 +1,53 @@
+# voice.md
+
+Copy this to `~/.claude/linkedin/voice.md` and fill it in. Every skill in the
+pack reads it. Ten minutes here is the difference between drafts you post and
+drafts you rewrite.
+
+If you would rather not fill it in by hand, paste three of your own posts into
+Claude and say "write my voice.md from these". That works better than guessing
+at the answers.
+
+---
+
+## Who I am
+
+- **Name:**
+- **What I do, in one sentence:**
+- **Who I am writing for:** (be specific: "agency owners doing $1-5M", not "professionals")
+- **What I sell:**
+
+## What I sound like
+
+- **Three of my own posts that sound most like me:** (paste them, or link them)
+- **Words I actually use:**
+- **Words I would never use:**
+- **Sentence length:** (short and punchy / mixed / long and considered)
+- **Do I swear:** (yes / mild / no)
+- **Emoji:** (never / one, rarely / freely)
+- **Contractions:** (yes - almost always yes)
+
+## My positions
+
+Three to five things I believe that some of my audience does not. These are
+where the good posts come from.
+
+1.
+2.
+3.
+
+## Off limits
+
+- **Topics I do not post about:**
+- **Clients or numbers I cannot name publicly:**
+- **Claims I am not allowed to make:** (regulated industry, employer policy, NDA)
+
+## Proof I can use
+
+Real numbers, outcomes and stories I am happy to put my name on. The skills
+will never invent one, so if this section is empty, every draft comes back
+with `{{your number}}` in it.
+
+-
+-
+-