Einstein simplify
A Claude Code skill that rewrites technical content so non-technical audiences follow every word, without losing accuracy or depth.
npx -y skills add jmsmrgn/einstein-simplifyAssembled from the repository path, not quoted from the project. Check it against their README if it does not work.
One thing to look at
- 2 stars2 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
What its author says it does
Copied from the file, not written here
Rewrites complex technical explanations, presentations, scripts, or any dense content so that a non-technical person sitting next to an expert could follow every word. Use this skill whenever the user wants to simplify a technical topic, make something ELI5, prepare an explanation for a mixed audience, strip jargon without losing accuracy, or says anything like 'explain it simply', 'make this accessible', 'dumb this down', 'non-technical version', 'teach this to a layman', or 'my audience isn't technical'. Also trigger when preparing presentations, demos, or scripts that will be delivered to audiences of mixed technical backgrounds. The Einstein frame: if you can't explain it simply, you don't understand it well enough. This skill enforces that standard.
SKILL.md
6.4 KB, as published. Nobody here has run it
einstein-simplify
Rewrite complex technical content so a non-technical person sitting next to an expert can follow every word — without losing accuracy or depth.
The goal is not to make things childish. It is to make things clear. An expert should feel the explanation is precise. A layman should feel it is followable.
Core Principles
1. Concept before label Never introduce a technical term before the concept it names exists in the listener's head. Lead with what something does, then name it.
- Bad: "RAG, which stands for Retrieval-Augmented Generation, solves the problem of..."
- Good: "The model doesn't know your documents. We solve that by giving it a specific set of pages to read before it answers. That pattern is called RAG."
2. Analogy before description For any abstract concept, deliver a concrete real-world analogy before the technical description. The analogy is the foundation. The description builds on it.
- Bad: "Vector embeddings map semantic meaning into high-dimensional space."
- Good: "Think of it like GPS coordinates, but for meaning instead of location. Every piece of text gets plotted as a point on a map. Things that mean similar things end up near each other — even if the actual words are different. That's what a vector embedding is."
3. One worked example beats four surface descriptions When multiple concepts need explaining, develop one fully with a concrete example rather than naming all four shallowly. Depth on one creates understanding. Width across many creates overwhelm.
- Bad: "There are four key decisions: chunk size, overlap, match threshold, and reranking."
- Good: "The most important decision is chunk size. Here's why it's not obvious: imagine chunking a legal document. Too big and you inject three paragraphs when only one sentence was relevant — noise. Too small and you cut a sentence from the paragraph that gives it meaning — loss of context. There's no universal answer. You tune it for the corpus. The other decisions — overlap, threshold, reranking — follow the same logic."
4. No acronyms until the concept exists Introduce labels only after the concept is understood. Never lead with an acronym even with an immediate expansion — the expansion is still jargon.
5. Replace, don't define Where possible, replace jargon with plain language rather than defining jargon. Definitions ask the listener to hold two words in mind. Replacements give them one.
- Bad: "cosine similarity (a measure of angular distance between vectors)"
- Good: use "nearest neighbors in meaning-space" instead — drop cosine entirely
6. The teachable moment deserves full space Every explanation has one moment where the mechanism clicks. Find it. Give it a full beat. Read it aloud if it's a script. Pause after delivery. Don't rush past the insight to the next concept.
7. The non-technical test After every rewrite section, ask internally: could a smart person with zero domain background follow this? If no — simplify further. If yes — move on.
Workflow
Step 1: Identify the audience gap
Before rewriting, assess:
- Who is the primary audience? Who is the secondary audience?
- What is the most complex concept in the content?
- What jargon appears that has no plain English equivalent being used?
- Where is the single most teachable moment?
Step 2: Scan for violations
Flag every instance of:
- Acronym introduced before concept
- Technical term used without analogy
- Multiple concepts enumerated shallowly
- Jargon defined rather than replaced
- A key insight rushed past without pause
Step 3: Rewrite
Apply the seven principles. For each flagged item:
- Concepts before labels: restructure the sentence order
- Analogies: insert before technical description, not after
- Worked examples: pick the most important concept, develop it fully, compress the rest
- Acronyms: delay until concept is established
- Jargon: find the plain English equivalent and use it exclusively
- Teachable moment: expand, slow down, give it space
Step 4: Show diff
Present a before/after for each changed section. Do not apply until confirmed.
Format:
Before:
[original text]
After:
[rewritten text]
Change: [one-line reason]
Step 5: Apply on confirmation
Output the full rewritten content once confirmed.
Hard Rules
- DO NOT sacrifice accuracy — simplification is not dumbing down, it is clarifying
- DO NOT remove content — restructure and rephrase, do not delete
- DO NOT add new analogies that are inaccurate or misleading
- DO NOT introduce new jargon while removing existing jargon
- ALWAYS keep the expert in the room satisfied — they should feel the explanation is still precise
- The non-technical person and the expert must both be able to follow — this is the dual standard
Reference: Common Jargon Replacements
| Jargon | Plain replacement |
|---|---|
| vector embedding | coordinates that represent meaning |
| cosine similarity | nearest neighbors in meaning-space |
| LLM | AI language model |
| inference | the model generating an answer |
| fine-tuning | retraining the model on specific data |
| context window | the text the model can read at once |
| retrieval | finding the relevant passages |
| chunking | breaking documents into passages |
| semantic search | searching by meaning, not exact words |
| latency | response time |
| token | roughly one word or part of a word |
Add domain-specific replacements as discovered during the rewrite.