Conference Talk Builder

Transform brain dumps, transcripts, or raw ideas into structured conference talk scripts using narrative frameworks and Nick Nisi's voice.

The output is a talk script — a narrative outline with slide-by-slide content plan, speaker notes, and timing guidance. It is deliberately tool-agnostic: feed the script into Slidev, Gamma, iA Presenter, Keynote, or whatever you use to build the actual slides.

Process

Stage 0: Entry Path

Determine how the user is starting:

From scratch — They have a topic but no material yet. Go to Stage 1.

From a brain dump — They have scattered notes, bullet points, ideas. Go to Stage 1 and use their material as the starting input.

From a transcript — They have a recording transcript, prior talk, or existing outline. Go to Stage 1-T.

From feedback — They have an existing talk script from a prior session and want to revise. Skip to Stage 4.

Stage 1: Information Gathering

Ask the user for (skip what they've already provided):

• Talk title (working title is fine)
• Topic — what's the talk about?
• Target audience — conference attendees, meetup crowd, internal team, workshop participants?
• Audience knowledge level — beginner, intermediate, expert, mixed?
• Duration — lightning (5 min), standard (20-30 min), extended (45+ min)?
• Main points they want to cover
• The story — what problem are they solving, what journey did they take, what do they want the audience to walk away with?
• Code density — is this code-heavy, concept-heavy, or balanced?
• Constraints — specific technologies, company context, anything off-limits?
• Brain dump — everything they know about the topic, unorganized is fine

Don't require all of this upfront. Ask for what's missing after the first pass.

Stage 1-T: Transcript Analysis

When working from existing material:

1. Read the provided transcript or outline
2. Extract: key themes, narrative arc (if any), main arguments, examples, audience assumptions
3. Identify gaps — what's missing for a complete talk?
4. Summarize what you found and ask the user to fill gaps
5. Proceed to Stage 2 with the extracted material

Stage 2: Narrative Framework Selection

Read references/framework-guide.md for the full selection algorithm.

Quick-match shortcuts (covers ~80% of talks):

• Personal journey / "I solved X" → Story Circle
• Teaching a concept → The Spiral or Socratic Path
• "Here's what went wrong" → In Medias Res or Reverse Chronology
• Tool/approach comparison → The Rashomon or Converging Ideas
• Vision / persuasion → The Sparkline
• Absurd complexity → Kafkaesque Labyrinth or Catch-22
• Recurring pain → Sisyphean Arc
• Myth-busting → The False Start or Comedian's Set

Run the scoring algorithm from the framework guide using the user's inputs (tone, duration, audience, topic type, code density). Present the top 2 recommendations with a brief sketch of how the talk maps to each framework's structure. Let the user choose or suggest alternatives.

Once a framework is selected, read only that framework's reference file from references/frameworks/. Do not preload all twenty-two.

Stage 3: Build the Talk Script

Read references/voice-tone.md to calibrate Nick's presentation voice.

Then calibrate against recent talks:

1. If the user has given prior talks or published slides, reference those for voice calibration
2. Note patterns that differ from blog writing — talks are more casual, use more humor, and rely on rhythm and pacing

Structure the talk script as a markdown document with:

Header

# [Talk Title]

**Duration**: [target length]
**Audience**: [who and what level]
**Framework**: [selected framework]
**Slide count target**: [based on duration — see framework reference]

## Narrative Arc

[2-3 sentence summary of the story arc using the framework's structure]

Slide-by-slide Content Plan

For each slide:

### Slide N: [Descriptive Title]

**Framework phase**: [which step/act of the framework this maps to]
**Key visual**: [what should be on the slide — a code block, image, diagram, list, quote, or just a heading]
**On screen**: [the actual text/content the audience sees]

**Speaker notes**: [what you say while this slide is up — written in Nick's voice]

**Transition**: [how this connects to the next slide]

Appendix

## Resources

[Links, references, further reading for the closing slide]

## Timing Guide

[Rough time allocation per framework phase]

Stage 4: Refine and Iterate

After presenting the talk script:

• Ask if the narrative arc feels right
• Check if any sections need expansion or compression
• Verify code examples are appropriately scoped
• Confirm the story flows — does each transition feel natural?
• Check pacing against duration target

Voice check: Re-read references/voice-tone.md and scan the speaker notes for:

• Does it sound conversational, not scripted?
• Is there vulnerability where appropriate?
• Are there specific details (tool names, numbers, real examples)?
• Is humor self-aware, not forced?
• Would Nick actually say this on stage?

Iterate based on feedback. The talk script is the deliverable — the user takes it to their slide tool of choice.

Key Principles

Tell a Story: You don't need to be an expert. Focus on how you approached a problem and solved it. The journey is more interesting than the destination.

One Idea Per Slide: Each slide earns its place by advancing exactly one concept. If you need a bullet list longer than 3-4 items, split across slides.

Show, Don't Tell: Code examples, diagrams, screenshots, and demos are more memorable than bullet points. But break complex code across multiple slides.

Pacing Matters: Vary the rhythm. Dense technical slides need breathing room — follow them with a simple visual or a moment of humor. Speaker notes should indicate pace changes.

Make Follow-up Easy: End with a memorable URL, QR code, or handle linking to slides and resources.

Engage the Audience: Use questions. Make eye contact. The speaker notes should include audience interaction cues where appropriate.

Bundled Resources

References

• references/voice-tone.md — Nick's voice and tone guide. Read this to calibrate speaker notes and talk style.
• references/framework-guide.md — Framework selection algorithm with scoring matrix. Read this in Stage 2.

Narrative frameworks (read only the selected one — do not preload all twenty-two):

Foundational:

• references/frameworks/three-act.md — Setup, confrontation, resolution in three clean beats
• references/frameworks/freytags-pyramid.md — Five-phase arc with rising action, climax, and falling action
• references/frameworks/story-circle.md — Eight-step hero's journey for personal transformation arcs
• references/frameworks/kishotenketsu.md — Four-act twist without conflict — recontextualize, don't confront

Existential:

• references/frameworks/sisyphean-arc.md — Recurring struggle reframed as meaningful through persistence
• references/frameworks/kafkaesque-labyrinth.md — Navigating absurd bureaucratic or systemic complexity
• references/frameworks/existential-awakening.md — Radical freedom and the weight of choosing your tools
• references/frameworks/strangers-report.md — Detached observational analysis of a system's contradictions

Absurdist:

• references/frameworks/the-waiting.md — Meaning found in the space where nothing happens
• references/frameworks/the-metamorphosis.md — Waking up to discover everything has fundamentally changed
• references/frameworks/catch-22.md — Circular logic and no-win constraints in systems
• references/frameworks/comedians-set.md — Setup-punchline rhythm with callbacks and escalating bits

Non-linear:

• references/frameworks/in-medias-res.md — Open mid-action, then rewind to explain
• references/frameworks/the-spiral.md — Revisit the same concept at increasing depth each pass
• references/frameworks/the-rashomon.md — Same event from multiple perspectives
• references/frameworks/reverse-chronology.md — Start with the outcome and work backward

Rhetorical:

• references/frameworks/the-sparkline.md — Alternate between "what is" and "what could be"
• references/frameworks/nested-loops.md — Layer stories inside stories, resolve in reverse order
• references/frameworks/the-petal.md — Multiple independent stories supporting one central thesis
• references/frameworks/converging-ideas.md — Separate threads that merge into a single conclusion
• references/frameworks/the-false-start.md — Begin with conventional approach, reveal why it fails
• references/frameworks/socratic-path.md — Drive through questions the audience is already asking

Example Workflow

User: "I want to create a talk about how we migrated our monolith to TypeScript"

1. Stage 0: Brain dump — they have experience but no structure. Go to Stage 1.
2. Stage 1: Gather details — audience is conference (intermediate), 30 min, code-heavy, story of a migration journey.
3. Stage 2: Run framework scoring. Top picks: Story Circle (journey/transformation, high code affinity) and The Spiral (can revisit migration patterns at increasing depth). User picks Story Circle.
4. Stage 3: Read references/frameworks/story-circle.md and references/voice-tone.md. Map the migration to the 8 steps:
   • You: Current JS monolith, team shipping features
   • Need: Type safety issues causing production bugs
   • Go: Research TypeScript, propose migration
   • Search: Pilot conversion on one module, learn the hard way
   • Find: Incremental migration strategy with strict mode
   • Take: Third-party library types, team resistance
   • Return: Full codebase migration complete
   • Change: 40% fewer runtime errors, team converts to TS advocates
5. Generate slide-by-slide talk script (~25-30 slides) with speaker notes in Nick's voice.
6. Stage 4: Iterate — user says the "Search" section is too long, compress. Add a humor beat after the "Take" section. Done.

The user then takes this script to Slidev, Gamma, or whatever tool they prefer.