Agent skill

Evidence-Grounded Explainer

by EveryInc in EveryInc/compound-engineering-plugin

Produces an evidence-backed explanation of how and why something has its current shape, or what happened over a stretch of work, tuned to its intended reader.

MITAuto-check passedDevelopment

Install Evidence-Grounded Explainer

skills CLI
$ npx skills add EveryInc/compound-engineering-plugin --skill ce-explain -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install EveryInc/compound-engineering-plugin ce-explain --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/EveryInc/compound-engineering-plugin.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/ce-explain .claude/skills/ce-explain && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
ce-explain
GitHub stars
25k
Token cost
~2.1k tokens
SKILL.md length
1,053 words
Files
9 (incl. references)
Skills in repo
37
Repo updated
First seen
Licence
MIT

At a glance

Produces an evidence-backed explanation of how and why something has its current shape, or what happened over a stretch of work, tuned to its intended reader.

  • Works in 4 steps: Establish the question and use → Ground → Compose the explanation → …
  • Explaining why a module or feature ended up with its current design
  • SKILL.md covers Consumer and interaction, Artifact Root, Execution Flow and Boundaries
  • Calls openssl and git

What it does

This skill answers a scoped how-or-why question and leaves the reader with enough understanding for their intended use. Project behavior is grounded in source evidence, and the explanation keeps documented rationale, inference and unknowns apart, so a result may describe verified behavior while saying that the historical reason is unknown. Depth and format follow the audience, whether a person needs a working answer or a calling agent needs a teaching artifact for someone else.

The agent resolves discoverable facts before asking and asks only when a missing detail would change the answer; if it cannot ask, it returns the open question and its consequence. It delivers the explanation with supporting evidence and material open questions, or else the specific blocker, and publishing is a separate action. Reference files cover intake, orchestration of evidence gathering and subagent dispatch, check-ins, destinations, and HTML or Markdown explainer formats, with two scout agents for behavior tracing and work recaps. Judgments and recommendations belong to the separate ce-pov skill.

When your agent uses it

  • Explaining why a module or feature ended up with its current design
  • Recapping what happened over a window of work
  • Producing a teaching explainer for a teammate or another workflow

Example prompts

  • “Explain how the retry logic in the sync service ended up the way it is, with evidence.”
  • “Recap what changed in the billing code over the last sprint and why.”
  • “Write an HTML explainer of how requests flow through our auth middleware for a new teammate.”

Workflow steps

4 steps, taken from the step headings in SKILL.md.

  1. Establish the question and use
  2. Ground
  3. Compose the explanation
  4. Deliver

What it can do on your machine

Read from SKILL.md and the folder at commit cef001f. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • openssl
    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Evidence-Grounded Explainer loads about 2.1k tokens when it runs, and up to ~8.8k if it reads all its reference files. Until then it costs about 53 tokens; SKILL.md has 1,053 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~53
When it runs · the whole SKILL.md, loaded when a task matches
~2.1k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~8.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from EveryInc/compound-engineering-plugin at commit cef001f, republished under its MIT licence (© EveryInc). 1,053 words, ~2,148 tokens.

