Claude Skill

scene-craft

This skill should be used when the user asks to "plan a scene", "scene structure", "sequel scene", "dialogue subtext", "deep POV", "psychic distance", "try fail", "scene cards", "exposition", "info dump", "flashback", "time skip", "story opening", "first page hook", "introduce a

LLM Mart · 0 points · 0 views 0 listing impressions 0 install-command copies
Virus-scanned Reviewed automatically before listing.

Full trust report

Download danjdewhurst-story-skills-skills_scene-craft-8350f77.zip · 15 KB
Part of danjdewhurst/story-skills — 11 skills

Install

skills CLI npx skills add https://github.com/danjdewhurst/story-skills/tree/main/skills/scene-craft
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install danjdewhurst-story-skills@llmmart
Git git clone https://github.com/danjdewhurst/story-skills.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole danjdewhurst/story-skills collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

Scene Craft

Overview

Plan and check scenes at the scene grain — the layer between plot beats and chapter prose. Covers the missing half of the chapter-writing scene model (Scene and Sequel), try/fail escalation, scene cards, dialogue subtext, deep POV and psychic distance, exposition handling, flashbacks and time skips, and openings. Use during chapter planning, before drafting, and in revision when a scene feels flat.

Prerequisites

A story project must already exist (created via the story-init skill), with characters defined (character-management) and a plot structure in place (plot-structure). This skill extends chapter-writing; it does not replace the outline-first drafting workflow.

Workflow

  1. Choose the craft layer. Identify which scene-grain problem this is:
    • Scene feels like incidents with no breathing room → references/scene-sequel.md
    • Middle of the chapter sags or resolves too easily → references/try-fail.md
    • Chapter has multiple POVs/timelines to order → references/scene-cards.md
    • Conversation reads flat or voices blur → references/dialogue-subtext.md
    • Narration feels distant or head-hops → references/deep-pov.md
    • Worldbuilding facts are piling up undelivered → references/exposition.md
    • Past events or a time jump are needed → references/flashbacks-time.md
    • Starting the book or a chapter, or introducing a character → references/openings.md
  2. Read the relevant reference(s). Each file carries its own checklists and planning fields; apply them, don't paraphrase them.
  3. Clarify missing inputs before planning or editing. Ask the user for any required inputs you cannot establish from the project files — scene purpose, viewpoint, location, canon-changing intent, and the applicable craft layer. Never guess at these or proceed on assumptions; a wrong guess edits canon. Only continue to step 4 once every required input is known.
  4. Plan before prose. For the scene in question, write the planning inputs the reference requires (sequel beats, try/fail positions, subtext wants, zoom level, exposition audit, flashback trigger, hook check) into the chapter outline or the scene's planning notes before drafting or revising.
  5. Record machine-readable state. Update the scene file in scenes/:
    • Set sequel: true/false and fill the dilemma: field plus the ## Sequel section (reaction/dilemma/decision) for scenes with sequel content (see references/scene-sequel.md)
    • Add flashback-to: (freeform note of the flashed-back moment, validated as a scalar by story validate but not used by continuity checks) and move flashback-only characters to mentions (see references/flashbacks-time.md)
    • Keep state-changes current for every change the scene makes
  6. Run the reference's checklist against the draft or the revision plan (try/fail checklist, deep-POV filter-word scan, tag-swap test, first-page hook check).
  7. Hand off cleanly. Scene/sequel planning feeds the chapter-writing drafting workflow; theme-audit findings feed revision-continuity. When a scene decision changes canon (new knowledge, moved objects, changed relationships), update continuity/state.md and the affected entity files (bidirectional links, per the story-init conventions).

Conventions

  • Scene ids stay chapter-{NN}-scene-{NN}; scene files live in scenes/ with kebab-case filenames.
  • All planning metadata (dilemma, decision, subtext wants, psychic-distance level) lives in frontmatter or a ## Planning / ## Scene Card section of the scene file — never only in chat.
  • characters vs mentions follows the story-init rule: characters present in-scene under characters; remembered, recorded, or flashback-only characters under mentions.
  • Do not overwrite chapter prose merely to satisfy a craft checklist. Flag intentional deviations (e.g. a deliberate info dump as a stylistic device) in the scene file's planning notes so a later audit doesn't "fix" them.

CLI Maintenance

Use the Story CLI when it is available. If story is not installed, use bun run story -- from the Story Skills repository checkout or the bundled fallback node ../story-maintenance/scripts/story.js with the same arguments, resolving the path relative to this skill folder. If no CLI is available, perform the registry, backlink, and word-count checks manually.

