ask
/ask
Answer a question about how the codebase works - research, not a fix. Load CANONIFY.md, route the question to the canons for its area, read them (and the code they cite) and produce a cited, developer-grade answer plus a short plain-language version you can hand to a client or stakeholder. No plan, no code, no diff. Run when the user types /canonify:ask, or says "a client is asking how X works", "does the system do Y", "what happens when Z", "how do we handle X", "explain how the W feature works", "I need to research a question about the project".
- Author
- ewebdzine ↗
- Repository
- canonify ↗
- Licence
- MIT
- Last repository change
- 14.09.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 14.09.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Answer a question about how the codebase works - research, not a fix. Load CANONIFY.md, route the question to the canons for its area, read them (and the code they cite) and produce a cited, developer-grade answer plus a short plain-language version you can hand to a client or stakeholder. No plan, no code, no diff. Run when the user types /canonify:ask, or says "a client is asking how X works", "does the system do Y", "what happens when Z", "how do we handle X", "explain how the W feature works", "I need to research a question about the project".
Triggers from the description
Original author description
Answer a question about how the codebase works - research, not a fix. Load CANONIFY.md, route the question to the canons for its area, read them (and the code they cite) and produce a cited, developer-grade answer plus a short plain-language version you can hand to a client or stakeholder. No plan, no code, no diff. Run when the user types /canonify:ask, or says "a client is asking how X works", "does the system do Y", "what happens when Z", "how do we handle X", "explain how the W feature works", "I need to research a question about the project".
How it works
- How to run
- Don't do
- Output template
SKILL.md preview
---
name: ask
description: Answer a question about how the codebase works - research, not a fix. Load CANONIFY.md, route the question to the canons for its area, read them (and the code they cite) and produce a cited, developer-grade answer plus a short plain-language version you can hand to a client or stakeholder. No plan, no code, no diff. Run when the user types /canonify:ask, or says "a client is asking how X works", "does the system do Y", "what happens when Z", "how do we handle X", "explain how the W feature works", "I need to research a question about the project".
---
# Ask - route a question to its canon, answer with citations
Canonify's **research** gate. The other read gates all assume you are about to *change* something -
Plan scopes an idea, Build routes a task, Commit audits a diff, Debug routes a failure. Ask is for
the fourth kind of session: someone (often a client) has a question about how the project already
behaves, and the job is to **answer it accurately and prove it** - not to plan, implement, or fix.
Same routing motion as `/canonify:build` (question -> `CANONIFY.md` summary sweep -> load the
implicated canons -> read the cited code), different deliverable: an answer with `file:line`
evidence, plus a plain-language restatement for the person who asked. And a different close-the-loop:
if the canon could not answer the question and you had to read code cold, that is a gap in the
canon worth capturing.
## How to run
1. **Load the index, set intent.** Read `CANONIFY.md` at the repo root - the manifest of one-line
canon summaries. If the user typed `/canonify:ask` alone, acknowledge and wait for the question;
if they included it, go on.
2. **Read the question.** Restate it in one line so the framing is explicit. Questions from clients
are often phrased in *product* terms ("why did the customer get two emails?", "can members see
each other's invoices?", "what happens if they cancel mid-cycle?") - translate that into the
*system* terms the canons are indexed by (which feature, which integration, which data flow).
If the question is too vague to route ("how does billing work?" for a project with six billing
canons), ask one clarifying question before continuing. Don't guess at what they meant.
3. **Route the question against the index.** Walk every `CANONIFY.md` summary line and ask whether
the question touches that area - the feature named, the integration implied, the data it reads
or writes, the access rule that gates it. Output the same routing table Build uses:
```
Implicated: <doc-a>.md, <doc-b>.md
Skipped: <doc-c>.md (one-line reason)
<doc-d>.md (one-line reason)
```
If nothing matches, say so and proceed on the code alone (step 4b) - do not shoehorn the
question into an unrelated canon.
4. **Read for the answer.**
- **4a. Load the implicated canons in full.** Most questions are answered here - the canon's
rules, checklists, worked examples, and gotchas exist precisely so this question does not need
a code dive. Note the `file:line` citations the canon gives for the parts that answer the
question.
- **4b. Verify against the code.** Open the cited files at the cited lines and confirm the canon
still describes what the code does. A canon can drift (that is what `/canonify:doctor` is
for); an answer going to a client must not. If the canon is silent on some part of the
question, read the code directly for that part and **mark it** as "from code, not canon" in
the answer - that marker is the signal for step 6.
- **Answer only what the code supports.** If the behavior is configurable, data-driven, or
environment-dependent and you cannot see the live value, say "depends on `<setting>` - it is
`<X>` in `<file:line>` / not visible from the repo" rather than asserting one outcome.
5. **Produce the answer.** Two layers, in this order:
- **Developer answer** - the precise behavior, every claim cited to `file:line` (or to the canon
section, which itself cites). Quote the canon's rules directly where they apply; don't
paraphrase a rule the user may need to verify. Include the edge cases and gotchas that bear on
the question - and only those; this is not a tour of the canon.
- **Plain-language answer** - three to six sentences in the client's terms, no file paths, no
internals, safe to paste into an email or ticket. It must say the same thing the developer
answer says; if there is a caveat ("only when X is enabled"), keep it - do not simplify it
away. If the honest answer is "it does not do that today", say so plainly.
6. **Close the loop - suggest, never write.** Judge what the session revealed about the canon:
- **the canon answered it outright** -> nothing to capture; say so in one line.
- **you had to read code the canon does not cover, and the question is one others will ask
again** -> "the `<canon>` canon is missing this - run `/canonify:update-canon` to add it"
(or `/canonify:create-canon` if no canon covers the area at all).
- **the canon was wrong or stale** (code at the cited line no longer does what the canon says)
-> flag it specifically: "`<canon>` says X, code at `<file:line>` does Y - run
`/canonify:update-canon` to correct it." This is the highest-value outcome of an Ask session;
don't bury it.
- **the question surfaced a defect** (the system does something the client reasonably did not
expect, and it looks unintentional) -> say so, and hand off to `/canonify:debug` - Ask does not
fix.
## Don't do
- **Don't plan or write code.** Ask answers. If the answer is "no, it doesn't do that" and the user
wants it to, that is a new task - hand off to `/canonify:plan` or `/canonify:build`.
- **Don't answer from the canon alone when the answer is going to a client.** Verify the cited
lines (step 4b). A canon is a routing aid and a first draft of the answer, not the ground truth;
the code is.
- **Don't answer from memory or general knowledge of the framework.** If the repo does not show
it, you do not know it. Say so.
- **Don't load every canon.** Walk the summaries and skip what doesn't apply, with a reason.
- **Don't drop caveats in the plain-language version.** Simpler words, same truth.
- **Don't write the canon update yourself.** Point at `/canonify:update-canon` /
`/canonify:create-canon` - all capture logic lives there.
## Output template
```
## /canonify:ask - research
Question: <one-line restatement, in system terms>
(Asked as: "<the client's original phrasing>", if it differs)
### Routing - CANONIFY.md summary sweep
Implicated:
- <doc-a>.md - <one-line reason>
Skipped:
- <doc-b>.md - <one-line reason>
- <doc-c>.md - ...
### Developer answer
<Precise behavior, each claim cited.>
- <claim> - `path/to/file.ext:NN` (canon: <doc-a>.md, "<section>")
- <claim> - `path/to/other.ext:NN`
- <claim> - `path/to/third.ext:NN` - *from code, not canon*
**Caveats / edge cases that bear on this question:**
- <caveat> - `file:line`
### Plain-language answer (for the client)
<Three to six sentences. No paths, no internals. Same caveats, simpler words.>
### Canon feedback
<one of:>
- Canon answered it fully - nothing to capture.
- `<doc-a>.md` doesn't cover <part> - answered from `file:line`. Worth adding: run `/canonify:update-canon`.
- `<doc-a>.md` is stale: says <X>, code at `file:line` does <Y>. Run `/canonify:update-canon` to correct it.
- No canon covers <area>. Run `/canonify:create-canon` if this will come up again.
- Looks like a defect, not a design choice: <one line>. Hand off to `/canonify:debug`.
```
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · ewebdzine/canonify | 100 | MIT |
| eliyce/paqad-ai | 100 | MIT |
| pleaseai/claude-code-plugins | 100 | MIT |
| vegardjorg/ravenseat | 100 | MIT |
| r3dlex/oh-my-auggie | 100 | Apache-2.0 |
| seemseam/claude_codex_bridge | 100 | AGPL-3.0 |
| keli-wen/agy-staff | 100 | MIT |
| inbarajaldrin/devdroid | 100 | Apache-2.0 |
| jayjiangct/knowlery | 100 | MIT |
Database snapshot: 13.11.2026 · package version 720ce70d750e (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100kickoff
One-time onboarding wizard that sets Canonify up in a fresh repo - a short survey (scan-and-seed? scheduled doctor?), then write CANONIFY.md + the docs/ skeleton and optionally bulk-seed canons by scanning the codebase. Run when the user types /canonify:kickoff, or says "set up… - 100doctor
Health-check the canon - verify every canon's references still exist and are registered, flag canons whose referenced source files have changed since they were last verified (git-derived staleness), and best-effort check whether the installed Canonify plugin is behind its GitHub… - 100prp-codebase-question
Research codebase questions using parallel agents - documents what exists, not what should change. Use when the user asks how the codebase works, where something lives, or invokes /prp-codebase-question. - 100prp-codebase-question
Research codebase questions using parallel agents - documents what exists, not what should change. Use when the user asks how the codebase works, where something lives, or invokes $prp-codebase-question. - 100research
Answer an open question for the fleet in a researcher pane — how a subsystem works, what an API or library does, which option fits — and keep the answer in the project home, where later lanes reuse it. Use when the orchestrator cannot name the files or facts that a brief or plan… - 95how
Explain how the current project, a feature, or a code path works in plain language for a beginner. Use when the user wants to understand an existing codebase or how its parts work together.