A Speckit preset for writing screenplays — features, TV pilots, limited series, and stage scripts. Parallel to the screenwriting preset, adapted entirely for Fountain format and screenplay workflow.
Requires speckit >=0.5.0.
- What's in this preset
- Workflow Overview
- Getting Started
- Command Reference
- Scene ID Conventions
- Draft File Naming
- Export Requirements
- Tutorials
- Comparable Products
- Sequence Diagrams
- Related Resources
| Type | Count |
|---|---|
| Templates | 26 |
| Commands | 32 |
| Scripts | 1 (Python) |
| Sequence diagrams | 6 |
Output format: .fountain (Fountain plain-text screenplay) for all drafted scenes; .fdx (Final Draft XML) and .pdf via the export command.
The preset covers six phases:
Phase 1 — Development constitution → specify → clarify → [brainstorm]
Phase 2 — Structure plan → [brainstorm] → analyze
Phase 3 — Drafting tasks → outline → implement → [research]
Phase 4 — Revision checklist → continuity → revise → polish → format
Phase 5 — Pitch synopsis → coverage → pitch → bio
Phase 6 — Production export (Fountain / FDX / PDF)
If you're not sure what to do next, run /speckit.help — it scans your project files and tells you the highest-value next action.
/speckit.constitution
Prompts for: format (feature / pilot / limited / stage), medium (film / streaming / broadcast / cable / stage), act structure (three-act / Save the Cat / TV pilot / network / cable), page count target, action line style (lean / dense / poetic), dialogue register, budget tier, genre, tone, and language.
/speckit.specify [your idea]
Creates spec.md with logline, premise, format table, character arcs (AS-1/AS-2/AS-3), plot requirements, and genre conventions.
/speckit.clarify
Resolves [NEEDS CLARIFICATION] markers before planning begins.
/speckit.plan
Generates plan.md (beat sheet + scene outline) and all Phase 0 supporting documents: research, characters, world-building, glossary, relationships, subplots, locations, themes, timeline, and series bible (if TV).
/speckit.tasks
/speckit.analyze
/speckit.outline [SCENE_ID] ← approve before drafting
/speckit.implement [SCENE_ID] ← writes .fountain file
/speckit.checklist [SCENE_ID]
/speckit.continuity
/speckit.revise [SCENE_ID] --from-checklist
/speckit.polish [SCENE_ID]
/speckit.format
/speckit.synopsis
/speckit.coverage
/speckit.pitch
/speckit.export --format all
| Command | Description |
|---|---|
speckit.constitution |
Set format, medium, act structure, craft rules |
speckit.specify |
Create screenplay brief from concept |
speckit.clarify |
Resolve ambiguity in the brief |
speckit.brainstorm |
Free-form brainstorm for any topic |
| Command | Description |
|---|---|
speckit.plan |
Build structure plan + all Phase 0 supporting docs |
speckit.analyze |
Pre-draft structural analysis and story bible alignment |
speckit.subplot |
B-story and C-story management; intersection mapping |
| Command | Description |
|---|---|
speckit.tasks |
Generate scene-by-scene task list |
speckit.outline |
Generate and approve per-scene outline (gates implement) |
speckit.implement |
Draft scene in Fountain format. Use --outline-only to stop after outline generation. |
speckit.research |
Research item tracking. Subcommands: add, resolve, check, status. |
| Command | Description |
|---|---|
speckit.checklist |
Scene quality checklist (FMT/SCN/ACT/DLG/VIS/STR/PGN) |
speckit.continuity |
Post-draft continuity and story bible compliance |
speckit.pacing |
Macro and micro pacing analysis. Subcommands: chart. |
speckit.revise |
Targeted scene revision. Flags: --from-checklist. |
speckit.polish |
Final line-level polish pass |
speckit.format |
Screenplay format audit (slug lines, cues, transitions) |
speckit.sensitivity |
Sensitivity and broadcast standards review |
speckit.feedback |
Feedback log management. Subcommands: triage, tasks. |
| Command | Description |
|---|---|
speckit.interview |
In-character dialogue session with a character |
speckit.roleplay |
Dialogue voice-testing and two-character scene mode |
speckit.series |
TV series bible management. Subcommands: init, audit. |
speckit.glossary |
Canonical term and slug-line management |
speckit.versions |
Version history navigation for .fountain files |
| Command | Description |
|---|---|
speckit.synopsis |
One-page and full synopsis. Flags: --one-page, --full, --tv. |
speckit.coverage |
Industry-format self-coverage report |
speckit.pitch |
Pitch document with submission tracker |
speckit.bio |
Writer bio (short and long) |
speckit.export |
Assemble and export. Flags: --format [fountain/fdx/pdf/all]. |
| Command | Description |
|---|---|
speckit.status |
Project dashboard: scene table, page counts |
speckit.statistics |
Page count, act breakdown, dialogue vs. action stats |
speckit.help |
Workflow navigator. Flags: --focus, --scene. |
Scene IDs use structure prefixes followed by a sequential number:
| Prefix | Structure |
|---|---|
F.NNN |
Feature (three-act) |
STC.NNN |
Save the Cat beat structure |
P.NNN |
TV pilot |
NET.NNN |
Network TV episode |
CBL.NNN |
Cable TV episode |
STG.NNN |
Stage play |
Story thread labels:
AS-1— A-story (protagonist)AS-2— B-storyAS-3— C-story
FEATURE_DIR/draft/[SCENE_ID]_[SceneName].fountain ← current working version
FEATURE_DIR/draft/[SCENE_ID]_[SceneName]_v1.fountain ← first saved version
FEATURE_DIR/draft/assembled/[TITLE].fountain ← assembled screenplay
FEATURE_DIR/draft/assembled/[TITLE].fdx ← Final Draft XML
FEATURE_DIR/draft/assembled/[TITLE].pdf ← PDF
- PDF export: requires Afterwriting CLI:
npm install -g afterwriting - FDX export: handled natively by
scripts/python/export.py— no additional dependencies
A feature film is a single, self-contained screenplay of 90–120 pages. This is the simplest structure and the best starting point if you are new to the preset.
/speckit.constitution
You will be prompted for:
- Format:
feature - Medium:
film(theatrical) orstreaming - Act structure:
three-actorsave-the-cat - Page count target: 90–120
- Action line style:
lean(modern spec),dense, orpoetic - Dialogue register: naturalistic, heightened, genre-coded
- Budget tier: micro / low / mid / studio
- Genre, tone, and language
This creates constitution.md — the governing authority for all subsequent commands.
/speckit.specify A disgraced air-traffic controller takes a night shift at a regional airport and realises the incoming flight she's guiding has no one in the cockpit.
Produces spec.md with: logline, premise, format table, character arcs (AS-1 protagonist, AS-2 B-story, AS-3 C-story), plot requirements, genre conventions, and page count targets per act.
/speckit.clarify
Scans spec.md for [NEEDS CLARIFICATION] markers across character motivation, timeline, tonal register, and world-building logic. Writes resolutions back into spec.md. Do not skip this step — ambiguities here become structural holes in the beat sheet.
/speckit.plan
Produces plan.md with the full act breakdown and scene-by-scene map, plus all Phase 0 supporting documents: research.md, characters/index.md, world-building.md, glossary.md, relationships.md, subplots.md, locations.md, themes.md, timeline.md.
/speckit.tasks
Produces tasks.md: every scene as an ordered writing task, blocked on prerequisite documents where applicable.
/speckit.analyze
Read-only. Verifies spec.md → plan.md → tasks.md coverage, act-proportion targets, and story bible compliance. Fix any gaps before drafting.
/speckit.outline all
Creates one outlines/[SCENE_ID]-outline.md per scene with: scene goal, causal beat sequence, character beats (want vs. get), dialogue requirements, visual action requirements, and slug line. All files start at status: DRAFT.
Review and edit each outline, then:
- Set
status: APPROVED→ AI drafts the scene in Fountain format - Set
status: SKIP→ you write the scene yourself; AI skips it
/speckit.implement
For each scene with an approved outline, drafts a .fountain file into draft/. Scenes with status: DRAFT outlines trigger an outline gate warning — the AI stops and requires author approval before proceeding.
/speckit.checklist [SCENE_ID]
/speckit.revise [SCENE_ID] --from-checklist
/speckit.polish [SCENE_ID]
/speckit.format
Repeat for each scene. Run speckit.status for a page-count dashboard.
A TV pilot introduces a world, establishes recurring characters, and poses a series-sustaining dramatic question. It requires one additional step compared to a feature: a series bible before drafting begins.
- Format:
pilot— choosenetwork(42–44 pages),cable(55–65 pages), orstreaming(25–60 pages) - Scene IDs: use
P.NNN(pilot) orNET.NNN/CBL.NNNfor episode format - Series bible:
speckit.series initscaffoldsseries-bible.mdbefore planning - Teaser structure:
speckit.plangenerates a cold open / teaser / act breaks layout for TV - Pilot-specific pitch documents:
speckit.pitchproduces a pilot packet (logline, series overview, character breakdowns, episode extensions, comp shows)
Run this after speckit.constitution, before speckit.specify:
/speckit.series init
Scaffolds series-bible.md with: series premise, world rules, recurring character roster, season arc questions, episode format, and network/streamer positioning. Fill in as much as you know — speckit.specify and speckit.plan will read from it.
| Structure flag | Format | Description |
|---|---|---|
tv-pilot |
Half-hour or hour | Teaser + 4–5 acts + tag |
network |
Network hour | Teaser + Act 1–4 + Tag (strict page targets) |
cable |
Premium cable | Open structure, act breaks more flexible |
/speckit.continuity
/speckit.series audit
speckit.series audit verifies that world rules established in the pilot hold, that no character knowledge is inconsistent with their arc position, and that series-level dramatic questions are properly seeded.
The planning phase locks the screenplay's architecture before a single scene is drafted. The order matters.
speckit.constitution → speckit.specify → speckit.clarify → speckit.plan → speckit.tasks → speckit.outline
speckit.constitution is a prerequisite for everything else. It encodes format, medium, act structure, action line style, dialogue register, budget tier, and all craft rules. Every command reads from it — no style drift across sessions.
speckit.specify converts a pitch into a structured brief. Keep your initial prompt to one or two sentences. The AI expands it into spec.md. Edit spec.md directly after to add anything the AI missed.
speckit.clarify is the most important step to not skip. Ambiguities in the brief do not disappear at the planning stage — they become structural gaps in the beat sheet. Run clarify until spec.md has no [NEEDS CLARIFICATION] markers remaining.
speckit.plan reads the clarified brief and constitution to produce the full scene map. For TV formats, it generates act-break markers, cold open/teaser scaffolding, and a series bible seed. For features, it aligns the beat sheet to your chosen act structure.
speckit.tasks converts every scene in plan.md into an ordered writing task in tasks.md. Tasks blocked on prerequisite documents (locations, research, characters) will be flagged — create those documents before drafting those scenes.
speckit.outline expands each plan entry into an author-editable outline file. plan.md captures what happens at the story level; the outline file captures how the scene plays — beat by beat, with visual action requirements, slug line, and dialogue subtext rules. Author approval of each outline is the last gate before Fountain prose is generated.
speckit.analyze is a mandatory pre-flight check before speckit.implement. It is strictly read-only — it never modifies files.
/speckit.analyze
Checks:
- Every spec requirement maps to at least one scene in
plan.md - Every scene in
plan.mdmaps to at least one task intasks.md - Act-page-proportion targets are within acceptable range for your format
- No orphan tasks (tasks referencing non-existent plan scenes)
- Story bible principles are not contradicted in
plan.md
If speckit.analyze flags gaps, resolve them in spec.md, plan.md, or tasks.md before proceeding. Drafting over structural holes costs far more revision time than fixing them pre-draft.
speckit.implement executes tasks in order from tasks.md. It operates in two modes:
/speckit.implement
For each scene:
- Reads the task from
tasks.md - Checks the checklist gate (previous scene must pass before continuing)
- Checks the outline gate: if
outlines/[SCENE_ID]-outline.mdexists withstatus: DRAFT, stops and requires author approval - If outline is
APPROVED: uses it as the working brief - If outline is
SKIP: marks the task done, moves to next scene — no Fountain file generated - If no outline file: falls back to
plan.mddirectly - Drafts the scene into
draft/[SCENE_ID]_[SceneName].fountain
/speckit.implement --outline-only
Generates the outline file for the next unwritten scene and stops. You write the scene in .fountain format manually (any tool). The same quality loop applies regardless of who wrote the prose.
Check project status at any time:
/speckit.status
Produces a dashboard showing page counts (actual vs. target per act), scene completion status, and outstanding quality gates.
These three commands form the per-scene quality loop. Run them in order.
/speckit.checklist [SCENE_ID]
Validates the craft layer of the scene:
| Gate | Code | Description |
|---|---|---|
| Format | FMT | Slug lines, action line length, parenthetical use, dual dialogue |
| Scene purpose | SCN | Does the scene turn on a shift in power, information, or relationship? |
| Act function | ACT | Does the scene serve its act-position role (setup / escalation / climax / resolution)? |
| Dialogue | DLG | Subtext, character voice differentiation, exposition buried |
| Visual action | VIS | Does action describe what the camera sees, not internal state? |
| Story bible | STR | Compliance with constitution.md craft rules |
| Page count | PGN | Within target range for format and act position |
Checklist result is saved to checklists/[SCENE_ID]-checklist.md.
If any gate fails:
/speckit.revise [SCENE_ID]
/speckit.revise [SCENE_ID] "DLG-003 VIS-001" ← specify failure codes
/speckit.revise [SCENE_ID] --from-checklist ← auto-read from checklist file
speckit.revise rewrites only the failing passages. It does not improve surrounding prose or change passing sections. Result is a versioned file (_v2.fountain) with a diff summary.
Only run after checklist PASS:
/speckit.polish [SCENE_ID]
Applies surface-level refinements:
| Fix | Rule |
|---|---|
| Action line economy | Passive constructions replaced; sentences over 4 lines split |
| Dialogue rhythms | Run-on speeches broken; alternating line-length variation |
| Repeated words | Same-word echoes eliminated within 10 lines |
| On-the-nose dialogue | Flags lines where character states the theme directly |
| Camera directions | Removes embedded camera directions in spec scripts |
| Slug line consistency | Ensures INT./EXT., location name, and time-of-day format match glossary.md |
Run once per draft-complete pass across all scenes:
/speckit.format
Full-script format audit: slug line casing, scene heading completeness, transition usage, title page block, and character-name consistency against characters/index.md.
Reader notes — from a script consultant, writer's group, or producer — enter the workflow through speckit.feedback.
/speckit.feedback notes.txt --reader-type consultant
/speckit.feedback "The second act loses momentum after the midpoint and the B-story disappears entirely." "John Doe" --reader-type producer
The command:
- Ingests raw notes (file path or quoted block)
- Categorizes each issue: Structural / Character / Pacing / Dialogue / Format / Clarity
- Assigns severity: CRITICAL / MAJOR / MINOR
- Maps issues to specific scene IDs
- Generates prioritized revision tasks appended to
tasks.md - Logs everything to
feedback/feedback.md
Sub-commands:
/speckit.feedback triage ← re-categorize without regenerating tasks
/speckit.feedback tasks ← generate tasks from a triaged log
After ingestion, address CRITICAL issues first, then run speckit.continuity to cross-reference the feedback against the current draft.
/speckit.synopsis
Produces synopsis.md with:
- One-page synopsis (400–600 words) — compressed arc, present tense, ending revealed. Required in most query and submission packages.
- Full synopsis (1,000–2,000 words) — beat-by-beat account of every major turn and character arc resolution.
/speckit.synopsis one-page ← regenerate only the short version
/speckit.synopsis full ← regenerate only the long version
/speckit.synopsis update ← regenerate from current draft
/speckit.synopsis check ← validate against spec.md and plan.md
Produces an industry-standard coverage report — the same format a studio reader or development executive would use:
/speckit.coverage
Includes: logline, summary, comments (premise / plot / character / dialogue / structure / commercial viability), and a PASS / CONSIDER / RECOMMEND rating with justification. Use this before sending to a consultant — it reveals the same issues a professional reader will find.
/speckit.pitch
Produces a pitch document containing: logline, series overview (if TV), world description, character breakdowns, comparable titles, tone reference, first-episode or first-act synopsis, and a submission tracker.
Planning a series from scratch adds one persistent authority document — series/series-bible.md — that governs canon, character state, and continuity constraints across all books. Every per-book command reads from it automatically.
Run this once before any individual book is planned:
/speckit.series init
This gathers the series-level parameters interactively:
| Parameter | Purpose |
|---|---|
| Series title | Used to pre-fill every book's spec and constitution |
| Total book count | Can be open series if undetermined |
| Genre + Target audience | Pre-filled into each book's constitution — confirm or override per book |
| Overarching dramatic question | The series-level spine; must not be fully answered until the final book |
| Overarching theme | Stated as a question |
| Series POV strategy | Consistency rule across all books |
| Series tense | Consistency rule across all books |
| Series ending contract | What the ending must feel like or resolve — not what happens |
Creates: series/series-bible.md
Repeat these steps for every book. The order is fixed — each step feeds the next.
Step 1 — speckit.constitution
Reads series/series-bible.md and pre-fills genre, audience, POV strategy, and tense — you only confirm or override. Set style mode, prose profile, plot structure, and tone.
Step 2 — speckit.specify
Reads series/series-bible.md and pre-fills series title, book position, and opening character states. The story idea is written as a brief shaped by the craft rules from Step 1.
Step 3 — speckit.plan
Reads both spec.md and constitution.md (both required). Generates all supporting documents in Phase 0, then builds the beat sheet and scene outline in Phases 1–3. Verifies series/series-bible.md and adds the new book entry automatically.
Step 4 — speckit.analyze
Pre-draft structural alignment check — confirms spec ↔ plan ↔ tasks consistency before any prose is written. Read-only.
Then follow the standard drafting loop: outline → implement → checklist → revise → polish.
After a book's draft is finalized:
/speckit.series update N
Syncs series/series-bible.md with what actually happened in Book N — new world canon, new continuity constraints, resolved threads, and updated character arc closing states that become Book N+1's opening states.
Then, before writing anything for Book N+1:
/speckit.series audit
Cross-script continuity check across all scripts. This is a mandatory gate — CRITICAL issues in the series bible must be fixed before the next brief is written. Validates:
- Character state chain: closing state of Book N must match opening state in Book N+1
- World canon consistency: every
SC-NNNrule across all drafts - Continuity constraint chain:
STC-NNNconstraints forward from their establishment book - Unresolved series threads: open
ST-NNNitems with no pay-off book assigned
Once audit is clean, start the per-book cycle again at Step 1.
series init
│
▼
constitution ◄─────────────────────────────────────────────────────────────┐
│ │
▼ │
specify │
│ series audit
▼ ▲
plan → analyze │
│ series update
▼ ▲
outline → implement → checklist → revise → polish │
│ │
└──────────────── continuity ─────────────────────────────────────────── ┘
(repeat for each book)
/speckit.export ← Fountain (assembled script, default)
/speckit.export fdx ← Final Draft XML
/speckit.export pdf ← PDF (requires Afterwriting CLI)
/speckit.export all ← all three formats
Assembly logic:
- Prefers
[SCENE_ID]_[SceneName]_polished.fountainover base drafts - Sorts scenes by scene ID order from
tasks.md - Highest version number wins (
_v3.fountainbeats_v2.fountain) - Inserts title page block from
constitution.md(title, author, contact)
All export metadata is read from constitution.md:
| Field | Source |
|---|---|
| Title | Title field |
| Author byline | Author Name |
| Contact block | Contact (optional) |
| Format / medium | Format + Medium |
General-purpose LLMs (ChatGPT, Claude, Gemini direct)
Most screenwriters using AI are chatting with these directly — "write this scene", "punch up this dialogue". ChatGPT Projects and Claude Projects give persistent memory, which helps across sessions. What they still lack is a consistency model: no format audits, no structural governance, no constitution-based authority that every command obeys. Scene 80 can still break the rules established in Scene 1 unless you manually re-state them every session. This preset removes that burden and replaces it with automated enforcement.
Final Draft 13 — the industry standard
Final Draft is the default tool in professional production. Every studio reader, story editor, and assistant expects FDX; it is the lingua franca of the industry. This preset exports FDX but cannot replicate Final Draft's native pagination engine, revision tracking color system, or production scheduling integration. Where this preset wins: it governs the development phase that happens before Final Draft ever opens. Final Draft is a formatting and production tool; this is a creation and development system. The two are complementary, not competitive — many writers will develop in speckit and deliver in Final Draft.
WriterDuet — best for co-writing
WriterDuet is the strongest option for real-time collaborative screenwriting. Two writers on the same script simultaneously is a use case this preset cannot support at all. Outside collaboration, WriterDuet is a format editor; it has no structural governance, no AI-driven development pipeline, no coverage or pitch tooling. Different audience entirely.
Arc Studio Pro — the closest real competitor
Arc Studio has AI features, beat board integration, and a clean modern interface. It is the most direct overlap. Where this preset wins: structural depth. Arc Studio generates beats and has a story map, but it doesn't enforce that drafted scenes stay coherent with those beats, doesn't run a post-draft continuity check, doesn't audit format line-by-line, and doesn't produce industry-format self-coverage. It's an assisted editor; this is a production pipeline.
Highland 2 — clean Fountain-native writing
Highland is excellent for Fountain-native writing on Mac. Fast, clean, distraction-free. No AI, no structural planning, no QA pass. A writing environment, not a workflow system. Mac-only is also a significant constraint.
Fade In — the professional Fountain alternative
Fade In is the closest free-and-paid alternative to Final Draft for formatting. Strong pagination, FDX compat, cross-platform. No AI, no workflow tooling. Like Highland, it is a format editor that sits downstream of what this preset does.
The honest gap vs. Arc Studio specifically
Arc Studio's visual beat board and card interface are genuinely better for writers who think visually — dragging cards, reordering acts spatially. This preset is entirely command-and-text-driven. If your process is visual first, Arc Studio wins the UX comparison. This preset wins when the problem is consistency at scale — across a TV pilot with 40 scenes or a limited series with 300.
The positioning in one sentence
Most screenwriting tools are format editors (write it right). This preset is a development system (develop it right, draft it consistently, then format it). That gap is currently underserved. The writers who get the most value are those who've already discovered that raw AI drafting produces incoherent structure at feature or series scale.
- Spec Kit Documentation
- screenwriting preset
- Fountain format specification
- Afterwriting CLI (PDF export)
MIT — see LICENSE.