← Back to chapters

Content Creation Automation

Beginner-Friendly Teaching Edition  ·  Claude Code as a general-purpose AI workstation
What you will learn
The author's real daily content pipeline — topic selection, research, writing, proofreading, images, publishing — run almost entirely through Claude Code. You will see a CLAUDE.md routing system, shared rules, how to build a Skill from scratch, a full topic-to-publication demo, multi-agent parallelism, and how Skills + Hooks + MCP form a complete "AI employee."
Router CLAUDE.mdShared rulesSkillsFull workflowParallel agentsSkills+Hooks+MCP

The Big Idea

Claude Code's most underrated capability is not writing code. The author runs a media operation: ~30% of time on AI-assisted development, ~70% on content (WeChat articles, Xiaohongshu posts, video scripts, research reports). For a long time he used Claude Code for development and a chat web interface for writing — and every switch to the web version lost all the rules and preferences built up in Claude Code, forcing him to re-explain everything.

Easy way to remember:
Moving the writing rules into CLAUDE.md, then adding Skills, then building a full pipeline, may be the most valuable thing the author has done with Claude Code — not any coding project. It saves time every single day.

Why This Topic Matters

  • Any work with repetitive output — writing, marketing, PM work — can use this approach directly.
  • It is the clearest demonstration that Claude Code is a general-purpose AI workstation, not just a programming tool. The book calls this "the single most important point."
  • Nothing here requires writing code: a CLAUDE.md is a rules document, a Skill is an operations manual, MCP config is a few parameters.

Step 1 — The CLAUDE.md Routing System

One project needs one CLAUDE.md. Multiple work contexts (writing, development, video) need a routing system: a root CLAUDE.md acts as a traffic controller — it reads what you say, works out what you are doing, and loads the matching subdirectory CLAUDE.md.

Writing/
├── CLAUDE.md              <- Router (~8KB)
├── 01-WeChat/
│   ├── CLAUDE.md          <- Full rules for WeChat articles
│   └── projects/
├── 02-Xiaohongshu/
│   ├── CLAUDE.md          <- Xiaohongshu writing rules
│   └── projects/
├── 03-Video/
│   ├── CLAUDE.md          <- Video script rules
│   └── projects/
├── 04-References/
│   └── SHARED-RULES.md    <- Cross-workspace shared rules
├── .claude/skills/        <- 27 Skills
└── 10-OrangeBook/         <- The book itself

Code example: the routing table in the root CLAUDE.md

## Workspace Routing
After receiving a task, determine the workspace and load the corresponding CLAUDE.md:

| Keywords                        | Workspace       | Load File                 |
|---------------------------------|-----------------|---------------------------|
| article, sponsorship, WeChat    | WeChat Writing  | /01-WeChat/CLAUDE.md      |
| Xiaohongshu, notes, image-text  | Xiaohongshu     | /02-Xiaohongshu/CLAUDE.md |
| video script, video production  | Video           | /03-Video/CLAUDE.md       |
| Orange Book, epub               | Orange Book     | /10-OrangeBook/CLAUDE.md  |

Routing principle: ambiguous task -> ask for clarification.
Multiple workspaces involved -> load each.

Explaining the flow

When you say "write a WeChat article about Claude Code," Claude Code:

  1. Reads the root CLAUDE.md, spots the keyword "WeChat" → matches the WeChat Writing workspace
  2. Automatically loads /01-WeChat/CLAUDE.md and applies its writing rules
  3. Starts working according to the WeChat style guidelines

Benefits: the root CLAUDE.md stays lean (~8KB) and does not waste context; each workspace's rules are maintained independently without interference; adding a workspace is one new routing line.

Remember: the core idea is one entry point, multiple destinations. You do not need to copy this structure exactly.

Step 2 — Shared Rules for Cross-Project Consistency

Some rules belong to no single workspace — they apply to all content, e.g.:

  • Research should draw from sources within the past 3 months
  • Three-pass proofreading (content review → style review → detail review)
  • Image workflow (screenshot → AI-generated image → upload to image host)
  • File naming conventions

These live in SHARED-RULES.md, referenced by every workspace's CLAUDE.md.

The three-pass proofreading process

PassFocusWhat it checks
1. Content reviewSubstanceFactual accuracy, logical flow, structural completeness. Do not touch writing style in this pass.
2. Style review"AI-ness"The six AI patterns (see table below)
3. Detail reviewPolishSentence length 15–25 words, paragraph spacing, ~10 bold highlights per article, quotation mark style, em-dash usage (at most 1–2 in the whole piece)

