ask
/ask
Odpowiada na pytania o działanie bazy kodu na podstawie CANONIFY.md, zwracając cytowaną odpowiedź dla programisty oraz krótką wersję w prostym języku dla klienta.
- Autor
- ewebdzine ↗
- Repozytorium
- canonify ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 14.09.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 14.09.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Odpowiada na pytania o działanie bazy kodu na podstawie CANONIFY.md, zwracając cytowaną odpowiedź dla programisty oraz krótką wersję w prostym języku dla klienta.
Wyzwalacze z opisu
Oryginalny opis (EN)
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".
Jak działa
- How to run
- Don't do
- Output template
Podgląd SKILL.md
---
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`.
```
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · 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 |
Migawka bazy z 13.11.2026 · wersja paczki 720ce70d750e (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100kickoff
Przeprowadza wdrożenie Canonify w nowym repozytorium: krótka ankieta, zapis CANONIFY.md i szkieletu docs oraz opcjonalne zasilenie kanonów skanem kodu. - 100doctor
Kontroluje zdrowie kanonów Canonify: sprawdza istnienie i rejestrację odwołań, wskazuje kanony ze zmienionymi plikami źródłowymi i sprawdza, czy wtyczka nie jest za źródłem na GitHubie. - 100prp-codebase-question
Odpowiada na pytania o działanie bazy kodu, opisując istniejący stan równoległymi agentami, bez proponowania zmian. - 100prp-codebase-question
Odpowiada na pytania o działanie bazy kodu, opisując istniejący stan równoległymi agentami, bez proponowania zmian. - 100research
Odpowiada na otwarte pytanie dla zespołu w osobnym panelu, np. jak działa podsystem, i trzyma odpowiedź w bazie projektu do ponownego użycia. - 95how
Wyjaśnia prostym językiem, jak działa obecny projekt, funkcja lub ścieżka kodu, dla osoby początkującej.