LearnGrok
Prompts
PromptIntermediateBuild something

Architecture decision record from design debate

Create a reviewable architecture decision record from design notes and options, for technical leads before implementation.

4 min read

An architecture decision record, or ADR, is useful when a design discussion has produced more material than a future reader can safely reconstruct. These prompts help you turn that material into one reviewable document before implementation begins. They suit technical leads and engineering teams deciding between concrete implementation approaches.

Key point

Record the decision, not the meeting

An ADR should say what the team will do, why alternatives were not chosen, and what work remains before the decision can be relied on.

Start with the source material

Collect the material that actually shaped the decision. Give each item a recognisable name, such as API gateway design notes, Caching spike results, or Platform review meeting, 14 May. Include the ticket or design document that states the problem, not only the notes that propose a solution.

Before pasting anything, separate these inputs:

  • The decision the team needs to make.
  • Non-negotiable constraints, such as a required interface, supported deployment environment, or data boundary.
  • Candidate approaches, including the approach a participant only mentioned briefly.
  • Evidence, such as test results, operational incidents, or an agreed product requirement.
  • Open questions that could change the result.

Use Extract decision inputs when the material is messy or contradictory. It produces a register rather than an ADR, which prevents a confident draft being built on an unstated assumption.

Watch out

Do not treat a preference as a constraint

A statement such as “we usually use this component” may be useful context, but it is not a requirement unless the source says why the team cannot choose otherwise.

Compare before selecting

Run Compare implementation options when two or more approaches are still credible. Paste the same constraints against every option. Do not describe one option in detail and another with a label only. If an option cannot be compared because its design is not known, record that gap.

The recommendation is a review input, not the decision itself. The decision owner still needs to choose, and the ADR needs to show that choice plainly. Use the comparison to ask focused questions in the review, for example whether a migration path is needed or who will own a new operational alert.

If tool behaviour, supported features, or integration details affect the decision, verify them against the current xAI documentation. These details can be version-dependent. Do not make an ADR depend on a remembered limitation.

Write the record after selection

Use Draft the ADR once the owner has selected an approach. Fill every placeholder before you send it. In particular, name the selected approach and every serious rejected option. A rejected option without a reason will invite the same debate later.

The Decision section should be precise enough for an engineer to tell whether planned work is in scope. For example, it should identify the affected service or boundary, the chosen mechanism, and any explicit exclusion. Avoid statements such as “improve reliability” unless the ADR also says what will change.

Use Challenge the draft ADR in the review meeting or pull request. It is most useful when reviewers have read the document but disagree about what is missing. Work through blockers first. Treat a needs owner or Unknown field as work to assign, not wording to tidy up.

Check

A reader should be able to reconstruct the choice

Give the ADR to someone outside the original discussion. They should be able to name the selected option, the main rejected alternative, the key consequence, and the next owner without asking for the meeting notes.

Check the output against the evidence

Do not check an ADR only for clear prose. Check each claim against a named source document. Look closely at these common failures:

If you see this Check this Do this
A firm claim with no source Whether it was stated, tested, or merely inferred Mark it as an assumption or add the source evidence
A rejected option described unfairly Whether its actual advantages and constraints are recorded Rewrite the option from the original notes
A consequence with no owner Whether someone must change monitoring, support, deployment, or documentation Add a follow-up item with completion evidence
An open question hidden in prose Whether its answer could reverse the decision Move it to Assumptions and unresolved questions

Run Prepare the accepted ADR only after review comments have explicit resolutions. Its publication check is the final gate. Store the finished record beside the design material or codebase where the implementing team will find it.

Stop

Do not erase disagreement to make approval easier

If a material uncertainty remains, record it and assign the work needed to resolve it. A neat but false record creates more rework than an incomplete one.

When the prompts do not produce a usable ADR

If the output contains many Unknown fields, do not keep rewriting the prompt. The decision is not ready for a durable record. Return to the decision owner with the missing questions, then rerun the input register and comparison.

If the model selects an option despite equal or incomplete evidence, remove the recommendation from the draft and ask the owner to decide. If the record becomes too broad, split it into separate decisions. One ADR should capture one decision with one accountable owner, even when several components are affected.

Copy-ready prompts

5 prompts. Open one to read it, or take the whole pack.

1Extract decision inputsUse this first when the debate is spread across design notes, tickets, meeting notes and chat excerpts.
Create a decision-input register for the architecture decision record titled `[ADR title]`.

Source material:
[paste design notes, meeting notes, ticket excerpts and relevant discussion]

Return a Markdown table with these columns: `Item`, `Type`, `Source evidence`, `Status`, `Effect on decision`.

Use only these values for `Type`: `problem`, `goal`, `constraint`, `requirement`, `assumption`, `risk`, `option`, `open question`, `out of scope`.

Use only these values for `Status`: `stated`, `inferred`, `conflicting`, `missing`.

Then provide these sections:
1. `Decision to make`, one sentence.
2. `Conflicts to resolve`, listing source statements that cannot both be true.
3. `Missing information`, listing the exact question, why it matters, and the person or team most likely to answer it if known.
4. `Candidate options named in the material`, with a one-sentence description of each.