The six "AI pattern" tells and their fixes

Pattern typeExampleHow to fix
Filler phrases"In today's era," "To summarize," "It's worth noting that"Delete entirely — meaning is preserved
AI sentence structures"Not A, but B," "Not only A, but also B"Replace with natural, conversational transitions
Overly formal language"possess," "exhibit," "embody," "empower"Swap for everyday vocabulary
Mechanical structureEvery paragraph starts with "First / Second / Finally"Vary the order; use narrative flow
Neutral stanceWishy-washy both-sides-ism that offends no oneTake a clear, explicit position
Missing specifics"Many users report…" (How many? Who?)Add concrete numbers and names

Once these rules are in SHARED-RULES.md, Claude applies them in every workspace, and you can trigger a review any time with the /proofreading Skill.

Step 3 — Create Your First Skill (from scratch)

# Create the skill directory inside your project
mkdir -p .claude/skills/huashu-proofreading

Code example: the SKILL.md

---
name: proofreading
description: |
  Three-pass proofreading workflow to reduce AI detection rate below 30%.
  Auto-trigger: user says "proofread," "less AI-sounding," "too robotic," "revise this"
  Manual trigger: /proofreading
---
# Three-Pass Proofreading

## Pass 1: Content Review
- Fact-check: verify all data, dates, version numbers
- Logic check: confirm cause-and-effect relationships hold
- Structure check: identify any missing key points

## Pass 2: Style Review
Check for the following 6 AI patterns (see table) and fix each:
1. Filler phrases -> delete
2. AI sentence structures -> rewrite as conversational
3. Overly formal language -> replace with everyday words
4. Mechanical structure -> vary; use narrative flow
5. Neutral stance -> add a clear personal position
6. Missing specifics -> add concrete data

## Pass 3: Detail Review
- Sentence length: aim for 15-25 words
- Paragraph length: 3-5 sentences
- Bold highlights: roughly 10 per article
- Quotation marks: use the correct regional style
- Em-dashes: at most 1-2 in the entire piece

Explaining the code

  • The front-matter description tells Claude when to auto-trigger (keywords like "proofread," "too robotic") and the manual trigger (/proofreading).
  • The three ## sections are the exact checklist Claude runs, in order, on the current document.
  • After it is written, typing /proofreading runs the workflow; saying "proofread this for me" triggers it by keyword.
Mental shift: Skills are written for the AI, not for you. You do not memorise the checks — you remember one command. Every detail is encapsulated in the Skill.

The author's 27-Skill library (a sample)

CategorySkillWhat it does
Writing/proofreadingThree-pass proofreading
Writing/article-editArticle editing with progress tracking
Writing/topic-genGenerates 3–4 topic directions
Writing/article-to-xAdapts WeChat articles into X (Twitter) threads
Video/video-outlineVideo script outline with title strategy
Video/script-polishScript refinement
Video/danmaku-genGenerates live comment / bullet-chat copy
Research/researchStructured research with auto-archiving
Research/info-searchInformation search with source verification
Research/material-searchSearches personal asset library
Publishing/book-pdfFull Orange Book build pipeline
Publishing/md-to-pdfMarkdown to PDF conversion
Images/image-uploadAI image generation + upload to image host
Images/designInfographic design
Integration/feishuCreate and send Feishu documents

The 27 Skills accumulated over about two months — each one emerged from a repetitive operation in daily work.

Step 4 — Full Workflow Demo: From Topic to Publication

10:00
Topic selection. Open Claude Code in the writing project. "Claude Code recently shipped some new features. Help me brainstorm a few WeChat article topics…" Claude spots "WeChat," routes to that workspace, loads its rules, triggers /topic-gen → 3–4 topic directions, each with a title, outline, and effort estimate (★ to ★★★). Pick direction two (★★).
10:10
Research. "Start with research — gather Claude Code's major updates and user feedback." Triggers /research: (1) creates a research file immediately, (2) appends findings after each search round (prevents data loss if the session is interrupted), (3) an interim summary after 3 rounds, (4) a structured final report — key facts, sources, gaps, writing recommendations.
10:30
Draft. "Based on the findings, write a WeChat article. Save to projects/2026.04-Claude-Code-Updates/draft.md, around 3,000 words, clear personal opinion — don't write it like a press release." Claude creates the project directory and writes the draft to an .md file (a standing rule: articles go to a file, never directly in the reply, because replies disappear when the session ends).
11:00
Proofreading. /proofreading draft.md runs the three-pass review, outputs revision suggestions, and on confirmation edits the file directly. A typical pass catches 10–20 AI-pattern issues.
11:20
Images. "Create a cover image for this article." Claude generates a prompt from the article, calls an AI image generator, uploads the result to an image host, and inserts the URL. You just check whether you like it.
11:30
Publishing. "Send the article to a Feishu document." Triggers /feishu: converts the .md to Feishu format, creates the document via API, sets permissions, and delivers it. One final manual review, then copy into the WeChat editor and publish.
Result: topic selection to a publication-ready document in roughly ninety minutes. Without the system, the same work would take half a day.

