
content
Tools for bootstrapping content creation such as blog posts and conference talks
- version
- 0.6.0
- GitHub stars
- 114
Install
/plugin install content@nicknisiRun it inside Claude Code after adding the marketplace with /plugin marketplace add nicknisi/claude-plugins.
Contents
Discovered from sourceSkills 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:
| Rule | Why |
|---|---|
Every mental-state sentence is a verbatim quote from step 2, or a [NICK: what were you actually thinking here?] marker | The core failure. Untagged invented interiority is an automatic fail. |
| Sections end on information — a fact, a number, a command, or just stop | Eight 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, maximum | A 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:
- The flat draft
- The interiority list — every sentence claiming his inner life, for him to rewrite or cut
- The gate output
- 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 corpusreferences/post-template.md— frontmatter schema and structural skeletonreferences/frameworks.md— diagnostic vocabulary for critiquing a finished draftscripts/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:
- Read the provided transcript or outline
- Extract: key themes, narrative arc (if any), main arguments, examples, audience assumptions
- Identify gaps — what's missing for a complete talk?
- Summarize what you found and ask the user to fill gaps
- 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:
- If the user has given prior talks or published slides, reference those for voice calibration
- 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 beatsreferences/frameworks/freytags-pyramid.md— Five-phase arc with rising action, climax, and falling actionreferences/frameworks/story-circle.md— Eight-step hero's journey for personal transformation arcsreferences/frameworks/kishotenketsu.md— Four-act twist without conflict — recontextualize, don't confront
Existential:
references/frameworks/sisyphean-arc.md— Recurring struggle reframed as meaningful through persistencereferences/frameworks/kafkaesque-labyrinth.md— Navigating absurd bureaucratic or systemic complexityreferences/frameworks/existential-awakening.md— Radical freedom and the weight of choosing your toolsreferences/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 happensreferences/frameworks/the-metamorphosis.md— Waking up to discover everything has fundamentally changedreferences/frameworks/catch-22.md— Circular logic and no-win constraints in systemsreferences/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 explainreferences/frameworks/the-spiral.md— Revisit the same concept at increasing depth each passreferences/frameworks/the-rashomon.md— Same event from multiple perspectivesreferences/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 orderreferences/frameworks/the-petal.md— Multiple independent stories supporting one central thesisreferences/frameworks/converging-ideas.md— Separate threads that merge into a single conclusionreferences/frameworks/the-false-start.md— Begin with conventional approach, reveal why it failsreferences/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"
- Stage 0: Brain dump — they have experience but no structure. Go to Stage 1.
- Stage 1: Gather details — audience is conference (intermediate), 30 min, code-heavy, story of a migration journey.
- 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.
- Stage 3: Read
references/frameworks/story-circle.mdandreferences/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
- Generate slide-by-slide talk script (~25-30 slides) with speaker notes in Nick's voice.
- 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:
| Category | Signal |
|---|---|
| Vocabulary clusters | 3+ AI-overused words in a section |
| Inflated significance | Phrases that inflate importance without adding information |
| Superficial -ing clauses | Participial phrases tacked on as fake depth |
| Promotional language | Travel-brochure / sales-deck vocabulary |
| Vague authority | Phantom expert attributions ("Industry reports suggest...") |
| Formulaic transitions | Five-paragraph-essay connectors (moreover, furthermore) |
| Negative parallelism | Overuse of "not X, it's Y" construction |
| Rule of three | Every list having exactly three items |
| Copula avoidance | "Serves as" instead of "is" |
| Elegant variation | Thesaurus cycling to avoid repeating a concrete noun |
| Em dash density | Em dashes at 2-3x human rate |
| Formatting tells | Mechanical 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