Results for “decision-record”

Structures an Architecture Decision Record (ADR) to capture context, decision, and consequences of significant architectural choices, ensuring decisions are documented with sufficient detail for future teams.

Creates and manages Architecture Decision Records using the Michael Nygard format, including new ADR creation, retrospective analysis, superseding, deprecating, and index generation.

Record durable project decisions with rationale, alternatives, assumptions, status, and revisit triggers. Load when the user says record this decision, we decided, decision log, why did we choose, revisit this later, or capture architectural/process rationale.

Produces auditable, schema-valid JSON decision records with assumptions, risks, recommendations, and review gating for high-stakes choices.

Design system architecture, evaluate microservices vs monolith, create architecture diagrams, analyze dependencies, choose databases, and make technical decisions with architecture decision records.

Records architectural decisions and documentation to capture the context, constraints, and trade-offs behind codebase choices.

Write and maintain Architecture Decision Records (ADRs) — when to write one, the standard format, status lifecycle, how to link related decisions, and how to surface ADRs in a codebase. Use when asked to "write an ADR", "document this decision", "architecture decision record", "why did we choose X over Y", or "we need a record of this choice". Do NOT use for: general documentation writing — ADRs are specifically for significant architecture decisions.

Record decisions with rationale, alternatives, and consequences — the ADR pattern as a primitive. Use when a consequential choice is made — architecture, tooling, process, scope, trade-off. Capture WHY, not just WHAT.

Records decisions and documentation. Use when making architectural decisions, changing public APIs, shipping features, or when you need to record context that future engineers and agents will need to understand the codebase.

Stop re-litigating decisions you already made. Keep a decision record where each entry captures the decision, the context that forced it, the options you weighed, why you chose, and when to revisit, one entry at a time, in plain searchable markdown you can grep later. Trigger on "log this decision", "why did we choose X", "write a decision record", "record why we're doing this", "what did we decide about", or any moment a real call gets made and would otherwise be forgotten.

Record a decision: finalized → ADR (optionally rule + guide or spec + plan); open proposal → RFC. Use for 'we decided', 'record this decision', 'make it a standard', 'draft an RFC', 'should we switch to Y'. Not for feature planning or documenting existing code.

Create and maintain lightweight Architecture Decision Records as agent-readable decision memory — what was decided, why, and which alternatives were rejected. Use when "record this decision", "set up ADRs", "the agent keeps suggesting Y again". Docs vs code drift → plan-docs-sync. Session state → handoff.

Structure a hard business decision — frame the choice, score options against weighted criteria, run a pre-mortem and stress-test, and produce a recommendation + decision record for any active brand

Decide

Decide

Write a new ADR when a non-trivial or hard-to-reverse decision is made. Use for architecture, workflow, tooling, or policy decisions that should persist in docs/adr.

Write, review, and maintain architecture decision records with clear context, alternatives, consequences, and lifecycle governance. Use when a consequential technical decision must remain understandable.

Creates an Architecture Decision Record following the Nygard format to document significant technical decisions, their context, and consequences. Use when making technical choices that affect system architecture, technology selection, or development patterns.

Logs board meeting decisions with a two-layer memory architecture, separating raw transcripts from approved decisions, and provides commands to review past decisions and overdue action items.

Write Architectural Decision Records following MADR template. Applies Definition of Done criteria, marks gaps for later completion. Use when generating ADR documents from extracted decisions.

An ADR records one decision at the moment it is made, with the information that

Capture an Architecture Decision Record — what was decided, why, what alternatives were considered, and when to revisit. Writes a numbered ADR file to docs/adr/ in the active repo, with consistent formatting that downstream skills (improve-codebase-architecture, refactor-plan) can read. Use right after deciding something non-obvious so the reasoning isn't lost.

Police the project's vocabulary — bust vague terms, keep the CONTEXT.md glossary sharp, and lock in decisions worth remembering as ADRs. Use when the user debates naming, says "what should we call this", asks to pin down terminology, wants a decision recorded, or when another skill (hot-seat, whiteboard) surfaces a decision that clears the ADR bar. Just reading the glossary for vocabulary is NOT this skill — trigger only when the words or decisions are being changed.

Captures important product, technical, or founder decisions as durable context with rationale, tradeoffs, and follow-up implications.

Save the current diagnosis state to disk for cross-session recall, including conclusions, rejected directions, and next steps.

Save information to persistent memory for cross-session recall. Stores preferences, conventions, decisions, and context.

Use to review how call recordings are notified, stored, accessed, redacted and deleted, including the parts that differ from text conversations. Trigger for "review our call recording practices", "do we need to tell customers we're recording", "who can listen to our calls", recording retention, card details spoken on a call, or a request for a customer's own recording.

Register a deferred decision in the debt registry. Trigger by judgment, not a marker scan, whenever a future reader would ask "why this way?": an unmade decision, stub, loosened type, bypassed check, swallowed error, a default picked "for now", or a TODO/FIXME/HACK/XXX marker. Trigger immediately whenever you defer work, or when the user invokes $add. Over-register freely; the developer drops with "drop A", "drop A,C", or "drop all".

Maintains persistent project context for Business Central AL extensions across sessions, developers, and AI agents. Combines two complementary mechanisms: Architecture Decision Records (ADRs) that capture why technical decisions were made, and Session Handoff documents that capture where the project is right now. Generates, updates, and queries both document types. Use this skill whenever starting a new coding session on an existing project, ending a session and need to document progress, onboarding a new developer or AI agent to an existing codebase, explaining why a technical decision was made, wondering why something is designed a certain way, resuming work after a break, or handing off work between team members. Also trigger when the user says 'document this decision', 'why is this designed like this', 'where did we leave off', 'catch me up', 'what was decided', 'create an ADR', 'end of session', 'handoff', or 'context for next session'.

Meeting to doc