Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Software Architect

    1

    Opinionated architecture planning that picks a stack, defines data models, and sets strict "will-not-build" boundaries.

    $10

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Software Architect

    Software Architect

    Example session with this skill installed

    Review docs/requirements.md for 'TaskFlow' (local-first productivity tool) and define the architecture. Focus on the core note-taking slice. Use docs/architecture.md for output.

    • Read your context and instructions
    • Compiled the software architect

    Processed requirements for TaskFlow. I have defined a local-first architecture focused on the core note-taking slice, emphasizing low latency and durability.

    Architecture: TaskFlow

    Header

    • Product: TaskFlow
    • Slice Goal: Core note-taking and persistence
    • UI: Yes
    • Hosting: local-first
    • Status: ready

    Drivers

    1. Low Latency: Interaction must feel instantaneous on desktop (ref: NFR-1).
    2. Local Persistence: Data must survive process restart without network (ref: FR-4).
    3. Single Operator: No multi-user synchronization or identity required for this slice (ref: Out-of-Scope).

    Chosen Stack

    • Language: TypeScript 5.0+
    • Runtime: Electron (Node.js 20+)
    • UI Toolkit: React with Tailwind CSS
    • Storage: SQLite (via better-sqlite3)

    Data Model

    EntityFieldsTypeKey
    Noteid, content, created_at, updated_atUUID, Text, ISO8601, ISO8601PK (id)
    Tagid, labelUUID, StringPK (id)

    Contracts

    • StorageProvider.saveNote(note: Note): Promise<void>
      • Errors: DiskFull, DatabaseLocked
    • StorageProvider.getNotes(): Promise<Note[]>
    • UI.renderEditor(noteId: string): void

    ADRs

    • Decision: SQLite over JSON files.
    • Rationale: Better query performance for future search features and ACID compliance for durability.
    • Alternatives Rejected: LocalStorage (size limits), MongoDB (operational overhead).

    Will-Not-Build

    1. User Accounts/Auth: The application is tied to the local machine user.
    2. Cloud Sync: Out of scope for this slice; no external API calls.
    3. Markdown Preview: Requirements specify plain-text only for P0.

    Next steps

    • Review the docs/architecture.md file for sign-off.
    • Initialize the repository using the TypeScript/Electron stack.
    • Hand off to the senior-planner skill to generate implementation tasks.

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

    About this skill

    The problem

    Developers often waste time debating framework menus or over-engineering infrastructure for simple requirements. Without a clear contract between design and implementation, projects suffer from scope creep and "just in case" microservices.

    What it does

    • Analyzes requirements and UX handoffs to select a single, concrete technology stack.
    • Defines a lean data model focused exclusively on P0 features.
    • Specifies module boundaries and API contracts (in-process or network) for implementation.
    • Generates an explicit "will-not-build" list to prevent unauthorized scope expansion.
    • Documents architectural decisions (ADRs) including rationales and rejected alternatives.

    Frameworks & tools

    Agnostic. Works with any stack including React, Python, SQLite, Node.js, and local-first or hosted environments.

    Why this beats prompting it yourself

    Generic prompts often return generic "best practices" or a list of five options. This skill forces a single opinionated path, strictly respects out-of-scope boundaries, and ensures every architectural choice is tied to a specific requirement driver.

    Use cases

    • Transforming a business requirements document into a technical blueprint.
    • Setting boundaries for junior developers by defining what NOT to build.
    • Resolving stack indecision by identifying the specific drivers that force a choice.
    • Creating clean module contracts before a single line of application code is written.

    Known limitations

    Does not perform implementation, cloud infrastructure setup, or task sequencing. It blocks execution if hosting intent or UX requirements are missing.

    Requires pre-existing requirements document. Will not select cloud providers if hosting is undecided. Does not write code or infrastructure scripts.

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

    Permissions

    Read Files
    Write Files
    Browser
    Listed2 months ago

    What's inside

    Frequently Asked Questions

    Unlike generic AI prompts that suggest multiple 'best practices,' this skill enforces a single, opinionated technical path and a strict 'will-not-build' list to prevent scope creep before implementation begins.

    The skill generates a comprehensive technical blueprint, including a finalized tech stack selection, data models for P0 features, API/module contracts, and documented Architectural Decision Records (ADRs).

    The Software Architect skill is agnostic and designed to integrate with any agent platform that supports standard text or markdown-based inputs for requirements and UX documentation.

    This skill focuses exclusively on high-level design and decision-making; it does not write application code, configure cloud environments, or manage project timelines.

    Simply provide your business requirements and UX handoffs; the skill will analyze these inputs and prompt you if critical information, like hosting intent or specific constraints, is missing.

    New in Agents & Orchestration