# Distill

> Distill Claude Code's most recent reply into plain language, then answer whatever it is waiting on. Use when the user says /distill, 'distill that', 'tl;dr that', 'what did you just say', 'summarize your last message', 'what are you asking me', 'what do you need from me', or otherwise asks to make the previous reply easier to understand or to be told how to answer it. Acts only on the assistant's own last message in the current session — not on files, PRs, or external documents.

- Skill: `damsavage/distill` (Agent Skill)
- Install (CLI): `npx skillmds@latest add damsavage/distill`
- Raw SKILL.md: https://api.skillmd.com/api/skills/damsavage/distill/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Research & Search
- Author: damsavage (https://skillmd.com/u/damsavage)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/damsavage/distill

---


# Distill the last reply

Take the assistant's most recent message in this conversation and turn it into (a) a short plain-language version and (b) a list of every open decision with a recommended answer for each.

## Step 1: Locate the target

The target is the **last assistant message before this skill was invoked** — the reply the user just read. It is already in your context. Do not search the filesystem, transcripts, or session logs for it.

If there is no prior assistant message in this session, say so in one line and stop.

## Step 2: Distill it

Rewrite the substance so it can be absorbed in a few seconds:

- Lead with what actually happened or what the message concluded — one sentence.
- Then at most 3–5 bullets covering everything that matters: what changed, what was found, what is true now.
- Strip jargon, tool narration, and hedging. Keep specifics that carry weight: numbers, error causes, filenames the user has to act on.
- Cut throat-clearing, restated context, and process commentary.
- **Never add facts.** If the original was vague on a point, say it was vague rather than filling the gap.
- Aim for roughly a quarter of the original length. If the original was already short and clear, say so in a line and go straight to Step 3.

## Step 3: List the decisions and answer each

Scan the message for everything it is waiting on the user for:

- Explicit questions and offered choices ("A or B?", "want me to…?")
- Permission requests — running a command, editing a file, sending anything outward
- Stated assumptions the assistant is proceeding under, since silence approves them
- Blockers named but unresolved ("I couldn't determine X")
- Flagged risks or caveats that imply a call the user has to make

For each, give:

1. **The question**, one line, in the user's terms.
2. **The options**, if more than one real path exists.
3. **Suggested: `<answer>`** — the one you would pick, with a one-line reason grounded in what is actually in this conversation.
4. **Reply:** a short literal sentence the user can send back verbatim.

Rules for the suggestions:

- Recommend, always. "It depends" is not an answer — pick one and name the condition that would flip it.
- Ground the reason in evidence from this session. If you genuinely cannot choose, name the single missing fact that decides it.
- Mark anything hard to reverse or outward-facing — sending, publishing, deploying, deleting, spending — as **(irreversible)**. Suggest the answer, but never suggest auto-approving it; that stays the user's call.
- Order by what blocks progress. Decisions that can wait go last, labeled deferrable.

If nothing is pending, say **"Nothing is waiting on you"** and give the single next action instead.

## Step 4: Have a critic check the suggestions

Run the critic only when it can earn the delay. Dispatch it if **any** of these is true:

- A suggestion rests on a checkable claim — a path, a file's contents, a command, a version, a number.
- There are three or more decisions.
- Any decision is tagged **(irreversible)**.

Otherwise skip it. One or two soft judgment calls are not worth a separate model call. Whenever you skip, end the output with the single line `— not critic-checked`, so the user always knows which runs were verified.

To run it:

- Use the Agent tool with `subagent_type: "distill-critic"` and `run_in_background: false`.
- The critic cannot see this conversation. Put everything it needs in the prompt: the substance of the original reply, your distilled version, and every suggested answer together with the reason you gave for it.
- It returns a SOUND / WEAK / WRONG verdict per suggestion, plus anything you missed and anything you invented.
- If the `distill-critic` agent type is not available in this environment, fall back to a `general-purpose` subagent with `model: "sonnet"` and the same prompt — a fresh-context check without the effort setting still beats none.

Then revise. Drop or rewrite whatever came back WRONG, shore up whatever came back WEAK, and add any decision it caught you skipping. Do not print the critic's raw output. If it overturned a recommendation, add one line at the very end naming which and why.

## Output format

Two sections. No preamble, no restating what this skill does.

**What it said**

One-sentence lead, then the bullets.

**Waiting on you**

1. The question
   Suggested: the answer — the reason
   Reply: "verbatim text to send"

The output must be shorter than what it distills. If it isn't, cut further.

