Archigen Documentation

Learn how to transform your app ideas into implementation-ready blueprints that work seamlessly with AI coding assistants.

Start Here

Getting Started

Archigen helps you go from idea to implementation-ready documentation in minutes. Here's how to get started:

Create a New Project

Describe Your Idea

Use the chat interface to describe your app. Be as detailed or as brief as you like — Archigen will ask clarifying questions to understand your vision.

Generate Your Blueprint

Once you've answered the questions, click "Generate" to create your complete documentation suite in about 30 seconds.

Export & Build

Download your documents as a ZIP, copy individual files, or get a starter prompt for AI coding assistants like Claude Code, Cursor, or Lovable.

Usage Guides

Step-by-step instructions for using your blueprints

IDE Guide: Using Your Generated Documents

A complete step-by-step guide for using your Archigen blueprints with AI coding assistants.

📌 This guide is for IDE-based development — using tools like Claude Code CLI, Cursor, Windsurf, or VS Code with AI extensions.

Using a no-code platform like Lovable, Base44, or Replit? See the No-Code Guide →

Describe Your App Idea

Start by creating a new project in Archigen and describing your app idea through the chat interface. Be as detailed as possible — the more context you provide, the better your generated documents will be.

Describe the core purpose and problem your app solves

Mention key features you want (e.g., "user authentication", "dashboard", "real-time chat")

Specify your preferred tech stack (Next.js, React, Vue, etc.)

Share design preferences (dark mode, minimal UI, specific color schemes)

Reference similar apps for inspiration (e.g., "UI similar to Linear" or "like Notion but simpler")

💡 Pro Tip: Reference Existing Apps

You can paste URLs of websites you want to reference. Archigen will automatically fetch and analyze them to understand the design patterns and features you're looking for. For example: "I want the UI to feel like https://linear.app — clean, minimal, dark mode with purple accents."

Example Conversation Starters:

"I want to build a project management tool for small teams. It should have task boards like Trello, but with a cleaner UI like Linear. Dark mode is a must. Users should be able to create projects, invite team members, and track progress with simple analytics."

"Build me a personal finance tracker. I want to connect bank accounts via Plaid, categorize transactions automatically, set budgets, and see spending trends over time. Mobile-first design, light mode, using React Native and Supabase."

✓ Good to Include

• Core problem you're solving
• Target users (developers, consumers, businesses)
• Must-have vs nice-to-have features
• Preferred tech stack and hosting
• Design inspiration or references
• Authentication requirements

⚡ The More Detail, The Better

Don't worry about being too detailed. Archigen will ask follow-up questions if it needs clarification. The more context you provide upfront, the more accurate and useful your generated documents will be.

Download Your Generated Documents

Once Archigen generates your 5 blueprint documents (DESIGN.md, PRD.md, SCHEMA.md, PLAN.md, RULES.md), download them to your local machine. You have several export options:

Download as ZIP (Recommended)

Downloads all 5 documents in a single ZIP file. Also includes optional .cursorrules and CLAUDE.md files pre-configured for AI assistants.

Copy Individual Files

Copy each document's content individually. Useful if you only need specific files or want to paste directly into your project.

📁 What's Included in the ZIP Download?

Core Documents:

• DESIGN.md — UI/UX specifications

• PRD.md — Product requirements

• SCHEMA.md — Database structure

• PLAN.md — Implementation roadmap

• RULES.md — Coding conventions

AI Assistant Configs (Optional):

• .cursorrules — For Cursor IDE

• CLAUDE.md — For Claude Code CLI

These are pre-configured versions of RULES.md formatted for each AI tool.

Understanding Each Document:

DESIGN

Contains your complete design system — colors, typography, spacing, component specifications, and UI patterns. Reference this when building any visual element.

PRD

Your product requirements with detailed user stories, acceptance criteria, and feature specifications. This is the "what" of your app.

SCHEMA

Database tables, relationships, field types, and validation rules. Use this to set up your database and define TypeScript types.

PLAN

Phased implementation roadmap with specific tasks, dependencies, and suggested order. This is your step-by-step building guide.

RULES

Coding standards, naming conventions, and AI assistant instructions. This ensures consistent, high-quality code generation.

Add Documents to Your Project

Extract the downloaded ZIP and place all 5 markdown files in your project's root directory. This makes them easily accessible to your AI coding assistant.

# Your project structure should look like this:

my-project/

├── DESIGN.md

├── PRD.md

├── SCHEMA.md

├── PLAN.md

├── RULES.md

├── .cursorrules (for Cursor)