After adding or revising scene records:

story reindex .
story links .
story validate .
story continuity .

Reference Files

  • references/scene-sequel.md - Sequel mechanics: reaction → dilemma → decision (Dwight Swain's scene framework)
  • references/try-fail.md - Try/fail escalation cycles and the Five Commandments scene shape
  • references/scene-cards.md - Scene card unit (start state → change → end state), reordering, POV braiding
  • references/dialogue-subtext.md - Subtext as planning input, dialogue-as-negotiation, voice differentiation, tag-swap test
  • references/deep-pov.md - Psychic distance zoom levels and checkable deep-POV rules
  • references/exposition.md - Drip-feed, conflict-carried exposition, in-world documents, info-dump warning
  • references/flashbacks-time.md - Flashback entry/exit mechanics, tension-cheat warning, time-skip conventions
  • references/openings.md - In medias res, "enter late, leave early", first-page hook check, character introduction technique
Files (story-skills)
  • references
    • deep-pov.md 3.4 KB
      # Deep POV and Psychic Distance
      
      Boundary note: this reference covers psychic distance as a **controllable
      planning variable** and deep-POV mechanics as **checkable structural rules**.
      Voice calibration and line-level prose quality belong to the `better-writing`
      skill; consult it before polishing prose.
      
      ## Psychic distance as a zoom level
      
      Psychic distance is how close the narration sits to a character's interior —
      a zoom the writer controls scene by scene. Common levels, from far to near:
      
      1. **Distant observer:** "The woman at the bar had been waiting an hour."
         (external, no character's interior)
      2. **Mild interiority:** "Sera had been waiting an hour, and the bartender
         still hadn't looked her way." (named character, mild interpretation)
      3. **Close third:** "Sera checked the clock again. Still no bartender. An
         hour, gone." (interior voice bleeding in)
      4. **Deep POV:** "The clock hadn't moved. Of course it hadn't moved. She'd
         counted the bottles twice." (pure character perception, no narrator
         mediation)
      
      Plan the zoom **per scene** before drafting:
      
      - **Action and revelation scenes:** zoom in. The reader needs the cost felt.
      - **Transitions and wide establishing moments:** zoom out. Distant narration
        moves faster.
      - **Shifts must be deliberate.** One zoom level per scene, chosen in advance
        and recorded in the scene record's planning notes (`psychic-distance:
        {distant|close|deep}`). Zooming mid-scene without a scene break reads as
        head-hopping's gentler cousin.
      
      ## Checkable deep-POV rules
      
      When a scene is planned at deep-POV level, enforce these mechanically before
      and after drafting:
      
      **Filter words to strike.** These words insert a narrator between the reader
      and the POV character's perception:
      
      - felt, feel, feeling (she felt afraid → her hands shook)
      - knew, know, knowing
      - wondered
      - thought, think, thinking (no thought-tags — see below)
      - realized, realization
      - noticed, saw, heard, smelled (as perception announcements: "she saw the
        door open" → "the door swung open")
      
      This is a checkable list, not a style guide. Scan the draft for each word;
      where it mediates perception, rewrite as direct perception.
      
      **No thought-tags.** Italicized thoughts with tags ("she thought," "she told
      herself") are training wheels. Deep POV expresses thought as unmediated
      narration: "The clock hadn't moved. Liar." Never tag interior monologue.
      
      **Perception filter.** Narrate only what the POV character could perceive:
      
      - Nothing that happens elsewhere (cut to a new scene or stay ignorant).
      - Nothing the POV character didn't notice (if it mattered and they missed
        it, that's a planned knowledge gap — log it in `continuity/questions/`,
        not an accident).
      - Nothing from the future (no foreshadowing inside the POV character's
        narration — that is narrator intrusion; plant foreshadowing in the world
        they perceive, not in their predictions).
      - Perception filtered by **job, history, and fears**: a soldier notices
        exits and hands; a botanist notices the rot on the roses; a liar watches
        for lies. When writing what the POV perceives, consult the character file's
        backstory and current emotional state — two characters in the same room
        should notice different things.
      
      ## Post-draft check
      
      For deep-POV scenes, run the filter-word list against the draft, then re-read
      the scene asking only: "Who perceived this?" If the answer is ever "the
      narrator, not the character," pull the zoom tighter or rewrite the passage.
      
    • dialogue-subtext.md 3.7 KB
      # Dialogue: Subtext and Voice Differentiation
      
      Boundary note: this reference covers dialogue as a **planning and
      structure** tool — what each character secretly wants in the scene, and a
      checkable recipe for making voices distinguishable. Line-level prose quality
      (literary dialogue rhythm, anti-generic phrasing) belongs to the
      `better-writing` skill. Consult that skill before polishing dialogue prose.
      
      ## Subtext as a planning input
      
      Subtext is the gap between what is said and what each character actually
      wants. Before drafting any conversation, write down for each participant:
      
      - **Said want:** what the character claims to want in this scene (their
        spoken goal).
      - **Hidden want:** what they actually want — usually emotional, often
        something they would never say aloud (approval, safety, revenge, proof
        they matter).
      - **Why they can't say it:** pride, fear, leverage, ignorance. The reason
        shapes every evasion.
      
      Record these in the scene record's planning notes or the chapter outline:
      
      ```yaml
      dialogue-subtext:
        - character: {character-kebab}
          said-want: "{What they claim to want}"
          hidden-want: "{What they actually want but won't say}"
        - character: {character-kebab}
          said-want: "..."
          hidden-want: "..."
      ```
      
      When said-want and hidden-want are the same, the dialogue has no subtext —
      either the character is being honest (mark it as a deliberate choice) or the
      exchange needs a hidden layer added.
      
      ## Dialogue as negotiation
      
      Treat every exchange as a negotiation, not a Q&A. Each turn of dialogue
      should do one of:
      
      - **Probe:** test the other person for information, weakness, or intention
      - **Parry:** deflect a probe without revealing anything
      - **Advance:** trade information for something, concede ground to gain ground
      - **Feint:** appear to concede while actually maneuvering
      
      Dialogue where characters take turns delivering information to the reader is
      an interrogation, not a conversation. If both characters' turns only pass
      facts, rewrite so at least one participant is trying to get something the
      other won't freely give.
      
      ## Voice differentiation recipe
      
      Build each character's dialogue voice from four checkable components
      (recorded in their `Voice & Speech Patterns` profile section, with example
      lines):
      
      1. **Verbal tic:** one recurring word, phrase, or hedge (not a caricature —
         one per character, used sparingly).
      2. **Syntactic preference:** short clipped sentences vs. long rolling ones;
         questions vs. declarations; formal vs. fragmentary.
      3. **Topic steered toward under stress:** when cornered, what does this
         character retreat to talking about?
      4. **Topic refused:** what will this character never discuss, and what do
         they do instead when it comes up (deflect, joke, go silent, leave)?
      
      ## The tag-swap test
      
      Strip the dialogue tags and speaker names from a finished exchange. Hand the
      bare lines to a cold read. If the voices are distinct, a reader familiar with
      the characters should be able to reassign most lines correctly. If not:
      
      - The voices are not distinct enough — strengthen one character's syntactic
        preference and stress-topic, not by adding more tics.
      - Do not "fix" it by giving every character a catchphrase. Tics are seasoning;
        syntax and motive are the meal.
      
      ## Beat economy
      
      - Keep **~3 spoken lines max** between action beats or sensory anchors. A beat
        is a line of physical action, a noticed detail, or a silence with weight.
      - Beats do double duty: they carry subtext (crossed arms while saying "I'm
        fine") and they break up speeches.
      - For arguments: allow interruptions and cut-offs. Let one character finish
        another's sentence wrongly. People fighting don't wait their turn, and they
        answer the argument they *heard*, not the one that was spoken.
      
    • exposition.md 3.1 KB
      # Exposition Craft
      
      Agents with full worldbuilding files are prone to dumping them onto the page.
      This reference is the guardrail: how to deliver necessary information without
      stopping the story.
      
      ## The info-dump warning
      
      If a passage exists only to transfer information from the worldbuilding files
      to the reader, it is an info dump. Test each expository passage:
      
      - **Cut test:** if you cut the passage, does the *scene's* action still make
        sense? If yes, the information belongs somewhere else — or nowhere.
      - **Knowledge test:** does the POV character have a *scene reason* to think
        or say this right now? "Because the reader needs it" is not a reason.
      
      ## Drip-feed
      
      Deliver background information in the smallest useful piece, at the latest
      possible moment:
      
      - The reader needs the **consequence** now and the **explanation** later.
        Show the sealed gate first; explain the treaty that sealed it three
        chapters later, when the treaty breaks.
      - One new world fact per scene is plenty. Two is crowded. A paragraph of
        history is a crowd.
      - When in doubt, delay: an unexplained detail the reader files away is
        foreshadowing; an explained one is exposition. Track planned delayed
        reveals in `continuity/questions/` so they don't become forgotten setups.
      
      ## Exposition carried by conflict
      
      Information the characters argue about gets absorbed; information they
      lecture about gets skipped. Delivery vehicles that carry conflict:
      
      - **An argument about the facts** — two characters with different stakes
        disputing what happened (and both may be partly wrong).
      - **A test or interrogation** — the POV character needs the information to
        survive the scene, not just to know it.
      - **Withheld leverage** — a character who knows something uses it as
        currency; the exposition arrives when they finally spend it.
      
      Conversely: never deliver exposition as a cooperative lecture between two
      characters who both already know it ("As you know, Bob..."). If both parties
      know it, they have no scene reason to say it.
      
      ## In-world documents as delivery vehicles
      
      When a chunk of information must arrive intact, embed it in a world artifact
      rather than narration:
      
      - Letters, orders, decrees, newspaper articles, lab reports, contracts,
        diary entries, inscriptions.
      - The document must have a **scene reason to exist**: someone delivers it,
        finds it, steals it, or forges it. A document that appears only to inform
        the reader is narration wearing a costume.
      - Keep it short. A three-sentence decree beats a page of minutes.
      - For gameable depth: documents can lie, omit, or be misread — the gap
        between the document and the truth is a planned `continuity/questions/`
        entry.
      
      ## Pre-draft exposition audit
      
      For each scene's planned exposition, record in the outline:
      
      1. The fact to deliver (one line).
      2. Why the POV character encounters it *now* (scene reason).
      3. Whether it's drip-fed, conflict-carried, or document-delivered.
      4. If it's a delayed explanation, the question id it was planted under.
      
      A scene whose only answer to (2) is "the reader needs to know" gets its
      exposition cut or rescheduled.
      
    • flashbacks-time.md 3.3 KB
      # Flashbacks and Time Skips
      
      ## Flashback entry and exit mechanics
      
      A flashback must feel like entering and leaving a room, not like a footnote.
      Use a two-step entry and a two-step exit:
      
      **Entry:**
      1. **Sensory trigger in the present** — a smell, a sound, a phrase that the
         POV character actually perceives right now. The trigger belongs in the
         present scene.
      2. **Clean break** — a scene break (`---`) or a hard paragraph transition.
         Then start the flashback *in media res* of the past moment, not with
         "She remembered when..." (that is a filter-word entry — see `deep-pov.md`).
      
      **Exit:**
      1. **Echo the trigger** — return on the same sensory detail, now changed by
         what the flashback revealed.
      2. **Resume present motion** — the present scene continues; the flashback
         must have *cost* something (time lost, a reaction seen, a decision
         changed) or it was free information.
      
      Record flashbacks in the scene record with `flashback-to: {when}` (a freeform
      scalar validated by `story validate` and preserved by the CLI) and the
      characters appearing in them under `mentions` (not `characters`), per the
      story-init convention — this keeps `story continuity` from flagging
      posthumous or temporally-impossible appearances (continuity checks use
      `mentions`, not `flashback-to`).
      
      ## The flashback-as-tension-cheat warning
      
      A flashback placed at a cliffhanger is a cheat: it pauses the present tension
      to spend cheaper past tension. Test every flashback placement:
      
      - **Does the present scene lose urgency because the flashback interrupts it?**
        If yes, move the flashback earlier (plant the memory before the crisis) or
        later (let the memory arrive when the character is safe enough to have it).
      - **Does the flashback contain the actual stakes of the story?** If the most
        dramatic events live in flashbacks, the story's timeline is wrong — the
        story should start later.
      
      The legitimate use: a flashback that *deepens* the present stakes (the
      ambush matters more because we now know who taught her to fight) placed at a
      moment of relative calm, not at a cliffhanger.
      
      ## Time skips
      
      When the story jumps forward (days, months, years):
      
      - **Bridge with a single decisive detail** — one line that shows what
        changed: "By spring, the orchard was a field of stumps." Not a summary
        paragraph of everything that happened.
      - **Update `continuity/state.md`** for every skipped interval: character
        state, object custody, and knowledge that would have changed. Skips are
        where continuity errors breed.
      - **Update `plot/timeline.md`** with the skipped period marked explicitly
        (`Day 40 → Day 120: {what the skip covers}`), so later agents don't assume
        nothing happened.
      - **Record the skip in the chapter frontmatter** as
        `time-skip: {from} → {to}`.
      
      ## Flashback discipline
      
      - One flashback per chapter is plenty; two needs justification.
      - Never open a chapter with a flashback (see `openings.md` — the first page
        must establish present-tense instability, not past context).
      - A flashback longer than the present scene around it has become the real
        scene: rename it and restructure.
      - Backstory delivered because "the reader should know" belongs in the
        character file, not on the page. Backstory delivered because the POV
        character *needs it now* to make their decision belongs in the sequel
        (see `scene-sequel.md`).
      
    • openings.md 3.1 KB
      # Openings and Character Introductions
      
      ## In medias res
      
      Open the story inside instability, not before it. "In medias res" means the
      first page carries a situation already in motion — a decision pending, a
      threat present, a want unmet — not the backstory that led to it.
      
      - **Chronology-first planning:** know the full chain of events, then choose
        to *start* at the latest point that still gives the reader a character to
        care about with a problem to follow. Everything before that point is
        backstory, deliverable later via `exposition.md` or `flashbacks-time.md`.
      - **Enter late, leave early:** scenes — and the story itself — should open
        as close to the inciting motion as possible and cut before the aftermath
        settles. The reader arrives mid-argument, leaves mid-escape.
      
      ## The first-page hook check
      
      Before approving a chapter-one opening (or any chapter opening), verify the
      first page delivers all three, in this order of priority:
      
      1. **Voice** — a narration or POV texture that is unmistakably *this
         character's*, not generic narrator prose.
      2. **Want** — the POV character wants something concrete, right now, on this
         page. Not a life goal: a scene goal.
      3. **Instability** — something is wrong, off, threatened, or about to change.
      
      What must NOT lead the first page:
      
      - Geography (descriptions of the landscape before a person with a problem).
      - Backstory (history before stakes).
      - Worldbuilding (the system before the character it will hurt).
      
      If the opening leads with any of the three, restructure: move the voice/want/
      instability forward, push context into the sequel or later scenes.
      
      ## Character introduction technique
      
      Introduce each significant character with this discipline:
      
      1. **Action-first entry.** The character's first appearance shows them *doing*
         something characteristic under mild pressure — working, arguing, fixing,
         fleeing. Never introduce a character at rest being described.
      2. **Prompt naming.** Name the character within their first paragraph of
         presence. A named-but-unseen character and a seen-but-unnamed character
         both confuse readers; give the name early.
      3. **Behavior over description.** Convey appearance through action and
         other characters' reactions, not through a static description block.
         One or two concrete details land harder than a full portrait. Record the
         full appearance in the character file, not on the page.
      4. **Entry with consequence.** The character's entrance should change the
         scene: new information, new tension, a decision forced. An entrance that
         changes nothing can be cut — have them already present instead.
      
      ## Chapter-opening checklist
      
      For every chapter opening (not just chapter one):
      
      - [ ] Opens on motion, want, or instability — not on weather, waking up, or
            a landscape pan (unless deliberately subverting the cliché, and then
            the subversion must land on page one)
      - [ ] Reader can answer "who, where, when" within the first page
      - [ ] Connects to the previous chapter's unresolved question or raises a new
            one within the opening beat
      - [ ] New characters follow the action-first / prompt-naming / behavior-over-
            description discipline
      
    • scene-cards.md 2.7 KB
      # Scene Cards
      
      A scene card is the planning unit between a plot beat and a chapter draft:
      one card per scene, each recording what changes. Use cards when a chapter
      has multiple POV lines or timelines to braid, or when scenes need reordering
      before drafting. They are the cheapest place to fix structure — reordering
      cards costs minutes; reordering drafted scenes costs days.
      
      ## Card contents
      
      One card per scene, with exactly these fields:
      
      - **Scene id:** `chapter-{NN}-scene-{NN}` (matches the `scenes/` record id)
      - **POV:** who carries the scene
      - **Location:** where
      - **Start state:** the situation, the POV character's emotional state, and
        the open question at the scene's beginning — one line each
      - **Change:** what shifts by the scene's end (plot fact, relationship,
        knowledge, or emotional state). If nothing changes, the card has no reason
        to exist — cut, fold, or combine it.
      - **End state:** the new situation and the new open question
      - **Type:** Scene (goal → conflict → outcome) or Sequel (reaction → dilemma
        → decision); see `scene-sequel.md`
      - **Try/fail position:** `try-1`, `try-2`, `try-3`, or `setback` when part
        of an escalation chain; see `try-fail.md`
      - **Arcs advanced:** which arcs move in this scene (kebab-case ids)
      
      Store the card in the scene's `scenes/` file under a `## Scene Card` section,
      or as a block at the top of the chapter outline. Keep the format identical
      everywhere so a later agent can read them.
      
      ## Reordering
      
      Lay the cards out and check:
      
      1. **Causality:** each card's start state must follow from the previous card's
         end state. Gaps are plot holes; contradictions are continuity errors.
      2. **Escalation:** across the chapter, stakes, pressure, or emotional cost
         rise. A card that lowers tension after the midpoint needs a reason.
      3. **Rhythm:** alternate scene types. Two pure action scenes back-to-back
         flatten; a sequel between them deepens both.
      4. **Reader knowledge vs character knowledge:** mark cards where the reader
         learns something the POV character doesn't (or vice versa). Unplanned
         dramatic-irony gaps are continuity bugs; planned ones are logged in
         `continuity/questions/`.
      
      ## Braiding POV lines
      
      When a chapter or sequence alternates POV characters:
      
      1. Write one card stack per POV line.
      2. Interleave so each line's cliffhanger resolves at least two of its own
         cards later — never cut away at a resolution, always at an unresolved
         question.
      3. Record the interleave order in the chapter outline and mirror it in the
         `scenes/` card stack.
      
      ## When to ask the user
      
      Reordering changes story shape. Present the proposed new order as a card list
      (start state → change → end state per card) and get approval before rewriting
      scene files or the chapter outline. Do not reorder silently.
      
    • scene-sequel.md 3.6 KB
      # Scene Sequel Mechanics
      
      Scene/Sequel is Dwight Swain's scene-unit framework from *Techniques of the
      Selling Writer*. chapter-writing covers Swain's **Scene** half
      (goal → conflict → outcome/setback). This reference covers the missing
      **Sequel** half: reaction → dilemma → decision. The sequel is where character
      interiority, motivation repair, and theme processing happen. Without it, a
      chapter becomes a string of incidents with no breathing room.
      
      ## When a scene needs a sequel
      
      Not every scene gets a sequel. Write one when:
      
      - The scene outcome was a **setback or disaster** the POV character must process
      - The POV character learned something that **changes their understanding** of the lie they live by (see `theme-craft`)
      - The next scene needs a **decision** with stakes — the sequel manufactures it
      - The pacing needs **breathing room** between action beats (see `try-fail.md`)
      
      Skip the sequel when the outcome was a clear victory with a self-evident next
      step, or when the following scene opens mid-action and the reaction can happen
      on the move.
      
      ## The four beats
      
      **1. Reaction (emotional).** The POV character's immediate, visceral response to
      the scene's outcome. Sensory, involuntary, in-the-body: nausea, shaking hands,
      laughing when they shouldn't. Keep it short — two beats of prose, not a page
      of wallowing.
      
      **2. Dilemma (rational).** The character tries to think their way out. A dilemma
      is not a problem with one right answer; it is a choice between two bad
      options, or a situation with no good path visible. Frame it as an explicit
      question with explicit stakes: "Give up the map and lose the one advantage she
      has, or keep it and let the person she promised to protect walk into the
      ambush?" Record the dilemma in the scene record's `dilemma` field.
      
      **3. Decision (act of will).** The character commits to a course of action. The
      decision must be *theirs* — made from who they are, not imposed by the plot —
      and it must cost something. A decision that costs nothing is not a decision.
      
      **4. Action (optional, launches the next scene).** Some writers count the action
      taken on the decision as part of the sequel; treat it as the bridge beat that
      ends the sequel and opens the next scene.
      
      ## Scene record fields
      
      The scene template (`chapter-writing/references/scene-template.md`) carries
      `sequel: {true|false}` and `dilemma:` frontmatter plus a `## Sequel` body
      section. For scenes with sequel content:
      
      ```yaml
      sequel: true
      dilemma: "{The explicit no-good-options question}"
      ```
      
      And in the `## Sequel` section, record the three beats:
      
      - **Reaction:** the POV character's emotional processing (one or two beats
        of prose, not a page).
      - **Dilemma:** the impossible choice restated with its stakes.
      - **Decision:** what the POV character commits to, what it costs, and the
        goal that launches the following scene.
      
      For pure action scenes with no sequel, set `sequel: false` and omit the
      rest.
      
      ## Planning workflow
      
      1. Read the scene's outcome from the chapter outline or scene record.
      2. Write the reaction as **one specific physical detail** — the body's answer
         before the mind's.
      3. Draft the dilemma as a single question. If you can find an easy answer,
         sharpen it until both options cost something the character values.
      4. Make the decision **reveal** character: a brave character may choose the
         cautious path if it protects what they love; that contradiction is where
         theme lives.
      5. Check the dilemma against the character's lie (see
         `theme-craft/references/lie-truth.md`): the lie should be fighting the
         decision. If the lie plays no part, the sequel is skimming the surface —
         deepen it.
      
    • try-fail.md 2.8 KB
      # Try/Fail Cycles and the Five Commandments
      
      Two scene-grain structure tools for pacing the middle of chapters and giving
      every scene a checkable shape. Both are widely-published craft concepts;
      this is a summary, not a reproduction of any commercial methodology.
      
      ## Try/Fail cycles
      
      From Dwight Swain's *Techniques of the Selling Writer*: most scenes in a
      chapter should be **attempt scenes** — the POV character tries something and
      fails. Escalate across attempts within the chapter:
      
      1. **First attempt fails** — the obvious solution doesn't work.
      2. **Second attempt fails worse** — the clever solution backfires, and the
         situation is now worse than before the attempt.
      3. **Third attempt leads to a setback or disaster** — partial progress at best,
         or the worst outcome, which forces the next scene.
      
      Rules for planning try/fail chains:
      
      - Each failure must be **caused by the attempt itself**, not by random bad
        luck. The reader should feel the POV character earned the worse situation.
      - Never resolve an attempt with a **coincidence that saves** the character
        (deus ex machina). Coincidences may *complicate*, never *rescue*.
      - Between failed attempts, insert sequel material (reaction/dilemma/decision —
        see `scene-sequel.md`) so the reader feels the rising cost, not just rising
        noise.
      - Track each attempt in the chapter outline as `try-1`, `try-2`, `try-3` with
        its failure and its new complication.
      
      ## The Five Commandments (Story Grid)
      
      Shawn Coyne's *Story Grid* describes every complete story unit — including a
      single scene — as moving through five stages (attributed here as a summary of
      the widely-discussed framework, not its full methodology):
      
      1. **Inciting incident** — something disrupts the scene's status quo.
      2. **Progressive complications** — the situation worsens or the goal gets
         harder to reach (this is where try/fail cycles live).
      3. **Crisis** — the POV character faces an irreversible choice between two
         bad options (or a best-bad-choice).
      4. **Climax** — the decision, and the action taken on it.
      5. **Resolution** — the new state: what changed, what it costs, what the
         character now knows.
      
      ## Scene-grain checklist
      
      For each scene in a chapter, verify:
      
      - [ ] An inciting incident opens the scene or the scene opens on its aftermath
      - [ ] At least one complication makes the goal harder before the outcome
      - [ ] The crisis presents a genuine either/or (no cost-free choice)
      - [ ] The climax shows the POV character acting on their decision
      - [ ] The resolution states the change: what is different now than at the
            scene's start (record in `state-changes` in the scene file)
      
      If a scene fails the checklist, it is either a transition (keep it short),
      a sequel beat (see `scene-sequel.md`), or it needs a complication and a
      crisis added before drafting.
      
  • SKILL.md 5.8 KB
    ---
    name: scene-craft
    description: This skill should be used when the user asks to "plan a scene", "scene structure", "sequel scene", "dialogue subtext", "deep POV", "psychic distance", "try fail", "scene cards", "exposition", "info dump", "flashback", "time skip", "story opening", "first page hook", "introduce a character", or wants scene-level craft for drafting or revision.
    ---
    
    # Scene Craft
    
    ## Overview
    
    Plan and check scenes at the scene grain — the layer between plot beats and
    chapter prose. Covers the missing half of the chapter-writing scene model
    (Scene **and** Sequel), try/fail escalation, scene cards, dialogue subtext,
    deep POV and psychic distance, exposition handling, flashbacks and time
    skips, and openings. Use during chapter planning, before drafting, and in
    revision when a scene feels flat.
    
    ## Prerequisites
    
    A story project must already exist (created via the story-init skill), with
    characters defined (character-management) and a plot structure in place
    (plot-structure). This skill extends chapter-writing; it does not replace the
    outline-first drafting workflow.
    
    ## Workflow
    
    1. **Choose the craft layer.** Identify which scene-grain problem this is:
       - Scene feels like incidents with no breathing room → `references/scene-sequel.md`
       - Middle of the chapter sags or resolves too easily → `references/try-fail.md`
       - Chapter has multiple POVs/timelines to order → `references/scene-cards.md`
       - Conversation reads flat or voices blur → `references/dialogue-subtext.md`
       - Narration feels distant or head-hops → `references/deep-pov.md`
       - Worldbuilding facts are piling up undelivered → `references/exposition.md`
       - Past events or a time jump are needed → `references/flashbacks-time.md`
       - Starting the book or a chapter, or introducing a character → `references/openings.md`
    2. **Read the relevant reference(s).** Each file carries its own checklists
       and planning fields; apply them, don't paraphrase them.
    3. **Clarify missing inputs before planning or editing.** Ask the user for
       any required inputs you cannot establish from the project files — scene
       purpose, viewpoint, location, canon-changing intent, and the applicable
       craft layer. Never guess at these or proceed on assumptions; a wrong
       guess edits canon. Only continue to step 4 once every required input
       is known.
    4. **Plan before prose.** For the scene in question, write the planning
       inputs the reference requires (sequel beats, try/fail positions, subtext
       wants, zoom level, exposition audit, flashback trigger, hook check) into
       the chapter outline or the scene's planning notes before drafting or
       revising.
    5. **Record machine-readable state.** Update the scene file in `scenes/`:
       - Set `sequel: true/false` and fill the `dilemma:` field plus the
         `## Sequel` section (reaction/dilemma/decision) for scenes with
         sequel content (see `references/scene-sequel.md`)
        - Add `flashback-to:` (freeform note of the flashed-back moment,
          validated as a scalar by `story validate` but not used by continuity
          checks) and move flashback-only characters to `mentions`
          (see `references/flashbacks-time.md`)
       - Keep `state-changes` current for every change the scene makes
    6. **Run the reference's checklist** against the draft or the revision plan
       (try/fail checklist, deep-POV filter-word scan, tag-swap test, first-page
       hook check).
    7. **Hand off cleanly.** Scene/sequel planning feeds the chapter-writing
       drafting workflow; theme-audit findings feed revision-continuity. When a
       scene decision changes canon (new knowledge, moved objects, changed
       relationships), update `continuity/state.md` and the affected entity
       files (bidirectional links, per the story-init conventions).
    
    ## Conventions
    
    - Scene ids stay `chapter-{NN}-scene-{NN}`; scene files live in `scenes/`
      with kebab-case filenames.
    - All planning metadata (dilemma, decision, subtext wants, psychic-distance
      level) lives in frontmatter or a `## Planning` / `## Scene Card` section
      of the scene file — never only in chat.
    - `characters` vs `mentions` follows the story-init rule: characters present
      in-scene under `characters`; remembered, recorded, or flashback-only
      characters under `mentions`.
    - Do not overwrite chapter prose merely to satisfy a craft checklist. Flag
      intentional deviations (e.g. a deliberate info dump as a stylistic device)
      in the scene file's planning notes so a later audit doesn't "fix" them.
    
    ## CLI Maintenance
    
    Use the Story CLI when it is available. If `story` is not installed, use `bun run story --` from the Story Skills repository checkout or the bundled fallback `node ../story-maintenance/scripts/story.js` with the same arguments, resolving the path relative to this skill folder. If no CLI is available, perform the registry, backlink, and word-count checks manually.
    
    After adding or revising scene records:
    
    ```shell
    story reindex .
    story links .
    story validate .
    story continuity .
    ```
    
    ## Reference Files
    
    - **`references/scene-sequel.md`** - Sequel mechanics: reaction → dilemma → decision (Dwight Swain's scene framework)
    - **`references/try-fail.md`** - Try/fail escalation cycles and the Five Commandments scene shape
    - **`references/scene-cards.md`** - Scene card unit (start state → change → end state), reordering, POV braiding
    - **`references/dialogue-subtext.md`** - Subtext as planning input, dialogue-as-negotiation, voice differentiation, tag-swap test
    - **`references/deep-pov.md`** - Psychic distance zoom levels and checkable deep-POV rules
    - **`references/exposition.md`** - Drip-feed, conflict-carried exposition, in-world documents, info-dump warning
    - **`references/flashbacks-time.md`** - Flashback entry/exit mechanics, tension-cheat warning, time-skip conventions
    - **`references/openings.md`** - In medias res, "enter late, leave early", first-page hook check, character introduction technique
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.

Related