Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Architecture Decision Record Writer

    1

    Converts informal notes, tickets, and PR discussions into structured Architecture Decision Records (ADRs).

    $9.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Architecture Decision Record Writer

    Architecture Decision Record Writer

    Example session with this skill installed

    We decided to use AWS Lambda for the image processing service instead of a dedicated EC2 cluster. We need to save costs on idle time and scale automatically during peaks. We considered EC2 but the ops overhead is too high.

    • Read your context and instructions
    • Compiled the architecture decision record

    I have drafted the ADR based on your preference for serverless image processing.

    Architecture Decision Record: Use AWS Lambda for Image Processing

    ADR Metadata

    • Status: Proposed
    • Date: 2023-11-22
    • Owner: Platform Engineering
    • Related systems: Image Processing Service

    Context
    The current image processing workload is highly bursty, with long periods of inactivity followed by sharp spikes. Maintaining a dedicated EC2 cluster results in high costs for idle resources and requires significant manual effort for scaling and patching.

    Decision Drivers

    • Cost efficiency (pay-per-use).
    • Operational simplicity (managed infrastructure).
    • Automatic scaling to handle unpredictable traffic spikes.

    Options Considered

    Option 1 - AWS Lambda (Chosen)

    • Summary: Serverless functions triggered by S3 uploads.
    • Benefits: Zero cost for idle time; scales automatically; no server management.
    • Drawbacks: Cold start latency; execution time limits (15 mins).
    • Risks: Potential for high costs if traffic becomes constant and high-volume.

    Option 2 - Dedicated EC2 Cluster

    • Summary: Auto-scaling group of EC2 instances.
    • Benefits: No execution time limits; predictable performance for long-running jobs.
    • Drawbacks: High operational overhead for patching and scaling logic; cost incurred during idle periods.

    Decision
    Adopt AWS Lambda for the image processing service.

    Rationale
    Lambda aligns with the primary drivers of cost reduction and minimized operational overhead. The bursty nature of the workload makes serverless more economical than maintaining persistent virtual machines.

    Consequences

    • Positive: Reduced infrastructure bill and near-zero server maintenance.
    • Negative: Image processing must be optimized to stay within Lambda timeout limits.
    • Neutral: Monitoring must transition to CloudWatch Logs and X-Ray for distributed tracing.

    Implementation Notes

    • Implement S3 trigger for Lambda functions.
    • Configure memory settings to balance processing speed and cost.
    • Set up dead-letter queues (DLQ) for failed processing attempts.

    Review Triggers

    • Review if average monthly execution costs exceed the cost of a reserved EC2 instance.
    • Review if image sizes grow to require >15 minutes of processing time.

    Next steps

    1. Validate the maximum image size against the Lambda 10GB ephemeral storage limit.
    2. Define the retry policy for the S3 trigger.
    3. Review the draft with the security team for IAM role scoping.

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

    About this skill

    The problem

    Engineering teams often make critical technical choices in meetings or Slack threads without documenting the "why." This leads to tribal knowledge, repeated arguments over settled topics, and future maintainers who are afraid to change code because they don't understand the original constraints.

    What it does

    • Converts informal notes, tickets, and PR discussions into structured Architecture Decision Records (ADRs).
    • Extracts concrete decision drivers, trade-offs, and consequences from raw technical reasoning.
    • Forces the documentation of rejected alternatives to ensure full decision traceability.
    • Audits existing ADRs against a quality rubric to find weak logic or missing risk assessments.
    • Generates implementation notes, review triggers, and follow-up actions for every decision.

    Why this beats prompting it yourself

    General LLMs often write vague design essays or skip the "negative consequences" section entirely. This skill enforces a strict architectural rubric that prioritizes technical debt visibility and future maintainability over marketing-speak. It ensures every "why" is backed by a specific driver rather than just calling a tool "scalable" or "fast."

    Use cases

    • Documenting a database migration or framework choice for a new service.
    • Creating a durable record of why a specific third-party API was selected over building in-house.
    • Auditing a team's documentation to ensure architectural decisions are actually traceable.
    • Onboarding new lead engineers by providing a clear history of system constraints.

    Known limitations

    The skill does not verify technical claims, benchmarks, or security facts. It relies entirely on the technical context provided by the user.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse All Claude Skills.

    Requires user-provided context for system facts and constraints. Does not perform independent technical validation, security audits, or cost analysis.

    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 buying a skill.

    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 2 months ago

    Permissions

    No special permissions declared or detected

    Listed2 months ago

    What's inside

    Frequently Asked Questions

    It transforms unstructured technical discussions from Slack, Jira, or PRs into professional Architecture Decision Records (ADRs) that clearly outline decision drivers, rejected alternatives, and future consequences.

    This skill is designed to work with major LLMs and AI coding assistants like Cursor, Windsurf, or GitHub Copilot, allowing you to generate ADRs directly within your IDE or terminal.

    Unlike generic prompts, this skill enforces a strict architectural rubric that mandates the inclusion of negative consequences and technical debt visibility, preventing the "vague essays" typical of standard LLMs.

    You receive the structured skill prompt optimized for architectural rigor, a template for standardizing ADRs across your organization, and a quality rubric for auditing existing documentation.

    Setup is immediate; you simply import the skill into your preferred AI agent's environment or custom instructions, and it is ready to analyze your technical context.

    The skill creates a permanent, searchable record of the 'why' behind technical choices, ensuring that new hires understand past constraints and avoiding repetitive debates on settled topics.