content-strategy
Use when you need a content plan to grow organic traffic for a product or new area — produces keyword research, topic clusters, and a content calendar targeting your category.
Best use case
content-strategy is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Use when you need a content plan to grow organic traffic for a product or new area — produces keyword research, topic clusters, and a content calendar targeting your category.
Teams using content-strategy should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/content-strategy/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How content-strategy Compares
| Feature / Agent | content-strategy | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Use when you need a content plan to grow organic traffic for a product or new area — produces keyword research, topic clusters, and a content calendar targeting your category.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Content Strategy
Content strategy is the intersection of what your audience searches for, what
you have authority to say, and what supports your business goals. This skill
helps you build a data-driven content plan — not a random blog schedule.
## Core Framework
```text
Business Goal → Target Audience → Keyword Research → Topic Clusters → Content Calendar
```
## Step 1: Define Your Content Goals
```text
> Help me define a content strategy for [product/company]:
>
> Product: [what you sell]
> Target customer: [who they are, what they care about]
> Business goal: [increase signups / build authority / retain users / etc.]
> Current content state: [have nothing / have a blog / have docs but no marketing content]
>
> What type of content strategy would best serve these goals?
```
Content strategy types:
- **SEO-led**: Target high-volume keywords; build organic traffic at scale
- **Authority-led**: Publish original research, opinions, and deep expertise
- **Product-led**: Content that drives product usage (tutorials, use cases)
- **Community-led**: User-generated content, forums, templates
## Step 2: Keyword Research
### Seed Keywords
```text
> I'm building a content strategy for [product/niche].
>
> Generate 20 seed keywords organized by intent:
> - Informational (how-to, what-is, learn)
> - Commercial (best, vs, review, alternatives)
> - Transactional (buy, sign up, free trial)
>
> For each keyword, estimate: search volume (rough order: hundreds / thousands / 10k+),
> competition level (low / medium / high), and funnel stage (awareness / consideration / decision)
```
### Long-tail Expansion
```text
> For the seed keyword "[main keyword]":
> Generate 15 long-tail variations that:
> - Have lower competition
> - Address specific use cases
> - Include question-format keywords (who, what, how, why, when)
>
> These should represent real queries your target users would type.
```
### Content Gap Analysis
```text
> Our top competitors in this space are: [Competitor A, B, C]
>
> Based on what I know about their content strategies, what topic areas
> are likely underserved that we could own?
>
> Prioritize by: search demand, our credibility to publish on this topic,
> and strategic differentiation value.
```
## Step 3: Topic Cluster Architecture
Build content clusters to establish authority in a topic area:
```text
> Design a topic cluster for the pillar keyword: "[main topic]"
>
> Include:
> 1. Pillar page (comprehensive 3,000+ word guide on the main topic)
> 2. 8-12 cluster pages (specific subtopics that link to and from the pillar)
> 3. Supporting content (comparison pages, case studies, tools)
>
> For each piece, define:
> - Target keyword
> - Search intent
> - Unique angle (why ours > existing content)
> - Estimated word count
> - Internal link connections
```
Example cluster for "product analytics":
- Pillar: "The Complete Guide to Product Analytics"
- Cluster: "How to Set Up Funnel Analysis", "Product Analytics vs. Web Analytics", "Best Product Analytics Tools", etc.
## Step 4: Content Calendar
```text
> Create a 12-week content calendar based on this strategy:
>
> Publishing cadence: [2x per week / 1x per week / 2x per month]
> Content types: [blog posts / videos / case studies / newsletters]
> Priority order: [highest-value content first]
>
> Format as a Markdown table:
> | Week | Content Title | Type | Target Keyword | Goal | Status |
```
## SQL Content Tracker
```sql
CREATE TABLE content_pieces (
id TEXT PRIMARY KEY,
title TEXT NOT NULL,
target_keyword TEXT,
content_type TEXT, -- blog | video | case_study | guide | landing_page
funnel_stage TEXT, -- awareness | consideration | decision
estimated_volume TEXT, -- hundreds | thousands | 10k+
competition TEXT, -- low | medium | high
priority_score REAL,
status TEXT DEFAULT 'planned', -- planned | in_progress | published | updating
published_url TEXT,
notes TEXT
);
-- Query by priority
SELECT title, target_keyword, funnel_stage, competition, status
FROM content_pieces
WHERE status = 'planned'
ORDER BY priority_score DESC;
```
## Content Brief Generator
For each content piece, generate a brief:
```text
> Write a content brief for: "[article title]"
>
> Target keyword: [keyword]
> Search intent: [what the user wants]
> Target audience: [who is reading this]
>
> Include:
> 1. H1 and meta description (with keyword)
> 2. Outline with H2/H3 structure
> 3. Key points to cover (must-have vs. nice-to-have)
> 4. Competitor gaps to address (what they miss that we should include)
> 5. Internal links to include
> 6. Call-to-action recommendation
```
## Content Performance Review
```text
> Analyze this content's performance:
>
> URL: [URL]
> Current position: [rank]
> Traffic: [monthly visitors]
> Conversions: [signups/leads]
>
> What should we do:
> A) Update and expand (if ranking 4-15, content is good but needs improvement)
> B) Consolidate (if similar content is cannibalizing)
> C) Deprecate (if no traffic, no conversions, no strategic value)
> D) Leave as-is (if ranking 1-3 and converting well)
```
## Tips
- **Pillar pages are your highest-leverage investment**: One great 3,000-word guide outperforms ten thin posts
- **Update before creating**: Refreshing a page ranking #8 to #3 is faster than ranking a new page
- **Keyword intent > keyword volume**: A 200-search/month "how to migrate from [Competitor]" keyword converts better than a 50,000/month generic term
- **Build for both humans and AI**: Structure your content to be cited by AI systems (see `ai-visibility` skill) AND scanned by human readers
- **Measure conversion, not just traffic**: Content that drives signups is worth 10x content that drives viewsRelated Skills
launch-strategy
Use when you're preparing to launch a product or feature publicly — builds a structured checklist covering positioning, distribution, messaging, and success metrics from private beta to GA.
multi-model-strategy
Use when choosing which AI model to use for a task — pick the right model family and tier based on cost, speed, context needs, and reasoning depth
verification-before-completion
Use before claiming any task is done — run the exact command that proves the fix works, read the output, and only then report success.
using-git-worktrees
Use when you need multiple branches checked out at once — create isolated working directories for parallel development without cloning the repository repeatedly
triage
Use when a single issue needs structured triage — classify it, reproduce if needed, request missing information, and leave a durable brief or close-out note in the tracker.
to-issues
Use when a plan, spec, or PRD must become an actionable backlog — break it into thin dependency-aware issues that each deliver a verifiable vertical slice
sprint-workflow
Use when starting a new feature, refactor, or multi-step dev task — runs the full sprint cycle (Think → Plan → Build → Review → Test → Ship → Monitor) using Copilot CLI's plan/autopilot modes.
sprint-retro
Use at the end of a sprint to run a data-driven retrospective — analyzes session history and git metrics to surface what shipped, what slowed you down, and concrete improvements.
security-audit
Use when a codebase needs a formal security audit beyond a quick scan — applies OWASP Top 10 and STRIDE threat modeling from a CSO perspective to surface systemic vulnerabilities.
release
Use when a sprint or feature is complete and ready to ship — tags the version, generates GitHub Release notes, runs rollout or smoke verification, and publishes to npm/PyPI/Docker registries.
prompt-optimizer
Use when a rough prompt, vague idea, or task description needs to become a finished copy-pasteable prompt for a chat-based LLM - rewrite it into one ready-to-send prompt with no blanks, no placeholders, and a clear output shape.
outside-voice
Use when you need an independent second opinion before, during, or after implementation — run challenge, consult, or review mode in a direct builder-to-builder voice