Menu
Transform technical insights into full 40-50 minute TED-style talks with concrete examples and Q&A
The review-first prompt is selected by default. You can switch to a direct command or download a local copy.
Read SKILL.md and any companion files shown by SkillsMP before deciding whether to install.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
npx skills add https://github.com/live-neon/skills --skill ted-talkThe command stays on one line. Scroll horizontally to inspect it before copying.
Prefer a local copy? Download the files currently available to SkillsMP.
Same skill compression power in half the context — 975 tokens vs 2,500.
Skill compression reminder in 100 tokens — just trigger, action, result.
Complete skill compression documentation — all options, modes, and calibration details (~2,500 tokens).
Based on SOC occupation classification
Showing SKILL.md
| name | ted-talk |
| version | 1.0.2 |
| description | Transform technical insights into full 40-50 minute TED-style talks with concrete examples and Q&A |
| author | Live Neon <hello@liveneon.ai> |
| homepage | https://github.com/live-neon/skills/tree/main/creative/ted-talk |
| repository | leegitw/ted-talk |
| license | MIT |
| tags | ["creative","presentation","speaking","storytelling","teaching","synthesis","reflection","knowledge-transfer"] |
| layer | creative |
| status | active |
| alias | ted |
| user-invocable | true |
| emoji | 🎤 |
Transform technical conversations and insights into full-length TED-style talks. Creates comprehensive 40-50 minute presentations with hooks, concrete examples, broader implications, and Q&A preparation.
Trigger: 明示呼出 (explicit invocation) or when deep technical insight emerges
Core insight: "The best technical talks don't just explain what — they reveal why it matters, with examples concrete enough to apply and implications broad enough to inspire."
openclaw install leegitw/ted-talk
Dependencies: None (standalone creative skill)
Data handling: This skill synthesizes content from user-supplied input or the current conversation context (default). It does NOT read files from the workspace or access project artifacts directly. Results are returned to the invoking agent, who decides how to use them.
Technical insights often stay trapped in conversations. A well-structured talk makes them teachable and shareable. This skill:
The insight: A 50-minute talk forces you to truly understand something — if you can't explain the why, address objections, and connect to broader implications, you don't fully understand it.
/ted [topic]
| Argument | Required | Description |
|---|---|---|
| topic | No | Topic focus (default: synthesize current conversation) |
Before creating a TED talk, ensure:
You must be able to answer:
| Question | What It Means |
|---|
| Core insight? | Not "we talked about X" but "we discovered X solves Y" |
| Problem solved? | The pain point, not just the topic |
| Why, not just what? | The reasoning, not just the outcome |
| Concrete examples? | Specific details from the context provided |
| Broader implications? | Why does this matter beyond the immediate context? |
## TED Talk: "[Talk Title]"
### Opening (0:00-2:00)
[Hook with relatable problem]
### Setup: Why This Matters (2:00-6:00)
[Context, stakes, personal connection]
### The Problem (6:00-12:00)
[Deep dive into the pain point]
### Core Concept (12:00-25:00)
[Explain the insight thoroughly]
### Real-World Examples (25:00-38:00)
[Concrete applications with specifics]
### Broader Implications (38:00-45:00)
[Why this matters beyond immediate context]
### Closing (45:00-48:00)
[Call to action or reflection]
### Q&A Preparation (48:00-50:00)
[Common objections and responses]
| Rule | Description |
|---|---|
| Full 40-50 minutes | NOT a summary — comprehensive content |
| Hook with problem | Start with relatable pain, not abstract concept |
| Concrete examples | Specific, real details — not hypothetical scenarios |
| Address objections | Q&A section anticipates pushback |
| No filler | Every section should teach something |
| Accessible but not condescending | Technical depth without jargon overload |
| Section | Duration | Purpose |
|---|---|---|
| Opening | 2 min | Hook with relatable problem |
| Setup | 4 min | Why this matters, stakes |
| Problem | 6 min | Deep dive into pain point |
| Core Concept | 13 min | The main insight, thoroughly explained |
| Examples | 13 min | Real-world applications |
| Implications | 7 min | Broader impact |
| Closing | 3 min | Call to action |
| Q&A Prep | 2 min | Objections and responses |
| Element | Question |
|---|---|
| Problem | What was broken/painful? |
| Discovery | What did we learn? |
| Solution | What pattern emerged? |
| Impact | Why does this matter? |
For each section:
TED talks resonate when they're specific, not hypothetical. Draw from:
Use what the user provides — don't invent specifics or assume access to files.
Context: Discovered reproduce-to-debug problem. Introduced Bootstrap → Learn → Enforce phases.
Title: "Bootstrap Before You Break: Why Greenfield Systems Need to Learn What Normal Looks Like"
It's 3 AM. Your pager goes off. The system is on fire — users are complaining, something is clearly wrong. You pull up your logs and... nothing. Metrics? Flat lines. Traces? What traces?
You're debugging blind.
And the worst part? You built this system. You know every line of code. But you have no idea what's happening.
This happened to me six months ago. And the solution we found changed how I think about every system I'll ever build.
We've all been taught: instrument your code, add logging, set up dashboards. The standard advice works great — for existing systems.
But what about greenfield? What about day one?
Here's the thing nobody tells you: you can't set meaningful thresholds for a system that's never run in production. What's a normal response time? What's an acceptable error rate? You don't know. You can't know. The system hasn't told you yet.
[... continues for full 50 minutes ...]
Note: Full TED talk outputs are 40-50 minutes of content. This excerpt demonstrates the opening sections.
Q: "This seems like overkill for small projects."
A: Fair point. The full three-phase approach is designed for systems where
debugging cost is high — production services, distributed systems, anything
where "just add a log line and redeploy" isn't an option. For a weekend
project, you probably don't need this. But the core insight — bootstrap
before you enforce — scales down too. Even a simple log.Debug everywhere
is a form of bootstrap phase.
Q: "How long should the bootstrap phase last?"
A: We found 7-14 days covers most patterns. You want at least one full business cycle (weekly patterns), and ideally two. The key indicator is when your anomaly detection stops alerting on normal behavior.
| Condition | Behavior |
|---|---|
| Insufficient context | Ask clarifying questions first |
| No concrete context | Ask for specific details before proceeding |
| Surface-level insight | Suggest deeper exploration first |
| No broader implications | Suggest finding wider relevance |
Input sources:
What this skill does NOT do:
Output behavior: This skill returns the full TED talk directly to the invoking agent. The agent can then display, save, or pass the result to another skill as needed.
Note on concrete details: The skill uses only what the user provides in the conversation or as explicit input. It does not access workspace files. Review output before sharing externally to ensure no sensitive information is included.
Provenance note:
This skill is developed by Live Neon (https://github.com/live-neon/skills) and published
to ClawHub under the leegitw account. Both refer to the same maintainer.
/ted synthesizes input or conversation into full-length talkPart of the Live Neon Creative Suite.