grill-with-docs

Files (5)

• ADR-FORMAT.md
• CONTEXT-FORMAT.md
• FORMATO-ADR.md
• FORMATO-CONTEXT.md
• SKILL.md

SKILL.md (first lines)

<what-to-do>

Grill me relentlessly about every aspect of this plan until we reach a shared understanding. Walk every branch of the design tree, resolving dependencies between decisions one at a time. For each question, provide your recommended answer.

Ask questions one at a time, pausing for feedback on each question before continuing.

If a question can be answered by exploring the code, explore the code instead.

</what-to-do>

<supporting-info>

## Domain awareness

While exploring the code, also look for existing documentation:

### File structure

Most repositories have a single context:

```
/
├── CONTEXT.md
├── docs/
│   └── adr/
│       ├── 0001-orders-with-event-sourcing.md
│       └── 0002-postgres-for-write-model.md
└── src/
```

If a `CONTEXT-MAP.md` exists at the root, the repository has multiple contexts. The map points to where each one lives:

```
/
├── CONTEXT-MAP.md
├── docs/
│   └── adr/                          ← system-wide decisions
├── src/
│   ├── orders/
│   │   ├── CONTEXT.md
│   │   └── docs/adr/                 ← context-specific decisions
│   └── billing/
│       ├── CONTEXT.md
│       └── docs/adr/
```

Create files on demand — only when you have something to write. If `CONTEXT.md` doesn't exist, create one when the first term gets resolved. If `docs/adr/` doesn't exist, create it when the first ADR is needed.

## During the session

### Challenge against the glossary

When the user uses a term that conflicts with existing language in `CONTEXT.md`, flag it immediately. "Your glossary defines 'cancellation' as X, but you seem to mean Y — which is it?"

### Sharpen vague language

When the user uses vague or overloaded terms, propose a precise canonical term. "You're saying 'account' — do you mean the Customer or the User? They are different things."

### Discuss concrete scenarios

When domain relationships are being discussed, pressure-test them with specific scenarios. Invent scenarios that probe edge cases and force the user to be precise about the boundaries between concepts.

### Cross-reference with code

When the user states how something works, verify that the code agrees. If you find a contradiction, surface it: "Your code cancels entire Orders, but you just said partial cancellation is possible — which is correct?"

### Update CONTEXT.md inline

When a term is resolved, update `CONTEXT.md` right there. Don't batch — capture as they happen. Use the format in [FORMATO-CONTEXT.md](./FORMATO-CONTEXT.md).

`CONTEXT.md` must be completely devoid of implementation details. Do not treat `CONTEXT.md` as a spec, a draft, or a repository of implementation decisions. It is a glossary and nothing more.

### Offer ADRs sparingly

Offer to create an ADR only when all three conditions are true:

1. **Hard to reverse** — the cost of changing your mind later is significant
2. **Surprising without context** — a future reader will wonder "why did they do it that way?"
3. **Result of a real trade-off** — there were genuine alternatives and you chose one for specific reasons

If any of the three is missing, skip the ADR. Use the format in [FORMATO-ADR.md](./FORMATO-ADR.md).

</supporting-info>

From hcb2019/claude-code-skills, MIT.

More from hcb2019/claude-code-skills