sergebulaev/linkedin-skills

Claude skills for LinkedIn. 12 Claude Code and Codex skills that write LinkedIn posts, comments, and replies in your voice. They draft content, strip AI tells, and wait for your approval before anything gets published. No coding required.

On another platform too? The same team ships matching marketing skill bundles for X (Twitter) · Instagram · YouTube · TikTok · Threads · Facebook. Same voice engine, same approve-before-publish flow.

Pick whichever way you use Claude Code or Codex:

codex plugin marketplace add sergebulaev/linkedin-skills
codex plugin add linkedin-skills@linkedin-skills

To test a local clone before publishing changes:

git clone https://github.com/sergebulaev/linkedin-skills.git
cd linkedin-skills
codex plugin marketplace add .
codex plugin add linkedin-skills@linkedin-skills

1. Open claude.ai and click Customize in the sidebar
2. Open the Plugins tab
3. Click Add
4. Choose Add marketplace → Add from a repository
5. Paste sergebulaev/linkedin-skills there and sync
6. Find the plugin under Discover, then click Add
7. Done. The skills activate automatically when you ask about LinkedIn.

Note: Skills/Plugins require a paid Claude plan (Pro, Max, Team, or Enterprise) with code execution enabled.

1. Open Claude Desktop
2. Click Customize in the left sidebar, then open the Plugins tab
3. Click the Add dropdown at the top right and choose Add marketplace
4. Select Add from a repository, paste sergebulaev/linkedin-skills, and sync
5. Switch to the Discover tab and find the plugin in the list
6. Click the + on the plugin card to install it
7. Switch back to Yours to confirm it is listed and enabled
8. Done. Start a new conversation and ask Claude to write a LinkedIn post.

The tab switch in steps 5 and 7 is the part that trips people: syncing a marketplace puts the plugin in the catalog (Discover), not in your installed list (Yours). The + in step 6 sits on the plugin card itself, not beside a section heading.

1. Open your OpenClaw working directory
2. Clone the skills into it:

   git clone https://github.com/sergebulaev/linkedin-skills.git

3. In OpenClaw settings, add this to your system prompt:

   You have LinkedIn marketing skills in ./linkedin-skills/.
   For any LinkedIn task, read the relevant skills/*/SKILL.md first.
   Use lib/url_parser.py for URL parsing,
       lib/apify_client.py for reading posts / comments / engagers,
       lib/publora_client.py for publishing actions.
   

4. Done. Ask OpenClaw to write a LinkedIn post or comment.

/plugin marketplace add sergebulaev/linkedin-skills
/plugin install linkedin-skills@linkedin-skills

Or clone the repo and open it as your working directory — the skills activate with no plugin install, which is the route to use where /plugin is unavailable:

git clone https://github.com/sergebulaev/linkedin-skills.git
cd linkedin-skills

The repo ships a .claude/skills/ mirror of symlinks, so Claude Code finds all 12 skills on its own.

On Windows those symlinks check out as twelve one-line text files unless git can create them, which needs Developer Mode or an elevated shell plus git config core.symlinks true. Without that, a plain clone loads no skills at all. Either clone with symlinks enabled, or replace the mirror with directory junctions, which need no admin rights:

for /d %s in (skills\*) do mklink /J .claude\skills\%~nxs ..\..\%s

Hermes Agent (Nous Research) follows the agentskills.io open standard and loads skills/*/SKILL.md directly. Clone the bundle into your Hermes skills folder:

git clone https://github.com/sergebulaev/linkedin-skills.git ~/.hermes/skills/linkedin-skills

Coming from OpenClaw? hermes claw migrate imports these skills automatically. Then call /<skill-name> from any of your Hermes chat surfaces.

One command that works across Claude Code, Codex, Cursor, and any other agent that reads SKILL.md files:

npx skills add sergebulaev/linkedin-skills

Found this useful? Star the repo. Curated Claude Code and Codex directories rank and gate by star count, so a star is what makes these skills findable for the next person. It is the only thing we ask. No signup, no email.

Once installed, just ask Claude Code or Codex for help with LinkedIn. The right skill activates automatically.

