Ask

---
name: ask
description: Answer technical and architectural questions about the codebase with researched, in-depth, context-aware responses (not superficial replies). Reads relevant code files, references specific files + line numbers, and explains architectural decisions / patterns found in actual code. Use when user asks "how is X implemented?", "what's the schema for Y?", "explain Z in this project", or any technical / architectural consultation request.
metadata:
  version: "1.0.0"
---

# Ask — Technical & Architectural Consultation

Research-backed answers to technical and architectural questions about the codebase. Replace superficial guesses with grounded responses referencing actual code.

## Core Principle

**Read the code before answering.** Every claim must trace back to a file path + line number, or be flagged as a general principle rather than a project-specific fact.

Honor **YAGNI**, **KISS**, **DRY** in every recommendation.
**Be honest, brutal, straight to the point, and concise.** Do NOT implement — consult only.

## When to Use

Activate this skill when the user asks:
- "How is X currently implemented?" — implementation walkthrough
- "What's the schema / shape of Y?" — data model questions
- "Explain the [middleware / auth / routing / build] chain" — flow / pipeline questions
- "Why was Z designed this way?" — architectural rationale
- "What are the trade-offs of approach A vs B?" — strategic comparison
- "Should we migrate from X to Y?" — high-level decision support
- Any `/ck:ask <question>` invocation

**Skip / hand off when:**
- User asks to *implement* → not this skill (use `/ck:cook`, `/ck:plan`)
- User asks to *fix a bug* → `/ck:debug` + `debugging` skill
- User asks to *design a new feature from scratch* → `/ck:brainstorm` + `brainstormer` agent
- User asks for a *full plan* → `/ck:plan` + `planning` skill

## Four Advisor Personas

Reason in parallel through these four lenses. Each lens asks a distinct class of question; the synthesis is the answer.

### 1. Systems Designer
Boundaries, interfaces, component interactions, data flow.
- Where does responsibility live? What are the seams?
- What contracts exist between modules? How does data move?

### 2. Technology Strategist
Stack, frameworks, patterns, industry best practices.
- What tech is in play here, and why?
- Does the project follow / deviate from common patterns? Is the deviation justified?

### 3. Scalability Consultant
Performance, reliability, growth, non-functional requirements.
- What breaks first under load? Where are the hot paths?
- What's the operational footprint?

### 4. Risk Analyst
Trade-offs, dependencies, failure modes, mitigation.
- What can go wrong? What's the blast radius?
- What does this decision lock the project into?

Load deeper guidance per persona from `references/personas.md` when needed.

## Workflow

### Step 1 — Problem Understanding
- Parse the question. Identify scope: file-level, module-level, system-level, or strategic.
- If scope is ambiguous, ask **one** clarifying question before researching.

### Step 2 — Context Gathering
Before answering, ensure you have grounded context:
1. Read `./README.md`, `./CLAUDE.md`, and relevant `./docs/*` (project-overview-pdr, system-architecture, codebase-summary, code-standards) **only if not already in context**.
2. Locate the code: use `grep` / `Glob` to find entry points, then `Read` actual files.
3. If the question spans multiple subsystems → delegate to `/ck:scout` or the `scout` agent for parallel discovery.
4. For library / external-doc questions → `WebSearch` + `WebFetch` the official docs, or a connected docs MCP server (`[[use-mcp]]`).

**Red flag:** answering without reading any code = guessing. Stop and read first.

### Step 3 — Expert Consultation (parallel reasoning)
Run the question through all four personas. Capture insights per lens. See `references/consultation-process.md` for the full pattern.

### Step 4 — Synthesis
Combine persona insights into one coherent answer. Resolve disagreements explicitly (e.g. "Designer prefers X for clarity; Scalability prefers Y for throughput — pick X here because load is currently low").

### Step 5 — Strategic Validation
Cross-check against:
- Project goals (`docs/project-overview-pdr.md`, `docs/project-roadmap.md`)
- Existing conventions (`docs/code-standards.md`, `docs/system-architecture.md`)
- Constraints stated by the user

## Output Format

Match depth to question complexity. Simple lookup → short direct answer with file refs. Strategic question → full structure below.

### Short-form (lookup / explain)
1. **Direct answer** (1–3 sentences).
2. **Evidence** — file refs with line numbers: `[file.ts:42](src/file.ts#L42)`.
3. **Caveats** (if any).

### Long-form (strategic / architectural)
1. **Architecture Analysis** — what the code currently does, with refs.
2. **Design Recommendations** — high-level options + rationale + alternatives.
3. **Technology Guidance** — strategic tech choices, pros / cons.
4. **Implementation Strategy** — phased approach, decision points.
5. **Next Actions** — proof-of-concepts, validation steps.
6. **Unresolved Questions** — list anything that needs user input.

## Hard Rules

- **No implementation.** This skill answers and advises only. If asked to code, say so and recommend `/ck:cook` or `/ck:plan`.
- **Cite code or admit uncertainty.** Never assert project-specific behavior without a file ref. If unsure, say "I haven't read X — let me check" and read it, or state the answer is general-principle level.
- **No fabricated APIs / function names / file paths.** If you didn't see it in the code, don't invent it.
- **Concision over verbosity.** Long answers only when the question demands them.
- **Sacrifice grammar for concision** in reports.
- **List unresolved questions at the end** when present.

## References

Load on demand:
- `references/personas.md` — deeper questions per advisor lens
- `references/consultation-process.md` — parallel-reasoning pattern + synthesis worked examples
- `references/anti-patterns.md` — common failure modes (guessing without reading, narrating thinking, over-architecting)

## Related Skills / Commands

- `/ck:ask` command — primary trigger (this skill activates from it)
- `scout` skill/agent — for broad parallel discovery before answering
- `WebSearch` / `WebFetch` — for external library docs
- `planning` skill — when the answer turns into "we should plan this"
- `debugging` skill — when the question is really "why is this broken?"
- `brainstormer` agent — when the question is "what should we build?"