Step 5 — Advanced: Multi-Agent Parallelism

The workflow above is sequential. Many steps can run in parallel. Writing this book, the author had four agents running at once:

# Terminal 1: Research Agent - finding the latest Claude Code updates
claude -p "Research Claude Code's major updates from the past three months..."

# Terminal 2: Writing Agent - drafting the extensibility chapter
claude -p "Based on the following outline, write the chapter..."

# Terminal 3: Proofreading Agent - reviewing a completed chapter
claude -p "Proofread fragments/part5-claude-md.html..."

# Terminal 4: Image Agent - creating visuals for the reviewed chapter
claude -p "Create an illustration for the first-project chapter..."

Each agent runs independently. Four at once improved the book's build efficiency several times over; API costs came to about $50 — far cheaper than hiring an assistant.

Parallelism requires task independence. If Agent B depends on Agent A's output, they cannot run in parallel. "Research first, then write" must be sequential. But "write chapter 3" and "write chapter 5" can run in parallel — different files, no conflict.

Step 6 — Skills + Hooks + MCP Working Together

ComponentRoleContent-workflow examples
CLAUDE.mdDefines rules and preferences — passive, auto-loaded every conversationRouting table, writing style, "write to a file not the reply"
SkillsEncapsulates workflows — triggered manually or by keywords/topic-gen, /research, /proofreading, /feishu
HooksAutomated checks — event-driven, no human involvementCheck filename conventions on create; format .md on edit; check for unresolved TODOs before commit
MCPConnects to the outside world — extends capability boundariesFeishu (create/edit docs), browser (operate Chrome), file system (reference material outside the writing dir)
If Claude Code were an employee: CLAUDE.md is the job handbook, Skills are the techniques they have learned, Hooks are the good habits they have internalised, and MCP is the set of tools they can use. Combine all four — a complete "AI employee" system.

Visual Mental Model: The Routing Pipeline

You: "write a WeChat article about X"
        │
   root CLAUDE.md (router, ~8KB)
        │  keyword "WeChat"
        ▼
   /01-WeChat/CLAUDE.md   +   SHARED-RULES.md
        │
   /topic-gen ─► pick one
        │
   /research  ─► research file (saved as it goes)
        │
   draft.md   ─► written to a FILE, not the reply
        │
   /proofreading ─► 3 passes, 10-20 fixes
        │
   image workflow ─► prompt -> generate -> upload -> insert URL
        │
   /feishu ─► doc created, permissions set ─► publish

Important Comparisons

One CLAUDE.mdRouting system
FitsA single project / contextMultiple contexts (writing, dev, video)
Root file sizeGrows with everythingStays lean (~8KB), only routes
Adding a contextMore clutter in one fileOne new routing line + a subdirectory CLAUDE.md
Sequential workflowParallel agents
WhenEach step needs the previous step's outputSteps are independent (different files)
ExampleResearch → draft → proofread"write chapter 3" & "write chapter 5" at once

Common Beginner Mistakes

  • Re-explaining rules in every new session instead of putting them in CLAUDE.md.
  • One giant CLAUDE.md for many unrelated contexts, wasting context window.
  • Mixing style edits into the content-review pass instead of keeping the three passes separate.
  • Letting the model write the article into the chat reply, which disappears when the session ends.
  • Research with no incremental saving — losing everything when the session compresses.
  • Running dependent tasks in parallel ("research" and "write" at the same time).
  • Trying to build 27 Skills at once instead of one at a time from real repetition.
  • Assuming this needs coding skills — it does not.

