All skills
flutter avatar

/grill-with-docs

@ae88b4d official
by flutterflutter/skills3k stars
182

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.

Use this Skill: https://skilld.dev/gh/flutter/skills/grill-with-docs

This session only. Nothing lands on disk.

ADR-FORMAT.md

≈692 tokens on demand. Your agent reads this file only when SKILL.md points to it.

ADR Format

ADRs live in docs/adr/ and use sequential numbering: 0001-slug.md, 0002-slug.md, etc.

Create the docs/adr/ directory lazily — only when the first ADR is needed.

Template

# {Short title of the decision}

{1-3 sentences: what's the context, what did we decide, and why.}

That's it. An ADR can be a single paragraph. The value is in recording that a decision was made and why — not in filling out sections.

Optional sections

Only include these when they add genuine value. Most ADRs won't need them.

  • Status frontmatter (proposed | accepted | deprecated | superseded by ADR-NNNN) — useful when decisions are revisited
  • Considered Options — only when the rejected alternatives are worth remembering
  • Consequences — only when non-obvious downstream effects need to be called out

Numbering

Scan docs/adr/ for the highest existing number and increment by one.

When to offer an ADR

All three of these must be true:

  1. Hard to reverse — the cost of changing your mind later is meaningful
  2. Surprising without context — a future reader will look at the code and wonder "why on earth 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 a decision is easy to reverse, skip it — you'll just reverse it. If it's not surprising, nobody will wonder why. If there was no real alternative, there's nothing to record beyond "we did the obvious thing."

What qualifies

  • Architectural shape. "We're using a monorepo." "The write model is event-sourced, the read model is projected into Postgres."
  • Integration patterns between contexts. "Ordering and Billing communicate via domain events, not synchronous HTTP."
  • Technology choices that carry lock-in. Database, message bus, auth provider, deployment target. Not every library — just the ones that would take a quarter to swap out.
  • Boundary and scope decisions. "Customer data is owned by the Customer context; other contexts reference it by ID only." The explicit no-s are as valuable as the yes-s.
  • Deliberate deviations from the obvious path. "We're using manual SQL instead of an ORM because X." Anything where a reasonable reader would assume the opposite. These stop the next engineer from "fixing" something that was deliberate.
  • Constraints not visible in the code. "We can't use AWS because of compliance requirements." "Response times must be under 200ms because of the partner API contract."
  • Rejected alternatives when the rejection is non-obvious. If you considered GraphQL and picked REST for subtle reasons, record it — otherwise someone will suggest GraphQL again in six months.

Source: SKILL.md on GitHub

No alerts1mo3 checks · Risk SAFE
  • Gen Agent Trust Hub1mo

    The skill provides a structured method for refining project documentation, glossaries, and architectural decisions through an interactive interview process. It focuses on internal project consistency and does not perform any dangerous operations.

  • Socket1mo

    No alerts

  • Snyk1mo

    Risk: LOW · No issues

Signed by skilld at ae88b4d. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub yesterday.

Activeupdated 5 months ago
  • Documentation
  • domain-driven-design
  • planning
  • adr
  • terminology
  • codebase-exploration
  • design-review
  • context-mapping

README badge

README badge for flutter/skills/grill-with-docs

Conducts a structured interview of your design plan against existing domain terminology and documented decisions, surfacing conflicts and gaps in the codebase. Updates CONTEXT.md and ADRs inline as the conversation resolves each decision point.

Generated from the current SKILL.md.

What's the difference between this skill and a standard code review or design doc feedback session?
This skill systematically challenges your plan against your project's existing domain model, terminology, and documented decisions (CONTEXT.md and ADRs), then updates those docs inline as ambiguities are resolved. It's not just critique — it's domain alignment plus documentation maintenance in one session.
Does this skill explore my codebase, or does it only work from what I tell it?
It actively explores your codebase to answer questions and validate claims. If a question can be resolved by reading code, it will do that instead of asking you. It also searches for existing CONTEXT.md and ADR files to cross-reference against.
Will this create new documentation files, or just update existing ones?
It creates files lazily — only when you've resolved something that needs to be captured. It will create CONTEXT.md on first use if it doesn't exist, and create docs/adr/ only when an ADR is genuinely needed (hard to reverse, surprising without context, result of a real trade-off).
How does this handle repos with multiple bounded contexts?
If your repo has a CONTEXT-MAP.md at the root, the skill recognizes you have multiple contexts and looks for CONTEXT.md and docs/adr/ folders within each context directory (e.g. src/ordering/CONTEXT.md).

Generated from the current SKILL.md. These answers refresh after source changes.