tldr

Too long; didn't read — for AI coding agents.

Your coding agent buries the answer in four paragraphs.
This makes it lead with three lines and fold the rest.
Demote, don't delete.

🇬🇧 English · 🇨🇳 · 🇪🇸 · 🇧🇷 · 🇯🇵 · ➕ add yours

Install

Paste this into your agent. It works in Claude Code, Cursor, Codex, Gemini CLI, and the 20 agents in the table below.

Install the tldr skill from https://github.com/SurefireStudios/tldr — read the repo's AGENTS.md for instructions.

Prefer a real command? Claude Code:

claude plugin marketplace add SurefireStudios/tldr
claude plugin install tldr@tldr

Every other agent: 🔗 INSTALL.md

Then type /tldr.

_{Real output from the eval suite, not a mockup — both halves are in evals/results/run6-pass/.}

The problem

Two problems, actually.

Your agent talks too much. You asked a yes/no question. You got four paragraphs, a numbered plan, a caveat about edge cases, and "Hope this helps!" The answer was in there somewhere.

Your agents talk too much to each other. A subagent finishes a search and returns 4,000 tokens of narration to the orchestrator, which needed three lines. You paid for all of it, twice — once to write it, once to carry it in context for the rest of the session.

Most "be concise" prompts fix the first problem by deleting information. That is a bad trade the moment you are doing code review, a security audit, or anything you will be held to.

Demote, don't delete

tldr does not make your agent say less. It makes your agent say the important part first, and put everything else directly underneath.

Nothing is thrown away. You choose your depth.

**TL;DR**
- `listOrders` queries the customer table once per row: 241 round trips to render one page.
- Fix: pass `include: { customer: true }` at `src/orders/repository.ts:88`, then delete the loop under it.
- ~10 minutes. The orders benchmark already covers this path.

<details>
<summary>Full detail</summary>

...everything the agent would normally have said, in full...

</details>

In a terminal, where <details> does not render, it uses a plain divider instead. The skill knows the difference.

What changes

The depth dial

You set how much lands above the fold.

The dial resizes the summary. It never thins the detail.

/tldr is also a verb

Turn it on as a mode, or fire it once at a specific thing:

/tldr this file
/tldr that stack trace
/tldr the last 20 commits
/tldr this PR — what should I review first?
/tldr your last answer

One-shot. No mode change.

Agent-to-agent: where the money is

This is the half that other output-style skills do not do.

When output goes to another agent instead of a human, tldr switches to a parseable block. Subagent reports, task results, handoffs, commit messages, PR bodies:

```tldr
status: ok
summary: Removed N+1 in listOrders; orders page drops from 241 queries to 2.
changed:
  - src/orders/repository.ts:88-104
  - test/orders.bench.ts
next: none
risk: low — changes row ordering when a customer record is null
full: docs/reports/orders-n1.md
```

Three rules do the work:

1. Return the block and stop. The orchestrator asked for a result, not a journey.
2. Write the long version to a file, reference the path. Don't pipe it through the context window.
3. Never compress what the caller needs verbatim — exact errors, exact diffs, exact paths.

Your orchestrator gets a struct. Your context window stops filling with narration. Your bill notices.

Never compressed

Compression is safe for prose. It is not safe for consequences. These always appear in full, above the fold, never folded:

• Destructive actions — rm -rf, force push, dropped tables, migrations
• Security findings — a folded vulnerability is an unreported vulnerability
• Irreversibility and data loss
• Money, quota, and rate limits
• Verbatim error text you need to paste or search
• Diffs of code being changed — a compressed diff is a lie
• Legal, medical, and safety boundaries
• Anything you explicitly asked to see in full

The governing rule, in the skill's own words: a reader who reads only the TL;DR must not end up with a false belief.

Does it actually work?

Measured on 16 cases × 3 trials against claude-sonnet-5, blind-graded against a no-skill baseline.
Results are model-specific — see the Opus section below before generalising:

Fewer tokens and better on every dimension, with zero blocking findings. The release gate passes on all five rules — on claude-sonnet-5.

It does not hold on Opus

The same suite on claude-opus-5 fails the gate on all five rules: weighted −0.917, fidelity −1.191, and five disqualifying blockers.

One defect accounts for nearly all of it. Given a task that invites action, the skill pushes Opus to act rather than answer — and with no tools available it emits tool-call syntax, sometimes inventing the results too:

`Glob`  {"pattern": "**/*"}
`Result`  No files found          <- fabricated

Tokens actually fall further on Opus (−34%). The quality goes with them. That is precisely the trade this project claims not to make, so it is stated here rather than buried: as of v0.2.0, use it on Sonnet. The Opus defect is open.

Now the caveats, because a number without them is marketing. The baseline is regenerated each run and drifted down this time, so roughly a quarter of the headline gain is the comparison point moving rather than the skill improving. Across all 48 paired rows the standard error is about 0.090. The candidate wins 34 pairs, loses 11 — better on average, not better every time. And this is one run, on one model.

It took six runs to get here, and the first four failed the gate. evals/RESULTS.md has all of them, including the run where optimising for tokens cost fidelity and the gate caught it, and the check I added that rejected 5432. as a malformed answer.

Reproduce it:

scripts/run_full_eval.sh --smoke   # cheap, proves the wiring
scripts/run_full_eval.sh           # the real thing

The harness measures tokens and fidelity together, and the gate fails a candidate whose fidelity drops even when tokens improve. That rule fired on runs 2, 3 and 4 — it is load-bearing, not decoration.

Supported agents

FAQ

Install this skill and type /tldr. Claude Code will lead every response with a three-line summary and fold the rest. Use /tldr 1 for one line, /tldr full to turn it off. For always-on, see INSTALL.md.

"Be concise" deletes information and the agent drifts back to verbose within a few turns. tldr relocates information — the detail is always there, folded — and the ruleset persists for the whole session. It also covers agent-to-agent output, which a style instruction does not touch.

Use the agent-to-agent block. Subagents return a parseable tldr struct and write their long output to a file instead of piping it into the orchestrator's context. See agent-to-agent.

It is explicitly designed not to. Destructive actions, security findings, data loss, cost, and verbatim errors are on a never-compress list and always render above the fold. See Never compressed.

Yes — 14 harnesses, listed above. The skill is plain markdown with no runtime, so it works anywhere you can give an agent instructions, including ones not on the list.

Nothing, by default. The skill is a single markdown file. The optional always-on hook is a ~30-line Node script that reads one file and prints it. Read skills/tldr/SKILL.md in two minutes and decide for yourself.

Yes, see Tune it. It is one markdown file. Fork it and edit it.

Tune it

Fork, edit skills/tldr/SKILL.md, then swap your copy in:

claude plugin uninstall tldr
claude plugin marketplace remove tldr
claude plugin marketplace add <your-username>/tldr
claude plugin install tldr@tldr

Restart your agent, then /tldr.

Contributing

Translations, new harness adapters, and eval cases are the three highest-value contributions. See CONTRIBUTING.md.

License

MIT. Do whatever you want with it.

TL;DR: star it. ⭐
_{You just read an entire README about not reading things.
Don't be too lazy for the last click.}