# Content Marketing

> Use when the user describes a content marketing goal at a high level ("publish a post on X", "launch a campaign about Y", "build next quarter's calendar") and isn't sure which specific skill to use. Routes the request to the right downstream skill or chains multiple skills into an end-to-end flow.

- Skill: `busyeugene/content-marketing` (Agent Skill)
- Install (CLI): `npx skillmds@latest add busyeugene/content-marketing`
- Raw SKILL.md: https://api.skillmd.com/api/skills/busyeugene/content-marketing/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Marketing & Growth
- License: MIT
- Author: busyeugene (https://skillmd.com/u/busyeugene)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/busyeugene/content-marketing

---


# Content Marketing — Router

Optional orchestrator for the Content Marketing Skills library. Interprets a high-level goal and either dispatches to one downstream skill or chains several into a complete flow. All downstream skills work standalone; this router just saves you from remembering which to call when.

## When this skill fires

Trigger this skill when the user says things like:

- "Write me an article about {topic}"
- "Launch a content campaign for {product feature}"
- "Plan next quarter's content"
- "Turn this blog post into everything" (repurpose flow)
- "Audit our content and tell me what to fix"

Don't fire this skill when the user names a specific task ("draft editorial guidelines", "run an SEO audit") — let the specific skill handle it directly.

## Setup

No keys of its own. Downstream skills check their own setup.

## Routes

The router recognizes these flows. For each, it confirms the plan with the user before running, then invokes skills in order. Each step's output becomes the next step's input.

### Flow A — "Write me an article about X"

**Skills:** `content-brief` → `blog-post` → `proofreading-style-check`

1. If `editorial-guidelines.md` is missing at the project root, pause and run `editorial-guidelines` first.
2. Run `content-brief` with the user's keyword or topic → produces `briefs/<slug>.md`.
3. Run `blog-post` against the brief → produces `posts/<slug>.md`.
4. Run `proofreading-style-check` against the draft → produces `review/<slug>-report.md`.
5. Stop. Report the three paths and the review verdict.
6. If the user then says "publish it", run the next flow.

### Flow B — "Publish this draft"

**Skills:** (optional) `proofreading-style-check` → `publish-webflow` or `publish-wordpress`

1. Ask which CMS. If not obvious from env vars, use `AskUserQuestion`.
2. If the draft hasn't been reviewed yet, run `proofreading-style-check` first and require zero critical findings before publishing.
3. Run the chosen publish skill in `draft` mode by default.
4. Report the post URL.

### Flow C — "Launch a campaign about X"

**Skills:** `content-brief` → `blog-post` → `proofreading-style-check` → `landing-page-copy` → `email-copy` → `social-post` → `repurpose-linkedin-carousel` → `repurpose-threads-x`

1. Confirm the campaign anchor: usually a new blog post or a landing page.
2. Run the anchor skill first (blog-post or landing-page-copy).
3. Run the downstream copy skills in parallel where possible (email, social, carousel, thread).
4. Report every file created with a one-line "what to do with it".

### Flow D — "Plan next quarter's content"

**Skills:** `competitor-analysis` → `content-calendar`

1. If a recent competitor analysis (< 30 days old) already exists under `competitors/`, reuse it. Otherwise run `competitor-analysis` fresh.
2. Run `content-calendar` with the competitor data.
3. Offer to run `content-brief` for each must-write entry in batch (user opts in per entry).

### Flow E — "Audit our content"

**Skills:** `seo-audit` → `proofreading-style-check` (optional) → `content-calendar` (for refresh queue)

1. Run `seo-audit` against the domain.
2. For each declining or critical page flagged in the audit, optionally run `proofreading-style-check` against its local copy if the user has one, or suggest adding it to the refresh queue.
3. Run `content-calendar` in "refresh-only" mode to schedule the fixes.

### Flow F — "Turn this blog post into everything"

**Skills:** `social-post` + `repurpose-linkedin-carousel` + `repurpose-threads-x` + `email-copy` (newsletter issue)

1. Take one blog post path as input.
2. Run all four skills in parallel.
3. Report the bundle of artifacts produced.

## Process (general)

1. **Classify intent.** Read the user's request and match it to one of the flows above. If ambiguous, ask via `AskUserQuestion` with the flows as options.
2. **Preflight check.** Confirm `editorial-guidelines.md` exists; if not, propose running the interview first.
3. **Confirm the plan.** Before running anything, present a one-block plan:
   - Which skills will run, in what order
   - What files they'll read and write
   - Which env vars need to be set (list any missing ones upfront)
4. **Run sequentially.** Do not parallelize skills that write to overlapping paths. Parallelize only where noted in Flow C and Flow F.
5. **Handle failures gracefully.** If a downstream skill fails, stop the chain, preserve any artifacts created so far, and report the exact failure with the suggested fix.
6. **Report.** Print a summary: every file created, next logical action, any skipped steps with the reason.

## Fallbacks

- **Missing downstream skill:** if a skill folder is missing from `~/.claude/skills/`, name which one and tell the user how to install it.
- **Missing env vars:** surface the full list at the start of the plan, not mid-run.
- **User interrupts mid-flow:** always save partial artifacts; never roll back.

## Verification

1. The router never writes files of its own. All outputs are produced by the downstream skills.
2. Running the router on a flow and running the same skills manually in the same order produces identical outputs.
3. The end-of-flow report lists every file touched, in the order it was created.