Tools for bootstrapping content creation such as blog posts and conference talks

version
0.6.0
GitHub stars
114

Install

/plugin install content@nicknisi

Run it inside Claude Code after adding the marketplace with /plugin marketplace add nicknisi/claude-plugins.

Contents

Discovered from source

Skills 3

Nick Nisi Blog Writer

Turn raw material into a draft Nick finishes. This skill does research, structure, and connective prose. It does not produce publishable first-person writing.

The rule this skill exists to enforce

Facts may come from logs. Feelings may not.

An earlier version of this skill shipped a post that readers called AI slop. The facts were impeccable — real timestamps, real commit stats, real Slack quotes. The failure was that it also generated Nick's inner life: what he thought, what he'd assumed, what moved him. Nine such claims; one had a source. Readers can't always name that, but they feel it, and they stop trusting the piece.

The measured version: that post claimed inner states at 5.84 per 1,000 words against Nick's corpus mean of 0.97. Six times his rate. He mostly writes about what he built. The draft wrote about how he felt about what he built.

Everything below follows from that.

Process

1. Gather the raw material

Accept the mess: scattered thoughts, code, commands, conclusions, links. Don't require organization.

If the material is thin, mine it — session logs, Slack, git history, the repos themselves. This is the pipeline's genuine strength and there's no reason to hold back. Record a source for every fact. A working file of claim → source keeps the draft honest and makes step 5 mechanical.

2. Interview for the parts you cannot mine

This is the highest-value step in the skill. Do not skip it.

Logs record what Nick did. They never record what he thought. Ask 8–15 targeted questions with ask_user_question or plain prose, and capture the answers verbatim:

  • "What did you actually think when X happened?"
  • "Why did you really stop doing Y? Not the tidy reason — the real one."
  • "What's the part of this you'd argue with someone about?"
  • "What did you get wrong that you'd rather not include?"

Tell him to type fast and not polish. His unpolished answers are the raw material for every voice-load-bearing sentence in the post. They will be flat, hedged, and specific — that flatness is the voice. Do not smooth it.

If he declines to be interviewed, the post ships with [NICK: ...] markers where his inner life would go. That is a correct outcome, not a failure.

3. Read the corpus, not a description of it

Read 2–3 recent posts from src/content/posts/ in full — most recent first, plus any on a similar topic. Write connective prose consistent with those, not with a summary of them.

Then read references/voice-tone.md, which is now a list of ceilings and prohibitions, not features to hit. Requesting a feature makes a model execute it every time it applies; that's what produced eight aphorisms in an eight-section post. Only constraints are safe to state.

4. Structure from the material

Find the chronology or the argument already in the facts and follow it.

Do not select a narrative framework. references/frameworks.md exists as diagnostic vocabulary for talking about a draft that already exists — never as a template to fill. Choosing a framework means choosing what the events meant, which is Nick's call, not the tool's. A flawlessly executed Story Circle is the single most detectable artifact this skill can produce, because no human drafting from memory has ever produced one.

The only structural instruction: identify the one turn the post exists to make, arrange the facts so it lands, and leave flat ground everywhere else.

Section headers are descriptive — they name the topic ("What Fleet is", "Three signals, none trustworthy alone"). Allusive narrative-beat headers ("The drift", "Coming home") read as chapter titles and are a tell in bulk.

5. Write the ugly draft

Informationally complete, rhetorically inert. Aim for flat.

Nick is good at adding voice to plain prose and bad at excising pastiche from clever prose. A draft that already sounds finished is the worst possible artifact to hand him — he has to fight it. Give him something that obviously needs him.

Hard rules while drafting:

RuleWhy
Every mental-state sentence is a verbatim quote from step 2, or a [NICK: what were you actually thinking here?] markerThe core failure. Untagged invented interiority is an automatic fail.
Sections end on information — a fact, a number, a command, or just stopEight aphoristic endings is the template's silhouette
Every number traces to a source"Twelve minutes of curiosity" was invented precision that narrativizes a life
One sustained metaphor per post, maximumA metaphor recurring across 3+ sections is a framework fingerprint
No narrator stage directions"Now watch what happened next" is Nick emceeing a post he'd never emcee

Where you'd reach for a rhetorical flourish, write the plain sentence instead and let Nick decide whether it deserves more.

6. Run the structural gate — before Nick reads it

python3 scripts/slopcheck.py \
  --corpus '/Users/nicknisi/Developer/nicknisi.com/src/content/posts/*.md*' \
  --draft path/to/draft.mdx

It calibrates against Nick's real posts and flags outliers in both directions — suppression is as suspicious as excess. A draft engineered to dodge a metric looks different from one that never considered it.

The gate's job is to produce Nick's rewrite list, not to certify the draft. Fix what it flags, then hand over.

The interiority section always prints and is not scored against the corpus — it exits non-zero while any claim is unconfirmed. A structurally clean draft with unconfirmed first-person claims is not a passing draft. Those lines go to Nick, not to you.

Vocabulary checks (the tighten-prose skill) run last and matter least. They scan for 2024-era tells like "delve" and "leverage" and will pass a maximally slop-shaped draft — they did exactly that on the post that caused this rewrite.

7. Hand off, don't ship

Deliver:

  1. The flat draft
  2. The interiority list — every sentence claiming his inner life, for him to rewrite or cut
  3. The gate output
  4. Open questions

Do not publish a post whose first-person sentences Nick has not read and approved. He isn't the editor of this artifact. He's the only source for half of it.

Output Format

See references/post-template.md for frontmatter schema and file conventions.