├── CLAUDE.md (for Claude Code)

├── package.json

├── src/

└── ...

💡 Why Root Directory?

AI coding assistants like Claude Code and Cursor automatically scan your project root for context files. Placing documents here ensures they're discovered and read without additional configuration.

📂 Alternative: /docs Folder

Some teams prefer organizing docs in a /docs folder. This works fine — just tell your AI assistant: "Read all files in the /docs folder first."

Quick Setup Commands:

# Extract ZIP and move to your project

unzip archigen-export.zip -d my-project/

# Or if you already have a project, extract directly into it

cd my-project && unzip ~/Downloads/archigen-export.zip

⚠️ Don't Forget

If you're using Git, consider adding these files to your repository. They serve as living documentation that can evolve with your project. Update PLAN.md as you complete tasks to track progress.

Configure Your AI Assistant with RULES.md

The RULES.md file contains coding conventions, project structure guidelines, and specific instructions for AI assistants. This ensures consistent, high-quality code generation.

For Claude Code CLI:

# Rename RULES.md to CLAUDE.md or copy its content there

cp RULES.md CLAUDE.md

For Cursor:

# Rename RULES.md to .cursorrules

cp RULES.md .cursorrules

Tell Your AI to Read the Documents:

Once your files are in place, instruct your AI assistant to read and understand all 5 documents. Here's an example prompt you can use:

"Please read the following files in my project root: DESIGN.md, PRD.md, SCHEMA.md, PLAN.md, and RULES.md. These contain the complete blueprint for this project. After reading them, give me a brief overview of what we're building and confirm you understand the project structure."

✓ What to Expect After the AI Reads Your Docs

After reading your documents, the AI should provide a summary that includes:

• Project name and description — What you're building
• Tech stack confirmation — Framework, database, hosting
• Core features overview — Main functionality to implement
• Design system understanding — Colors, typography, components
• Implementation phases — The roadmap from PLAN.md

This confirms the AI understands your project and is ready to help you build.

AI Tool-Specific Configuration:

Claude Code CLI

Claude Code automatically reads CLAUDE.md from your project root. Simply rename RULES.md or use the included CLAUDE.md file.

mv RULES.md CLAUDE.md

Cursor IDE

Cursor reads .cursorrules for project-specific instructions. This file is hidden but recognized by Cursor.

mv RULES.md .cursorrules

Other AI Tools (Windsurf, Copilot, etc.)

Keep RULES.md as-is and manually tell the AI to read it at the start of each session: "Please read RULES.md for project conventions before we begin."

Start Building with PLAN.md

The PLAN.md file contains a phased implementation plan with specific tasks, dependencies, and the recommended order of development. This is your roadmap for building the project.

How PLAN.md is Structured:

Phase 0 — Foundation/Setup

Project initialization, dependencies, folder structure, environment setup

Phase 1 — Core Features

Essential functionality that makes the app work

Phase 2 — Advanced Features

Additional functionality and enhancements

Phase 3 — Integrations

Third-party services, APIs, external connections

Phase 4 — Polish & Hardening

Testing, optimization, error handling, final touches

Tell Your AI to Start Building:

"Let's start building. Please begin with Phase 0, Task 0.1 in PLAN.md. Follow the task description exactly and reference DESIGN.md for styling, SCHEMA.md for data models, and PRD.md for feature requirements. Update the task status to 'In progress' as you work and 'Done' when complete."

Sample Task from PLAN.md:

### Task 1.1 — User Authentication

Status: In progress

What will be done:

- Set up authentication with NextAuth.js

- Create login/signup pages

- Implement protected routes

Files/components:

- app/auth/login/page.tsx

- app/auth/signup/page.tsx

- lib/auth.ts

Each task includes specific files to create, dependencies, and clear success criteria. The AI follows these exactly.

More Helpful Prompts for Building:

// After completing a task

"Task 1.1 is complete. Please mark it as 'Done' in PLAN.md and move to Task 1.2."

// When you need to understand a feature better

"Before implementing Task 2.3, explain how this feature should work based on PRD.md."

// When building UI components

"Create the dashboard layout following DESIGN.md specifications — use the exact colors and spacing defined there."

// When setting up the database

"Set up the database schema following SCHEMA.md. Create all tables with the specified relationships and constraints."

✓ Do This

