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:

File	Purpose
./content-queue.json	Idea lifecycle state
./research/	Research results (by date + slug)

Commands

Parse user input, match first hit:

Input	Command	Action
/pipeline <topic>	run	Full pipeline: research -> ideate -> write -> queue
/pipeline url <url>	url	Extract from URL -> ideate -> write -> queue
/pipeline seed <idea>	seed	Add raw idea to queue as seed
/pipeline status	status	Show queue grouped by status
/pipeline review <id>	review	Show a draft for review
/pipeline approve <id>	approve	Mark as approved
/pipeline adapt <id> <platform>	adapt	Generate platform variant
/pipeline publish <id>	publish	Mark as published + timestamp
/pipeline clean	clean	Archive items published 30+ days ago

---

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:
2. Twitter/X search for relevant posts and threads
3. Web search for articles and data
4. Any domain-specific sources you have access to
5. 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}, ...]

1. Select the highest-scored angle
2. 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:
3. Content <= 280 chars -> short post (tweet)
4. 280-2000 chars -> long post (thread)

5. 2000 chars -> article

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

Stage 4: Queue

1. Read content-queue.json
2. Create new entry:
3. status: "drafted"
4. platform: target platform
5. research_file: relative path
6. hook_angle: selected angle description
7. draft: written text
8. Write back content-queue.json
9. 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:
2. status: "seed"
3. topic: the idea text
4. draft: null (seeds have no draft yet)
5. 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:
3. Different character limits
4. Different audience expectations
5. Different formatting norms
6. Store in variants.<platform> field
7. 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