# content-creator

Adopt this skill: https://proskills.md/skills/marketing/ijonis-geo-lint-skills-content-creator

Page: https://proskills.md/skills/marketing/ijonis-geo-lint-skills-content-creator
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/content-creator/SKILL.md
size: 8062
upstream: https://github.com/ijonis/geo-lint/blob/main/skills/content-creator/SKILL.md

```text
---
name: content-creator
description: >
  Self-configuring content creation pipeline with geo-lint validation.
  On first use, scans your project to learn its framework, content schema,
  categories, and authors, then creates SEO & GEO-optimized content matched
  to your brand voice. Validates every piece with geo-lint's 92 rules until
  zero violations. Triggers on: "content-creator", "create content",
  "write blog", "new post", "content calendar", "brand voice",
  "content strategy".
argument-hint: "setup | create [blog|page|project] | voice | calendar | refresh"
allowed-tools:
  - Bash(npx geo-lint*)
  - Bash(npm *)
  - Bash(node *)
  - Bash(python *brand_voice*)
  - Read
  - Write
  - Edit
  - Grep
  - Glob
  - WebSearch
  - AskUserQuestion
  - Agent
metadata:
  version: 1.0.0
  author: Alireza Rezvani
  contributors:
    - Jamin Mahmood-Wiebe
  category: marketing
  domain: content-creation
  updated: 2026-03-01
---

# Content Creator

Self-configuring content creation pipeline. Creates SEO & GEO-optimized content
matched to your project and brand voice, then validates with geo-lint until clean.

For project-specific rules (components, file naming, categories), the skill
generates a local `content-config` skill on first use via the `setup` workflow.

## Command Router

Parse `$ARGUMENTS` and route to the matching workflow:

| Argument | Workflow |
|----------|----------|
| `setup` | Auto-discover project, questionnaire, generate content-config |
| `create [blog\|page\|project]` | Full content creation pipeline |
| `voice` | Analyze and configure brand voice |
| `calendar` | Plan monthly content calendar |
| `refresh` | Re-scan project, update content-config |
| _(no args)_ | If no config exists → auto-trigger `setup`. Otherwise show commands. |

## Pre-Flight Check

Before any workflow except `setup`:

1. Check if `.claude/skills/content-config/SKILL.md` exists in the project root.
2. If missing → inform the user: "No project content config found. Running setup first..." Then auto-trigger the `setup` workflow.
3. If found → read it into context and proceed with the requested workflow.

---

## Workflow: setup

Three phases: auto-discover → questionnaire → generate.

### Phase 1: Auto-Discovery

Run these steps silently, collecting results into a discovery report:

**1. Framework Detection**
- Read `package.json` dependencies and devDependencies for: `next`, `astro`, `@astrojs/*`, `gatsby`, `hugo`, `nuxt`, `vite`, `remix`, `@11ty/eleventy`
- Check for config files: `next.config.*`, `astro.config.*`, `nuxt.config.*`, `gatsby-config.*`, `.eleventy.js`
- Record: framework name + version

**2. Content Directories**
- Search for common patterns: `content/`, `src/content/`, `posts/`, `blog/`, `pages/`, `articles/`, `src/pages/`
- If `geo-lint.config.ts` exists → read its `contentPaths`
- Record: all content directories and file extensions (`.md`, `.mdx`, `.astro`, `.html`)

**3. Frontmatter Schema**
- Read 5–10 representative content files across detected directories
- Parse YAML frontmatter (lines between `---` delimiters)
- Compute the union of all field names; classify each as required (present in >80% of files) or optional
- Record: field schema with types inferred from values

**4. Categories**
- Extract unique values from `category` and `categories` frontmatter fields across all content
- Cross-reference with `geo-lint.config.ts` `categories` array if present
- Record: canonical category list

**5. Authors**
- Extract unique `author` values from all content frontmatter
- Record: author names

**6. Locales & i18n**
- Detect from: frontmatter `locale` fields, file naming patterns (`.de.mdx`, `.en.mdx`), directory patterns (`/de/`, `/en/`)
- Check `geo-lint.config.ts` i18n config if present
- Record: locales and default locale

**7. Site URL**
- Check in order: `geo-lint.config.ts` siteUrl → `package.json` homepage → framework config `site`/`url` field
- Record: URL or "not found"

**8. Image Directories**
- Search for: `public/images/`, `static/images/`, `assets/images/`, `src/assets/`
- Record: directories found

**9. Components (MDX projects only)**
- If `.mdx` files exist → scan for JSX component usage patterns (`<ComponentName`)
- Exclude standard HTML tags
- Record: component names found

### Phase 2: Questionnaire

Present the discovery summary as a formatted table. Then use `AskUserQuestion` to gather:

1. **Confirm discoveries** — "Here's what I found about your project: [table]. Is this correct? Any corrections?"
2. **Brand voice archetype** — Options from `references/brand_guidelines.md`: The Expert, The Friend, The Innovator, The Guide, The Motivator. Allow primary + secondary selection.
3. **Tone attributes** — Pick 3–5 from: Authoritative, Friendly, Innovative, Trustworthy, Inspiring, Educational, Witty
4. **Target audience** — Free text (e.g., "B2B decision-makers in manufacturing, CTOs")
5. **Content goals** — Free text (e.g., "thought leadership, lead generation, brand awareness")

### Phase 3: Generation

1. **Generate `.claude/skills/content-config/SKILL.md`** in the project root using the Content-Config Template below. Fill all `[placeholders]` with discovered and questionnaire data.

2. **geo-lint.config.ts** — if it does not exist:
   - Generate it with discovered `siteUrl`, `contentPaths`, `categories`, and `geo.brandName` if known
   - Install `@ijonis/geo-lint` as a devDependency if not present

3. **geo-lint.config.ts** — if it exists but is missing discovered data:
   - Propose additions (new categories, new contentPaths) for user confirmation

4. **Validation test** — run `npx geo-lint --format=json` to confirm config loads correctly

5. Report: "Setup complete. Your content pipeline is ready. Run `/content-creator create` to start."

---

## Workflow: create

Full content creation pipeline with built-in validation.

### Step 1: Load Project Config

Read `.claude/skills/content-config/SKILL.md` for project-specific rules: content schema, brand voice, categories, components, file naming conventions, languages.

### Step 2: Topic & Type

Ask the user for:
- **Topic or title** for the new content piece
- **Content type** — blog, page, or project (default: blog)

### Step 3: Duplicate & Overlap Gate (MANDATORY)

Scan ALL existing content (titles, slugs, descriptions) before proceeding:

| Finding | Action |
|---------|--------|
| Exact duplicate (same topic + angle) | **Stop.** Suggest updating the existing post instead. |
| Substantial overlap (same topic, different angle) | **Stop.** Propose a clearly differentiated angle. Get user approval before proceeding. |
| Tangential overlap (related topic, distinct focus) | **Proceed.** Note the related post for cross-linking. |
| No overlap | **Proceed.** |

Report which existing posts were checked and the gate result.

### Step 4: Keyword & Search Research (MANDATORY)

Use `WebSearch` to research the topic. Follow the **purchase-intent-first** strategy:

1. Search for trending angles, competitor coverage, and keyword variations
2. Identify: 1 primary keyword, 3–5 secondary keywords, 10–15 LSI keywords
3. Explicitly mine for purchase-intent keywords (e.g., +pricing/cost, +provider/agency, +comparison/vs/alternative; for German markets also +Kosten, +Anbieter, +Vergleich)
4. Run the SERP Viability Filter for the primary keyword:
   - **Authority Check** — are top results Wikipedia/Forbes (red flag) or mid-size blogs (green flag)?
   - **Intent Check** — are ranking results blog posts (match) or product pages (mismatch)?
   - **Coverage Check** — does the site already rank for this? (`site:domain "[keyword]"`)
   - **Long-Tail Check** — does a long-tail variant have community demand?
5. Document: confirmed primary keyword with 2–3 sentence rationale, intent classification, differentiation angle

### Step 5: Select Template

Load `references/content_frameworks.md`. Choose the best template for the topic:
- **How-To Guide** — prerequisites → steps → troubleshooting → results
- **Li
```

## File: README.md
upstream: https://github.com/ijonis/geo-lint/blob/main/README.md

````text
# @ijonis/geo-lint

**The first open-source linter for GEO (Generative Engine Optimization). Validates your content for AI search visibility -- then lets your AI agent fix it automatically.**

[![npm version](https://img.shields.io/npm/v/@ijonis/geo-lint)](https://www.npmjs.com/package/@ijonis/geo-lint)
[![CI](https://img.shields.io/github/actions/workflow/status/ijonis/geo-lint/ci.yml?branch=main&label=CI)](https://github.com/IJONIS/geo-lint/actions)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/IJONIS/geo-lint/blob/main/LICENSE)
[![Claude Code Skill](https://img.shields.io/badge/Claude_Code-Skill-blueviolet)](https://github.com/IJONIS/geo-lint)

![geo-lint demo](docs/demo.gif)

---

## Use with Claude Code

Install the geo-lint skill in one command:

```bash
curl -fsSL https://raw.githubusercontent.com/IJONIS/geo-lint/main/install.sh | bash
```

Then in any Claude Code session:

```
/geo-lint audit        # Full sweep — find and fix all violations
/geo-lint fix <slug>   # Fix a single content file
/geo-lint rules        # Show all 97 rules with fix strategies
/geo-lint init         # Set up geo-lint.config.ts for a new project
/geo-lint report       # Generate a GEO/SEO health summary
```

The skill runs an autonomous lint-fix loop: scan your content, read structured violations, fix them using each violation's `suggestion` field, and re-lint until clean. Parallel subagents handle multiple files simultaneously.

### Content Creation Pipeline

The install also adds `/content-creator` -- a self-configuring content pipeline that creates SEO & GEO-optimized content matched to your project:

```
/content-creator setup      # Auto-discover your project + configure brand voice
/content-creator create      # Create content with keyword research + validation
/content-creator voice       # Analyze and adjust brand voice
/content-creator calendar    # Plan monthly content calendar
/content-creator refresh     # Update config when your project evolves
```

On first use, the skill scans your project to learn its framework, content schema, categories, and authors. It then asks a few questions about your brand voice and audience. From that point on, every piece of content is created with full project awareness and validated against geo-lint's 97 rules until clean -- zero manual intervention for mechanical quality.

Or paste this into **any** AI agent (Claude Code, Cursor, Windsurf, Copilot):

```
Run npx geo-lint --format=json, then fix every violation using each
violation's suggestion field. Re-run until the output is [].
```

---

## Why this exists

I run multiple content-heavy sites and there was no deterministic way to validate whether my content was actually optimized -- not "probably fine," but actually checked against concrete rules. SEO linters exist, but they're either paid SaaS, not automatable, or completely ignore the structural patterns that AI search engines use when deciding what to cite.

So I built one. **GEO (Generative Engine Optimization)** is the practice of structuring content so it gets cited by ChatGPT, Perplexity, Google AI Overviews, and Gemini. Traditional SEO gets you into search result lists. GEO gets you **cited in AI-generated answers**. Both matter -- and no existing open-source tool checks for GEO.

The goal was simple: install one tool, point your AI agent at it, and walk away. The agent runs the linter, reads the JSON violations, fixes the content, re-lints until clean -- across an entire site, no manual input. One command, both SEO and GEO validated.

**97 rules: 36 GEO, 34 SEO, 14 content quality, 10 technical, 3 i18n.** Readability analysis inspired by Yoast SEO. We researched the current state of GEO and AEO to make sure the rules reflect what actually gets content cited -- not outdated advice.

---

## Quick Start

```bash
npm install -D @ijonis/geo-lint
```

Create `geo-lint.config.ts`:

```typescript
import { defineConfig } from '@ijonis/geo-lint';

export default defineConfig({
  siteUrl: 'https://your-site.com',
  contentPaths: [{
    dir: 'content/blog',
    type: 'blog',
    urlPrefix: '/blog/',
  }],
});
```

Run it:

```bash
npx geo-lint                  # Human-readable output
npx geo-lint --format=json    # Machine-readable for AI agents
```

Works out of the box with `.md`/`.mdx` files. For Astro, HTML, or other formats, see [Custom Adapters](docs/custom-adapters.md).

---

## GEO in Action

Three examples of what GEO rules catch and how to fix them. See [all 7 core GEO rules with examples](docs/geo-rules.md).

### `geo-weak-lead-sentences`

AI systems use the first sentence after a heading as the citation snippet. Filler openings get skipped.

**Before:**
```markdown
## What is serverless computing?

In this section, we will take a closer look at serverless computing and
what it means for modern development teams.
```

**After:**
```markdown
## What is serverless computing?

Serverless computing is a cloud execution model where the provider
dynamically allocates compute resources per request, eliminating the
need to provision or manage servers.
```

### `geo-low-citation-density`

AI answers prefer citable claims backed by numbers. Vague statements get passed over.

**Before:**
```markdown
Adopting TypeScript significantly reduces bugs in large codebases.
```

**After:**
```markdown
Adopting TypeScript reduces production bugs by 38% in codebases
exceeding 50,000 lines of code, according to a 2023 study by
Microsoft Research.
```

### `geo-missing-table`

Tables are highly structured and unambiguous -- ideal for AI extraction. Content with comparison tables is cited significantly more often than equivalent prose.

**Before:**
```markdown
React is component-based and uses a virtual DOM. Vue is also
component-based but uses a reactivity system. Svelte compiles
components at build time.
```

**After:**
```markdown
| Framework | Architecture     | Bundle Size | Learning Curve |
|-----------|------------------|-------------|----------------|
| React     | Virtual DOM      | 42 KB       | Moderate       |
| Vue       | Reactivity proxy | 33 KB       | Low            |
| Svelte    | Compile-time     | 1.6 KB      | Low            |
```

---

## All 97 Rules

| Category | Rules | Severity Mix | Focus |
|----------|-------|-------------|-------|
| SEO | 34 | 6 errors, 28 warnings | Titles, descriptions, headings, slugs, OG images, canonical URLs, keywords, links, schema, sameAs, service pages |
| Content | 14 | 2 errors, 12 warnings | Word count, readability, dates, categories, jargon density, repetition, vocabulary diversity, transition words, sentence variety |
| Technical | 10 | 3 errors, 7 warnings | Broken links, image files, trailing slashes, external URLs, performance, feeds, llms.txt |
| i18n | 3 | 0 errors, 3 warnings | Translation pairs, locale metadata |
| GEO | 36 | 0 errors, 36 warnings | AI citation readiness: E-E-A-T signals, content structure, freshness, RAG optimization, author entity type |

See the [complete rule reference](docs/rules.md) with descriptions and severity for every rule.

---

## Works With

**AI agents**: Claude Code, Cursor, Windsurf, GitHub Copilot -- any agent that can run shell commands and edit files

**Content formats**: Markdown and MDX out of the box. Astro, HTML, Nuxt, any CMS via [custom adapters](docs/custom-adapters.md)

**Build tools**: Runs in any CI pipeline. JSON output for programmatic consumption

**Runtime**: Node.js >= 18. Zero peer dependencies

---

## Agent-First Design

This linter is **deterministic** -- same content in, same violations out, every time. Your AI agent provides the creativity to fix the content; geo-lint provides the guardrails to verify it's correct. The loop runs until violations hit zero.

### Claude Code Plugin

Install the skill and use `/geo-lint audit` to validate and fix your entire content directory automatically. The skill runs the full lint-fix loop with parallel subagents -- one per file. See [
````
