Chapter Drafter

Name: Chapter Drafter
Author: jwynia

jwynia/agent-skills

370 installs
133 repo stars
Updated February 24, 2026
jwynia/agent-skills

Draft long-form fiction or nonfiction chapters with consistent voice, pacing, and scene structure when turning outlines into readable manuscript sections via an agent.

About

chapter-drafter helps agents produce complete book chapters from outlines or briefs, maintaining tone, scene logic, and narrative momentum across long-form creative or informational writing projects.

Scene-level drafting from beats
Voice and pacing consistency
Long-form chapter structure
Revision-ready prose blocks
Agent-guided narrative flow

Chapter Drafter by the numbers

370 all-time installs (skills.sh)
+7 installs in the week ending Aug 2, 2026 (Skillselion tracking)
Ranked #459 of 1,335 Generative Media skills by installs in the Skillselion catalog
Data as of Aug 5, 2026 (Skillselion catalog sync)

npx skills add https://github.com/jwynia/agent-skills --skill chapter-drafter

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/jwynia/agent-skills/chapter-drafter.svg)](https://skillselion.com/skills/jwynia/agent-skills/chapter-drafter)

Installs	370
repo stars	★ 133
Last updated	February 24, 2026
Repository	jwynia/agent-skills ↗

What it does

Draft long-form fiction or nonfiction chapters with consistent voice, pacing, and scene structure when turning outlines into readable manuscript sections via an agent.

Files

SKILL.mdMarkdownGitHub ↗

Chapter Drafter: Orchestrator Skill

You autonomously draft and polish chapter scenes through iterative editorial passes. Given an outline, you produce polished first-draft prose by drafting each scene, evaluating it against editorial criteria, and revising until quality thresholds are met.

Core Principle

Orchestration is iteration with hierarchy. Fix structure before character, character before originality, originality before dialogue, dialogue before prose. Don't polish what might be cut; don't revise dialogue in a scene that needs structural rework.

---

Prerequisites

Before invoking this skill, ensure:

1. Complete outline exists - Scene beats with goals, conflicts, and intended outcomes 2. Characters defined - Lie/want/need, voice patterns, arc positions 3. World established - Setting details sufficient for scene work 4. Story-sense diagnosis complete - No structural story problems remaining

Do NOT use this skill if:

Outline is still in flux
Character arcs undefined
Story-sense would diagnose structural problems

---

The Orchestration Loop

FOR each scene in chapter outline:

    1. BUILD CONTEXT
       - Load character voices from previous scenes
       - Load open plot threads
       - Load cliche avoidances
       - Extract scene purpose from outline

    2. DRAFT SCENE
       - Generate initial prose from outline beat
       - Apply character voices
       - Maintain plot thread continuity

    3. EVALUATION LOOP (max 5 cycles)
       │
       ├─► Pass 1: scene-sequencing (35%)
       │   └─► If FAIL: REWRITE scene
       ├─► Pass 2: character-arc (25%)
       ├─► Pass 3: cliche-transcendence (15%)
       ├─► Pass 4: dialogue (15%)
       └─► Pass 5: prose-style (10%)
       │
       Calculate composite score
       │
       ├─► >= 80: ACCEPT
       ├─► 60-79: TARGETED FIX → re-evaluate
       ├─► 40-59: REWRITE → return to draft
       └─► <40: REJECT → full re-draft from outline

    4. POST-ACCEPT
       - Extract character voice patterns → update context
       - Track plot thread changes → update registry
       - Record cliche transcendences → update avoidances
       - Write scene to output
       - Update progress tracker

END FOR

---

Pass Criteria

Pass 1: Scene-Sequencing (35% weight)

Evaluates Goal-Conflict-Disaster structure and pacing.

Criterion	PASS	WARN	FAIL
Goal clarity	POV goal clear in opening beats	Goal exists but buried	No discernible goal
Conflict escalation	Opposition intensifies	Conflict static but present	No real opposition
Disaster quality	"Yes, but..." or "No, and..."	Simple "No"	Clean "Yes" or no resolution
Sequel presence	Reaction-dilemma-decision present	Abbreviated sequel	Missing after high-tension
Scene-sequel ratio	Matches intended pacing	Slight mismatch	Severely mismatched

Critical: If scene-sequencing FAILS, do NOT proceed to other passes. Structural problems invalidate downstream evaluation.

Pass 2: Character-Arc (25% weight)

Evaluates transformation consistency and arc progress.

Criterion	PASS	WARN	FAIL
Lie visibility	False belief evident in choices	Lie present but unstated	No lie operative
Want/Need gap	Clear tension between stated/actual	Gap exists but unclear	Want = Need (no tension)
Arc progress	Scene advances or challenges arc	Arc static but consistent	Character contradicts arc
Transformation markers	Choices reflect arc position	Position unclear	Acts against personality

Pass 3: Cliche-Transcendence (15% weight)

Evaluates originality via orthogonality test.

Criterion	PASS	WARN	FAIL
Form axis	Non-default form	Slight variation	Exactly genre default
Knowledge axis	Own concerns, accidental intersection	Some plot awareness	Fully story-serving
Goal axis	Own agenda that collides	Goal connected to plot	Purely protagonist-serving
Role axis	Own story that intersects	Somewhat independent	Exists only for hero
Orthogonality test	2+ axes orthogonal	1 axis orthogonal	All axes match default

Pass 4: Dialogue (15% weight)

Evaluates voice distinctiveness, subtext, and function.

Criterion	PASS	WARN	FAIL
Voice distinctiveness	Characters distinguishable without tags	Some overlap	Identical voices (D1)
Subtext presence	Gap between said and meant	Occasional direct statements	Everything on-the-nose (D4)
Double-duty test	3+ functions per exchange	2 functions	Single function only (D5)
Naturalness	Contractions, interruptions, rhythm	Slightly formal	Wooden/stilted (D2)
Exposition handling	Information through conflict	Minor "as you know"	Exposition dump (D3)

Pass 5: Prose-Style (10% weight)

Evaluates sentence-level craft.

Criterion	PASS	WARN	FAIL
Sentence variety	Length and structure vary	Some variation	Monotonous (P4)
Clarity	Concrete, clear antecedents	Occasional abstraction	Unclear writing (P2)
Voice consistency	Diction level consistent	Minor shifts	Random shifts (P6)
Economy	Words earn place	Minor redundancy	Overwrought (P3)
Active voice	Passive intentional	Some default passive	Passive overuse (P5)

---

Composite Scoring

Each pass produces a score from 0-100:

All PASS = 100
Each WARN = -15
Each FAIL = -40

Composite = SUM(pass_score × pass_weight)

Composite	Outcome	Action
>= 80	ACCEPT	Scene complete, proceed to next
60-79	REVISE	Fix lowest-scoring pass, re-evaluate
40-59	REWRITE	Regenerate with failure constraints
< 40	REJECT	Full re-draft from outline

---

Iteration Limits

Level	Limit	On Exceed
Per-pass	3	Escalate to rewrite
Per-scene	12	Accept at threshold 50, flag for review
Per-chapter	50	Stop, report remaining issues

Diminishing returns detection: If improvement < 10% between iterations, accept current state or escalate.

---

Context Accumulation

Maintain across scenes:

Character Voices

After each scene, extract and store:

Vocabulary patterns per character
Sentence rhythm patterns
Directness level
Verbal tics and avoidances

Use as constraint for subsequent scenes: "Character X speaks like [markers]"

Plot Threads

Track:

Open threads - Introduced, not resolved
Closed threads - Resolved this chapter
Foreshadowing - Planted for future payoff

Each scene checks:

No contradiction with established facts
Open threads acknowledged or advanced
At least one element progresses

Cliche Avoidances

After cliche-transcendence pass, record:

Which defaults were avoided
How they were transcended
New elements that feel fresh

Use as constraint: "Already transcended [X], maintain freshness"

---

Progress Tracker

Use the progress tracker template to persist state:

## Chapter Progress: [Title]
Started: [timestamp]
Current: Scene [N], Pass [M], Iteration [K]

### Scenes
| Scene | Status | Pass | Iterations | Score | Issues |
|-------|--------|------|------------|-------|--------|

### Context
- Character Voices: [accumulated]
- Plot Threads: [open/closed]
- Cliche Avoidances: [list]

### Change Log
- [timestamp] [change]

---

Revision Strategy

Targeted Fix (score 60-79)

1. Identify lowest-scoring pass 2. Extract specific failure criteria 3. Generate minimal fix addressing that criterion 4. Re-evaluate that pass + downstream passes 5. If pass improves, recalculate composite

Rewrite (score 40-59)

1. Preserve scene goal from outline 2. Generate new draft with explicit constraints:

"Must include clear goal in opening"
"Conflict must escalate"
etc. based on failures

3. Re-run full evaluation loop

Reject (score < 40)

1. Return to outline beat 2. Re-draft from scratch 3. Treat as new scene (reset iterations)

---

Conflict Resolution

When fixing one pass breaks another:

1. Detect: Re-run all passes after any fix 2. Compare: Did any pass regress? 3. Prioritize: Higher-weight pass wins ties 4. Seek synthesis: Can fix satisfy both? 5. Accept trade-off: If irreconcilable, accept per hierarchy

Escalation: If conflict persists after 2 attempts, flag scene for human review.

---

Anti-Patterns

The Infinite Polisher

Pattern: Keeps iterating because one criterion is at WARN. Fix: WARN is acceptable. Accept at threshold after iteration limit.

The Pass Skipper

Pattern: Jumps to prose-style when scene-sequencing failed. Fix: Hard gate on structural passes. FAIL blocks progression.

The Context Amnesiac

Pattern: Each scene drafted in isolation, losing voice and threads. Fix: Explicit context loading before each scene draft.

The Cascade Blind Spot

Pattern: Fixes dialogue, doesn't check if prose-style regressed. Fix: Always re-evaluate current pass + downstream after any fix.

The Silent Failer

Pattern: Hits iteration limit, proceeds without documentation. Fix: Log all limit exits with categorized remaining issues.

---

Output Persistence

Progress Tracker

Location: context/chapter-drafter/[chapter]-progress.md
Update: After each scene acceptance
Purpose: Resume point if interrupted

Scene Output

Location: drafts/[story]/[chapter]/scene-[N].md
Update: On scene acceptance
Purpose: Accumulated draft prose

Context State

Location: context/chapter-drafter/[chapter]-context.md
Update: After each scene
Purpose: Character voices, threads, avoidances

---

Integration

Inbound (feeds into chapter-drafter)

Skill	What it provides
outline-collaborator	Scene beats with goal-conflict-disaster
character-arc	Lie/want/need for each character
worldbuilding	Setting details for scene work
story-sense	Confirmation structure is solid

Outbound (chapter-drafter produces)

Output	Next step
Draft chapter	revision (for full manuscript revision)
Flagged scenes	Human review
Context state	Next chapter drafting

---

Example Invocation

Input: Chapter outline with 5 scene beats

Process: 1. Load outline, confirm prerequisites 2. Initialize progress tracker 3. For each scene:

Build context from prior scenes
Draft initial prose
Run evaluation loop
On ACCEPT: extract context, write output

4. Complete: 5 polished scenes, flagged issues documented

Output:

5 scene files in drafts/[story]/[chapter]/
Progress tracker showing all iterations
Context file for next chapter
List of any flagged issues for human review

#!/usr/bin/env -S deno run --allow-read

/**
 * Scene Scoring Calculator for Chapter-Drafter Orchestrator
 *
 * Calculates composite scores from pass evaluations.
 * Used to determine ACCEPT/REVISE/REWRITE/REJECT outcomes.
 *
 * Usage:
 *   deno run --allow-read scripts/score-scene.ts --json '{"scene-sequencing": {...}}'
 *   deno run --allow-read scripts/score-scene.ts --interactive
 */

// Pass weights from chapter-drafter configuration
const PASS_WEIGHTS: Record<string, number> = {
  "scene-sequencing": 0.35,
  "character-arc": 0.25,
  "cliche-transcendence": 0.15,
  dialogue: 0.15,
  "prose-style": 0.1,
};

// Score values for each rating
const RATING_SCORES: Record<string, number> = {
  PASS: 100,
  WARN: 85,
  FAIL: 60,
};

// Decision thresholds
const THRESHOLDS = {
  ACCEPT: 80,
  REVISE: 60,
  REWRITE: 40,
};

interface CriterionResult {
  name: string;
  rating: "PASS" | "WARN" | "FAIL";
  notes?: string;
}

interface PassResult {
  pass: string;
  criteria: CriterionResult[];
  score?: number;
}

interface SceneEvaluation {
  scene: string;
  passes: PassResult[];
  composite?: number;
  decision?: "ACCEPT" | "REVISE" | "REWRITE" | "REJECT";
}

/**
 * Calculate score for a single pass based on its criteria
 */
function calculatePassScore(criteria: CriterionResult[]): number {
  if (criteria.length === 0) return 0;

  const total = criteria.reduce((sum, c) => {
    return sum + RATING_SCORES[c.rating];
  }, 0);

  return Math.round(total / criteria.length);
}

/**
 * Calculate composite score from all passes
 */
function calculateCompositeScore(passes: PassResult[]): number {
  let weightedSum = 0;
  let totalWeight = 0;

  for (const pass of passes) {
    const weight = PASS_WEIGHTS[pass.pass] || 0;
    const score = pass.score ?? calculatePassScore(pass.criteria);

    weightedSum += score * weight;
    totalWeight += weight;
  }

  return totalWeight > 0 ? Math.round(weightedSum / totalWeight) : 0;
}

/**
 * Determine decision based on composite score
 */
function determineDecision(
  composite: number,
  passes: PassResult[]
): "ACCEPT" | "REVISE" | "REWRITE" | "REJECT" {
  // Critical failure: scene-sequencing FAIL overrides score
  const sceneSequencing = passes.find((p) => p.pass === "scene-sequencing");
  if (sceneSequencing) {
    const hasFail = sceneSequencing.criteria.some((c) => c.rating === "FAIL");
    if (hasFail) {
      return "REWRITE"; // Structural failure forces rewrite regardless of score
    }
  }

  if (composite >= THRESHOLDS.ACCEPT) return "ACCEPT";
  if (composite >= THRESHOLDS.REVISE) return "REVISE";
  if (composite >= THRESHOLDS.REWRITE) return "REWRITE";
  return "REJECT";
}

/**
 * Find the lowest-scoring pass for targeted revision
 */
function findLowestScoringPass(passes: PassResult[]): string | null {
  let lowest: PassResult | null = null;
  let lowestScore = Infinity;

  for (const pass of passes) {
    const score = pass.score ?? calculatePassScore(pass.criteria);
    if (score < lowestScore) {
      lowestScore = score;
      lowest = pass;
    }
  }

  return lowest?.pass ?? null;
}

/**
 * Get all failing criteria across all passes
 */
function getFailingCriteria(
  passes: PassResult[]
): Array<{ pass: string; criterion: CriterionResult }> {
  const failing: Array<{ pass: string; criterion: CriterionResult }> = [];

  for (const pass of passes) {
    for (const criterion of pass.criteria) {
      if (criterion.rating === "FAIL") {
        failing.push({ pass: pass.pass, criterion });
      }
    }
  }

  return failing;
}

/**
 * Process a complete scene evaluation
 */
function evaluateScene(evaluation: SceneEvaluation): SceneEvaluation {
  // Calculate pass scores
  for (const pass of evaluation.passes) {
    pass.score = calculatePassScore(pass.criteria);
  }

  // Calculate composite
  evaluation.composite = calculateCompositeScore(evaluation.passes);

  // Determine decision
  evaluation.decision = determineDecision(
    evaluation.composite,
    evaluation.passes
  );

  return evaluation;
}

/**
 * Generate a summary report
 */
function generateReport(evaluation: SceneEvaluation): string {
  const lines: string[] = [];

  lines.push(`# Scene Evaluation: ${evaluation.scene}`);
  lines.push("");

  // Pass scores
  lines.push("## Pass Scores");
  lines.push("");
  lines.push("| Pass | Score | Weight | Weighted |");
  lines.push("|------|-------|--------|----------|");

  for (const pass of evaluation.passes) {
    const weight = PASS_WEIGHTS[pass.pass] || 0;
    const weighted = Math.round((pass.score ?? 0) * weight);
    lines.push(
      `| ${pass.pass} | ${pass.score} | ${(weight * 100).toFixed(0)}% | ${weighted} |`
    );
  }

  lines.push("");
  lines.push(`**Composite Score:** ${evaluation.composite}`);
  lines.push(`**Decision:** ${evaluation.decision}`);
  lines.push("");

  // Failing criteria
  const failing = getFailingCriteria(evaluation.passes);
  if (failing.length > 0) {
    lines.push("## Failing Criteria");
    lines.push("");
    for (const { pass, criterion } of failing) {
      lines.push(
        `- **${pass}**: ${criterion.name}${criterion.notes ? ` - ${criterion.notes}` : ""}`
      );
    }
    lines.push("");
  }

  // Revision guidance
  if (evaluation.decision === "REVISE") {
    const lowestPass = findLowestScoringPass(evaluation.passes);
    lines.push("## Revision Guidance");
    lines.push("");
    lines.push(`Target lowest-scoring pass: **${lowestPass}**`);
    lines.push("");
  }

  return lines.join("\n");
}

// Example evaluation for testing
const exampleEvaluation: SceneEvaluation = {
  scene: "Chapter 1, Scene 3",
  passes: [
    {
      pass: "scene-sequencing",
      criteria: [
        { name: "Goal clarity", rating: "PASS" },
        { name: "Conflict escalation", rating: "PASS" },
        { name: "Disaster quality", rating: "WARN", notes: "Simple 'No' ending" },
        { name: "Sequel presence", rating: "PASS" },
        { name: "Scene-sequel ratio", rating: "PASS" },
      ],
    },
    {
      pass: "character-arc",
      criteria: [
        { name: "Lie visibility", rating: "PASS" },
        { name: "Want/Need gap", rating: "PASS" },
        { name: "Arc progress", rating: "WARN", notes: "Arc static this scene" },
        { name: "Transformation markers", rating: "PASS" },
      ],
    },
    {
      pass: "cliche-transcendence",
      criteria: [
        { name: "Form axis", rating: "PASS" },
        { name: "Knowledge axis", rating: "WARN", notes: "Mentor too plot-aware" },
        { name: "Goal axis", rating: "PASS" },
        { name: "Role axis", rating: "PASS" },
      ],
    },
    {
      pass: "dialogue",
      criteria: [
        { name: "Voice distinctiveness", rating: "PASS" },
        { name: "Subtext presence", rating: "WARN", notes: "Some on-the-nose lines" },
        { name: "Double-duty test", rating: "PASS" },
        { name: "Naturalness", rating: "PASS" },
        { name: "Exposition handling", rating: "PASS" },
      ],
    },
    {
      pass: "prose-style",
      criteria: [
        { name: "Sentence variety", rating: "PASS" },
        { name: "Clarity", rating: "PASS" },
        { name: "Voice consistency", rating: "PASS" },
        { name: "Economy", rating: "PASS" },
        { name: "Active voice", rating: "PASS" },
      ],
    },
  ],
};

// Main execution
function main() {
  const args = Deno.args;

  if (args.includes("--help") || args.includes("-h")) {
    console.log(`
Scene Scoring Calculator for Chapter-Drafter

Usage:
  score-scene.ts --example          Run with example evaluation
  score-scene.ts --json '<json>'    Evaluate JSON input
  score-scene.ts --interactive      Interactive mode (prompts for input)

Pass Weights:
  scene-sequencing:     35%
  character-arc:        25%
  cliche-transcendence: 15%
  dialogue:             15%
  prose-style:          10%

Decision Thresholds:
  ACCEPT:  >= 80
  REVISE:  60-79
  REWRITE: 40-59
  REJECT:  < 40
`);
    Deno.exit(0);
  }

  if (args.includes("--example")) {
    const result = evaluateScene(exampleEvaluation);
    console.log(generateReport(result));
    console.log("\n---\n");
    console.log("JSON Output:");
    console.log(JSON.stringify(result, null, 2));
    Deno.exit(0);
  }

  const jsonIndex = args.indexOf("--json");
  if (jsonIndex !== -1 && args[jsonIndex + 1]) {
    try {
      const input = JSON.parse(args[jsonIndex + 1]);
      const result = evaluateScene(input);
      console.log(generateReport(result));
    } catch (e) {
      console.error("Error parsing JSON:", e);
      Deno.exit(1);
    }
    Deno.exit(0);
  }

  // Default: show example
  console.log("Run with --example to see sample evaluation");
  console.log("Run with --help for usage information");
}

main();

// Export for use as module
export {
  calculatePassScore,
  calculateCompositeScore,
  determineDecision,
  evaluateScene,
  generateReport,
  findLowestScoringPass,
  getFailingCriteria,
  PASS_WEIGHTS,
  RATING_SCORES,
  THRESHOLDS,
};

export type { CriterionResult, PassResult, SceneEvaluation };

Pass Criteria Reference

Detailed evaluation criteria extracted from editorial skills. Use this reference when evaluating scenes.

---

Pass 1: Scene-Sequencing (35% weight)

Source: skills/fiction/scene-sequencing/SKILL.md

Core Principle

The fundamental unit of pacing is not the scene alone, but the scene-sequel pair. Scenes create tension; sequels process it.

Scene Structure: Goal → Conflict → Disaster

Goal Evaluation

[ ] Goal is specific and concrete
[ ] Goal is achievable within the scene
[ ] Goal connects to larger story goals
[ ] Goal is clear to reader within first beats

PASS: Clear goal in opening beats WARN: Goal exists but buried FAIL: No discernible character goal

Conflict Evaluation

[ ] Opposition to goal present
[ ] Conflict escalates (not static)
[ ] Each beat makes goal harder
[ ] Source of conflict appropriate (character, environment, internal)

PASS: Opposition intensifies through scene WARN: Conflict present but static FAIL: No real opposition

Disaster Evaluation

[ ] Scene ends with clear outcome
[ ] Outcome creates complications

Outcome Type	Strength
Yes, but...	Strongest (goal achieved, new problem)
No, and furthermore...	Strong (goal failed, situation worse)
No	Moderate (goal failed, must retry)
Yes	Weak (kills tension)

PASS: "Yes, but..." or "No, and furthermore..." WARN: Simple "No" FAIL: Clean "Yes" or no resolution

Sequel Structure: Reaction → Dilemma → Decision

Sequel Evaluation

[ ] Emotional reaction present
[ ] Character faces choice with no good options
[ ] Decision leads to next scene's goal

PASS: Full sequel present (or appropriate compression) WARN: Abbreviated sequel FAIL: Missing after high-tension scene

Pacing Ratio

[ ] Scene/sequel ratio matches intended pacing
[ ] More scene = fast-paced, action-heavy
[ ] More sequel = slow-paced, reflective

PASS: Matches intent WARN: Slight mismatch FAIL: Severely mismatched

Anti-Patterns to Flag

The Relentless Scene (no processing time)
The Wallowing Sequel (introspection without decision)
The Arbitrary Disaster (outcome disconnected from conflict)
The Clean Victory (drains tension)
Missing Goal (no drive)

---

Pass 2: Character-Arc (25% weight)

Source: skills/fiction/character-arc/SKILL.md

Core Principle

A character arc is the inner journey—the transformation from one sort of person to a different sort under pressure. The arc is not the plot.

Arc Components

Lie Evaluation

[ ] Character's false belief is evident
[ ] Lie manifests in choices/behavior
[ ] Lie connects to backstory wound

PASS: False belief evident in choices WARN: Lie present but unstated FAIL: No lie operative in this scene

Want/Need Gap

[ ] What character thinks they need (Want) is clear
[ ] What would actually fulfill them (Need) is different
[ ] Gap creates tension

PASS: Clear tension between stated and actual need WARN: Gap exists but unclear FAIL: Want = Need (no tension)

Arc Progress

[ ] Scene advances character toward or away from truth
[ ] Or scene challenges the arc meaningfully

PASS: Scene advances or challenges arc WARN: Arc static but consistent FAIL: Character contradicts established arc

Transformation Markers

[ ] If this is a transformation beat, it's earned
[ ] Character's choices reflect current arc position
[ ] Resistance to change is visible when appropriate

PASS: Choices reflect arc position WARN: Position unclear FAIL: Acts against established personality

Anti-Patterns to Flag

The Informed Arc (told changed, not shown)
The Magic Mentor (change from telling, not discovery)
The Trauma = Transformation Fallacy
The Perfect Protagonist (no lie = no arc)
The Instant Epiphany (no buildup)

---

Pass 3: Cliche-Transcendence (15% weight)

Source: skills/fiction/cliche-transcendence/SKILL.md

Core Principle

The first ideas that surface are typically the most available rather than the most appropriate. A trope becomes cliché when every aspect matches the default pattern.

The Four Axes Evaluation

Axis	Cliché	Orthogonal
Form	Expected element	Same but with twist
Knowledge	Knows about central plot	Has own concerns, intersects accidentally
Goal	Wants to help/stop protagonist	Wants something unrelated that collides
Role	Exists for protagonist	Has own story that intersects

Orthogonality Test

For each significant element in the scene:

[ ] Form axis: Is it the expected version?
[ ] Knowledge axis: Does it know what story it's in?
[ ] Goal axis: Does it exist to serve the protagonist?
[ ] Role axis: Does it have its own story?

PASS: At least 2 axes orthogonal WARN: Only 1 axis orthogonal FAIL: All axes match default (pure cliché)

Key Question

"Does it know what story it's in?"

Cliché: Elements act as if they know their narrative function
Fresh: Elements have own logic that collides with story

Anti-Patterns to Flag

Inversion as Innovation (opposite equally tired)
Novelty Over Function (original but doesn't serve story)
Enumeration Avoidance (didn't identify the defaults)
Form-Only Changes (corporate security = FBI in different uniform)
Protagonist Orbit Preservation (everything serves hero)

---

Pass 4: Dialogue (15% weight)

Source: skills/fiction/dialogue/SKILL.md

Core Principle

Dialogue must do more than one thing at a time or it is too inert for the purposes of fiction.

The Three Layers

Layer	Definition	Check
Text	What's literally said	Character-specific? Natural rhythm?
Subtext	What's meant beneath	Gap between said and meant?
Context	What shapes exchange	Power dynamics? History?

Voice Distinctiveness (D1)

[ ] Characters distinguishable without tags
[ ] Vocabulary differs per character
[ ] Sentence complexity varies
[ ] Directness levels differ

PASS: Speakers identifiable without tags WARN: Some overlap but distinct FAIL: Identical voices

Naturalness (D2)

[ ] Contractions used appropriately
[ ] Some incomplete sentences
[ ] Characters interrupt/talk past each other
[ ] Reads naturally aloud

PASS: Natural rhythm, contractions, interruptions WARN: Slightly formal FAIL: Wooden/stilted

Exposition Handling (D3)

[ ] No "As you know, Bob..." constructions
[ ] Information through conflict/discovery
[ ] Characters disagree about facts

PASS: Information through conflict WARN: Minor "as you know" FAIL: Exposition dump

Subtext Presence (D4)

[ ] Emotional states shown, not declared
[ ] Characters want things they can't ask directly
[ ] Gap between said and meant

PASS: Clear subtext layer WARN: Occasional direct statements FAIL: Everything on-the-nose

Double-Duty Test (D5)

For each exchange, count functions served: 1. Plot advancement 2. Character revelation 3. Subtext/tension 4. Relationship development

PASS: 3+ functions WARN: 2 functions FAIL: Single function only

Anti-Patterns to Flag

The Exposition Dump
The Identical Twins (same voice)
The Court Reporter (meaningless realism)
The Emotional Narrator (tags do dialogue's job)
The Tennis Match (perfect alternation)

---

Pass 5: Prose-Style (10% weight)

Source: skills/fiction/prose-style/SKILL.md

Core Principle

Style is not decoration; style is content. Vigorous writing is concise.

Sentence Variety (P4)

[ ] Sentence lengths vary (short, medium, long)
[ ] Sentence structures vary (simple, compound, complex)
[ ] Sentence openings vary (not all subject-verb)

PASS: Clear variety WARN: Some variation FAIL: Monotonous

Clarity (P2)

[ ] Concrete language outweighs abstract
[ ] Pronoun antecedents clear
[ ] Logic visible, not compressed

PASS: Clear, concrete WARN: Occasional abstraction FAIL: Reader must reread

Voice Consistency (P6)

[ ] Diction level consistent
[ ] Shifts are intentional
[ ] Tone maintained

PASS: Consistent voice WARN: Minor shifts FAIL: Random voice changes

Economy (P3)

[ ] No adjective stacking
[ ] Adverbs used sparingly
[ ] Words earn their place

PASS: Vigorous, concise WARN: Minor redundancy FAIL: Overwrought/purple

Active Voice (P5)

[ ] Passive used intentionally
[ ] Important agents named
[ ] Action sequences active

PASS: Active voice default, passive intentional WARN: Some default passive FAIL: Passive overuse

The Read-Aloud Test

[ ] No stumbles when read aloud
[ ] Rhythm feels natural
[ ] Awkward passages caught

Anti-Patterns to Flag

The Thesaurus Abuser
The Adjective Hoarder
The Passive Defaulter
The Monotone
The Purple Writer

---

Scoring Reference

Per-Criterion Scoring

PASS = 100
WARN = 85
FAIL = 60

Per-Pass Scoring

Pass Score = Average of all criteria scores

Composite Scoring

Composite = SUM(Pass Score × Weight)

Pass	Weight
scene-sequencing	0.35
character-arc	0.25
cliche-transcendence	0.15
dialogue	0.15
prose-style	0.10

Decision Thresholds

Composite	Decision
>= 80	ACCEPT
60-79	REVISE
40-59	REWRITE
< 40	REJECT

Chapter Progress Tracker

Chapter: [Title]

Story: [Story Name] Started: [YYYY-MM-DD HH:MM] Last Updated: [YYYY-MM-DD HH:MM] Status: [In Progress | Complete | Flagged for Review]

---

Current Position

Scene: [N] of [Total]
Pass: [scene-sequencing | character-arc | cliche-transcendence | dialogue | prose-style]
Iteration: [K] of [max_iterations]
Global Iterations: [X] of [global_max_iterations]

---

Scenes

Scene	Beat Summary	Status	Current Pass	Iterations	Score	Issues
1	[goal/disaster]	[Pending/In Progress/Accepted/Flagged]	-	-	-	-
2	[goal/disaster]	Pending	-	-	-	-
3	[goal/disaster]	Pending	-	-	-	-

---

Scene Detail: [Current Scene]

Outline Beat

[Copy from outline: goal, conflict, disaster, purpose]

Pass History

Pass	Iteration	Score	Result	Issues Found	Issues Fixed
scene-sequencing	1	-	-	-	-
character-arc	-	-	-	-	-
cliche-transcendence	-	-	-	-	-
dialogue	-	-	-	-	-
prose-style	-	-	-	-	-

Composite Scores

After iteration 1: -
After iteration 2: -
After iteration 3: -
Final: -

Actions Taken

1. [timestamp] [action: draft/revise/rewrite] 2. [timestamp] [action]

---

Context Accumulation

Character Voices

Character	Vocabulary	Rhythm	Directness	Tics	Avoids
[Name]	[patterns]	[short/medium/long]	[blunt/indirect]	[phrases]	[topics]

Plot Threads

Thread	Status	Introduced	Last Touched	Notes
[Thread name]	[Open/Closed/Foreshadowed]	Scene [N]	Scene [N]	[details]

Cliche Avoidances

Element	Default Avoided	Transcendence Used	Scene
[element]	[what was avoided]	[how it was made fresh]	[N]

Established Facts

[Fact 1 from earlier scenes]
[Fact 2]

---

Flagged Issues

Issues that hit iteration limits or require human judgment:

Scene	Pass	Issue	Category	Iterations	Notes
[N]	[pass]	[issue]	[Minor/Structural/Stylistic]	[N]	[context]

---

Change Log

Timestamp	Scene	Action	Details
[YYYY-MM-DD HH:MM]	[N]	[Draft/Revise/Rewrite/Accept/Flag]	[what changed]

---

Summary Statistics

Total Scenes: [N]
Accepted: [N]
Flagged: [N]
Total Iterations: [N]
Average Iterations per Scene: [N]
Average Final Score: [N]

Pass Performance

Pass	Avg Score	Avg Iterations	Most Common Issue
scene-sequencing	-	-	-
character-arc	-	-	-
cliche-transcendence	-	-	-
dialogue	-	-	-
prose-style	-	-	-

Related skills

Remotion Best PracticesGet Remotion-specific coding guidance that prevents common video rendering mistakes when creating animated React videos.451k4.2k

Ai Video GenerationGenerate videos using 40+ AI models including Veo, Seedance, and others via inference.sh442k665

Ai Image GenerationGenerate images using 50+ AI models including FLUX, Gemini, and Replicate via inference.sh441k665

Ai Avatar VideoGenerate videos featuring AI avatars for product demos, tutorials, marketing, or explainers441k665

Remotion RenderRender videos programmatically using React components and Remotion framework441k665

Remotion RenderGenerate high-quality MP4 videos from React code using Remotion inside an AI coding agent.363k665

Generative Mediallmautomation