Claude General-Purpose Long-Form Writing Workflow Research

1. Introduction

1.1 What is "Writing Novels with a General-Purpose Harness"

This article is a representative of "Writing Novels with a General-Purpose Harness", and is the sample in this group that best embodies the six-layer capability model.

The difference from the platforms discussed above is fundamental:

Core judgment: the general-purpose Harness reaches the strongest level on four of this group's six-layer capabilities (L1, L3, L4, L5), at the cost of the highest barrier to entry. This distribution precisely confirms this group's core thesis — long-form capability is determined by L4, and L4's deep engineering (versioned state snapshots) can currently only be achieved by self-built workflows.

1.2 Ecosystem Composition

Must be made clear: all of the above workflows and configuration files (AGENTS.md / SKILL.md) are community practices and are NOT official standards from any vendor. Within this group's search scope, no commercial platform was found to publish its AGENTS.md / SKILL.md standard files.

1.3 Pricing

There is one important feature in the cost structure: cost is not related to "whether you use AI to write novels", but to "how many tokens you use". This means the better the context engineering (L1) and the better the state externalization (L4), the lower the cost — engineering optimization directly translates into economic benefit, which is in the same incentive direction as Sudowrite's credit-based system.

1.4 Open Form

"Everything is a file" is the most essential advantage of this route: state, roles, skills, and manuscripts are all files that can be version-controlled, diffed, and rolled back. This turns long-form creation from an "uncontrollable generation process" into an "auditable engineering process".

2. Glossary

3. Feature Description

3.1 Three-Tier Memory Mechanism

The three-tier memory summarized from the measured article:

How it works: when context grows too long, earlier content is automatically compressed into a structured summary, retaining only key threads. This corresponds to this group's "long-range state management paradigm A · structured rolling summary".

Why three tiers instead of one:

Key insight: the value of the long-term memory layer is not that it is "large in capacity", but that it is "not compressed by the model". The character settings in CLAUDE.md are written by humans and will not be rewritten by the model; while the rolling summary is written by the model, and every round may introduce bias. Put information that tolerates no error into the human-maintained layer, and put information that tolerates ambiguity into the auto-compressed layer — this is the design principle of three-tier memory.

3.2 Context Selection Strategy

Three types of strategies recorded in the measured article:

The third one deserves the most attention: using the user's operational behavior as a signal of context relevance. This is an idea borrowed from software engineering's "cache eviction strategy" — a smarter version of LRU (least recently used): it looks not only at recency but also at access frequency.

3.3 Sub-Agent Role System

Measured record: after one instruction "I want to turn you into my dedicated novel-writing assistant, how do I do it?", Claude Code created 10 subagents on its own:

Each subagent generates a configuration .md under `.claude/commands`, and the author can embed their own creative SOP.

"The author can embed their own creative SOP" is the core value of this system: turning personal experience into reusable, version-controllable, shareable configuration files. This is exactly the role of AGENTS.md / SKILL.md in software engineering, migrated to the novel-writing scenario.

3.4 Scripts as Tools

Experience from Chinese practice: large models are bad at naming and counting words → hand these over to Python scripts, wrapped as skills.

The original author's statement: "this is also the most suitable scenario for skills".

"Scripts as tools" is a sign of maturity for third-generation Harness in the novel-writing scenario: stripping deterministic tasks away from the model, letting the model do only uncertain creative work. This principle shares the same goal as Sudowrite's 1,000+ plugins, but the implementation path differs — plugins are written by others, while scripts are written by yourself.

3.5 Knowledge Graph and Snapshots

The solution of the Chinese practice (tulancn):

The node design of the knowledge graph:

entities/
├── characters/      # 角色节点（每角色一个 md）
├── techniques/      # 功法节点
├── items/           # 物品节点
└── locations/       # 地点节点
        + 标签系统索引（跨类型关联）

4. Platform Architecture

图 4-1｜通用 Harness 写小说 · 六层能力架构（L1–L6）

数据来源：基于本文分析绘制的示意图。

4.1 Claude Book Four-Directory Architecture

State versioning + symlink pattern (key design):

state/
├── current/      # Symlink → 最新章节状态
├── chapter-01/   # 第 1 章后归档
├── chapter-02/
└── template/

Core benefit (per the original text): when writing chapter 15, the model can precisely obtain what happened in chapters 1–14 without needing a 100K token context.

Automatic generation of the Bible:

