chinese-novelist-skill: A Structured Agent Workflow for Full-Length Chinese Novels

Why a Novel Needs a Pipeline, Not a Prompt

Writing a 10 to 50 chapter Chinese novel in one LLM session fails because context decays, style drifts, and the model forgets earlier plot threads. This skill attacks that problem by turning the task into a staged workflow with explicit artifacts. It is built for people who already use Claude Code or another coding agent and want to produce long-form web fiction, the kind serialized on platforms like Qidian or Jinjiang. The skill does not generate a novel from a single instruction. It runs a four-phase process: initialization, layered questioning, planning with confirmation, then fully automatic chapter writing and validation. The README positions the core pain point as 'persisting to the end', and the design reflects that: every phase exists to keep the story moving forward without the user re-explaining preferences or re-checking progress.

The Four-Phase Data Flow: From Preferences to Finished Manuscript

The repository layout shows a clear data flow. Phase 0 loads a user preferences file and checks for interrupted projects. Phase 1 asks three mandatory questions about genre, protagonist, and core conflict, then offers five optional questions about worldview, narrative perspective, theme, target reader, and chapter count. Each question supports random generation or skipping. Phase 2 generates a seven-column chapter outline, character profiles, and a machine-readable writing plan JSON, which the user must confirm. After confirmation, Phase 3 writes chapters in one of three modes: serial, sub-agent parallel, or Agent Teams. The README shows a per-chapter cycle: pre-writing analysis, drafting 3000 to 5000 Chinese characters, polishing to remove 'AI flavor', word count check, and summary update. Phase 4 runs an automatic check on total word count and coherence, and rewrites failing chapters up to three times. The output is a folder named with a timestamp and story title, containing the outline, character files, writing plan JSON, and one markdown file per chapter. This structure is the core value: it externalizes state so the agent can resume after interruption and coordinate parallel writers.

Installation and the First Command: Two Paths to the Same Skill

Getting the skill running requires installing it into Claude Code's skills directory. The README gives two methods. The first is a one-line command: `npx skills add PenglongHuang/chinese-novelist-skill`. The second is manual: copy the directory into `~/.claude/skills/chinese-novelist/`. After installation, you invoke it with a Chinese instruction like `使用 chinese-novelist 帮我写一部小说`. The skill then begins Phase 0 and walks through the Q&A. There is no mention of a Python dependency beyond the word count script, which lives at `scripts/check_chapter_wordcount.py`. The script enforces the 3000 to 5000 character target per chapter, but the README does not specify how to run it or whether the agent invokes it automatically. That gap matters: if the script requires a specific Python version or a package, the README does not say. Users should expect the agent to handle it, but verifying the script runs in your environment before a 20 chapter job is a reasonable caution.

The Memory System: Persistent Preferences Across Projects

A notable feature is the preference memory system. After each creation, the skill automatically learns the user's preferences for genre, narrative style, chapter count tendency, and text density, storing them in `user-preferences.json`. The file is described as shared across projects, which means it sits outside any single novel folder. On the next run, Phase 0 loads these preferences and shows a personalized welcome. This is a genuine convenience for repeat users who write several novels. But it is also a double-edged sword. If the preferences file accumulates stale or conflicting data, the skill may keep applying an old genre choice or a chapter count that no longer fits. The README does not describe any mechanism to edit or reset the preferences file manually. Users who want a clean slate for a different genre will need to locate and delete or edit the JSON file themselves. The documentation does not provide a command for that, which is a small but real operational gap.

Three Writing Modes: Speed Versus Coherence

The skill offers three writing modes, chosen after the plan is confirmed. Serial mode has the main agent write each chapter sequentially. The README calls it stable and reliable, and recommends it by default. Sub-agent parallel mode splits chapters across multiple sub-agents to write in batches, targeting speed. Agent Teams mode uses Claude Code's multi-agent collaboration for 'large long-form works'. The trade-off is clear: parallel modes risk continuity errors because each sub-agent may not have full context of earlier chapters. The README's own validation phase exists partly to catch those errors, but the check is described as word count and coherence, not deep plot logic. The writing plan JSON is meant to coordinate parallel writing, but the README does not explain how the JSON prevents two sub-agents from writing contradictory character actions. For a 50 chapter novel, parallel writing is tempting, but the coherence check may not be strong enough to catch subtle inconsistencies.

