Przejdź do treści
Biblioteka skilli
Programowanie · Research

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.

Repozytorium
canonify ↗
Licencja
MIT
Ostatnia zmiana repozytorium
14.09.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 14.09.2026, bez odwołań do wycofanych modeli i API.

Licencja

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

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

  1. How to run
  2. Don't do
  3. Output template
Sekcje z nagłówków SKILL.md, w oryginale · 132 linii, 1 155 słów
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

RepozytoriumWynikLicencja
Ta strona · 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

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.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.