conference-talk-builder — Claude Code skill: talk scripts and setup
conference-talk-builder turns rough notes, transcripts, or a topic into a structured tech talk script with a slide-by-slide plan. Use it to shape ideas into a narrative.
MIT ★ 114 updated 2026-08-11
/plugin marketplace add nicknisi/claude-plugins
/plugin install content@nicknisiWhat conference-talk-builder does
The skill builds a talk script around a narrative framework. It lays out what appears on each slide, adds speaker notes and transitions, and suggests how to allocate time. The result is a script, not a slide deck; you take it to a presentation tool of your choice.
It first gathers details such as the topic, audience, and talk length. For a transcript or an existing outline, it extracts themes and arguments, then asks about gaps. Next, it offers two framework options for the speaker to choose from, drafts the script, and revises it based on feedback.
The skill uses reference files to select a narrative framework and shape the speaker notes. references/framework-guide.md contains the selection guidance, while references/voice-tone.md informs the notes’ style. Slide creation happens separately, so expect a written deliverable rather than a finished presentation.
What it helps with
- Turn scattered notes into a tech talk outline
- Extract themes and arguments from a transcript
- Map a talk’s narrative onto individual slides
- Adjust a script to the target duration
- Revise a talk after receiving feedback
Example prompts for the agent
- Turn these rough notes into a tech talk script and suggest two narrative structures.
- Analyze this transcript, pull out the main arguments, and draft a slide-by-slide talk plan.
- Revise my talk script and check its transitions, pacing, and section length.
How to install conference-talk-builder
1Plugin marketplace
/plugin marketplace add nicknisi/claude-plugins/plugin install content@nicknisiThis installs the whole content plugin with all its skills
2Skills CLI (Vercel)
npx skills add nicknisi/claude-plugins --skill conference-talk-builder -a claude-code3Manually: put the files in place
~/.claude/skills/conference-talk-builder/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/conference-talk-builder/
1Skills CLI (Vercel)
npx skills add nicknisi/claude-plugins --skill conference-talk-builder -a codex2Manually: put the files in place
.agents/skills/conference-talk-builder/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add nicknisi/claude-plugins --skill conference-talk-builder -a cursor2Manually: put the files in place
.cursor/skills/conference-talk-builder/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install nicknisi/claude-plugins plugins/content/skills/conference-talk-builder2Manually: put the files in place
.github/skills/conference-talk-builder/SKILL.md1Skills CLI (Vercel)
npx skills add nicknisi/claude-plugins --skill conference-talk-builder -a gemini-cli2Platform CLI
gemini skills install https://github.com/nicknisi/claude-plugins --path plugins/content/skills/conference-talk-builderManually: put the files in place
.devin/skills/conference-talk-builder/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about conference-talk-builder
How do I install conference-talk-builder in Claude Code?
Add the marketplace with /plugin marketplace add nicknisi/claude-plugins, then install the skill with /plugin install content@nicknisi.
What does conference-talk-builder do?
It turns a topic, notes, or a transcript into a talk script with a narrative structure, slide content, speaker notes, transitions, and timing guidance. It does not generate presentation files.
Does it create slides or a script?
It produces a written script and slide-by-slide content plan. You can use that material in Slidev, Gamma, iA Presenter, Keynote, or another presentation tool.
Source text
SKILL.md · MIT
--- name: conference-talk-builder description: Create conference talk outlines and slide-by-slide content plans using narrative frameworks. Use when the user wants to structure a tech talk, create presentation content, or needs help organizing talk ideas into a story-driven format. Tool-agnostic — outputs a talk script, not slides. --- # 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 ```markdown # [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: ```markdown ### 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 ```markdown ## 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.
© Nick Nisi · MIT · nicknisi/claude-plugins