Best Practices

  • Root CLAUDE.md as a keyword router; keep it lean (~8KB).
  • Put cross-workspace rules in SHARED-RULES.md and reference it everywhere.
  • Separate the three proofreading passes; style/AI-pattern work belongs only in Pass 2.
  • Write drafts and research to files, never only to the chat reply.
  • Save research incrementally after every search round.
  • Build one Skill at a time from your most-repeated instruction; the library grows on its own.
  • Parallelise only independent tasks (different files).
  • Combine Skills + Hooks + MCP for a full Harness / "AI employee."
  • Start small: Week 1 a root CLAUDE.md with 3–5 rules; Week 2 your first Skill; Week 3+ expand when something recurs more than three times a week.

Interview / Revision Questions

  1. What problem does moving writing rules into CLAUDE.md solve?
  2. What is a routing system, and what does the root CLAUDE.md contain?
  3. Walk through what happens when you say "write a WeChat article about Claude Code."
  4. Why keep the root CLAUDE.md to ~8KB?
  5. What lives in SHARED-RULES.md and why?
  6. Name the three proofreading passes and what each one does.
  7. List the six AI-pattern tells and one fix for each.
  8. In a SKILL.md, what does the description front matter control?
  9. Why is research designed to "search and save as you go"?
  10. Why must articles be written to a file rather than the chat reply?
  11. What does parallelism require, and give one valid and one invalid parallel pair.
  12. Map CLAUDE.md / Skills / Hooks / MCP onto the "AI employee" analogy.

Practice Exercises

Exercise 1: Create a root CLAUDE.md with a routing table for two or three of your own work contexts.
Exercise 2: Write a SHARED-RULES.md with four rules that apply to all your output.
Exercise 3: Build a SKILL.md for the instruction you repeat most (proofread / translate / summarise notes), including auto and manual triggers.
Exercise 4: Take an AI-written paragraph and run the six-pattern style pass by hand.
Exercise 5: Do one topic → research → draft → proofread cycle, saving each stage to a file.
Exercise 6: Identify two content tasks you could run as parallel agents and one pair you could not.

Quick Memory Map

Content Creation Automation
│
├── Router CLAUDE.md (~8KB): keyword -> workspace -> load its CLAUDE.md
│   + SHARED-RULES.md (research recency, 3-pass proofread, image flow, naming)
│
├── 3-pass proofreading
│   1 Content (facts/logic/structure)  2 Style (6 AI patterns)  3 Detail (polish)
│
├── Skills (write for the AI, one command to remember)
│   SKILL.md front matter = auto-trigger keywords + manual /name
│   27 skills over ~2 months, one per repeated task
│
├── Full demo (~90 min): /topic-gen -> /research (save as you go)
│   -> draft.md (file, not reply) -> /proofreading -> image flow -> /feishu
│
├── Parallel agents: only for INDEPENDENT tasks (different files); ~$50 for the book
│
└── Full Harness = CLAUDE.md (handbook) + Skills (techniques)
                   + Hooks (habits) + MCP (tools)  = "AI employee"
   Start: Wk1 root CLAUDE.md (3-5 rules); Wk2 first Skill; Wk3+ expand

Complete Chapter Revision

  1. Claude Code's most underrated use is content work, not code — a general-purpose AI workstation.
  2. A routing CLAUDE.md maps keywords to workspaces and loads each workspace's own rules; it stays lean (~8KB).
  3. SHARED-RULES.md holds rules that apply to all content (recency, proofreading, image flow, naming).
  4. Three-pass proofreading: content, then style (six AI-pattern tells), then detail.
  5. A Skill is built from your most-repeated instruction; its front matter defines auto and manual triggers; it is written for the AI.
  6. The full demo runs topic → research (saved incrementally) → draft (to a file) → proofread → images → Feishu in ~90 minutes.
  7. Parallel agents speed things up but only for independent tasks; the book was built with four agents for ~$50.
  8. Skills + Hooks + MCP + CLAUDE.md form a complete "AI employee": handbook, techniques, habits, tools.
  9. Build it in phases: root CLAUDE.md first, then one Skill, then expand when something recurs 3+ times a week.
  10. None of this requires coding — the book calls that its single most important point.

Final Takeaway

The chapter's central lesson:

The key is not the number of Skills — it is the habit: package repetitive tasks into Skills, lock rules into CLAUDE.md, and use MCP to connect external services. Do that and your whole workflow reaches a new level — Harness Engineering in practice, for anyone whose work involves repetitive output.

This teaching edition is based on the supplied April 2026, 2nd edition of Claude Code: The Complete Guide (§12, "Hands-on Project: Content Creation Automation"). Skill names, directory structures, tool integrations and timings reflect the author's setup in that edition and may change over time.