Content Pipeline

Content Pipeline Orchestrator

One command, from topic to review-ready draft. Research -> Ideate -> Write -> Queue

When to use vs. not

Use pipeline (original content that needs research):

• Writing from scratch on a topic you haven't deeply explored
• Need to survey existing discussion, find data, pick an angle
• Example: "write about the impact of MoE on local inference" / "year-end market review"

Don't use pipeline (already have material):

• Quoting someone else's post -> just write directly
• Replying/commenting -> just write directly
• Polishing an existing draft -> just edit directly
• These scenarios waste 4-5x tokens through the pipeline with zero benefit

File locations

Configure these paths for your project:

Commands

Parse user input, match first hit:

Queue data model

File: ./content-queue.json

{
  "ideas": [
    {
      "id": 1,
      "topic": "AI Agent end-to-end automation",
      "status": "drafted",
      "platform": "twitter",
      "created": "2026-03-03T15:00:00Z",
      "updated": "2026-03-03T15:05:00Z",
      "research_file": "research/20260303-ai-agent-automation.md",
      "hook_angle": "Builder perspective: Writing is easy, Research is the bottleneck",
      "draft": "This person built a full...",
      "variants": {},
      "source_url": null,
      "feedback": [],
      "published": null
    }
  ],
  "next_id": 2
}

Status flow: seed -> researched -> drafted -> approved -> published -> archived

Queue read/write rules

1. Read: Read ./content-queue.json
2. Write: Write back complete JSON (single-user, no concurrency issue)
3. ID assignment: Use next_id, increment after write
4. Timestamps: ISO 8601 with timezone

Command details

/pipeline -- Full Pipeline

Input: topic (keywords or short phrase)

Stage 1: Research

1. Search for existing discussion on the topic using available search tools:
   • Twitter/X search for relevant posts and threads
   • Web search for articles and data
   • Any domain-specific sources you have access to
2. Compile findings into a research file:

   ./research/YYYYMMDD-{slug}.md
   

   slug = topic keywords, lowercase with hyphens, max 30 chars

Research file format:

# Research: {topic}
**Date**: YYYY-MM-DD
**Sources**: [list search methods used]

## Key findings
- [Finding 1 + source attribution]
- [Finding 2 + data/numbers]
- [Finding 3 + opposing viewpoint]

## Notable posts/articles
1. @user1 (N likes): "Core point summary"
2. @user2 (N likes): "Core point summary"

## Data points
- [Specific numbers, comparisons, statistics]

## Opposing viewpoints
- [Contrarian takes, if any]

## Source links
- [List of original URLs]

Stage 2: Ideate

1. Read the research file
2. Generate 3 hook angles based on the research:

Angle generation prompt (adapt for your LLM of choice):

You are a content strategist. Based on the following research, generate 3 hook angles for a post.

Research:
{research file content}

Requirements:
1. Each angle includes:
   - Hook type (contrast / counterintuitive / data-driven / story / question)
   - Core thesis (one sentence)
   - Key supporting points (2-3)
   - Estimated virality score (1-5)
2. Match the creator's voice and domain expertise
3. Avoid: AI cliches, marketing speak, listicle format

Output as JSON array:
[{"type": "contrast", "thesis": "...", "supports": ["...", "..."], "score": 4}, ...]

3. Select the highest-scored angle
4. If multiple angles tie, present options for user to choose

Stage 3: Write

1. Write the draft using the selected hook angle + research data points
2. Content format routing:
   • Content <= 280 chars -> short post (tweet)
   • 280-2000 chars -> long post (thread)

   • 2000 chars -> article

3. Apply your preferred writing style/voice (integrate with a style skill if you have one)
4. Verify all claims have source attribution from the research

Stage 4: Queue

1. Read content-queue.json
2. Create new entry:
   • status: "drafted"
   • platform: target platform
   • research_file: relative path
   • hook_angle: selected angle description
   • draft: written text
3. Write back content-queue.json
4. Output confirmation:

   Pipeline complete -- queued #<id>
   Topic: <topic>
   Hook: <angle summary>
   Draft: <first 80 chars>...
   Format: short / long / article
   Use /pipeline review <id> to see full content
   

/pipeline url -- From URL input

1. Fetch the URL content using available tools
2. Extract core arguments and data points
3. Skip Stage 1 (use extracted content as research)
4. Continue to Stage 2 (ideate) -> Stage 3 (write) -> Stage 4 (queue)
5. Record source_url in the entry

/pipeline seed -- Add raw seed

1. Create queue entry:
   • status: "seed"
   • topic: the idea text
   • draft: null (seeds have no draft yet)
2. Output: Seed added to queue #<id>

Seeds are raw ideas waiting to be developed. Run /pipeline <topic> later to expand a seed through the full pipeline.

/pipeline status -- Queue status

Read content-queue.json, output grouped by status:

Content Pipeline Status

Seed (N):
  #3 "Multi-agent orchestration" -- 3/3 15:00

Drafted (N):
  #1 "AI Agent automation" -- 3/3 15:05
  #2 "Market arbitrage math" -- 3/3 16:20

Approved (N):
  #5 "MCP practical experience" -- 3/2 20:00

Published (N):
  #4 "Three-layer scraping approach" -- 3/1

Total: N items | Pending: seed(N) + drafted(N)

Show only non-archived items. If over 20 items, show most recent 20 + total count.

/pipeline review -- Review

1. Find the entry in queue
2. Display full info:

Review #<id>

Topic: <topic>
Status: <status>
Hook: <hook_angle>
Created: <created>

--- Draft ---
<full draft text>

--- Variants ---
[list any platform variants]

--- Research ---
File: <research_file>
[first 5 key findings if research file exists]

Actions:
  /pipeline approve <id> -- approve for publishing
  /pipeline adapt <id> <platform> -- generate platform variant

/pipeline approve -- Approve

1. Change status to "approved"
2. Update updated timestamp
3. Output: #<id> approved -- ready to publish

/pipeline adapt -- Multi-platform adaptation

Adapt the draft for a different platform:

1. Read the entry's draft
2. Rewrite for the target platform's conventions:
   • Different character limits
   • Different audience expectations
   • Different formatting norms
3. Store in variants.<platform> field
4. Output: <platform> variant generated -- /pipeline review <id> to see

/pipeline publish -- Publish marker

1. Change status to "published"
2. Record published timestamp
3. Output: #<id> marked as published

/pipeline clean -- Archive cleanup

1. Scan all published entries
2. Archive entries older than 30 days
3. Output: Archived N old entries

Design principles

• Research and Ideate stages are platform-agnostic -- only the Write stage adapts for platform
• One research effort can produce content for multiple platforms ("one fish, many meals")
• Drafts should be source-verified before entering the queue -- no unsourced claims
• Seeds are cheap to capture, expensive to develop -- capture freely, develop selectively
• The pipeline is a framework, not a straitjacket -- skip stages when you already have what you need