Storyboard Storytelling Pipeline

Use this skill when the user wants a storyboard that truly tells the story, not just a pile of shots.

This skill treats storyboarding as a full pipeline:

script read -> sequence map -> camera strategy -> scene shot flow -> rough thumbnails -> animatic review -> structure revision -> shot-language refinement -> key panels -> rough board -> clean pass -> final delivery

Read These References

Read in this order before substantial work:

1. references/floobynooby-core.md
2. references/workflow.md
3. references/templates.md

Read references/night-nuo-case-study.md when you need a full worked example, a trailer calibration, or a sanity check for object-driven stakes, delayed climax, and story-first lens language.

The full bundled case pack now lives under:

• references/night-nuo-case/index.md

Primary Stance

• Planning comes first. Do not jump straight to a detailed shot list.
• Clarity beats cleverness.
• Story point decides shot progression, not habit.
• Close-ups are budgeted impact tools, not default coverage.
• Cuts need motivation.
• Continuity protects comprehension.
• Rough passes come before clean passes.
• The audience should be able to feel the story by reading the shots in order.
• If a board only works because notes explain it, the board is not solved yet.

When To Use This Skill

Use it for any of these:

• A full script that needs a complete storyboard workflow
• A scene or sequence that needs stronger shot progression
• A broken storyboard that needs structural repair
• A trailer or short-drama board that feels readable on paper but not visual in the head
• A project that needs sequence maps, rough-thumbnail tasks, animatic checks, or clean-pass rules
• A request to continue an already-started storyboard package from a later stage

Do not use this skill when the user only needs:

• pure image-generation prompts
• a simple shot glossary
• a review of one existing board without continuing the workflow

Stage Detection

Before producing output, identify what stage already exists.

Common cases:

• Fresh script only: start at Step 1
• Script plus scene notes: usually start at Step 2 or Step 3
• Existing storyboard draft: audit it against the workflow, find the highest stable step, continue from the next step
• Existing rough boards: move to animatic review, structural revision, or clean-pass rules instead of restarting everything

When resuming, preserve any completed stage that is still sound. Replace weak stages, not the whole package by reflex.

Default Workflow

Follow the full 15-step pipeline unless the user explicitly asks for a narrower slice.

1. Read the whole script for dramatic structure, not shots.
2. Build a sequence map.
3. Assign each sequence a camera / lens-language strategy.
4. Build each scene's dramatic spine and shot flow.
5. Create rough-thumbnail tasks for the full piece.
6. Review it with animatic thinking.
7. Correct big structure before polishing shots.
8. Refine single-scene shot language.
9. Re-run a second rough pass with corrected shot logic.
10. Lock key panels for the most valuable beats.
11. Build a coarse animatic review plan.
12. Write scene-level shot-by-shot boards for the key scenes.
13. Assemble a full rough-board package.
14. Write clean-pass execution rules and final checks.
15. Deliver a final storyboard master document and a short delivery note.

See references/workflow.md for the detailed purpose, output, and failure mode of each step.

Output Rules

• Default to stage-based deliverables, not a giant undifferentiated wall of shots.
• Name the current step clearly.
• Keep each document story-facing and executable.
• At every stage, make it obvious:
  • what the audience should know
  • who owns the reaction
  • what the climax beat is
  • why the shot progression is shaped this way
• Use concrete visual language that a board artist can thumbnail immediately.
• Avoid analysis labels unless they help the work move forward.
• When a stage is finished, say what the next stage should be.

Non-Negotiable Checks

At every stage, verify:

1. Is the story getting clearer?
2. Is the emphasis landing on the right beat?
3. Are close-ups saved for the beats that deserve them?
4. Does every important cut have a reason?
5. Is the audience still oriented in space and stakes?
6. Has any middle section accidentally become a false climax?
7. Can the board still read if most explanatory notes disappear?

Deliverable Patterns

Use the templates in references/templates.md.

Common deliverables:

• sequence drama map
• per-sequence camera strategy
• scene dramatic core + shot flow
• rough-thumbnail execution sheet
• animatic review memo
• structural revision memo
• shot-language refinement memo
• key-panel sheet
• shot-by-shot scene board
• full rough-board summary
• clean-pass rules

Worked Example

When the user needs proof of how the pipeline should feel in practice, load references/night-nuo-case-study.md.

That reference shows how the workflow handles:

• opening with rule before monster
• saving the real climax for the back half
• turning public danger into private temptation
• protecting the hold on the cursed mask reveal
• protecting the stillness after the mask is worn
• letting the final verdict outrank the flashy inserts

Embedded Case Index

For sharing and quick onboarding, keep this compact example in mind even before opening the full case-study reference.

The reference project follows the full 15-step pipeline like this:

1. Script read:
   • identify that the opening hook is a rule, not a monster
   • identify that the middle fight is not the real climax
2. Sequence map:
   • break the trailer into dramatic sections before thinking in shots
3. Per-sequence camera strategy:
   • keep the opening wider
   • let the middle sell scale without peaking
   • compress the back half into private temptation and then stillness
4. Scene dramatic core + shot flow:
   • assign reaction owner, climax duty, and continuity anchor to each scene
5. Rough thumbnails pass 1:
   • run the whole piece rough before polishing
6. Animatic review:
   • protect the late triple hit instead of over-rewarding the middle fight
7. Big structure revision:
   • compress middle action first if anything must shrink
8. Shot-language refinement:
   • decide how each scene opens, when it earns a close-up, where it holds, and why it cuts
9. Rough thumbnails pass 2:
   • rerun the boards after the language fix
10. Key panels:

• lock the mask reveal, choice triangle, frozen world, and final verdict

11. Coarse animatic plan:

• decide what must hold, what must cut fast, and what must be sound-led

12. Shot-by-shot scene boards:

• convert the crucial scenes into drawable boards

13. Full rough-board package:

• assemble the entire piece into one reviewable board system

14. Clean-pass rules:

• improve readability and finish without redesigning the sequence

15. Final delivery:

• collapse the approved result into one single source of truth plus a short handoff note

Portable lessons from that case:

• protect the real climax from the middle
• keep object stakes visually alive
• turn public danger into private temptation through a clear visual gate
• save stillness for rank change
• let the final verdict outrank flashy inserts

What This Skill Must Avoid

• Jumping from script straight to a long shot list
• Treating wide / medium / close as a fixed emotion dictionary
• Explaining scenes instead of boarding them
• Burning all impact in the middle
• Using too many close-ups or fancy angles too early
• Confusing action coverage with story progression
• Going clean before the rough / review stages are stable

Success Condition

The pipeline is successful when the user ends up with a storyboard package that can actually be produced:

• the story reads
• the shot progression feels inevitable
• the climax lands where it should
• the rough board can be reviewed
• the clean pass has hard guardrails

If those conditions are not met, keep working the earlier stage instead of forcing polish.