• The `book-analyzer` skill can automatically extract from source books to obtain quantitative style rules: average sentence length, dialogue tag frequency, lexical constraints, explicit forbidden elements;
• `bible-merger` can merge the analysis results of multiple source books.

"Never changes during generation" is an extremely strong engineering constraint: the Bible is frozen during the writing process, meaning the style baseline will not drift because of the model's momentary improvisation. This is isomorphic to Claude-Code-Novel-Writer's "source of truth / derived" idea.

4.2 Claude-Code-Novel-Writer Directory Architecture

├── AGENTS.md                 # 规范化的项目指引（harness-neutral）
├── CLAUDE.md                 # Claude 侧 import AGENTS.md
├── .agents/
│   ├── roles/                # 规范化专能角色
│   └── skills/               # 规范化写作工作流
├── .claude/agents|skills|output-styles|settings.json
├── .codex/agents|config.toml|hooks.json
├── .pi/prompts/
├── manuscript/chapters/      # 权威源
├── planning/  characters/  worldbuilding/
└── automation/

The layering of AGENTS.md and CLAUDE.md is worth noting: `AGENTS.md` is a harness-neutral general-purpose guide, and `CLAUDE.md` only handles the import. This design lets the same set of role and skill definitions be reused across Harnesses — this is the standard approach for decoupling the "project constitution" from the "runtime".

4.3 Orchestrator-Worker Pipeline

Claude Book's role division:

The gating flow:

plan
  |
  v
planner 写 beats
  |
  v
writer 生成章节到 draft
  |
  v
subagents 并行校验（style / character / continuity）
  |
  +-- 通过 --> 移入 story 文件夹 --> state-agents 更新 current 状态
  |
  +-- 不通过 --> 返回 writer 重写

Responsibility boundary (key constraint):

• the reviewer subagent only verifies, never writes the novel;
• there are only two writers: coordinator (when invoking the perplexity skill) and writer (when a chapter needs rewriting).

The engineering significance of this boundary: it prevents the "review agent overstepping to rewrite, causing state inconsistency". If the reviewer could edit, the same draft could be concurrently modified by multiple agents, and the State's source of truth would fail.

5. Harness Design

5.1 L1 Context Engineering Layer

Strongest in this group. Four mechanisms combined:

The State snapshot is the most valuable innovation of the L1 layer. Its essence is: turning "what you would need to read 14 chapters of body text to know" into "what you can know by reading a single state file".

Quantitative benefit (per the original text): when writing chapter 15, you precisely obtain what happened in chapters 1–14, without needing a 100K token context.

The deeper significance of this innovation: doing L4 thoroughly decompresses L1 in return. Most teams' solution is "apply for a larger context window", while Claude Book's solution is "make less need to enter the context". The former is expanding capacity, the latter is reducing burden — the latter is more sustainable.

5.2 L2 Tool & Execution Layer

The three levels of tools:

1. Deterministic tools (naming, word count, graph queries) — must be scripted, never handed to the model;
2. Analytical tools (book-analyzer extracting average sentence length, dialogue tag frequency) — require precise statistics, combining scripts + models;
3. Diagnostic tools (verify-system, dashboard) — purely engineering observability.

5.3 L3 Orchestration & Control Layer

Strongest in this group. Three orchestration forms coexist:

Parallel review is the biggest highlight of the L3 layer: the three reviewers — Style / Character / Continuity — verify in parallel, not serially. The value of this design is not just speed — parallelism means the judgments of the three dimensions do not interfere with one another, whereas serial execution would let a later reviewer see the previous reviewer's revision comments and develop an anchoring effect.

The responsibility boundary constraint (reviewers only verify, never write) is the most easily overlooked but most critical design of the L3 layer. Together with Claude-Code-Novel-Writer's "source of truth / derived" principle, it forms the consistency guarantee mechanism of long-form engineering.

5.4 L4 Memory & State Layer

Strongest in this group, and the only solution that fully covers all six state categories:

Full implementation of all three paradigms: of the three long-range state-management paradigms this group has summarized, the Claude workflow is the only solution that implements all three at once:

This directly confirms this group's core thesis: whoever makes L4 solid can support long-form fiction. The completeness of the Claude workflow on L4 is exactly why it can precisely recall a foreshadowing across 7 chapters (~21,000 characters) (see section 6.2).

The source-of-truth / derived principle: `manuscript/chapters/` is the only source of truth; tracking is derived and can be regenerated via `./sync-state.sh`. This principle demotes L4 from "memory that can be corrupted" to "an index that can be rebuilt from the source" — even if the entire state layer is lost, it can be rebuilt from the manuscript. This is the most important risk-mitigation measure in long-form engineering.