Bundled Resources

  • references/voice-tone.md — ceilings and prohibitions, with measured rates from his corpus
  • references/post-template.md — frontmatter schema and structural skeleton
  • references/frameworks.md — diagnostic vocabulary for critiquing a finished draft
  • scripts/slopcheck.py — corpus-calibrated structural detector

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.

Tighten

A final editing pass that catches and removes AI-detectable writing patterns. Not a detector — an editor. The output reads like a human wrote it because, after this pass, a human shaped every sentence.

What this pass cannot see

This skill scans vocabulary and sentence-level habits. It is blind to structure, and structure is where modern AI prose gives itself away.

A ghost-written blog post once passed this gate with zero findings — no AI vocabulary, em-dash rate below the author's own baseline — while ending eight of eight sections on an aphorism, using six "Not X. That's Y." antitheses, and asserting nine invented claims about the author's inner life. Readers called it slop immediately. The gate had certified its own blind spot.

If you are tightening a draft written for someone else in their voice, run a corpus-calibrated structural check first — see plugins/content/skills/blog-post-writer/scripts/slopcheck.py. Two rules that pass list can't encode:

  • Slop is a rate, not a presence. Real writers use every device on the list below. The tell is one firing on every section instead of once a post. Thresholds have to be measured against the author's real corpus.
  • Check both directions. A metric sitting far below an author's baseline means someone wrote to the metric. That's as suspicious as excess.

Run this skill last and weight it least.

When to Run

  • After completing any prose-heavy output (blog posts, documentation, emails, talks)
  • When another skill requests a tighten pass as a quality gate
  • When the user asks to clean up or improve writing
  • Before shipping anything where "sounds like AI" would undermine credibility

Process

1. Load the Tells Reference

Read references/ai-tells.md for the full catalog of patterns, organized by category with examples and fix strategies.

2. Fetch Live Patterns

AI writing tells evolve as models change. Fetch the current vocabulary list from Wikipedia:

https://en.wikipedia.org/w/api.php?action=parse&page=Wikipedia:Signs_of_AI_writing&prop=wikitext&format=json

Extract the "Words to watch" lists and AI vocabulary entries. Newer models drop old tells and develop new ones — the live source catches drift the static reference cannot.

If the fetch fails, the static reference is sufficient. Proceed without it.

3. Scan for Pattern Density

Read the full text and scan across all categories:

CategorySignal
Vocabulary clusters3+ AI-overused words in a section
Inflated significancePhrases that inflate importance without adding information
Superficial -ing clausesParticipial phrases tacked on as fake depth
Promotional languageTravel-brochure / sales-deck vocabulary
Vague authorityPhantom expert attributions ("Industry reports suggest...")
Formulaic transitionsFive-paragraph-essay connectors (moreover, furthermore)
Negative parallelismOveruse of "not X, it's Y" construction
Rule of threeEvery list having exactly three items
Copula avoidance"Serves as" instead of "is"
Elegant variationThesaurus cycling to avoid repeating a concrete noun
Em dash densityEm dashes at 2-3x human rate
Formatting tellsMechanical boldface, title case headings, emoji decoration

The signal is density, not individual hits. One "crucial" is fine. A cluster of three AI vocabulary words in two paragraphs is a rewrite.

4. Report Findings

Present a concise summary:

  • Which categories showed pattern density above noise level
  • Specific examples quoted from the text
  • Severity: how many sections need work vs. isolated hits

Do not list every individual word match. Report clusters and structural patterns.

5. Rewrite Flagged Sections

For each flagged section, rewrite to eliminate tells while preserving meaning.

Fix strategies:

  • Inflated significance — Say what actually happened. Specific facts beat vague importance.
  • Superficial -ing — If the clause adds no new information, cut it entirely.
  • Copula avoidance — If a fancy verb replaces "is" without reason, use "is."
  • Formulaic transitions — Use casual transitions or drop them. "Here's the thing:" beats "Moreover."
  • Elegant variation — Repeat the concrete noun. "Vim" twice is better than "vim... the editor... the tool."
  • Rule of three — Vary list lengths. Two items is fine. Four is fine. One is fine.
  • Vague authority — Name the person or drop the attribution.
  • Promotional language — Replace with specifics. What exactly makes it good?
  • Em dashes — Keep the ones that earn their place. Replace the rest with commas or periods.

Constraints:

  • Preserve the original meaning and information content
  • Maintain the existing voice and tone — do not flatten personality
  • Keep legitimate rhetorical devices. A single "not X, it's Y" used for emphasis is a deliberate choice, not a tell. The tell is when every other paragraph uses it.
  • When a pattern appears intentional and isolated, leave it

6. Present the Tightened Version

If only a few sections changed, present before/after pairs for the changed passages. If the whole piece needed work, present the full rewrite.

Do not explain every change. The writing should speak for itself. Mention only changes where the reasoning is non-obvious.

Composability

Designed to work standalone or as a step in other writing workflows.

Standalone: Point at text and say "tighten this up."

Composed: Another skill (like blog-post-writer) calls for a tighten pass as its final quality gate. When composed, respect any voice calibration the parent skill has already established. Tighten removes autopilot patterns, not personality.

Bundled Resources

  • references/ai-tells.md — Full catalog of AI writing tells with examples, fix strategies, and density guidance. Adapted from Wikipedia's "Signs of AI writing."

Sponsors

Details

Marketplace
nicknisi/claude-plugins
Source
plugins/content
Author
Nick Nisi
Category
Community
Keywords
content, blog, blogging, talks, developer-talks, meetups

More from nicknisi/claude-plugins

All 11