Download SKILL.mdSave it as .claude/skills/ce-explain/SKILL.md (or your agent's skills folder). This skill also uses 8 other files; get the full folder from GitHub.
name
ce-explain
description
Explain how and why something has its current shape, or what happened over a window of work, grounded in evidence. Use when the user asks for an explanation. Use ce-pov for a judgment or recommendation.
argument-hint
[question, concept, change, or work window] [intended use or reader]

Explain How and Why

Produce an explanation that answers the scoped question and gives its consumer enough understanding for the intended use. The subject and purpose come from the request and available context, whether a person or another workflow supplied them. Ground project behavior in source evidence; distinguish documented rationale, inference, and unknowns.

Done: deliver the explanation with supporting evidence and material unanswered questions, or return the specific blocker. When an artifact is requested, deliver the artifact and its location. Publication is a separate action, not a condition of having explained the subject.

Consumer and interaction

Adapt depth and presentation to the intended readers and use. A person may need a working answer; a calling agent may need a teaching artifact for someone else. Do not infer the output from the caller's identity alone. When contributing to an ongoing workflow, deliver the requested result and leave continuation to its owner, the calling workflow. Do not add destination menus or follow-up offers to that return.

Resolve discoverable facts before asking. Ask only when missing information materially changes the answer and cannot be resolved from the request or evidence. If interaction is unavailable, return the unresolved question and its consequence rather than waiting or inventing an answer. A result may explain verified behavior while reporting that its historical rationale is unknown.

Read references/orchestration.md before grounding, the first blocking question, or subagent dispatch. It defines evidence gathering, tool use, model tiers, and their fallbacks.

Artifact Root

An explainer lands under <root>/explainers/ only when archived to the repo, and learnings may be read under <root>/solutions/. Resolve <root> only when you compose such a path; a scratch-only or external-concept run never composes one. Pass the resolved path to any subagent, not the config.

<!-- ce-docs-root:start -->

Resolve the CE artifact root <root> before composing any artifact path.

  • Read docs_root from <repo-root>/.compound-engineering/config.yaml only (<repo-root> = git rev-parse --show-toplevel). Do not read it from config.local.yaml. Unset -> <root> is docs, exactly as before.
  • Validate a set value: a repo-relative directory whose real, symlink-resolved path stays inside the repo and is neither the repo root nor under .git/. Otherwise stop with an error naming docs_root and the value -- never fall back to docs.
  • Use <root> as the sole artifact location: create it if absent, compose each path as <root>/<subdir> with this skill's own subdirectory, and never also read docs.
<!-- ce-docs-root:end -->

Execution Flow

Phase 1: Establish the question and use

Read references/intake.md now. It defines how the subject and time window are resolved, the input tokens, and how the delivery form is chosen. Explain only the requested subject. A bare invocation with no recoverable subject needs clarification under the interaction rule above, not an invented topic or default artifact.

Phase 2: Ground

Follow references/orchestration.md for the scoped evidence pass. Use existing evidence when it is adequate and current; check claims whose support is missing, disputed, or affected by source changes.

Create a run directory only when an artifact or an evidence dossier needs one. Use this block before writing either; it rejects a symlink or a scratch root owned by another user:

bash
SCRATCH_ROOT="/tmp/compound-engineering-$(id -u)";
[ ! -L "$SCRATCH_ROOT" ] && (umask 077; mkdir -p "$SCRATCH_ROOT") 2>/dev/null && [ ! -L "$SCRATCH_ROOT" ] && [ -O "$SCRATCH_ROOT" ] && [ -w "$SCRATCH_ROOT" ] || SCRATCH_ROOT="${TMPDIR:-/tmp}/compound-engineering-$(id -u)";
if [ -L "$SCRATCH_ROOT" ]; then echo "unsafe scratch root symlink: $SCRATCH_ROOT" >&2; exit 1; fi;
(umask 077; mkdir -p "$SCRATCH_ROOT") || exit 1;
if [ -L "$SCRATCH_ROOT" ] || [ ! -O "$SCRATCH_ROOT" ]; then echo "scratch root is not owned by the current user: $SCRATCH_ROOT" >&2; exit 1; fi;
chmod 700 "$SCRATCH_ROOT" || exit 1;
RUN_DIR="$SCRATCH_ROOT/ce-explain/$(date +%Y%m%d)-$(openssl rand -hex 3)";
(umask 077; mkdir -p "$RUN_DIR") || exit 1; chmod 700 "$RUN_DIR" || exit 1;
echo "$RUN_DIR";

A behavior trace that splits across ownership boundaries writes scout dossiers. Create this run directory before dispatching those scouts.

  • Diff mode. Empty range or missing subject: do not silently explain something else. Report that before explaining an adjacent thing. Use a substitute only when the request permits it or the user agrees; name the substitution in the result and artifact Subject when present. Otherwise return the unresolved scope to the caller.
  • Recap mode. Do not pre-scan, count, or characterize the window in the main conversation. Instead dispatch a generic subagent directly at the extraction tier, seeded with references/agents/work-recap-scout.md and passed the resolved window, repo root, and $RUN_DIR. Empty window: report the absence of activity and finish without an explainer artifact. When the harness exposes no subagent primitive, run the scout inline with its prompt's sources and budgets, still write recap-evidence.md, and form no view of the window until it is done. If dispatch fails, follow the fallback rule in references/orchestration.md.
Show full SKILL.md (386 more words)Show less
Phase 3: Compose the explanation

Answer the question using the evidence, preserving material constraints and uncertainty. Before delivery, check every factual claim against its source. A function call does not establish guarantees about its uninspected implementation. Remove unsupported claims or state their uncertainty where they appear, including in diagrams and exercise answers. Choose prose, code, tables, or visuals when they improve understanding; no particular arrangement is required. Keep attribution accurate when explaining work by multiple people. When selecting from more evidence than the requested scope or depth can hold, disclose the selection; never silently present a partial account as exhaustive.

For an answer or material another workflow will incorporate, return that content directly. Each passage must carry the qualifications needed to use it accurately without separate notes. When another workflow will use the answer, that return includes the evidence, the constraints that still apply, and the unanswered questions. Do not create a standalone artifact unless the intended use needs one.

For a standalone artifact, read references/explainer-html.md or references/explainer-markdown.md at compose time for the selected format's compatibility and metadata requirements. For teaching artifacts, also read references/check-in.md. The run never blocks on the check-in; any exercises are static content in the artifact. Write $RUN_DIR/explainer.html or explainer.md, then deliver an inline summary plus the file path.

Phase 4: Deliver

A delivered answer or local artifact completes the explanation. Do not require a destination choice or manufacture follow-on work. If a destination was requested, read references/destinations.md before acting; it defines each destination and the consent publishing needs. When a calling workflow owns the surrounding document, return the content to it rather than placing or publishing it yourself.

Publishing to ht-ml.app is never headless and never inferred. Naming it is a choice of destination rather than confirmation after its public-publishing warning. If confirmation cannot be obtained, do not publish; preserve the canonical HTML and report its local $RUN_DIR/explainer.html path.

Boundaries

  • Use ce-pov to judge whether an approach should be adopted or changed. Explaining a historical choice is not endorsing it today.
  • Use ce-compound to capture durable project learning. Producing an explanation does not authorize maintaining repo memory.
  • Explain an idea as supplied; generating alternatives and scoping implementation belong to ce-ideate, ce-brainstorm, and ce-plan.
  • A reported failure to diagnose or fix belongs to ce-debug; a factual explanation of current behavior remains here.

© EveryInc, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 8 other files (references) in skills/ce-explain of EveryInc/compound-engineering-plugin.

  • SKILL.md
  • references/agents/behavior-trace-scout.md
  • references/agents/work-recap-scout.md
  • references/check-in.md
  • references/destinations.md
  • references/explainer-html.md
  • references/explainer-markdown.md
  • references/intake.md
  • references/orchestration.md

Open the folder on GitHubat commit cef001f

Compare with similar skills

Evidence-Grounded Explainer next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Evidence-Grounded Explainer compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Evidence-Grounded Explainer this skillEveryInc/compound-engineering-plugin25k—~2.1kAutomated safety check: PassMIT
Project Onboarding Guide from Knowledge GraphEgonex-AI/Understand-Anything85k—~1.2kAutomated safety check: PassMIT
Deepwiki Rssopaco/deepwiki-rs3.1k—~748Automated safety check: PassMIT
Acquire Codebase Knowledgegithub/awesome-copilot40k1 repos~2.3kAutomated safety check: PassMIT
Codex Proxy RS Development Guidezyycn/codex-proxy-rs738—~618Automated safety check: PassApache-2.0
Spec MinerJeffallan/claude-skills12k1 repos~1.2kAutomated safety check: PassMIT

Similar skills

  • Writes an onboarding guide for new team members from a project's existing knowledge graph, after checking that the graph still matches the current commit.

    85k GitHub stars~1.2k tokensUpdated yesterday
    DevelopmentAuto-check passed
  • Deepwiki Rs

    sopaco/deepwiki-rs

    AI-powered Rust documentation generation engine for comprehensive codebase analysis, C4 architecture diagrams, and automated technical documentation.

    3.1k GitHub stars~748 tokensUpdated 23 days ago
    DevelopmentAuto-check passed
  • Acquire Codebase Knowledge

    github/awesome-copilot

    Official

    Maps an unfamiliar codebase into seven evidence-backed documents in docs/codebase/, using a scan script and templates, for onboarding or architecture write-ups.

    40k GitHub starsUsed in 1 repo~2.3k tokens
    DevelopmentAuto-check passed
  • Routes development, troubleshooting, review and documentation tasks on the Codex Proxy RS repository to the right section of its docs, instead of loading the whole architecture or contributing guide.

    738 GitHub stars~618 tokensUpdated today
    DevelopmentAuto-check passed
  • Spec Miner

    Jeffallan/claude-skills

    Reads an undocumented codebase and writes up what it does: architecture, data flows, observed behavior as EARS requirements, and open questions to confirm.

    12k GitHub starsUsed in 1 repo~1.2k tokens
    DevelopmentAuto-check passed
  • Eazyr Repo Onboarding Kit

    buildfastwithai/gen-ai-experiments

    Creates a QUICKSTART, doctor scripts and a documented .env.example for an unfamiliar repo from facts scanned in the repo, and audits how easy it is to onboard.

    785 GitHub stars~1.4k tokensUpdated 15 days ago
    DevelopmentAuto-check: notes

More from EveryInc/compound-engineering-plugin

All 37 skills in this repo
  • Compound Learning Writer

    EveryInc/compound-engineering-plugin

    Records one solved and verified problem as a durable learning in the repository, but only when the reasoning is not already clear from the final code, tests or docs.

    25k GitHub stars~2k tokensUpdated today
    Auto-check passed
  • Compound Learnings Refresh

    EveryInc/compound-engineering-plugin

    Audits a repo's stored learnings against the current codebase, fixes stale, overlapping or superseded docs and reports on every document.

    25k GitHub stars~2k tokensUpdated today
    Auto-check passed
  • Compound Engineering Prototype

    EveryInc/compound-engineering-plugin

    Builds a throwaway prototype at just the fidelity needed to settle a specific how-it-should-work-or-feel question, before committing to an approach other work will treat as fixed.

    25k GitHub stars~1.9k tokensUpdated today
    Auto-check passed
  • Compound Engineering Setup

    EveryInc/compound-engineering-plugin

    Checks Compound Engineering plugin health and repo-local config, or scaffolds a Compound Pack when you ask for one by id.

    25k GitHub stars~1.9k tokensUpdated today
    Auto-check passed
  • PR Babysitter

    EveryInc/compound-engineering-plugin

    Watches an open GitHub pull request over time, routing review comments and CI failures to other skills until the PR is ready to merge.

    25k GitHub stars~2k tokensUpdated today
    Auto-check passed
  • CE Brainstorm

    EveryInc/compound-engineering-plugin

    Turns a vague or ambitious feature idea into a requirements-only plan through dialogue with you, sized to the work, before any code is written.

    25k GitHub stars~1.9k tokensUpdated today
    Auto-check passed

Categories

Questions about Evidence-Grounded Explainer

What does Evidence-Grounded Explainer do?

Produces an evidence-backed explanation of how and why something has its current shape, or what happened over a stretch of work, tuned to its intended reader. This skill answers a scoped how-or-why question and leaves the reader with enough understanding for their intended use. Project behavior is grounded in source evidence, and the explanation keeps documented rationale, inference and unknowns apart, so a result may describe verified behavior while saying that the historical reason is unknown.

When should I use Evidence-Grounded Explainer?

Evidence-Grounded Explainer fits situations like: explaining why a module or feature ended up with its current design; recapping what happened over a window of work; producing a teaching explainer for a teammate or another workflow.

How do I install Evidence-Grounded Explainer in Claude Code?

Run `npx skills add EveryInc/compound-engineering-plugin --skill ce-explain -a claude-code`. Or copy the skill folder (skills/ce-explain in EveryInc/compound-engineering-plugin) into .claude/skills/ce-explain in your project. Claude Code loads it when a task matches its description.

How do I install Evidence-Grounded Explainer in Codex?

Run `npx skills add EveryInc/compound-engineering-plugin --skill ce-explain -a codex`. Or copy the skill folder (skills/ce-explain in EveryInc/compound-engineering-plugin) into .agents/skills/ce-explain in your project. Codex loads it when a task matches its description.

Can I use Evidence-Grounded Explainer in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add EveryInc/compound-engineering-plugin --skill ce-explain -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/ce-explain, .gemini/skills/ce-explain, .github/skills/ce-explain and .opencode/skills/ce-explain in your project.

What does Evidence-Grounded Explainer need to run?

Going by SKILL.md and its folder, Evidence-Grounded Explainer needs the command-line tools its instructions call (openssl and git).

Does Evidence-Grounded Explainer access the network?

SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Evidence-Grounded Explainer safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Evidence-Grounded Explainer use?

Evidence-Grounded Explainer is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Evidence-Grounded Explainer use?

About 2.1k tokens (SKILL.md is roughly 8.6k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 6.6k tokens, read only when the agent opens those files.

What are the alternatives to Evidence-Grounded Explainer?

Skills that share tags, products or a category with Evidence-Grounded Explainer: Project Onboarding Guide from Knowledge Graph (Egonex-AI/Understand-Anything, 85k stars), Deepwiki Rs (sopaco/deepwiki-rs, 3.1k stars), Acquire Codebase Knowledge (github/awesome-copilot, 40k stars) and Codex Proxy RS Development Guide (zyycn/codex-proxy-rs, 738 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Evidence-Grounded Explainer?

EveryInc (a GitHub organization) maintains it in EveryInc/compound-engineering-plugin, which has 25,412 GitHub stars. The repository holds 37 skills in this directory. The repository was last updated on October 7, 2026.

Source: EveryInc/compound-engineering-plugin on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.