Catalog
mattpocock/grill-with-docs

mattpocock

grill-with-docs

Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Use when user wants to stress-test a plan against their project's language and documented decisions.

global
0installs0uses~842
v1.0Saved May 2, 2026

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

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

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

Domain awareness

During codebase exploration, also look for existing documentation:

File structure

Most repos have a single context:

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

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

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

Create files lazily — only when you have something to write. If no CONTEXT.md exists, create one when the first term is resolved. If no docs/adr/ exists, create it when the first ADR is needed.

During the session

Challenge against the glossary

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

Sharpen fuzzy 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? Those are different things."

Discuss concrete scenarios

When domain relationships are being discussed, stress-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, check whether 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 right?"

Update CONTEXT.md inline

When a term is resolved, update CONTEXT.md right there. Don't batch these up — capture them as they happen. Use the format in CONTEXT-FORMAT.md.

Don't couple CONTEXT.md to implementation details. Only include terms that are meaningful to domain experts.

Offer ADRs sparingly

Only offer to create an ADR when all three are true:

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

If any of the three is missing, skip the ADR. Use the format in ADR-FORMAT.md.

Files3
3 files · 6.8 KB

Select a file to preview

Overall Score

84/100

Grade

B

Good

Safety

92

Quality

85

Clarity

82

Completeness

78

Summary

grill-with-docs is a domain modeling and documentation skill that conducts structured interviews about architectural plans, stress-tests them against existing domain language and codebase, and incrementally updates CONTEXT.md and ADRs as decisions crystallize. It bridges the gap between informal planning and documented domain knowledge by catching terminology conflicts, sharpening fuzzy language, validating claims against code, and recording hard decisions.

Detected Capabilities

Codebase exploration and file reading (CONTEXT.md, ADRs, source files)Interactive interview and questioning (one question at a time, awaiting feedback)Domain terminology validation against existing documentationCode-to-design consistency checking (cross-referencing user claims with implementation)File creation and inline updates (CONTEXT.md, ADR files) following structured formatsMulti-context repository navigation (CONTEXT-MAP.md detection and context isolation)Lazy file creation (only create CONTEXT.md, docs/adr/ when needed)Scenario-based edge case probing for domain relationships

Trigger Keywords

Phrases that MCP clients use to match this skill to user intent.

domain model reviewvalidate architectural planupdate domain documentationresolve terminology conflictscross-context designcreate ADR

Risk Signals

INFO

Writes to documentation files (CONTEXT.md, ADR files) inline during the session

SKILL.md: 'Update CONTEXT.md inline' section
INFO

File creation (CONTEXT.md, docs/adr/ directory) based on user decisions

SKILL.md: 'Create files lazily' section and supporting-info
INFO

Codebase exploration to answer questions and validate claims

SKILL.md: 'If a question can be answered by exploring the codebase, explore the codebase instead'
INFO

No destructive operations, no secrets access, no privilege escalation detected

Entire SKILL.md and supporting files

Use Cases

  • Refine and validate a new feature plan against existing domain terminology before implementation
  • Resolve ambiguous language in a domain model (e.g., 'account' vs. 'customer') through structured questioning
  • Document a significant architectural decision (e.g., event sourcing, context boundaries) after discussion
  • Stress-test a multi-context system design by walking through concrete scenarios across bounded contexts
  • Create or update CONTEXT.md and ADRs from scratch in a project that lacks domain documentation

Quality Notes

  • Excellent scope clarity: the skill is narrowly focused on domain modeling, documentation, and plan validation. It does not attempt to implement features or run tests.
  • Well-structured supporting formats (CONTEXT-FORMAT.md, ADR-FORMAT.md) with clear rules, templates, and examples. These dramatically reduce ambiguity for agents and users.
  • Strong error-handling and edge case guidance: instructions for single vs. multi-context repos, lazy file creation, and when NOT to create ADRs (three-part test for ADR candidacy).
  • Excellent use of concrete examples and dialogues (e.g., example 'Dev' and 'Domain expert' conversation in CONTEXT-FORMAT.md) that help agents understand the intended interactions.
  • Clear decision rules ('Challenge against the glossary', 'Sharpen fuzzy language', 'Discuss concrete scenarios') that guide the agent's behavior at decision points.
  • Potential gap: no explicit guidance on how to handle disagreements or unresolved conflicts between user claims and code. The skill says 'surface' contradictions but doesn't specify how to proceed if the user disputes the finding.
  • Potential gap: no guidance on how to handle very large codebases where exploration might be time-prohibitive. When should the agent stop exploring and ask the user instead?
  • Potential gap: the skill assumes CONTEXT.md and ADR formats are followed correctly in existing files, but doesn't specify how to handle malformed or inconsistent existing documentation.
Model: claude-haiku-4-5-20251001Analyzed: May 2, 2026

Reviews

Add this skill to your library to leave a review.

No reviews yet

Be the first to share your experience.

Add mattpocock/grill-with-docs to your library

Command Palette

Search for a command to run...