Works with the AI Agents you already use
Varchy
Autonomous AI software architect that transforms ideas into validated PRDs, database schemas, and implementation DAGs.
Free
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
| ID | Requirement | Priority | Traceability |
|---|---|---|---|
| REQ-001 | Offline-first data persistence via IndexedDB | P0 | TASK-001 |
| REQ-002 | Conflict-free Replicated Data Types (CRDT) for sync | P0 | TASK-004 |
| REQ-003 | Biometric authentication for local vault | P1 | REQ-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
- Review the generated
docs/02-design/screens.mdfor the 4-state UI specifications (Empty, Loading, Success, Error). - Run
varchy validateto check the 100-point readiness score. - 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
- Discovery involves identifying constraints like latency targets, security compliance, and tech stack archetypes.
- Drafting creates a structured documentation tree across product, design, engineering, and quality folders.
- Modeling defines the component architecture and data flow using Mermaid sequence diagrams.
- Validation checks the plan against a 100-point deterministic readiness gate for requirement traceability.
- Orchestration generates universal agent instruction files like
AGENTS.mdand.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.
Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.
Requires structured output directory. Focuses on planning and architecture rather than direct application code generation.
How to use
- 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
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 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
Free to use
No account required to browse
Trust & safety
Security scan
Security scan passed 6 days ago
- Free with an Agensi account