linkedin-strategy

$npx mdskill add alirezarezvani/claude-skills/linkedin-strategy

Three decisions, in this order. Out of order is why most LinkedIn efforts produce a feed of unrelated observations and stop in week five.

SKILL.md

.github/skills/linkedin-strategyView on GitHub ↗
---
name: linkedin-strategy
description: Use when someone needs a LinkedIn plan rather than a post — content pillars, positioning for a career change or consulting or thought leadership, a sustainable posting cadence, or a newsletter decision. Triggers on "what should I post about", "how often should I post", "LinkedIn content strategy", "should I start a LinkedIn newsletter", "grow my following", "90-day plan". Validates the positioning brief, sizes the week against real hours and refuses a plan that will not survive week five, and gates a newsletter against eligibility and a six-month cadence commitment.
license: MIT
metadata:
  version: 1.0.0
  author: Alireza Rezvani
  category: marketing
  updated: 2026-08-25
---

# LinkedIn Strategy — brief, cadence, newsletter

Three decisions, in this order. Out of order is why most LinkedIn efforts produce a feed of
unrelated observations and stop in week five.

## Workflow

**1. The brief — an editorial constitution, not a wish.** Walk the five questions one at a
time, each with a recommended answer, then validate:

```bash
python3 scripts/positioning_brief.py --input brief.json --output human
```

It refuses on the two things that make everything downstream impossible: an objective that
is not one of the six real ones (`career-change`, `consulting`, `thought-leadership`,
`hiring`, `fundraising`, `community`), and an audience too broad to exclude anyone. It also
refuses fewer than two exclusions — **a positioning that excludes nothing is availability.**

Pillars: two to four, shares summing to 100, at least one backed by proof that already
exists, at least one at 10-20% as the experimental slot. Every pillar needs a "why you"; if
anyone could post it, cut it.

The script emits observable 90-day criteria. Follower count is deliberately absent — it moves
for reasons unrelated to whether the objective is being met.

**2. The cadence — priced against a bad week.**

```bash
python3 scripts/cadence_planner.py --minutes 240 --stage starting --target-posts 3 --output human
```

Exit 0 fits / 2 below the 90-minute floor / 3 over budget with the overage named. Every
activity is priced in minutes including the reply window, which is part of the post and not
an extra. Allocation shifts with stage: from a standing start **60% of the budget belongs in
other people's comment sections**, because a post published to nobody reaches nobody.

Below 90 minutes a week it refuses to plan a posting schedule and returns a comment-only
week: a cadence abandoned in week five is worse than one never started, because the
abandonment is visible on the profile. Every plan ships with a minimum viable week.

**3. The newsletter — only if the promise can be paid.**

```bash
python3 scripts/newsletter_planner.py --followers 1800 --cadence biweekly \
  --minutes-per-month 420 --pillar "..." --output human
```

Refuses below LinkedIn's published 150-follower evaluation floor, and refuses a cadence
whose six-month cost exceeds the budget. Emits a 12-issue arc rotating issue types across
pillars, and a stop rule written before issue one.

## Rules

- **One objective.** Two objectives serve neither; the audiences overlap less than they look.
- **The exclusion list is the positioning.** Refuse to skip it.
- **Price the week from a bad week, not a good one.**
- **Consistency over volume.** A skipped week is fine; a skipped month resets you.
- **Review the brief quarterly, not weekly.** A brief revised monthly is a mood.

## Scripts

| Script | Role |
|---|---|
| [`scripts/positioning_brief.py`](scripts/positioning_brief.py) | Validates objective, audience, 2-4 proof-backed pillars, and the exclusion list; emits observable 90-day criteria. |
| [`scripts/cadence_planner.py`](scripts/cadence_planner.py) | Prices the week in minutes, allocates by stage, refuses over-budget targets, emits the minimum viable week. |
| [`scripts/newsletter_planner.py`](scripts/newsletter_planner.py) | Eligibility + six-month sustainability gate, 12-issue arc across pillars, stop rule. |

## References and assets

- [`references/objective_to_pillars.md`](references/objective_to_pillars.md) — the six objectives and the pillar arithmetic (7 sources)
- [`references/cadence_and_consistency.md`](references/cadence_and_consistency.md) — what a post really costs and why the floor exists (7 sources)
- [`references/newsletter_playbook.md`](references/newsletter_playbook.md) — eligibility, cadence as a promise, the stop rule (7 sources)

- [`assets/positioning_brief_template.md`](assets/positioning_brief_template.md) — fillable brief
- [`assets/example_brief.json`](assets/example_brief.json) — a passing brief, for the validator

## Distinct from

- **`linkedin-content`** — drafts and lints individual posts. This decides what they are about
  and how many there are. Posts without pillars are noise; offer this first, never chain silently.
- **`linkedin-analytics`** — tells you what happened. This decides what to do next.
- **`marketing-skill/content-strategy`** — company-level content marketing. This is one
  person's own presence.

---

**Version:** 1.0.0

More from alirezarezvani/claude-skills