Rules of Writing: The Golden Laws and 13 Hook Types

The skill embeds a set of writing rules that go beyond generic prompting. The README lists four core laws: show don't tell, conflict-driven plot, a hook at every chapter's end, and a climax in the first 20 percent. These are not just suggestions; the flow documents and guides enforce them. For example, `hook-techniques.md` catalogs 13 types of chapter-ending hooks, and `chapter-guide.md` covers opening techniques and Chinese literary methods. The presence of these reference files is a strong signal that the skill encodes a specific aesthetic: web novel pacing with high tension per chapter. This is a point of view, not a neutral tool. Writers who prefer slow-burn literary fiction or who dislike formulaic chapter endings will find the skill's rules restrictive. The skill is opinionated about what makes a good chapter, and that opinion is baked into the validation process. If you do not share that aesthetic, you will spend effort fighting the system.

Validation Limits: Word Count Is Not Plot Coherence

Phase 4 is the skill's safety net. It checks word count and coherence, and rewrites failing chapters up to three times. The README shows a sample output with chapter word counts like 3247, 3582, and 3412, all within the 3000 to 5000 range. The word count check is objective and scriptable. The coherence check is less clear. The README does not specify what algorithm or criteria the coherence check uses. It likely relies on the agent comparing chapter summaries, but the documentation does not confirm that. Three rounds of rewriting are also a hard cap. A chapter that still fails after three attempts is presumably left as is, or the skill stops. The README does not describe what happens in that failure case. For a 50 chapter novel, the cumulative risk of unresolved continuity errors is real. The validation is a guardrail, not a guarantee. Users should not expect the skill to produce a publish-ready manuscript without their own review.

Alternatives and Upgrade Path: What You Give Up and What You Gain

The main alternative to this skill is writing a custom prompt or using a generic agent workflow with a vector store for story context. A generic approach gives full control over pacing, style, and validation, but requires you to build the state management, the outline generation, and the chapter-by-chapter checks yourself. This skill packages those pieces into a coherent system, which is its main advantage. The v2.0 rewrite, described in the README, moved detailed instructions from a single SKILL.md into separate flow documents under `references/flows/`, which makes the process easier to maintain and modify. The upgrade from v1.0 to v2.0 added the three-layer Q&A, the memory system, interruption recovery, and the validation phase. If you used v1.0, the README points to a pull request for migration notes, but the content of that PR is not in this material. For new users, v2.0 is the version to install. The MIT license means you can fork and adapt the skill, which is a practical option if the built-in rules do not match your writing style.

Maintenance and License: A Living Project with a Single Maintainer

The repository is not archived and the last push was September 2026, which suggests active maintenance. The README mentions a sponsorship page on Afdian, indicating the project is sustained by donations rather than commercial backing. That is a risk factor: if the maintainer stops, the skill will not receive updates for new Claude Code versions or changes in the agent ecosystem. The MIT license allows you to take over maintenance yourself, which mitigates that risk. The documentation is in Chinese, so non-Chinese speakers will face a language barrier when reading the flow documents and guides. The skill is designed for Chinese-language output, and the writing guides reference Chinese literary techniques, so it is not a general-purpose novel writer. Maintenance cost for users is low: there is no server to run, and the skill runs inside Claude Code. The main ongoing cost is reviewing and editing the generated chapters, since the validation is not a substitute for human editorial judgment.

Editorial conclusion

Adopt this skill if you use Claude Code or a compatible coding agent, write Chinese web fiction, and want a structured pipeline that enforces chapter length, continuity, and cliffhangers without manual follow-up. Skip it if you write in other languages, prefer full manual control over every paragraph, or need guaranteed coherence across 50 chapters, since the validation is rule-based and the three-round rewrite cap may leave flaws. Verify first that your agent supports the skills directory convention, that the Python word-count script runs in your environment, and that you accept the trade-off of letting the agent drive the whole process with no per-chapter approval.

Official sources

1. Issues
2. License: MIT
3. PenglongHuang/chinese-novelist-skill on GitHub
4. README