memorix-reasoning

Record and retrieve technical decision rationales linked to commit references.

618|48|Updated Feb 14, 2026

Search Tags:#software architecture #reasoning #rationale #technical decision #design decision

Ready to run

npx skills add https://github.com/AVIDS2/memorix --skill memorix-reasoning

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: memorix-reasoning
Source: https://github.com/AVIDS2/memorix/tree/main/plugins/copilot/memorix/skills/memorix-reasoning
Command: npx skills add https://github.com/AVIDS2/memorix --skill memorix-reasoning

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill helps you keep track of technical decisions and their rationales, ensuring that the reasoning behind your choices is preserved and accessible over time.

Core Features & Use Cases

Reasoning Memory Storage: Store explanations for technical decisions.
Rationale Retrieval: Quickly find previous rationales when revisiting decisions.
Topic Key Suggestion: Generate stable keys for topics like 'decision' or 'rationale'.
Linking to Commit Evidence: Attach rationale to specific commit references.
Use Case: If you need to justify a design decision or review a trade-off, use this Skill to record and link the reasoning behind it.

Quick Start

Store the reasoning for a design decision in the 'memorix-reasoning' skill using the command 'memorix_store_reasoning --entity "design decision" --decision "decide on feature X" --rationale "Explanation of decision"'.

Frequently Asked Questions about memorix-reasoning

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

FAQPage Schema

How do I document the reasoning behind a software architecture decision?▼

Documenting software architecture decision reasoning involves storing the design choice and its rationale. You can record this technical decision context by specifying the entity, the decision made, and the detailed explanation of the trade-offs considered.

What is the best way to link architectural rationale to a specific git commit?▼

Linking architectural rationale to a commit requires attaching the decision reasoning directly to the commit reference. This preserves the technical context and design trade-offs alongside the historical code changes for future review.

How can I retrieve past design decisions and their technical rationale?▼

Retrieving past design decisions and technical rationale requires searching the stored reasoning memory. You can find previous architectural explanations by looking up the stable topic keys generated for those specific design choices.

Does this rationale tracking approach require access to commit history?▼

Yes, this rationale tracking approach requires access to your commit history. Interaction with the reasoning capabilities and commit history is necessary to properly link architectural design decisions with their technical evidence.

Can I generate stable keys for technical decision topics?▼

Yes, you can generate stable keys for technical decision topics. The system suggests consistent keys like 'decision' or 'rationale' to organize and reliably retrieve your software architecture explanations.