Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Varchy

    1

    Autonomous AI software architect that transforms ideas into validated PRDs, database schemas, and implementation DAGs.

    Free

    Security scanned
    Varchy

    Varchy

    Example session with this skill installed

    Architect a local-first task manager with offline sync. Generate the PRD and database schema.

    • Read your context and instructions
    • Compiled the varchy

    I have initiated the Varchy Architectural Protocol for the local-first task manager. I have generated the discovery constraints and the initial PRD.

    Engineering Blueprint: Local-First Task Manager

    docs/01-product/prd.md

    IDRequirementPriorityTraceability
    REQ-001Offline-first data persistence via IndexedDBP0TASK-001
    REQ-002Conflict-free Replicated Data Types (CRDT) for syncP0TASK-004
    REQ-003Biometric authentication for local vaultP1REQ-001

    docs/03-engineering/database.md

    -- ENT-001: TaskEntity
    CREATE TABLE tasks (
      id UUID PRIMARY KEY,
      title TEXT NOT NULL,
      content_json JSONB,
      is_completed BOOLEAN DEFAULT FALSE,
      last_modified_at TIMESTAMP WITH TIME ZONE,
      vector_clock JSONB, -- For CRDT sync logic
      user_id UUID REFERENCES users(id)
    );
    
    -- ENT-002: SyncLog
    CREATE TABLE sync_logs (
      id SERIAL PRIMARY KEY,
      entity_id UUID NOT NULL,
      operation_type TEXT CHECK (operation_type IN ('INSERT', 'UPDATE', 'DELETE')),
      payload JSONB,
      applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    );
    

    docs/03-engineering/architecture.md

    • Pattern: Local-First / Event-Sourced
    • Storage: IndexedDB (Client) + PostgreSQL (Sync Server)
    • Sync Strategy: Optimistic UI with background synchronization workers.

    Next steps

    1. Review the generated docs/02-design/screens.md for the 4-state UI specifications (Empty, Loading, Success, Error).
    2. Run varchy validate to check the 100-point readiness score.
    3. Proceed to Phase 1 of the Task DAG in docs/04-development/tasks.md.

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

    About this skill

    Stop building on shaky foundations. Writing code before planning leads to "vibe coding hangovers" where agents hallucinate schemas and produce conflicting API routes. This skill enforces a principal-level software architecture protocol to validate every engineering decision before the first line of code is written.

    What it does

    • Architect blueprints by transforming high-level ideas into mathematically validated engineering documents.
    • Generate PRDs with immutable requirement IDs and prioritized user journeys.
    • Design data schemas including relational/document models with explicit types, indexes, and keys.
    • Map API contracts defining RESTful or GraphQL endpoints with request/response payloads.
    • Build task DAGs decomposing projects into strictly ordered, non-circular implementation phases.
    • Audit existing stacks to identify missing edge cases, circular dependencies, or schema gaps.

    How it works

    1. Discovery involves identifying constraints like latency targets, security compliance, and tech stack archetypes.
    2. Drafting creates a structured documentation tree across product, design, engineering, and quality folders.
    3. Modeling defines the component architecture and data flow using Mermaid sequence diagrams.
    4. Validation checks the plan against a 100-point deterministic readiness gate for requirement traceability.
    5. Orchestration generates universal agent instruction files like AGENTS.md and .cursorrules.

    Frameworks & tools

    This skill is framework-agnostic but provides optimized templates for SaaS, API Backends, and Local-First apps. It generates directives for Claude Code, Cursor, and GitHub Copilot.

    Why this beats prompting it yourself

    Generic prompts often miss non-functional requirements like p99 latency or edge-case UI states. This skill enforces a 7-stage architectural protocol that ensures every frontend mutation has a corresponding backend API endpoint and a verifiable task in the DAG.

    Use cases

    • Greenfield projects requiring a complete technical specification from a one-sentence idea.
    • Database migrations needing strictly typed schemas and entity relationship mapping.
    • Agent orchestration to set up consistent rules across multiple AI coding tools.
    • Pre-flight audits to verify a project is ready for implementation based on a readiness score.

    Known limitations

    Requires a structured file system to output documentation. It does not write the final application implementation code, only the architectural blueprints and task roadmaps.

    Requires structured output directory. Focuses on planning and architecture rather than direct application code generation.

    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

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 6 days ago

    • Free with an Agensi account

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Listed6 days ago

    What's inside

    Frequently Asked Questions

    Unlike generic chat prompts, this skill uses a deterministic 7-stage protocol to ensure 100% requirement traceability, preventing the 'vibe coding' errors where AI agents hallucinate inconsistent API routes or database schemas.

    The skill generates universal directive files, such as .cursorrules and AGENTS.md, making it fully compatible with Claude Code, Cursor, Windsurf, and GitHub Copilot.

    No, this skill focuses exclusively on the 'Architectural Phase,' providing the blueprints, schemas, and task DAGs that you then feed into your preferred coding agent to generate the actual application code.

    You will receive the complete Varchy Architectural Protocol, including optimized templates for SaaS and API backends, Mermaid diagram generators, and the 100-point deterministic readiness gate.

    The skill is designed to work within any AI environment that supports a structured file system, as it needs to output a documentation tree across product, design, and engineering folders.

    Yes, the blueprints include a 100-point readiness score and a Task DAG (Directed Acyclic Graph) which identifies missing edge cases and circular dependencies in your existing project structure.

    New in Agents & Orchestration