Do not select an option. Do not fill gaps with common practice. If the source is ambiguous, quote the relevant wording and mark it `ambiguous`.
2Compare implementation optionsUse this once the candidate approaches and constraints are known, but before the team has committed to one.
Compare the implementation options for the architecture decision record `[ADR title]`.

Decision statement:
[paste the decision to make]

Constraints and requirements:
[paste the agreed constraints and requirements]

Options:
[paste each option, including any known design detail]

Return:
1. A Markdown comparison table with rows for each option and these columns: `Meets stated requirements`, `Operational impact`, `Delivery impact`, `Security or privacy impact`, `Failure modes`, `Migration or rollback`, `Unknowns`.
2. A `Trade-offs by option` section. Give three to six concrete trade-offs per option.
3. A `Decision criteria` section. Rank the criteria using only evidence from the supplied material.
4. A `Recommendation` section containing: `recommended option`, `why it best fits`, `conditions before approval`, and `evidence gaps`.

Separate stated facts from assumptions. Label every assumption as `Assumption:` and every unsupported comparison as `Cannot determine from the supplied material`. If two options are materially equivalent on the available evidence, say so rather than forcing a winner.
3Draft the ADRUse this when the team has selected an approach and needs a durable record for review before implementation starts.
Write an architecture decision record in Markdown using the exact template below.

ADR title: [paste title]
Status: [proposed, accepted, superseded or rejected]
Decision owner: [paste name or team]
Decision date: [paste date or write unknown]
Design notes and evidence: [paste source material]
Selected approach: [paste selected option]
Rejected or competing options: [paste options]
Known constraints: [paste constraints]
Open questions and planned work: [paste items]

Use this exact structure:
## Context
## Decision drivers
## Decision
## Options considered
## Consequences
## Follow-up work
## Assumptions and unresolved questions
## References

Requirements:
- In `Decision`, state exactly what will be implemented, where it applies, and what is explicitly excluded.
- In `Options considered`, give each option a heading and record why it was rejected, deferred or selected.
- In `Consequences`, separate positive consequences, negative consequences, operational changes, and rollback or reversal considerations.
- In `Follow-up work`, use a Markdown table with `Work item`, `Owner`, `Due point`, `Completion evidence`, and `Dependency`.
- In `References`, identify supplied source documents by their given names only.

Do not invent owners, dates, measurements, approvals or technical facts. Write `Unknown` where a required field is absent. For ambiguity, record the competing interpretations and add a follow-up item instead of choosing silently.
4Challenge the draft ADRUse this in review when an ADR sounds settled but may hide an untested assumption, missing option or weak consequence.
Review the draft architecture decision record below as a sceptical technical reviewer.

ADR draft:
[paste the ADR]

Return a review in Markdown with these sections:
## Decision clarity
## Evidence and assumptions
## Option coverage
## Consequences and operations
## Follow-up work
## Review verdict

Under each section, list findings in a table with columns: `Severity`, `ADR field`, `Finding`, `Why it matters`, `Required change`.

Use only `blocker`, `major`, `minor` or `question` for `Severity`.

Check specifically whether the ADR:
- makes one implementable decision rather than describing a discussion;
- distinguishes facts, assumptions and unresolved questions;
- gives a fair rejection reason for each material alternative;
- names operational ownership, monitoring, migration and rollback implications where relevant;
- contains follow-up work with observable completion evidence.

Finish with `Review verdict: approve`, `approve with changes`, or `do not approve`, followed by the minimum changes needed. Do not propose facts that are absent from the draft. Phrase missing evidence as a question for the decision owner.
5Prepare the accepted ADRUse this after review comments have been resolved and the record is ready to be stored with the code or design documentation.
Prepare the final architecture decision record from the draft and review resolution below.

ADR draft:
[paste approved or revised ADR]

Review comments and resolutions:
[paste comments, answers and agreed changes]

Return two items.

1. The complete ADR in Markdown, using these sections in this order:
## Context
## Decision drivers
## Decision
## Options considered
## Consequences
## Follow-up work
## Assumptions and unresolved questions
## References

2. A `Publication check` table with columns: `Check`, `Result`, `Evidence in ADR`, `Action needed`.

Set `Result` to only `pass`, `fail` or `needs owner`. Check the title, status, decision owner, decision statement, rejected options, consequences, follow-up ownership, completion evidence, unresolved questions and references.

Incorporate only resolutions that are explicitly stated. Preserve unresolved disagreement in `Assumptions and unresolved questions`. If a review comment conflicts with the recorded decision, flag it in the publication check and do not rewrite the decision to make the conflict disappear.

Last checked against xAI’s own pages on 2026-08-21. Grok changes quickly; anything version-specific should be confirmed upstream before you rely on it.

More in Build something

Found something out of date?

Grok changes quickly and this page is a snapshot. If something here is wrong, or you know a better resource, send it over.

Suggest a link →

Advertise on LearnGrok

$420.69one-time, for a 30-day run

Square works best. PNG, JPEG or WebP, up to 2 MB.

Stripe on the next step. Live once approved.