Write a post:

"Write me a LinkedIn post about why AI agencies are replacing traditional ones. Make it viral."

Comment on someone's post:

"Comment on this post: https://linkedin.com/posts/... — I want to add a thoughtful take."

Check a draft before publishing:

"Audit this post draft for AI tells and algorithm issues: [paste your text]"

Reverse-engineer a viral post:

"What hook formula does this post use? https://linkedin.com/posts/..."

Plan your week:

"Create a 7-day LinkedIn content plan. I'm a B2B SaaS founder targeting VPs of Marketing."

Rewrite your profile:

"Optimize my LinkedIn profile for inbound leads: https://linkedin.com/in/yourname"

Remove AI tells from any text:

"Humanize this text: [paste AI-generated draft]"

Every skill shows you a draft first and waits for your OK before doing anything. Nothing gets posted without your approval.

If you are a founder, the bundle ships a dedicated founder layer. Your real constraint is rarely reach. It is a small number of high-stakes readers: the next investor, the next hire, the design partner who becomes a case study. The founder layer optimizes for trust with that narrow audience instead of impressions.

• 10 founder angles (references/founder-topics.md) as fill-in templates: reprice the category, content-to-pipeline, audience of one, the scarce-shots math, the unglamorous bet, the limit of delegation, designed serendipity, the evasive-sentence test, the delegation line, the learning gate. Each maps to an engagement goal and a hook formula.
• 4 structural hook formulas (F17-F20) that shape a post's logic: controlled A/B anecdote, false-binary dissolve, anecdote-meets-evidence bridge, diverging-curves close.
• A founders-edition content plan (Conviction / Building in public / The math / Proof) in the Content Planner.

Just tell the Post Writer you are a founder, or ask the Content Planner for a "founder plan," and the skills reach for these first.

Standalone skills built by other people on this bundle's conventions (same voice rules, same approval-card flow, same Not for X (use Y) disambiguation). They live in their authors' repos, so the core stays at 12 skills and one read/write pipeline. Install them next to this bundle the same way.

• linkedin-outreach by @smfardeen7 - drafts 300-character connection-request notes (10 scenario templates) and post-accept follow-up sequences with day offsets and stop rules. Draft-only: LinkedIn has no invite or DM API, you paste and send.

Built one? Open a PR that adds a single line here.

Four of the skills (Comment Drafter, Reply Handler, Hook Extractor, Engagement Monitor) can read post bodies, comment threads, your own recent comments, and the people who liked or commented on any post. Without an Apify token they fall back to asking you to paste the relevant text. With one, they fetch automatically.

Apify free tier ships with $5/month of credit, which goes a long way at $1-$5 per 1,000 results. The skills use four no-cookies actors:

Setup: drop APIFY_TOKEN=apify_api_... into your .env. The thin client at lib/apify_client.py exposes fetch_post, fetch_post_comments, fetch_user_recent_comments, and fetch_post_engagers.

This tier needs Claude Code, not claude.ai (web). Publora and Pixfaro each publish a connector, so publishing and image generation work on claude.ai with one click. Apify does not: the client reads APIFY_TOKEN from the environment and runs a Python process, and claude.ai gives a skill neither. On claude.ai the reading skills notice the missing token and ask you to paste the post or thread instead, which is the same quality of result with one more step. For automatic reads, run the bundle in Claude Code with a .env.

A typical creator running daily comment ops + a weekly engager-analytics sweep stays under $2/month, well inside the free tier.

By default, skills draft content for you to copy-paste into LinkedIn. If you want Claude Code or Codex to publish directly to your LinkedIn (and optionally to X, Threads, Instagram), connect Publora. It takes about 2 minutes.

Publora is a publishing API that handles LinkedIn's quirks (3 different URL formats, reaction type mismatches, thread flattening bugs). The free tier gives you 15 posts/month.

Publora also ships official MCP skills (npx skills add publora/skills): one skill per platform, covering the publish side only. This bundle is the layer above them, adding the reading, the writing craft and the approval flow.

Before or after any of it, one command tells you where you stand:

