Anthropic's Most-Used Internal Skill Is a 321-Byte Prompt
On the morning of August 22, while scrolling X, I saw Thariq had posted another viral thread. This Anthropic Claude Code engineer's previous post about the 'headless SaaS' business model got 4,002 likes. This time, it was even bigger, hitting 11,700 likes and over 900 retweets in two days, yet the content was incredibly simple: he publicly shared a skill that has been used most frequently internally at Anthropic, called ELI5. Installing it into Claude Code requires only two commands.
Honestly, my first reaction wasn't 'another plugin,' but curiosity: what kind of internal tool makes engineers across an entire cutting-edge AI lab use it daily, and compels someone at the founder level to manually retweet it until it goes viral?
So I did the most natural thing: I tore its source code apart.
What does this skill do?
ELI5, Explain Like I'm 5, explains anything as if to a 5-year-old. The usage is a single line:
/eli5 <what you want to understand>
For example, the official example given in the README:
/eli5 how does DNS work
Claude will generate an HTML artifact: a big picture, very few words, explaining DNS to 'someone who knows nothing about this field.' It's not a document, nor a 5,000-word essay; it's a single-page diagram you can drag over to show someone else.
In his post, Thariq gave three very 'engineer's daily life' usage examples:
/eli5 how does this module work
/eli5 why did we make this tradeoff
/eli5 what caused this incident
Notice the commonality of these three scenarios: you are not learning new knowledge; you are catching up. Taking over an unfamiliar module, digging into a technical decision made three years ago, or reviewing an incident that happened at 3 a.m. In these moments, what you lack isn't information (the code, docs, and logs are all there), but someone to treat you like a beginner and explain it from scratch.
After tearing down the source code, I paused
After installing the plugin, the first thing I did was browse its source code directory, prepared to read a bunch of complex logic. The entire directory tree looked like this:
eli5/
├── .claude-plugin/
│ └── plugin.json # 318 bytes, plugin metadata
├── skills/
│ └── eli5/
│ └── SKILL.md # 321 bytes, all core logic
└── README.md # 197 bytes
plugin.json contains metadata like name, version, author, and license. The author is Thariq Shihipar himself, under the MIT license.
The real 'source code,' SKILL.md, is reproduced in full below, verbatim:
---
name: eli5
description: Explain a topic like I'm 5 year old. Use when the user types
/eli5 <topic> or asks for a dead-simple picture explainer of how something works.
---
# eli5
Explain like I'm someone who knows nothing about this topic, using a HTML
artifact with big pictures and few words.
Topic: $ARGUMENTS
That's it. 321 bytes. The core prompt is a single 26-word English sentence:
Explain like I'm someone who knows nothing about this topic, using a HTML artifact with big pictures and few words.
A skill with 11,700 likes, used frequently inside Anthropic, and installed by countless people with two commands—its entire secret is this one sentence.
Why a 26-word prompt is the most effective
After reading this prompt, I re-read it several times. The more I read it, the more I felt that not a single word was wasted. It packs several layers of constraints into one sentence, and each layer solves a major pitfall in AI explanation problems.
First, look at 'knows nothing about this topic.' This is audience anchoring. When asking an AI to explain something, the most common failure is that it doesn't know how much you already understand. You say, 'Tell me about DNS,' and it defaults to treating you as a peer, starting with 'the iterative query process between recursive resolvers and authoritative servers.' If you ask again, it swings to the other extreme, starting from 'what is a network.' This prompt nails the audience down: someone who knows absolutely nothing about this. The entire essence of the Feynman Technique is in this one line; if you can explain it to someone who knows nothing, you truly understand it.
'Big pictures and few words' is the most easily overlooked but most valuable layer. Without constraining the format, the AI's default output is a short essay: five paragraphs, bolded keywords, hierarchical lists. It looks structurally neat, but the cognitive load is explosive. 'Big pictures, few words' directly nails the output to a diagram. Pictures are responsible for building intuition, and words only keep the most necessary anchors. This isn't a new invention; textbooks, airport signs, and IKEA manuals have long proven this is the most efficient form of explanation. We just always forget to demand it when writing prompts.
Then there's 'HTML artifact,' the carrier constraint. Why HTML and not Markdown? Because Markdown can't draw pictures. HTML is the most universal canvas in a browser: layout, colors, SVG, animation—it can hold everything. Claude generates a self-contained HTML file, and opening it gives you a scrollable, shareable, screenshot-able diagram card. With the right carrier, 'big pictures, few words' can actually land.
Several layers of constraints, in one sentence, without a single superfluous word. Compared to the hundreds of lines of 'system prompt compendiums' we usually cobble together, this 321-byte file forces a rethink: does a prompt's power come from its length, or from whether its constraints hit the vital points?
I actually ran it once
For the first case, I ran the official example /eli5 how does DNS work. Below is a screenshot of the actual HTML artifact produced:
Five cards, five steps: Look up the phonebook → The librarian → Layer-by-layer directions → Get the number → Write it on a sticky note. Each card has one big picture and one sentence. Not a single technical term requires you to look it up first.
The best part is the final summary: 'DNS is just a phonebook that writes its own notes.' This compresses a pile of concepts—recursive resolution, iterative queries, TTL caching—into a metaphor a 5-year-old can remember.
The second case was even more interesting. I aimed the question at Claude itself.
While writing this article, I casually ran a more 'meta' one: /eli5 where this skill is installed, using ELI5 to ask ELI5 where it lives. Note this input; it's so colloquial it's almost grammatically broken, but that's exactly the state of a real question: throwing the doubt in your mind out as is, without first translating it into precise terminology.
Claude's approach is also worth mentioning: it didn't just start drawing immediately. Instead, it acted like a detective, browsing the file system, ls-ing the plugin cache, global skills, and project skills directories one by one. Only after confirming the real paths did it start working, producing the diagram below:
Three 'home' cards: the Mall Warehouse (installed from the plugin marketplace, with a version number doorplate), the Carry-on Suitcase (global skill, goes wherever you go), and the Company Toolbox (project-specific, committed with git). At the end, a directory map, wrapped up in a slogan: 'Mall warehouse shows the version, suitcase travels the world, toolbox follows the project.' For this type of question, checking the docs would require looking up three separate official guides. Instead, it first verified the real directories on your machine, then drew the picture. Every path on the diagram was empirically confirmed.
Applying it to the codebase you touch every day is where this craft truly shines. /eli5 how does this module work—Claude reads the code first, then explains it to you with a diagram. It's like every module comes with a classmate who draws pictures and explains problems. /eli5 why did we make this tradeoff forces it to reconstruct the historical decisions in the code into a narrative of 'why we chose this back then.' Both tasks would take an afternoon if you dug through the docs yourself. Asking this way takes two minutes to build a framework, and then going back to chew on the details is much faster.
The other half of the truth in the comments
If you only look at the like count, this is a perfect story. But after scrolling through hundreds of replies, I found the comment section was actually split into two halves.
One half was asking for it to be made official and sharing use cases. The most interesting one came from a former Stripe employee: they had built a similar skill on Stripe's internal LLM platform at the end of 2023, and it was one of the most used skills internally. They made three 'zoom levels': ELI5 / ELI12 / ELIPhD. The only thing was, in the GPT-4 era, HTML graphics weren't available. In other words, the idea of 'giving AI a simple explainer persona' was a hidden, rigid demand inside large companies two years ago. Thariq just productized it using Claude's artifact capability and plugin system.
The other half was using the opportunity to complain. A highly upvoted comment wrote: 'The only reason this skill is needed is because you guys broke the model.' The criticism was aimed at the output style of Opus 5: even when explicitly asked to use simple words and be concise, it often churns out a lengthy novel. Someone proposed an even more biting improvement direction for ELI5: not ELI5, but ELI10, 'Five years old is too childish.' To this criticism, Thariq himself replied personally: 'We're working very hard on this.'
This criticism is actually more informative than the praise. Half the credit for ELI5's viral success goes to that 26-word prompt, and the other half goes to the fact that the model's default output is indeed too verbose. The skill is paying off the model's debt. The most incisive comment, quoted repeatedly, said it best: 'not more intelligence, more intellegible.' What the model lacks isn't more smarts, but more understandability.
Two commands, install and use
Back to the original point: how to install it. The installation method Thariq gave is just two commands. First, add the community plugin marketplace, then install this plugin:
claude plugin marketplace add anthropics/claude-plugins-community
claude plugin install eli5@claude-community
After installation, just use /eli5 <anything>. If you find installing a plugin too troublesome, someone in the comments revealed the essence: paste that 26-word prompt directly into the conversation, and the effect is exactly the same. This was its entire source code to begin with.
While browsing the commit history, I also found an interesting detail: this plugin was committed to the community repository just 40 minutes before the tweet was sent, and it was revised 5 times in 6 minutes, from 'Add eli5 plugin' to 'Use HTML artifact wording,' and then to 'Reword eli5 skill prompt.' In other words, behind that 11,700-like tweet was a last-minute wording polish right before release. Even a single prompt sentence needed 5 iterations to refine. This is probably the best footnote for 'constraints must hit the vital points.'
This anthropics/claude-plugins-community is a community marketplace officially maintained by Anthropic. It currently hosts 2,282 plugins. Thariq himself is still debating whether to turn ELI5 into an official plugin. Judging by this level of hype, it's likely just a matter of time.
The installation chain itself is worth a closer look: for the first time, a 'skill' has become an independent product form that can be installed and uninstalled with a single command. The marketplace is the repository, the plugin is the package, and SKILL.md is the entire logic inside the package. This structure is exactly like npm or Homebrew, except the package content has changed from code to 'an instruction manual teaching AI to do one thing.'
Write your own Skill in 5 minutes
After seeing the 321 bytes of source code, a very natural conclusion is: the barrier to writing a Skill has been compressed down to a single Markdown file. You don't need to write any code, just a frontmatter block and a few lines of instructions:
---
name: my-skill
description: Describe in one sentence what this skill does and when it should trigger.
---
# my-skill
Write the instructions here. Treat the AI as a smart but new colleague who doesn't know your context.
Tell it: who the audience is, what the output format is, and what the hard constraints are.
How to write these few lines of instructions well? Just reverse-engineer it from those 26 words in ELI5.
First, nail down the audience. Describe in one sentence 'who you are explaining to': someone who knows nothing, a senior engineer, or a product manager. Then, nail down the format: diagram, list, code, table. Don't let the AI freely improvise into a short essay. There's also one most easily overlooked point: only write the vital constraints. Every time you add a prompt sentence, first ask yourself what erroneous output it cuts out. Any prompt that cuts out no errors is just noise.
Writing this, I recall the hottest discussion direction under Thariq's post: what surprised everyone wasn't how powerful this skill is, but how small it is. 321 bytes, a YAML header plus one English sentence. Was it worth 11,700 likes in two days? Yes. Because it demonstrates a brand new 'product' form in the Agent era: not a stack of code, but a precise understanding of 'how to make AI get it right the first time.'
The skill is the product, and the product manual, one sentence is enough.
Material references: Thariq's main post · Usage example tweet · anthropics/claude-plugins-community · ELI5 plugin v1.0.0, MIT License; interaction data as of 2026-08-23