Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Decision Journal

    1

    Capture architectural trade-offs and technical decisions in a searchable, numbered Markdown journal.

    $5.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Decision Journal

    Decision Journal

    Example session with this skill installed

    We decided to use Redis for the caching layer instead of Memcached because we need the data persistence and built-in pub/sub features. Record this as a new decision.

    • Read your context and instructions
    • Compiled the decision journal

    I have recorded the decision to use Redis for the caching layer. A new entry has been created and the index has been updated.

    Decision Recorded: 0005-redis-caching-layer.md

    FieldValue
    ID0005
    Statusaccepted
    TitleUse Redis for caching layer
    DecisionChose Redis over Memcached because we require RDB/AOF persistence and pub/sub capabilities for future real-time updates.
    Tagsinfrastructure, caching, redis
    File Pathdocs/decisions/0005-redis-caching-layer.md

    Entry Preview

    Context
    The application requires a shared cache across multiple instances. While basic key-value storage is the primary need, our roadmap includes real-time notifications and we cannot risk a full cache wipe on service restarts.

    Consequences

    1. Benefit: Reduced latency for pub/sub operations compared to a separate MQ.
    2. Benefit: Durable cache state across deployments.
    3. Cost: Increased operational complexity compared to Memcached's simpler memory model.
    4. Revisit: If memory overhead becomes a bottleneck or persistence is moved to the primary DB.

    Next steps

    1. Review docs/decisions/0005-redis-caching-layer.md to ensure the consequences list is exhaustive.
    2. Commit the new file and the updated docs/decisions/INDEX.md.
    3. Reference this decision ID in the cache initialization module comments.
    0005-redis-caching-layer.md

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Technical projects often suffer from "lost context" where later developers can see what was built but not why specific trade-offs were made. This skill implements a disciplined Decision Journal (ADR) system within your repository to capture architectural reasoning at the moment of choice. It prevents re-litigating old debates and ensures every technical constraint is documented alongside its rejected alternatives.

    What it does

    • Formalizes trade-offs by enforcing a "Chose X over Y because Z" format for all technical decisions.
    • Automates ADR creation using a provided script to generate numbered, timestamped Markdown entries.
    • Manages decision lifecycles by handling supersession and deprecation to prevent circular reasoning.
    • Indexes architecture in a central INDEX.md for fast grep-based or script-based retrieval.
    • Validates reasoning by ensuring every entry includes context, consequences, and a named alternative.

    How it works

    1. Search the existing journal using decision.sh search to see if a standing decision already covers the current problem.
    2. Initialize a new entry with decision.sh new "<title>" when a choice constrains future work or overrides a default.
    3. Document the specific context, the rejected option, and the long-term consequences in the generated Markdown file.
    4. Supersede old entries when architectural directions change, creating a clear audit trail of the project's evolution.

    Frameworks & tools

    This skill uses Bash scripts for automation and standard Markdown for storage. It is compatible with any repository structure but defaults to docs/decisions/.

    Why this beats prompting it yourself

    Generic LLMs often provide "notes" rather than "decisions," missing the critical rejected alternatives that make an ADR useful. This skill enforces a strict schema that ensures reasoning is actually testable and reversible by future developers.

    Use cases

    • Documenting why a specific database or storage engine was chosen over common alternatives.
    • Recording the reasoning for specific API contract shapes or authentication models.
    • Tracking the evolution of project standards, such as choosing a specific testing library.
    • Capturing "hidden" preferences from senior developers that aren't obvious in the code.

    Known limitations

    Does not support multi-decision entries; each choice requires a unique file to maintain clean supersession chains. Logic is restricted to local filesystem operations.

    Requires one decision per entry. Only manages local Markdown files. Does not integrate with external project management tools like Jira or Linear.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Permissions

    Terminal / Shell
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill implements a lightweight Architectural Decision Record (ADR) system, ensuring that technical 'whys' are preserved in your repo alongside the 'what' to prevent losing context as teams scale or change.

    The skill is designed for any AI agent or developer environment with access to a Bash terminal and filesystem, making it compatible with most local or containerized development agents.

    You receive the core automation script (`decision.sh`), a set of standardized Markdown templates, and the indexing logic required to maintain a searchable audit trail of your architecture.

    Yes, while it defaults to `docs/decisions/`, you can point the skill to any directory in your repository to match your existing documentation structure.

    Unlike a simple note-taker, this skill enforces a strict schema requiring rejected alternatives and consequences, ensuring your AI agent generates structured, high-signal documentation instead of vague summaries.

    The skill includes a built-in supersession command that links new decisions to old ones, automatically updating the status of the original entry to keep your architecture index accurate.

    New in Technical Documentation