5.5 L5 Evaluation & Observability Layer

Quality philosophy (from Claude-Code-Novel-Writer's original text):

`automation/quality-check.sh` only records mechanical signals such as word count, paragraph length, and dialogue ratio; they can reveal anomalies but do not judge literary quality; revision decisions should be based on chapter intent, voice, pacing, continuity, motivation, and reader effect.

This "boundary statement" itself reflects the maturity of L5 — knowing what automated evaluation cannot do is more important than what it can do.

The four-layer separation of the evaluation layer:

The independence requirement of the Perplexity Gate: the judging source (local Ministral) must be different from the generation model. If you use the same model for self-checking, it is equivalent to asking it to judge "whether what it said itself is mediocre" — the model would tend to affirm itself. This is a universal principle in designing any AI evaluation system.

5.6 L6 Governance & Safety Layer

"Information-disclosure sequence control" is the biggest trap in Agent writing, and the most valuable governance design in this workflow:

Problem: if the knowledge graph stores the whole book's information, the model might "accidentally" reveal chapter 30's secrets already in chapter 3.

Three countermeasures:

1. The knowledge graph keeps only the story's current-progress information, syncing automatically after each plot advance → avoids premature disclosure of future information;
2. Context pruning: a subagent gathers information for a dedicated writing Agent, giving it just enough information, avoiding making things up;
3. Controlling the plot: split out the "plot point" concept in the chapter outline, strictly controlling the chapter's direction, avoiding over-free play by the Agent.

These three countermeasures jointly solve a problem that commercial platforms have not realized at all: AI is not that it writes badly, but that it knows too much.

Governance gap: this workflow has no AIGC labeling capability. When submitting to Chinese platforms, the labeling obligation falls entirely on the author.

5.7 Six-Layer Capability Summary

Response to the core thesis (the most complete one): the Claude workflow is the strongest positive evidence for this group's core thesis. On L4 it achieves full coverage of all six state categories, full implementation of all three paradigms, and establishes the anti-risk principle of "source of truth / derived"; and solid L4 directly brings about L1's decompression (the State snapshot replaces a 100K context). Its verifiable result — the precise recall of a foreshadowing across 7 chapters (~21,000 characters) — is this group's most compelling empirical evidence of long-range capability.

6. Practical Cases

6.1 Case 1: Build a 10-Person Creative Team in 3 Minutes and Produce 32,000 Words in 27 Minutes

Background: an author tried to build a novel-writing assistant with Claude Code.

Approach: after the one-sentence instruction "I want to turn you into my dedicated novel-writing assistant, how do I do it?", Claude Code created 10 subagents on its own.

Measured timeline:

Efficiency comparison: a professional web-novel writer averages 6,000 words of daily updates in 4–6 hours; Claude Code completes about 5 days of workload in under 20 minutes.

A boundary to note: this is the first-draft production speed, not including human revision time. This group does not argue that "27 minutes equals a publishable novel" — there is still a lot of human work between first draft and final draft, and Claude-Code-Novel-Writer explicitly states that mechanical signals "do not judge literary quality".

6.2 Case 2: Precise Recall of a Foreshadowing Across 7 Chapters (~21,000 Characters)

Background: the hardest capability to verify in long-form creation is "cross-chapter foreshadowing recall".

Quality-verification results (recorded in the measured article):

This is this group's most important single piece of evidence. The 7-chapter / 21,000-character span far exceeds the capability range of NovelAI and Fanqie, relying precisely on the L4 layer's three-tier memory + long-term project files (CLAUDE.md / AGENTS.md), plus the pre-planned schedule of 6 foreshadowing plant-and-recall events (precise to the chapter) in the 10-chapter outline.

Engineering breakdown:

Key insight: a foreshadowing is not "the model remembered it", but engineering turns the foreshadowing into a trackable ledger object. The ledger lives in the outline, in the long-term memory files, and in the reviewer's checklist — three places of redundancy, which is what ensures the 7 chapters never lose the thread.

6.3 Case 3: Claude Book's 18-Chapter French Novel and Forbidden-Element Gating

Background: Claude Book's starting point was two stubborn problems — Coherence Drift (forgetting character traits, timeline, and plot threads in long outputs) and AI Slope (output sliding toward the statistical average, taking the "most-traveled road").

Result: an 18-chapter French novel (imitating the style of Enid Blyton's Famous Five series) + a 3,000-word English chapter.

Example of forbidden-element gating:

Engineering interpretation: this is the only fully recorded instance in this group of "an automatic style gate intercepting and rewriting". It shows that "forbidden elements" are not a slogan in a document, but an executable, interceptable, rewrite-triggering engineering rule.

Comparison with other platforms:

6.4 Case 4: The Chinese Practice's Knowledge Graph and Information-Disclosure Control

Background: Chinese web novels have far more settings than Western fiction (techniques, sects, treasures, realm systems), making the context-bloat problem more severe.

Pitfalls and countermeasures (tulancn's practice):

"Information-disclosure order" is this case's most distinctive contribution — it identified a problem that commercial platforms have not realized at all:

AI is not that it writes badly, but that it knows too much.

If the knowledge graph stored the whole book's information, the model might "accidentally" reveal chapter 30's secrets already in chapter 3. The countermeasure is to have the knowledge graph keep only the current progress, syncing as the plot advances.

In the Harness context, this countermeasure belongs to the L6 governance layer — it is not about restricting "what content cannot be written", but about restricting "what information cannot be known at this moment". This is a governance dimension more refined than content review.

7. Summary

7.1 Advantages

1. L4 memory & state layer is the strongest and most complete in this group: the four directories Bible/State/Story/Timeline + knowledge graph + versioned snapshots, full coverage of all six state categories, full implementation of all three long-range paradigms.
2. L1's innovation is the most effective: the State symlink snapshot turns "reading 14 chapters of body text" into "reading a single state file", and solid L4 decompresses L1 in return.
3. The only solution with a foreshadowing ledger: plans a "plant-and-recall schedule, precise to the chapter" in the outline, empirically staying connected across 7 chapters and ~21,000 characters.
4. The only solution with parallel review and clear responsibility boundaries: Style/Character/Continuity in parallel + reviewers only verify, never write.
5. The only solution with an automatic AI Slope gate: the Perplexity Gate uses an independent local model to detect predictable phrases.
6. The only solution that explicitly states "mechanical signals do not judge literary quality" — clear evaluation boundaries.
7. The "source of truth / derived" principle: state can be rebuilt from the manuscript, demoting L4 from "memory that can be corrupted" to "a rebuildable index".
8. Scripts as tools: deterministic tasks and creative tasks are thoroughly separated.
9. Everything is a file: Git version control, diff, rollback, and collaboration are all possible.
10. Cross-Harness compatibility: all three — Claude Code / OpenAI Codex / Pi.

7.2 Limitations and Known Shortcomings

1. Highest barrier to entry: requires engineering capability, with no out-of-the-box experience.
2. No finished UI: everything is done in files and the command line.
3. Configuration quality determines output quality: if the Bible is written poorly, the whole system is poor.
4. Community practices are not official standards: all AGENTS.md / SKILL.md files are community projects, with no vendor endorsement.
5. No AIGC labeling capability: submitting to Chinese platforms requires self-declaration.
6. The literary-quality layer must be human: eval can only detect anomalies, not judge quality.
7. The measured data comes from a single source: figures such as 3 minutes / 27 minutes / 32,000 words appear only in the measured article and have not been cross-verified by multiple parties.
8. The very existence of the error-recovery role shows the system can fail: v4.1 specifically sets up an error-recovery role, indicating that failures are the norm during long-form runs.

7.3 Applicability Boundary

7.4 Selection Recommendations

• Primary scenario: your project exceeds 300,000 words, and "setting collapse" is the risk you can least accept. This is the only solution in this group that can provide systematic guarantees.
• Secondary scenario: you need multiple parallel progress points (exploring different directions within the same worldview) — the snapshot skill and the `state/chapter-NN/` archive are the only solution that supports rollback.
• Combination recommendation: it is not recommended to abandon commercial tools entirely. A viable practice is "Claude workflow manages state + commercial tools manage generation" — use Bible/State/Timeline to maintain long-range consistency, and use Sudowrite or NovelAI for per-chapter generation and polishing.
• Getting-started recommendation: directly use the GitHub community project Claude-Code-Novel-Writer v4.1 as the skeleton (7 roles + 5 skills + directory structure), then adjust it according to your own creative SOP. Note that this is a community project, not an official standard.
• Compliance note: this solution has no AIGC labeling capability. When submitting to Chinese platforms, you must complete the declaration yourself per the Measures for the Labeling of AI-Generated Synthetic Content (effective 2025-09-01) (see `04-fanqie-ai.md`).

Information-Gap Statement

1. No commercial platform publishes AGENTS.md / SKILL.md: within this group's search scope, apart from the GitHub community project Claude-Code-Novel-Writer, no commercial platform was found to publish its standard Harness configuration files. All the specification forms described in this article are community practices or drafts, and do not constitute official standards.
2. Claude-Code-Novel-Writer is a community project: no vendor endorsement; last commit 2026-08-21; not an official standard.
3. The measured data comes from a single source: data such as 3-minute setup / 27-minute output / 32,000 words / 7-chapter 21,000-character foreshadowing appear only in a single measured article (reposted from "夕小瑶科技说"), and have not been cross-verified by multiple parties.
4. The complete list of the 10 subagents: the source only lists 6 (brainstorm / outline / character / write-chapter / dialogue / check-quality); the remaining 4 are marked `[To be filled]`.
5. Claude Book's 18-chapter French novel: no work title, word count, or actual quality assessment was found; marked `[To be filled]`.
6. The specific thresholds and judgment criteria of the Perplexity Gate: no technical details were found; marked `[To be filled]`.
7. Pricing: depends on the underlying subscription and API; there is no standalone pricing item; the specific amount is marked `[To be filled]`.
8. AIGC labeling: this solution has no built-in capability; Chinese submissions must be self-declared.
9. The specific configuration content of v4.1's 7 roles and 5 skills: the source only gives a list of names, not the original configuration files.

8. References

1. Measured article "Using Claude Code to Write Novels, Accidentally Discovering the Team-Up Cheat Mode" (reposted from "夕小瑶科技说") — 2026. https://m.aitntnews.com/newDetail.html?newId=20196
2. GitHub — forsonny/Claude-Code-Novel-Writer (Multi-Agent Novel Writer v4.1) — 2026. https://github.com/forsonny/Claude-Code-Novel-Writer
3. HackerNoon "Claude Book: A Multi-Agent Framework for Writing Novels with Claude Code" — HackerNoon. https://hackernoon.com/claude-book-a-multi-agent-framework-for-writing-novels-with-claude-code
4. Blog "How to Write a Novel with Agents (Part 2)" — tulancn. https://tulancn.github.io/%E5%AD%A6%E4%B9%A0/study/%E5%A6%82%E4%BD%95%E7%94%A8Agent%E5%86%99%E4%B8%80%E6%9C%AC%E5%B0%8F%E8%AF%B4%EF%BC%88%E5%85%B6%E4%BA%8C%EF%BC%89
5. Sudowrite official blog "How Sudowrite Works: Story Bible, Muse, and the Tools" — Sudowrite. https://sudowrite.com/blog/how-sudowrite-works
6. AI Wiki "Sudowrite" — AI Wiki. https://aiwiki.ai/wiki/sudowrite
7. BuildFastWithAI "NovelAI Review 2026" — BuildFastWithAI. https://buildfastwithai.com/ai-tools/novelai
8. Fanqie Novel official announcement "AI Writing Tool Feature Launch Notice" — Fanqie Novel, 2024. https://fanqienovel.com/writer/zone/article/7327136545129906238
9. Haike Finance "Fanqie Novel's AI Challenge" (Sina Finance) — Haike Finance, 2025. https://finance.sina.com.cn/search/2025-10-09/doc-infthsqh9655363.shtml
10. GeekPark "Can AI Write 'Joy of Life'?" — GeekPark. https://so.html5.qq.com/page/real/search_news?docid=70000021_10168f9fb6122152
11. China Youth Daily "'Miaobi Tongjian' and 'Manju Assistant' Launched: AI Empowers Web-Novel Creation and IP Adaptation" (Tencent News) — China Youth Daily, 2025. https://new.qq.com/rain/a/20251017A08J6J00
12. Tencent News "Manju Grows over 45% a Year: IP and AI Dual-Engine Drive a Hundred-Billion Market" — Tencent News, 2026. https://new.qq.com/rain/a/20260319A03C2U00
13. Toutiao "Novel-Writing Tips Notes: From Beginner to Advanced" — Toutiao. https://m.toutiao.com/article/7666250379276927531
14. Meipian "How Beginners Start Web-Novel Writing" — Meipian. https://www.meipian.cn/5gn73n9w
15. Roleforge "Best AI Dungeon Master Tools 2026" — Roleforge. https://roleforge.ai/blog/best-ai-game-master-tools-compared