python3 scripts/selftest.py          # install, accounts, tests, and which skills work right now
python3 scripts/selftest.py --fresh  # clone to a temp dir and check a genuinely clean install

It reports each of Apify, Publora and Pixfaro separately, using free endpoints that verify a key without doing any work, and it names what is missing rather than only that something is. Skills that need a layer you have not connected still work, by drafting for you to paste, and the report says which ones those are.

A connector, if you are on claude.ai or Claude Code. Publora and Pixfaro both publish one. Authorize it once in your connector settings and the skills use it: no key on disk, no .env, nothing to rotate. Publora's connector also carries post_stats and profile_stats, which the REST path below does not have.

An API key, if you are anywhere else — a plain terminal, CI, a script, or you would rather the credential lived in a file you control. That is the seven steps below.

They are not exclusive and neither is second-class. One caveat worth knowing: scripts/check_config.py and scripts/selftest.py read .env and the shell, so a connector is invisible to them. If they say "manual" while your posts are going out, the connector is doing the work and nothing is wrong.

Step 1. Sign up at https://app.publora.com/signup (free)

Step 2. Connect LinkedIn: click Channels in the left sidebar, then Add Channel, pick LinkedIn, authorize.

Step 3. Find your Platform ID: go to Channels, click your LinkedIn account. The ID looks like linkedin-ABC123DEF. Copy the whole thing including linkedin-.

Step 4. Get your API key: click Settings (gear icon, bottom-left), then API, then Create Key. Copy the sk_... string.

Step 5. Create a file called .env in the linkedin-skills folder:

PUBLORA_API_KEY=sk_paste_your_key_here
LINKEDIN_PLATFORM_ID=linkedin-paste_your_id_here

If you cloned the repo, you can copy the template instead:

cp .env.example .env

Then open .env and replace the placeholders with your real values.

Step 6. Install two small Python packages:

pip install requests python-dotenv

Step 7. Test it. Ask Claude Code or Codex:

"Schedule a test LinkedIn post via Publora 24 hours from now: 'testing the API connection — will cancel in dashboard'."

If Publora returns a scheduled-post ID, you're set. Cancel the post in the Publora dashboard before the scheduled time. If you get HTTP 401, your API key is wrong. If you get HTTP 400 about a missing platformId, your LINKEDIN_PLATFORM_ID isn't set. See Troubleshooting.

Posts with a visual get more dwell time. The Post Writer can generate an illustration for a draft (a feed image, a carousel slide, or a quote-card of your hook) and attach it automatically when publishing. Without a key it drafts the image prompt and asks you to generate it yourself, so nothing breaks.

Pixfaro is a single image API over multiple models (from flux-schnell at $0.004 to gpt-5-image). It composites your handle, brand color, or logo onto the image as a pixel-exact overlay, so a cheap base model still renders crisp text on a quote-card or thumbnail. Pull those brand fields from your Voice & Brand Profile (section 6) and every asset stays on-brand.

Setup: sign up at api.pixfaro.com/signup, create a key (name it linkedin, scope Generate), and put PIXFARO_TOKEN=pf_live_... in .env at the root of the linkedin-skills folder (next to this README; keys are shown once). Then python3 scripts/check_config.py calls Pixfaro's GET /v1/key and prints the key's name and scope when it is right. The thin client at lib/pixfaro_client.py and the wrappers lib.illustrate(prompt, kind=...) / lib.refine(image_id, instruction) return a hosted URL that flows straight into lib.publish(..., media_urls=[url]). refine edits a prior image by its id (cheaper than regenerating); results carry cost, balance_after, and a premium flag so the skills never quietly spend on a pricey model.

For text-led visuals (a quote-card of your hook), the skills skip the image model entirely and use Pixfaro's design templates: lib.quote_card("<hook>", handle="@you", style="brand") typesets the card server-side (POST /v1/renders), so the line is crisp at any length — same hosted-URL flow. lib.available_templates() lists templates and live prices. A brand logo can be uploaded once with lib.brand_logo("logo.png") (full-scope key); the returned logo_id goes into Voice & Brand Profile §6 and every overlay from then on stamps the real mark.

