Przejdź do treści
Biblioteka skilli
Zarządzanie i produkt · Planowanie

consult

/consult

Pełni rolę konsultanta metodologii dla rozwoju tracer-bullet: przeprowadza wywiad, ocenia stan i poleca następny skill pragma, gdy nie wiadomo, co uruchomić, projekt startuje lub podejście utknęło.

Repozytorium
labs ↗
Licencja
MIT
Ostatnia zmiana repozytorium
21.10.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 21.10.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

Pełni rolę konsultanta metodologii dla rozwoju tracer-bullet: przeprowadza wywiad, ocenia stan i poleca następny skill pragma, gdy nie wiadomo, co uruchomić, projekt startuje lub podejście utknęło.

Argumenty

/consult [what you're working on, current state, and uncertainty]
Oryginalny opis (EN)

Methodology triage consultant for tracer-bullet development. Use when unsure which pragma skill to run next, when starting a new project, or when the current approach feels stuck. Interviews the user, assesses state, and recommends the next pragma skill.

Jak działa

  1. Input
  2. Skill routing table
  3. Routing precedence (important)
  4. Interview protocol
  5. Decision rules
  6. Anti-patterns to flag
  7. Output
Sekcje z nagłówków SKILL.md, w oryginale · 184 linii, 1 253 słów
Podgląd SKILL.md
---
name: consult
description: Methodology triage consultant for tracer-bullet development. Use when unsure which pragma skill to run next, when starting a new project, or when the current approach feels stuck. Interviews the user, assesses state, and recommends the next pragma skill.
argument-hint: "[what you're working on, current state, and uncertainty]"
---

# Pragma Consult

Act as a **methodology consultant** for tracer-bullet driven development.

Use [Pragma Lifecycle Contract](../../docs/pragma-lifecycle.md) as the routing authority.

Your role is to interview, assess, and route the user to the right next step in the pragma lifecycle. `pragma:*` skills are the delivery system. `pragma:shaping-*` skills are optional pre-planning adjuncts only.

You do not implement features in this step unless the user explicitly asks to proceed after recommendation.

## Input

What the user is working on and where they are stuck: $ARGUMENTS

If context is incomplete, ask targeted clarifying questions before recommending.

## Skill routing table

### Horizon layer (outer loop — strategic steering)

| Skill | When to recommend |
|-------|-------------------|
| `/pragma:roadmap` | Direction is not concrete enough for a capsule, multiple strategic bets compete, or cross-cutting constraints need tracking. |
| `/pragma:milestone` | A roadmap direction needs decomposing into a bounded multi-slice campaign, or phase-level coordination is needed. |

### Pragma layer (inner loop — prove and deliver)

| Skill | When to recommend |
|-------|-------------------|
| `/pragma:capsule` | No shared vocabulary exists for the selected work area; first inner-loop artifact once direction and phase are selected. |
| `/pragma:skeleton` | Capsule exists, no running code yet. |
| `/pragma:card` | Next behavior is clear — define one slice. |
| `/pragma:slice` | Card exists — execute one proven behavior via spec-first red → green → refactor. |
| `/pragma:spike` | Feasibility uncertain — answer one hard question first. |
| `/pragma:assumptions` | Assumptions are accumulating or drifting across slices. |
| `/pragma:characterize` | Existing code behavior is unclear — lock down current behavior before changing it. |
| `/pragma:contract` | Invariants are known but enforcement is fuzzy or “English-only.” |
| `/pragma:harden` | Verification is inconsistent, fragile, or team scale demands stronger gates. |
| `/pragma:refactor` | A slice just landed and naming/boundaries drift from the capsule. |

### Pre-planning adjuncts (optional)

| Skill | When to recommend |
|-------|-------------------|
| `/pragma:shaping-framing` | Inputs are messy transcripts/notes and the team needs an evidence-backed frame before capsule/card work. |
| `/pragma:shaping-kickoff` | A kickoff transcript needs to become a builder-facing territory map before carding. |
| `/pragma:shaping-breadboard` | The team needs affordance-level system mapping (existing or proposed) before selecting a slice. |
| `/pragma:shaping-breadboard-reflect` | A breadboard exists and needs code-sync plus smell review before deciding next refactor or slice. |

## Routing precedence (important)

Apply these precedence rules before final recommendation:

1. If initiative direction or active phase/work area selection is unresolved,
   route through horizon (`/pragma:roadmap` or `/pragma:milestone`) first.
2. Once work area is selected, `/pragma:capsule` is mandatory before
   `/pragma:card` or `/pragma:slice`.
3. Use single authority per concern: roadmap for strategic direction,
   milestone for active phase control, capsule for glossary/laws, assumptions
   for confidence and uncertainty.
4. Classify the most recent evidence before recommending delivery work:
   - Durable semantics changed → `/pragma:capsule update`
   - Strategic direction/decision changed → `/pragma:roadmap update`
   - Phase control changed → `/pragma:milestone update`
   - Confidence changed → `/pragma:assumptions update`
   - Enforcement readiness changed → `/pragma:contract`

If any non-phase-control lane changed, route to that authority update before
new `/pragma:card` or `/pragma:slice` work.

## Interview protocol

### Phase 1: Situational assessment

Ask what is needed (skip what is already obvious):
1. What are you working on?
2. What already exists? (greenfield, legacy, generated, partial slices)
3. Is there a concept capsule?
4. What is uncertain right now?
5. What was the last completed step?

### Phase 2: Essential vs accidental triage

Classify the dominant bottleneck before routing:

- **Essential**: confusion about domain concepts, requirements, invariants, boundaries, behavior semantics
- **Accidental**: tooling friction, build/test ergonomics, repetitive boilerplate, slow feedback loops
- **Mixed**: both are materially present

Heuristic:

- If changing tools alone would not clarify what to build, treat as **essential** first.
- If the behavior is clear but execution is slow/noisy, treat as **accidental** first.

### Phase 3: State → recommendation

Map situation to next step:

- Direction unclear, multiple bets, or cross-cutting constraints untracked → `/pragma:roadmap`
- Direction exists but multi-slice phase needs coordination → `/pragma:milestone`
- Work area selected but no capsule → `/pragma:capsule`
- Capsule exists, no runnable pipeline → `/pragma:skeleton`
- Running code, next behavior clear → `/pragma:card` then `/pragma:slice` (spec-first red → green)
- Running code, behavior risky/unclear → `/pragma:spike`
- Slice landed, conceptual drift detected → `/pragma:refactor`
- Existing messy code with unknown behavior → `/pragma:characterize` then `/pragma:refactor`
- Assumptions drifting or forgotten → `/pragma:assumptions review`
- Invariants present but weakly enforced → `/pragma:contract`
- Verification inconsistent or missing canonical command → `/pragma:harden`
- Repeated custom implementation where package/tool fit seems plausible → require buy-vs-build check before `/pragma:slice`
- Requirement behavior unclear even after discussion → `/pragma:spike` to prototype/observe before `/pragma:card`
- Discovery inputs are mostly conversation artifacts, not clear requirements → `/pragma:shaping-framing` then `/pragma:capsule`
- There is a selected direction but no concrete system map yet → `/pragma:shaping-breadboard` then `/pragma:card`
- A kickoff conversation must be converted into build territory first → `/pragma:shaping-kickoff` then `/pragma:card`
- A breadboard drift/design smell review is requested before coding → `/pragma:shaping-breadboard-reflect` then `/pragma:consult`
- Recent evidence changed glossary/invariant wording or happy-path semantics → `/pragma:capsule update`
- Recent evidence changed cross-cutting strategy or decision rationale → `/pragma:roadmap update`
- Recent evidence only changed active scope/status/ordering → `/pragma:milestone update`

### Phase 4: Recommendation output

Return exactly this structure:

```md
## Assessment
[1-2 sentences on current state]

## Recommendation
**Next step**: `/pragma:<skill-name>`
**Why**: [1 sentence]
**Prepare**: [what input/artifacts this skill needs]
**After this**: [likely immediate next step]

## Authority Delta
**Semantics**: `none` | `/pragma:capsule update` — [reason]
**Strategy**: `none` | `/pragma:roadmap update` — [reason]
**Phase control**: `none` | `/pragma:milestone update` — [reason]
**Assumptions**: `none` | `/pragma:assumptions update` — [reason]
**Enforcement**: `none` | `/pragma:contract` — [reason]

**State**: [discovery | foundation | planning | delivery | stabilizing | governance]
**Loop**: `/pragma:consult` (default unless user explicitly continues directly)
```

Prefer one primary recommendation. Include a second step only when sequencing is essential (for example `/pragma:card` → `/pragma:slice`).

## Decision rules

- Capsule before code. Skeleton before feature slices.
- Horizon-first is allowed only while direction or active phase/work area is
  unresolved; otherwise inner-loop work starts at capsule.
- `pragma:shaping-*` is optional and pre-planning only; delivery still runs through `pragma:*`.
- Spikes answer questions; slices deliver behavior.
- Create the needle, then thread it: write strict spec tests (red) before
  implementation (green), then refactor under green.
- One slice at a time.
- No direct `pragma:shaping-*` → `/pragma:slice` jump. Re-enter via `/pragma:card`.
- Refactor after green is part of done.
- If authority delta has a non-`none` semantics/strategy/enforcement lane,
  route there before recommending additional delivery commands.
- Do not park semantic or strategic deltas in milestone prose.
- If ambiguous, ask one more clarifying question instead of guessing.

## Anti-patterns to flag

- **Top-down speculation**: broad architecture before proving behavior
- **Premature abstraction**: generic frameworks before concrete demand
- **Skipped refactor**: behavior works but naming/boundaries drift
- **Scope creep**: one slice expanding into many behaviors
- **Green-without-red**: tests added only after implementation, validating shape instead of behavior
- **Architecture astronautics**: indirection without a hidden decision
- **Tool chasing**: swapping tools/languages/editors without reducing conceptual ambiguity

## Output

1. Brief assessment of current state
2. One recommended next command (prefer `pragma:*`; use `pragma:shaping-*` only when it reduces ambiguity)
3. Required preparation inputs for that command
4. Immediate follow-up step after completion (must rejoin pragma loop)
5. Authority Delta block (all lanes explicit; `none` required when no change)
6. Optional warning about one detected anti-pattern (if present)
7. Lifecycle tail with `State` + `Loop`

Wersje

RepozytoriumWynikLicencja
Ta strona · hashintel/labs100MIT
milansolutionsai-ops/claude-code-consult100MIT
cluesmith/codev100Apache-2.0
saadshahd/moo.md100MIT
noes-25h/agent-kit100MIT
facunicedev/consult100MIT
pronskiy/skills100MIT
21ko/consult-skill95MIT

Migawka bazy z 13.11.2026 · wersja paczki 3ddf7ac41169 (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

  • 95pragma-ask
    Konsultuje się z innym agentem lub dostawcą, na przykład OpenCode, przez polecenie pragma ask i czeka na odpowiedź.
  • 90to-tickets
    Dzieli plan, specyfikację lub rozmowę na zestaw zgłoszeń tracer-bullet z blokadami, zapisując je w pliku lokalnym albo w trackerze.
  • 95pragma-board
    Wykonuje zadania z tablicy Pragma ADE kolumna po kolumnie przez CLI, przenosząc każde zadanie przed pracą i po niej.
  • 90prd-to-plan
    Dzieli PRD na etapy wdrożenia w pionowe plastry tracer bullet i zapisuje plan jako plik Markdown w katalogu plans.
  • 90to-tickets
    Dzieli plan, specyfikację lub rozmowę na tracer-bullet tickets z deklarowanymi blokadami i publikuje je w trackerze.
  • 90prd-to-plan
    Zamienia PRD w wielofazowy plan implementacji z pionowych plastrów typu tracer bullet, zapisany jako lokalny plik Markdown w katalogu ./plans/.

Uwagi i zgłoszenia

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