• Follow tasks in order (they're sequenced for dependencies)
• Update task status as you complete them
• Reference other docs when building features
• Ask the AI to explain before implementing

✗ Avoid This

• Skipping Phase 0 (foundation matters)
• Jumping to advanced features before core
• Ignoring the RULES.md coding conventions
• Not updating task statuses

You're All Set!

You now have everything you need to build your app with AI assistance. Your documents work together as a complete system:

DESIGN

How it looks

PRD

What to build

SCHEMA

Data structure

PLAN

Build order

RULES

How to code

No-Code Guide: Using with AI Platforms

A guide for using your Archigen blueprints with AI-powered no-code and low-code platforms.

📌 This guide is for no-code/low-code platforms — Lovable, Base44, Replit, Bolt.new, v0.dev, and similar tools.

Using an IDE like Cursor or Claude Code? See the IDE Guide →

Supported Platforms:

LovableBase44Bolt.newReplit Agentv0.devCreate.xyzVercel AI

⚡ Key Difference from IDE Workflow

With no-code platforms, you don't download files to your local machine. Instead, you paste your documents directly into the AI chat as context. The platform's AI reads your blueprints and generates the app within their environment.

Generate Your Documents in Archigen

Start by creating your project in Archigen and describing your app idea. Once generated, you'll have 5 comprehensive blueprint documents ready to use.

💡 Tip for No-Code Platforms

When describing your app to Archigen, mention that you'll be using a no-code platform. For example: "I'm building this with Lovable" or "This will be deployed on Replit." This helps tailor the technical specifications.

Copy the AI Starter Prompt

Instead of downloading files, use the "Copy AI Prompt" button in Archigen. This bundles all 5 documents into a single, formatted prompt optimized for AI platforms.

What the AI Prompt Includes:

Project Overview — App name, description, and goals

Design System — Colors, typography, component specs from DESIGN.md

Features & Requirements — User stories and acceptance criteria from PRD.md

Data Models — Database schema and relationships from SCHEMA.md

Implementation Order — Phase-by-phase tasks from PLAN.md

✓ Why Use the AI Prompt?

The bundled prompt is formatted specifically for AI chat interfaces. It provides all context in one message, making it easy for the AI to understand your complete project before generating any code.

Paste Into Your Platform

Open your preferred no-code platform and paste the AI prompt as your first message. Here's how it works on each platform:

LovableUsing Archigen with Lovable

1. Go to lovable.dev and create a new project

2. In the chat, paste your Archigen AI prompt as the first message

3. Add this instruction at the end:

"Please build this app following the specifications above. Start with the foundation (Phase 0), then implement core features. Use the exact design system colors and components specified."

4. Lovable will generate a complete app preview. Iterate by asking for changes.

Tip: Lovable works best with clear, specific requests. After the initial generation, ask for individual features: "Now add the user authentication from Phase 1"

Base44Using Archigen with Base44

1. Go to base44.com and start a new project

2. Paste your Archigen AI prompt in the project description or initial chat

3. Base44 will analyze your requirements and suggest an app structure

4. Use the PLAN.md phases to guide your building order

Tip: Base44 excels at database-driven apps. Reference SCHEMA.md specifically when setting up your data models.

Bolt.newUsing Archigen with Bolt.new

1. Go to bolt.new

2. Paste your Archigen AI prompt directly into the prompt box

3. Bolt will generate a full-stack application with preview

4. Use the chat to refine: "Update the colors to match DESIGN.md exactly"

Tip: Bolt.new can handle large prompts well. Include the full AI prompt for best results, then iterate on specific features.

ReplitUsing Archigen with Replit Agent

1. Go to replit.com and create a new Repl with Agent

2. Start by telling the agent: "I have detailed specifications for an app I want to build."

3. Paste the Archigen AI prompt when asked for details

4. Replit Agent will create files and set up your environment automatically

Tip: Replit Agent can also download and use your docs as files. Download the ZIP and upload to your Repl for persistent reference.

v0.devUsing Archigen with v0.dev

1. Go to v0.dev

2. For v0, focus on pasting the DESIGN.md content specifically — v0 excels at UI generation

3. Request individual components: "Create a dashboard component following these design specs: [paste DESIGN.md excerpt]"

4. Export components and integrate into your project

Tip: v0 is best for UI components, not full apps. Use it to generate individual screens from DESIGN.md, then assemble in your main project.

Build Phase by Phase

Even with no-code platforms, follow the phased approach from PLAN.md. This ensures you build features in the right order with proper dependencies.

Suggested Prompts for Each Phase:

Phase 0 — Foundation

"Set up the basic app structure with navigation and layout. Use the design system colors from my specifications."

Phase 1 — Core Features

"Now implement user authentication and the main dashboard. Follow the user stories in my PRD."

Phase 2 — Data & Features

"Add the data models from my schema. Create forms for [specific feature] with validation."

Phase 3 — Integrations

"Connect [third-party service] as specified in my requirements. Handle the API integration."

Phase 4 — Polish

"Add loading states, error handling, and responsive design. Make sure all screens work on mobile."

Iterate and Refine

No-code platforms are iterative. Use your Archigen documents as a reference to ensure consistency as you build.

✓ Keep Referencing Your Docs

• "Make sure the button uses the primary color from my design system"
• "This form should match the validation rules in my schema"
• "Add the features listed in Phase 2 of my plan"
• "Follow the user flow described in my PRD"

⚡ Common Refinements

• "The colors don't match — use #1a1a2e for background"
• "Add the missing field [X] to this form"
• "The navigation should have these items: [list from DESIGN.md]"
• "This feature is missing the [X] from my requirements"

You're Ready to Build!

With your Archigen blueprints, you have everything needed to guide any no-code platform's AI. Your documents serve as:

Source of Truth

Consistent specs to reference

Building Roadmap

Phases to follow in order

Quality Checker

Verify AI output matches specs

💡 Pro Tips for No-Code Platforms

• Start small: Don't paste everything at once. Start with the overview, then add details as needed.

• Be specific: "Use the exact hex color #6366f1" works better than "use purple"

• Reference by name: "As specified in my DESIGN.md" or "According to my PRD"

• Iterate often: Build one feature, verify it matches specs, then move to the next

• Save your prompts: Keep a copy of working prompts for future reference

Reference

Learn more about Archigen's features and capabilities

How It Works

Archigen uses AI to transform your app idea into structured, comprehensive documentation that AI coding assistants can understand and implement.

Conversational Input

Describe your idea naturally. Our AI asks smart follow-up questions to understand platform, features, tech stack, and design preferences.

AI Generation

Our AI synthesizes your inputs into 5 comprehensive documents, each optimized for a specific aspect of development.

AI-Ready Output

Documents are formatted for AI coding tools. Copy directly into Claude Code, Cursor, or any AI assistant to start building.

Generated Documents

Archigen generates 5 markdown documents that cover every aspect of your project:

DESIGN.md

Visual design specifications, color palettes, typography, component hierarchy, and UI/UX guidelines.

Best used for: Understanding the look and feel, creating consistent UI components

PRD.md

Product Requirements Document with features, user stories, acceptance criteria, and prioritization.

Best used for: Understanding what to build, feature scope, and success criteria

SCHEMA.md

Database schema, data models, relationships, and API endpoint specifications.

Best used for: Setting up your database, defining types, building API routes

PLAN.md

Step-by-step implementation plan with tasks, dependencies, and suggested order of development.

Best used for: Breaking down work, understanding what to build first

RULES.md

Coding conventions, project structure, naming patterns, and AI assistant instructions.

Best used for: Configuring AI coding tools like Claude Code and Cursor

Chat Interface

The chat interface is designed to gather everything needed to generate comprehensive documentation.

What We Ask About

Platform (Web, Mobile, Desktop, API)
Core features and functionality
Target users and use cases
Tech stack preferences
Design style and aesthetics
Authentication requirements

Tips for Better Results

•Be specific about your core features
•Mention apps you want to be similar to
•Describe your target user persona
•Share any design preferences (dark mode, minimal, etc.)
•Include any technical constraints

Export & Integration

Get your blueprints into your development workflow in multiple ways:

Copy Individual Documents

Copy any document directly to your clipboard. Paste into your IDE, AI assistant, or project folder.

Download as ZIP

Export all 5 documents as a ZIP file. Includes optional .cursorrules and CLAUDE.md files for AI assistants.

AI Starter Prompt

Get a pre-formatted prompt with all your documents bundled together. Paste directly into Claude Code, Cursor, or Lovable to start building.

Share & Collaborate

Generate a public share link to let others view your blueprint. Great for team collaboration or getting feedback.

Tips & Best Practices

Start with MVP scope

Focus on core features first. You can always regenerate with additional features later. This keeps your initial blueprint focused and actionable.

Edit and iterate

After generation, you can edit any document directly in Archigen. Refine the schema, adjust the plan, or update design specifications as your vision evolves.

Use RULES.md with AI assistants

The RULES.md document is designed to configure AI coding assistants. Copy it to .cursorrules or CLAUDE.md in your project root for best results.

Follow the PLAN.md order

The implementation plan is sequenced for optimal development flow. Following it helps avoid dependency issues and ensures a smooth build process.

Ready to build your app?

Transform your idea into implementation-ready blueprints in minutes.