Every skill follows these rules automatically:

1. Em dashes capped at about 1 per 100 words. The character stopped being a tell in 2026; the density is.
2. Capitalize names. Always. Lowercase reads as disrespectful.
3. No AI vocabulary: "leverage", "fundamentally", "streamline", "harness", "delve", "unlock", "foster".
4. Specific numbers beat adjectives. "$14,200" beats "significant savings".
5. One sharp insight per comment beats three vague ones.
6. 200-350 chars for comments, 900-1,300 chars for posts.

• references/industry-benchmarks.md — engagement rates, time-per-post, reach multipliers across industries
• references/engagement-metrics-taxonomy.md — what to measure at post / account / team / business level

linkedin-skills/
├── skills/          ← SKILL.md frontmatter; native to Claude Code and Codex, others read as markdown
├── .codex-marketplace/ ← generated nested Codex package (run scripts/sync_codex_marketplace.py)
├── lib/             ← pure Python, works in any agent runtime
├── references/      ← pure markdown, works anywhere
└── scripts/         ← pure Python CLI, works anywhere

git clone git@github.com:sergebulaev/linkedin-skills.git

# Add to OpenClaw system prompt:
# "You have LinkedIn marketing skills in ./linkedin-skills/.
#  Read the relevant skills/*/SKILL.md before any LinkedIn task.
#  Use lib/url_parser.py for URL parsing,
#      lib/apify_client.py for reading posts / comments / engagers,
#      lib/publora_client.py for publishing."

import sys; sys.path.insert(0, "path/to/linkedin-skills")
from lib import parse_linkedin_url, PubloraClient, ApifyClient

parsed = parse_linkedin_url("https://www.linkedin.com/posts/slug-activity-7448808898326654978-iW20")
print(parsed["post_urn"])  # urn:li:activity:7448808898326654978

# Read side (Apify)
apify = ApifyClient()  # reads APIFY_TOKEN from env
post = apify.fetch_post(post_url="https://www.linkedin.com/posts/...")
engagers = apify.fetch_post_engagers(post_url="https://www.linkedin.com/posts/...", max_items=50)

# Write side (Publora)
client = PubloraClient()  # reads PUBLORA_API_KEY from env
client.create_comment(post_urn=parsed["post_urn"], message="draft", platform_id="linkedin-xxx")

# Image side (Pixfaro) — optional, reads PIXFARO_TOKEN from env
from lib import illustrate
img = illustrate("Minimal flat-vector lighthouse, calm blue palette", kind="wide")
# img["url"] -> pass to publish(..., media_urls=[img["url"]])

python lib/url_parser.py "https://www.linkedin.com/posts/<author-handle>_activity-<id>"

• Publora API docs — endpoint reference for the publishing layer
• Apify console — manage actors, tokens, and usage for the read layer
• 360Brew paper — LinkedIn's ranking foundation model
• AuthoredUp 2026 reach data — format-level reach benchmarks

These skills come out of Creative Content Crafts, an engineering company. We build the machinery underneath a company's public voice: ICP parsing, engagement systems, content guardrails, and posting infrastructure. We do not sell the words themselves.

We call that layer content engineering. Writing collapsed to the price of a chat subscription. What stayed valuable is everything below it: pulling every post your market wrote this week, keeping a live list of the people who matter, engaging on it daily with judgment in the loop, and catching the risky drafts before the platform does.

On LinkedIn specifically, that is the whole job. We are engineers of LinkedIn growth, not a ghostwriting agency.

This repo is the thin top layer of that stack, open-sourced. The engine underneath is what we build for clients.

MIT. Powered by Publora.

Part of a family of AI social-media marketing skill bundles for Claude Code and Codex:

• linkedin-skills - LinkedIn (this repo)
• x-skills - X (Twitter)
• instagram-skills - Instagram
• youtube-skills - YouTube
• threads-skills - Threads
• tiktok-skills - TikTok
• facebook-skills - Facebook Pages

Also: Anthropic Skills repo, the awesome-claude-skills directory.