SkillDescription
a11y-auditAccessibility audit skill for scanning, fixing, and verifying WCAG 2.2 Level A and AA compliance across React, Next.js, Vue, Angular, Svelte, and plain HTML codebases. Use when auditing accessibility, fixing a11y violations, checking color contrast, generating compliance reports, or integrating accessibility checks into CI/CD pipelines.
ab-test-setupWhen the user wants to plan, design, or implement an A/B test or experiment. Also use when the user mentions "A/B test," "split test," "experiment," "test this change," "variant copy," "multivariate test," "hypothesis," "conversion experiment," "statistical significance," or "test this." For tracking implementation, see analytics-tracking.
ad-creativeWhen the user needs to generate, iterate, or scale ad creative for paid advertising. Use when they say 'write ad copy,' 'generate headlines,' 'create ad variations,' 'bulk creative,' 'iterate on ads,' 'ad copy validation,' 'RSA headlines,' 'Meta ad copy,' 'LinkedIn ad,' or 'creative testing.' This is pure creative production — distinct from paid-ads (campaign strategy). Use ad-creative when you need the copy, not the campaign plan.
adversarial-reviewerAdversarial code review that breaks the self-review monoculture. Use when you want a genuinely critical review of recent changes, before merging a PR, or when you suspect Claude is being too agreeable about code quality. Forces perspective shifts through hostile reviewer personas that catch blind spots the author's mental model shares with the reviewer.
aeoAnswer Engine Optimization (AEO) skill — optimize content to be cited by AI language models (ChatGPT, Perplexity, Claude, Gemini, Mistral) as authoritative sources. Distinct from SEO — AEO optimizes for citation in LLM-generated responses, not search rankings. Use when planning content for AI-first search audiences, auditing existing content for E-E-A-T signals, tracking which pages get cited by which LLMs, or building a citation-friendly content strategy. Triggers — 'AEO audit', 'optimize for ChatGPT', 'get cited by Perplexity', 'LLM citation strategy', 'answer engine optimization', 'content for AI search', 'E-E-A-T audit'. Output is a markdown audit report (default) or JSON for pipeline integration. Stdlib-only Python tools.
agent-decision-receiptsMint a tamper-evident, post-quantum-signed receipt for a consequential agent action (deploy, delete, pay, grant-access, model decision) so it can be verified later from the certificate alone. Use when an autonomous agent takes a side-effecting action that may need to be proven later, or when satisfying EU AI Act Article 12 record-keeping. Three decisions: whether an action needs a receipt, minting it, verifying it. Signing is delegated to the open-source OpenAgentOntology package. Not after-the-fact log analysis; not a hosted notary; not a legal opinion.
agent-designerUse when the user asks to design a multi-agent system, pick an orchestration pattern (supervisor/swarm/pipeline), generate tool schemas for agents, or evaluate agent execution logs for cost, latency, and failure bottlenecks. Examples: 'design an agent architecture for research automation', 'generate Anthropic tool schemas from these tool descriptions', 'analyze these agent run logs for bottlenecks'. NOT for Claude Code workflow files (use workflow-builder) or single-agent prompt design (use agent-workflow-designer).
agent-harnessTurn any domain folder of skills into a bounded agentic loop: compile a goal into a verifiable task plan, execute tasks with the domain's own tools, verify every task with machine-run checks, retry with caps, escalate to a human when budgets exhaust, and refuse to close until everything is verified or explicitly waived. Use when you want an agent or subagent to pick up a goal and drive it to a verified close across one of this repo's 18 domains ('run this goal through the engineering harness', 'set up an agentic loop for marketing work', 'make the finance domain self-verifying'). NOT for authoring Claude Code Workflow-tool .js scripts (workflow-builder), N-agent tournaments on one task (agenthub), single-file metric optimization (autoresearch-agent), or discovering published loop recipes (loop-library).
agent-launcher-orchestratorUse when a user wants to build, launch, grade, or schedule a Claude Managed Agent (CMA) in their own Anthropic account — "build me an agent", "launch this as a managed agent", "run this on a schedule", "grade my agent against a rubric", "set up a nightly worker". Reads the per-session goal (./my-agent/goal.json), routes deterministically to one of five phase sub-skills (interview → stage-launch → grade-iterate → run-without-you → wrap-up) via goal_router.py, and compiles the goal+phase into an execution shape (single-pass workflow / bounded grade→iterate loop / recurring cron deployment loop) via loop_compiler.py. Forks context so heavy intake (build sheets, payloads, eval cases) stays out of the parent thread. All launches are emitted as BYOK curl the user runs with their own key; no tool makes API calls. Inspired by anthropics/launch-your-agent (Apache-2.0). Distinct from engineering/agent-harness (generic domain loop) and engineering/write-a-skill (authors Claude Code skills, not CMAs).
agent-memoryUse when a project's CLAUDE.md has grown past what anyone reads and you want the agent to learn durable facts from its own sessions instead — or when asking why the agent keeps re-learning the same correction, why a remembered rule is wrong, or where a memory line came from. Implements a four-tier store (L0 transcripts / L1 candidates / L2 project context / L3 stable persona) where promotion is earned by recurrence across sessions and days, never by one confident statement, and nothing reaches a committed file without a human adopting it.