diataxis:explanation

Document architectural rationale, context, and trade-offs for subsystem decisions.

2|Updated Jan 12, 2026
One-click install
npx skills add https://github.com/jayteealao/agent-skills --skill diataxis-explanation
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: diataxis:explanation
Source: https://github.com/jayteealao/agent-skills/tree/main/plugins/sdlc-workflow/skills/explanation-writer
Command: npx skills add https://github.com/jayteealao/agent-skills --skill diataxis-explanation

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Captures the rationale, context, and trade-offs behind architectural decisions to help teams understand the "why" behind designs, rather than prescribing "how" to implement them.

Core Features & Use Cases

  • Produces architecture rationales and design rationales that explain decisions, constraints, and alternatives.
  • Supports onboarding and review by providing a coherent mental model of subsystem context.
  • Useful for architecture decision records, design documentation, and knowledge transfer.

Quick Start

Draft a concise rationale document that explains the key trade-offs and architectural context for the new module.

Frequently Asked Questions about diataxis:explanation

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I write architectural documentation that explains design decisions instead of implementation steps?

Architectural documentation should capture the rationale, context, and trade-offs behind decisions to clarify the "why" rather than prescribing procedural instructions. It explains design constraints and alternatives to provide conceptual guidance for software systems.

What is a design rationale document and what should it include for software architecture reviews?

A design rationale document explains the reasoning, assumptions, and alternatives behind architectural decisions. It includes system context and trade-off discussions to provide a coherent mental model, supporting onboarding and architecture reviews without procedural instructions.

When do I need to document architectural context and trade-offs for a new software subsystem?

You need to document architectural context and trade-offs when onboarding teams to a new subsystem or transferring knowledge. Producing architecture rationales provides a coherent mental model that clarifies design constraints and assumptions for review purposes.

Can I use conceptual guidance to create architecture decision records for software systems?

Yes, reasoning-oriented conceptual guidance is useful for drafting architecture decision records. It clarifies context, assumptions, and alternatives, providing the design rationale and trade-off discussions needed for effective knowledge transfer across software systems.

What is the best way to document the 'why' behind architectural decisions without writing a tutorial?

The best way to document the "why" is to draft a concise rationale document capturing trade-offs and system context. This reasoning-oriented approach explains architectural decisions and design constraints without including procedural implementation instructions.

Why does my architecture overview fail to help new developers understand the system context?

Your architecture overview likely fails because it lacks design rationale explaining the trade-offs and assumptions behind decisions. Providing reasoning-oriented conceptual guidance builds a coherent mental model, which is essential for effective onboarding and knowledge transfer.