Make LinkedIn work like a system.
A practical agent-skill bundle for planning, writing, reviewing and publishing LinkedIn content in your own voice.
Skills
content ops, packaged
It gives your agent a repeatable LinkedIn operating system.
Instead of asking for a generic “viral post”, you install a set of specialised skills. Each skill knows what to ask for, which references to read, what shape the output should take, and when to stop for your approval.
Consistency without flattening your voice.
Less blank-page work
The Post Writer, Interviewer and Story Bank turn raw experience into concrete material before drafting starts.
More deliberate formats
Hooks, pillars, CTAs and post lengths are selected for a purpose rather than improvised every time.
Human review stays in the loop
Every action-taking skill shows a draft and waits for explicit approval before publishing.
Start small, add power later
Draft-only mode works with no credentials. Reading and publishing connectors are optional layers.
From “what should I post?” to a small set of reliable moves.
Write a post
Give it a topic, audience and goal. It chooses a hook structure and drafts the post.
Comment with substance
Paste a post URL and get a thoughtful comment rather than a summary of the original.
Study a strong hook
Reverse-engineer a post into a formula and a blank template you can reuse.
Shape the week
Generate a seven-day plan with pillars, formats, timing and comment targets.
Keep threads warm
Monitor author replies and draft follow-ups inside the 6–24 hour window.
Improve your profile
Rewrite headline, About, Featured, Experience and other profile components.
Adapt existing work
Turn a tweet, video, blog or newsletter into something native to LinkedIn.
Run advocacy
Give a team a cadence, governance rules and a way to measure business impact.
How the bundle turns prompts into a workflow.
The interesting design is the boundary between specialised instructions, shared references, optional data connectors and a hard approval checkpoint.
One loop keeps content work legible.
Understand the topic, URL, audience, goal and any constraints.
Read the relevant skill and reference files, then create the requested artefact.
Show a standard approval card with preview, target and character count.
Only after “yes” does the selected backend post, schedule or hand off.
Drafting and acting are separate
You can use nearly all the creative system without granting it publishing credentials.
The gate is a convention layer
lib/approval.py formats the card. The skills must still stop and wait for an explicit user response.
Small skills, one shared content engine.
The skills stay focused because the durable knowledge lives in references rather than being copied into every instruction file.
It separates “how I sound” from “what I have to say”.
Style memory
Built from three to six posts you already wrote. It describes your language, rhythm and preferences.
Substance memory
Built through an interview. It keeps roles, numbers, turning points, scars and positions you would defend.
Power is added in layers, not required up front.
Draft, review and copy-paste. Reading skills ask you to provide the post text or comment URLs. Best for first use, privacy-sensitive work or simple publishing.
Fetch post bodies, comments, replies, recent comments, likers and commenters through no-cookie actors. Without a token, the same skills fall back to pasted content.
Publish or schedule after approval. The bundle deliberately needs both credentials for automatic posting; a half-configured setup stays manual.
Generate illustrations, quote cards and branded overlays. Without the token, the skill drafts an image prompt for you.
The system is opinionated about where agency stops.
Show the draft
Approval cards include the action, full preview, target URL, reaction and character count.
Wait for an explicit yes
Skills are instructed to stop until the user says “post”, “yes” or provides edits.
Keep a way back
Scheduled or queued posts can be cancelled through Publora before they go live. A live LinkedIn post must be removed on LinkedIn.
draft → approval card → copy-paste
# configured mode
draft → approval card → Publora publish / schedule
It is a folder of markdown contracts with a thin Python layer.
Claude Code · Codex
Install as a plugin or clone the repo. Skills activate when the request matches their description.
Hermes Agent
Loads skills/*/SKILL.md through the agentskills.io pattern.
OpenClaw
Clone the bundle, point the system prompt at the skill directory and expose the helper libraries.
Cursor · Cline · Aider
Read the relevant markdown contracts as context and import lib/ when you want the Python wrappers.
Start with the smallest useful setup.
You can get value with a clone and an agent. Add credentials only when the manual loop is proven and you know which layer you actually need.
Choose your host, then add the bundle.
For Claude Code or Codex, the plugin route is the cleanest starting point. A local clone is useful when you want to inspect or modify the skills.
codex plugin marketplace add sergebulaev/linkedin-skills
codex plugin add linkedin-skills@linkedin-skills
# Or test locally
git clone https://github.com/sergebulaev/linkedin-skills.git
cd linkedin-skills
# Any agent that reads SKILL.md
npx skills add sergebulaev/linkedin-skills
Run the self-test before connecting anything.
The repository’s self-test checks install health, optional account layers, offline tests, and per-skill coverage. It reports what will work now and what will fall back to copy-paste.
python3 scripts/selftest.py
# clean-install check in a temporary directory
python3 scripts/selftest.py --fresh
# inspect local credential wiring without network calls
python3 scripts/check_config.py --offline
Add Apify when copy-pasting context becomes the bottleneck.
The read layer is useful for comment drafting, reply handling, hook extraction and engagement analysis. Keep it optional if you prefer to paste the exact content you want the agent to see.
What it unlocks
Post bodies, comment threads, your recent comments, and post engagers through the thin client in lib/apify_client.py.
What happens without it
The skills ask you for pasted text or URLs. Nothing else in the bundle stops working.
APIFY_TOKEN=apify_api_your_token_here
# then verify the wiring
python3 scripts/check_config.py
Connect Publora only after you trust the approval loop.
Automatic publishing is deliberately a second step. Start with manual copy-paste, then add Publora once you know the drafts are good and your account connection is correct.
PUBLORA_API_KEY=sk_paste_your_key_here
LINKEDIN_PLATFORM_ID=linkedin-paste_your_id_here
# install the small API dependencies
pip install requests python-dotenv
# run a diagnostic
python3 scripts/check_config.py
Both values matter
A key without the LinkedIn platform ID leaves the backend in manual mode.
Use a cancellable test
Schedule a harmless test post, confirm the returned ID, then cancel it in the Publora dashboard before it goes live.
Use a real task with a narrow brief.
Example: “Draft a LinkedIn post about shipping AI agents in production for product leaders. Optimise for thoughtful comments, not reach.”
Use the Interviewer to capture a specific receipt, a dated moment or a position you would defend.
Check the voice, factual claims, audience fit, sensitive information, target URL and the exact action requested.
In manual mode, copy-paste. In Publora mode, confirm the post or schedule response and retain the returned identifier.
Make the system better by improving its context.
Feed the Story Bank
Capture proof, turning points and opinions so drafts stop inventing generic “insights”.
Use the Humanizer as an editor
Audit for density, rhythm, performed sincerity and other patterns you personally dislike.
Track outcomes, not vanity alone
Use the engagement taxonomy to connect post-level signals to audience and business outcomes.
A sensible first week with the repo.
Founders, product leaders, recruiters, technical experts and small teams who want a repeatable content practice without handing over publishing judgement.
The bundle cannot manufacture a point of view, verify every claim or guarantee reach. It makes the work easier to repeat and inspect.
Useful system, with boundaries worth keeping visible.
Progressive setup
Draft-only mode is useful immediately, so credentials do not become a prerequisite for learning the workflow.
External services add dependency
Apify, Publora and Pixfaro introduce third-party accounts, pricing, failure modes and data-handling decisions.
Clear separation of concerns
Markdown skills hold behaviour; references hold knowledge; Python wrappers hold integrations.
Some “algorithm” claims need scrutiny
Heuristics, engagement multipliers and detector guidance should be treated as hypotheses to test, not timeless platform laws.
What to remember.
The value is in reusable, specialised behaviours.
Approval is the line between assistance and publishing agency.
Specific lived material beats more prompt cleverness.
Start manual; layer in read, write and visual services deliberately.
Open the repo. Read the contracts. Try the smallest loop.
GitHub repository
README, skill files, Python clients, scripts, tests, references and plugin metadata.
Installation guide
Codex CLI, Claude Code, Claude Desktop, OpenClaw, Hermes Agent and generic skills CLI paths.
Deck prepared from the repository contents available on 20 September 2026.