narrative-spine
Skill4 starsChanged 3 months agoMITView on GitHub
Use this skill after solution architecture and capture intent to write the proposal's narrative spine — a one-page, plain-prose argument of what the proposal claims and why it is compelling against the customer's actual problem — for human sign-off before storyboarding or drafting begins.
In this repository30 other files it gives its agents.
- CLAUDE.mdCLAUDE.md
- adversarial-reviewSkill
- capture-demand-signalsSkill
- capture-intentSkill
- capture-portal-structureSkill
- capture-scorecardSkill
- capture-submissionSkill
- competitor-assessmentSkill
- compliance-checkSkill
- customer-intelSkill
- dashboardSkill
- evidence-checkSkill
- export-proposalSkill
- import-from-captureSkill
- new-proposalSkill
- opportunity-quick-lookSkill
- past-performanceSkill
- pricing-analystSkill
- proposal-editorSkill
- proposal-graphicsSkill
- proposal-managerSkill
- proposal-patcherSkill
- proposal-solution-architectSkill
- proposal-storyboardSkill
- proposal-writerSkill
- red-team-reviewSkill
- setup-companySkill
- statusSkill
- submission-summarySkill
- technical-reviewSkill
The file
We split this skill into the rules it gives an agent
5 rules. About 0 are common, 2 are distinctive, and 3 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈2
Distinctive · estimate
This author's own choices. Worth a look.
3
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 13
Write the proposal's narrative spine — the single, coherent argument the whole proposal makes — in plain prose, before any section …
- Very specific: line 21
Run after /proposal-solution-architect and /capture-intent (and after /past-performance and /pricing-analyst if the proposal type runs them …
- Very specific: line 48
If a required input is missing, state it explicitly and proceed only if the argument can still be formed.
- Distinctive: line 68
After writing it, stop and hand it to the human (see Human Sign-Off Gate).
- Very specific: line 127
After writing working/narrative-spine.md, stop.
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Narrative Spine Skill
Purpose
Write the proposal's narrative spine — the single, coherent argument the whole proposal makes — in plain prose, before any section structure or draft text exists.
The pipeline already produces requirement matrices, capability matrices, a proposal plan, a capture-intent document, and an architecture concept. What it has never produced is the thing a senior capture lead writes in their head before drafting: the story of why this proposal wins against the customer's actual problem. Win themes get reduced to a three-column table; the architecture gets recorded as a fielded concept; the strategic intent gets written as internal alignment notes. None of those is an argument. They are inputs to an argument.
Without a spine, the proposal-writer fills connective tissue between pre-validated atoms — and that is the structural cause of stilted, capability-tour prose. The spine is the missing artifact. It is what the storyboard decomposes and what the writer drafts from. It is also the cheapest possible place to put a human in the loop: one page, three minutes to read, easy to redirect.
When to Use
Run after /proposal-solution-architect and /capture-intent (and after /past-performance and /pricing-analyst if the proposal type runs them — real proof points and the cost envelope should inform the argument). Run before /proposal-storyboard.
For white papers (which skip the storyboard), run it after /proposal-solution-architect and before /proposal-writer.
Recommended workflow:
/proposal-solution-architect
/past-performance (if the type runs it)
/pricing-analyst (if the type runs it)
/narrative-spine <<< here — human signs off before continuing
/proposal-storyboard
/proposal-writerInputs
Always read
working/proposal-type.md— read first. If this skill is inskipped_skills, exit with "Skipped for type <type_id>." Notepage_targetandevaluator_framing— they control how ambitious the spine can be (see Discipline Rules).- The solicitation and customer source material, directly — every file in
inputs/00_priority/andinputs/01_customer/. This is deliberate and non-negotiable. The narrative-spine skill is the one pre-prose stage that reads the customer's own words instead of a digested matrix. The argument has to answer the problem the customer actually stated, in language traceable to how they stated it. working/capture-intent.md— strategic intent: why we are bidding, customer beliefs to create, posture, prohibited claims, ghosting direction. The spine operationalizes this into a single argument.working/proposal-plan.md— evaluation criteria and win themes.working/architecture-concept.mdandworking/solution-strategy.md— what is actually being proposed.reference/narrative-operating-modes.md— use it to scale the argument to the response length and evaluator frame before writing the spine.reference/voice-anchors/*.md— voice cadence exemplars. Read these before drafting the spine. Imitate their rhythm and clinical confidence; do NOT reuse their content. The spine is the first place voice matters, and getting its cadence right carries forward through the writer. (Canonical source:reference/PROSE-QUALITY-DOCTRINE.md.)
If a required input is missing, state it explicitly and proceed only if the argument can still be formed. If capture-intent.md is missing, recommend running /capture-intent first — without it the spine has no strategic posture to express.
Read if relevant
working/customer-profile.md— if/customer-intelwas run (decision-maker hot buttons sharpen the argument).working/competitor-assessment.md— if/competitor-assessmentwas run (the argument should beat a real alternative, not a strawman).drafts/past-performance.mdorworking/pp-relevance-matrix.md— so the spine argues with real proof points.working/pricing-inputs.md— so the argument respects the cost/LOE envelope.working/capability-matrix.md,working/requirement-matrix.md— for grounding, not as the primary source.
Output
Write one file:
working/narrative-spine.mdIt is prose. It has no section numbers, no field tables, no per-section breakdown. If it looks like a storyboard, it is wrong — see Discipline Rules.
After writing it, stop and hand it to the human (see Human Sign-Off Gate).
The Spine Standard
working/narrative-spine.md contains exactly five parts, in this order:
# Narrative Spine — [Proposal Name]
## Positioning
<One sentence. What this proposal IS, framed against what it is not.
This is the line a reader should be able to repeat after a single read.
Example shape: "This is disconnected adaptive autonomy infrastructure for
tactical UxS operations — not another AI platform.">
## Narrative Mode
<One line naming the selected mode from `reference/narrative-operating-modes.md`
and the reason. Example: "Mode: solution-brief — 7-page CSO screener, so
the argument must establish fit, feasibility, proof, and next action without
teaching the whole market.">
## The Argument
<The case, in movements. One short paragraph per movement. A movement is
one beat of the argument — a claim the reader must accept before the next
one lands. Plain prose. No bullets. No section numbers. Write it the way
you would explain to a sharp colleague why this proposal wins. Typically
3-6 movements. Each movement should be traceable to a customer-stated
problem and to real evidence or architecture — not to what we wish were
true.>
## Through-Line
<One or two sentences naming the single idea the reader should still feel
at the end of the last section. If the argument has a heartbeat, this is
it.>
## What This Proposal Must Not Become
<2-4 bullets naming the drift the spine exists to prevent — e.g. "a tour
of company capabilities," "a brochure exec summary," "a restatement of
the SOO." Pulled from capture-intent's prohibited claims plus the failure
modes specific to this opportunity.>Discipline Rules
- Prose, not structure. The spine runs lengthwise through the whole proposal — it is the argument start to finish. The storyboard runs crosswise — a per-section table of fields. If
narrative-spine.mdhas section numbers or a field table, it has become a storyboard. Delete and rewrite as prose. - Read the customer's own words. Quote one or two short phrases from the solicitation that the argument must answer. The spine earns its keep by being demonstrably about this customer's problem, not a generic case.
- Length-aware. Match the spine's ambition to
page_target. A 2-3 page white paper has no room to teach abstract concepts — its spine is ~150 words and compresses the argument into the tightest possible form. A 20-40 page proposal can afford to teach — its spine is up to one page and may name what each movement will explain. Do not write a 30-page-proposal spine for a white paper. - Mode-aware. The selected narrative mode changes the spine's job. A
compressed-briefspine should make the recommendation feel inevitable quickly. Ascored-volumespine should keep compliance sections connected by one evaluator-facing case. Atechnical-meritspine should make the technical hypothesis, proof plan, and transition logic coherent. - One argument, not a list. The spine asserts a single coherent case. If you cannot state it in one positioning sentence, the capture strategy is not resolved — say so plainly and recommend the user revisit
/capture-intentrather than papering over it. - Honest. The spine argues with the real evidence and the real weaknesses from
capture-intent.md. It does not wish. A spine built on an unsupported claim produces a proposal built on an unsupported claim. - Do not draft proposal prose. The spine is the plan for the argument. The storyboard decomposes it; the writer drafts it. Writing section text here defeats the purpose and collides with
/proposal-writer.
Human Sign-Off Gate
After writing working/narrative-spine.md, stop. Do not chain into /proposal-storyboard or /proposal-writer.
Emit a decision card (per reference/schemas/decision-card.schema.json) — present it to the user in chat, and append it as one JSON line to working/decision-cards.jsonl. The card makes the gate fast to act on without hiding the artifact:
{"schema_version":"decision-card.v1","gate_id":"narrative-spine-approval","proposal_id":"<slug>","generated_by":"narrative-spine","generated_at":"<timestamp>","decision":"Approve the proposal's central argument before storyboarding/drafting begins.","artifact":"working/narrative-spine.md","recommendation":"<approve as written | approve with the noted change | revisit /capture-intent first>","confidence":"<High|Medium|Low>","rationale":"<one or two sentences>","risk_if_wrong":"<what the whole proposal gets wrong if this argument is off>","on_approval":"the storyboard decomposes this spine and the writer drafts it","human_time_estimate":"3 minutes","approve_action":"/proposal-storyboard","review_required":true}review_required is always true for this gate. The card does not replace reading the one-pager — it frames it. Tell the user, explicitly:
The narrative spine is written to
working/narrative-spine.md— read the one page. This is the highest-leverage three minutes in the whole proposal: it decides the argument every section will carry, and it is the cheapest point to correct course. Edit it or approve it. When it reads right, run/proposal-storyboard(or/proposal-writerfor a white paper).
The spine is the one stage designed for human judgment. Surface it and wait.
Integration With Downstream Skills
/proposal-storyboarddecomposes the approved spine into sections. Each section storyboard should advance one movement of the argument; a section that advances no movement is a candidate for cutting./proposal-writerreadsworking/narrative-spine.mdfirst, as primary orientation. Every drafted section should be traceable to a movement of the spine. The writer drafts the argument; it does not invent a new one./red-team-reviewchecks whether the drafted proposal still carries the spine's through-line — a proposal that lost its spine in drafting is a red-team finding.
Anti-Patterns to Prevent
The narrative-spine stage exists to prevent:
- capability-tour proposals (a list of what we do, with no argument)
- executive summaries that read like a company brochure
- sections that restate the solicitation instead of answering it
- proposals where every section is competent but the whole makes no case
- a "spine" that is secretly a storyboard (field tables, section numbers)
- an argument built on aspirational rather than real proof points
Activity Trail
On completion, append one line to working/activity.md:
## <timestamp> — narrative-spine — wrote <N>-movement argument, positioning line set, handed to human for sign-off → working/narrative-spine.mdAppend one JSON line to working/ai-runs.jsonl per reference/schemas/ai-run.schema.json:
{"schema_version":"ai-run.v1","timestamp":"<timestamp>","skill":"narrative-spine","proposal_id":"<proposal>","job_type":"planning","provider":"anthropic","model":"claude-opus-4-7","input_tokens_estimate":null,"output_tokens_estimate":null,"cost_estimate_usd":null,"notes":"narrative spine — pre-prose argument"}Final Rule
This skill plans the argument. It does not write the proposal. One page, prose, handed to a human. That is the whole job.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

