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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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/.gitignorenew file mode 100644index 0000000..4b0e230--- /dev/null+++ b/.gitignore@@ -0,0 +1,5 @@+.DS_Store+__pycache__/+*.pyc+.venv/+*.tmpdiff --git a/LICENSE b/LICENSEnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.pynew file mode 100755index 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.pynew file mode 100755index 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.jsonnew file mode 100644index 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 filediff --git a/skills/li-inbox/SKILL.md b/skills/li-inbox/SKILL.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.jsonnew file mode 100644index 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.mdnew file mode 100644index 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.jsonnew file mode 100644index 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 filediff --git a/skills/li-reply/SKILL.md b/skills/li-reply/SKILL.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.++-+-+-