Skip to content
Skills Library
Programming · Research

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".

Repository
canonify ↗
Licence
MIT
Last repository change
14.09.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 14.09.2026, without references to retired models or APIs.

Licence

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

a client is asking how X worksdoes the system do Ywhat happens when Zhow do we handle Xexplain how the W feature worksI need to research a question about the project
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

  1. How to run
  2. Don't do
  3. Output template
Original SKILL.md headings · 132 lines, 1,155 words
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

RepositoryScoreLicence
This page · ewebdzine/canonify100MIT
eliyce/paqad-ai100MIT
pleaseai/claude-code-plugins100MIT
vegardjorg/ravenseat100MIT
r3dlex/oh-my-auggie100Apache-2.0
seemseam/claude_codex_bridge100AGPL-3.0
keli-wen/agy-staff100MIT
inbarajaldrin/devdroid100Apache-2.0
jayjiangct/knowlery100MIT

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.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.