vibe-agents

Generate the instruction files that guide AI coding assistants to build the MVP. Use progressive disclosure - master plan in AGENTS.md, details in agent_docs/.

1. Look for docs/PRD-*.md - REQUIRED
2. Look for docs/TechDesign-*.md - REQUIRED
3. If either is missing, suggest running the appropriate skill first

Extract from documents:

From PRD:

• Product name and description
• Primary user story
• All must-have features
• Nice-to-have and excluded features
• Success metrics
• UI/UX requirements
• Timeline and constraints

From Tech Design:

• Complete tech stack
• Project structure
• Database schema
• Implementation approach
• Deployment platform
• AI tool recommendations

Ask the user:

> Which AI tools will you use? (Select all that apply)

> 1. Claude Code (terminal-based)

> 2. Gemini CLI (free terminal agent)

> 3. Google Antigravity (agent-first IDE)

> 4. Cursor (AI-powered IDE)

> 5. VS Code + GitHub Copilot

> 6. Lovable / v0 (no-code)

Then ask:

> What's your technical level?

> - A) Vibe-coder

> - B) Developer

> - C) In-between

Create the following structure:

```

project/

├── AGENTS.md # Master plan

├── agent_docs/

│ ├── tech_stack.md # Tech details

│ ├── code_patterns.md # Code style

│ ├── project_brief.md # Persistent rules

│ ├── product_requirements.md # PRD summary

│ └── testing.md # Test strategy

├── CLAUDE.md # If Claude Code selected

├── GEMINI.md # If Gemini/Antigravity selected

├── .cursorrules # If Cursor selected

└── .github/copilot-instructions.md # If Copilot selected

```

```markdown

# AGENTS.md - Master Plan for [App Name]

App: [Name]

Goal: [One-liner]

Stack: [Tech stack]

Current Phase: Phase 1 - Foundation

1. Understand Intent First: Identify what the user actually needs
2. Ask If Unsure: If critical info is missing, ask before proceeding
3. Plan Before Coding: Propose a plan, get approval, then implement
4. Verify After Changes: Run tests/checks after each change
5. Explain Trade-offs: When recommending, mention alternatives

1. Plan: Outline approach, ask for approval
2. Execute: One feature at a time
3. Verify: Run tests/checks, fix before moving on

Load only when needed:

• agent_docs/tech_stack.md - Tech details
• agent_docs/code_patterns.md - Code style
• agent_docs/project_brief.md - Project rules
• agent_docs/product_requirements.md - Requirements
• agent_docs/testing.md - Test strategy

Last Updated: [Date]

Working On: [Task]

Recently Completed: None yet

Blocked By: None

Phase 1: Foundation

• [ ] Initialize project
• [ ] Setup database
• [ ] Configure auth

Phase 2: Core Features

• [ ] [Feature 1 from PRD]
• [ ] [Feature 2 from PRD]
• [ ] [Feature 3 from PRD]

Phase 3: Polish

• [ ] Error handling
• [ ] Mobile responsiveness
• [ ] Performance optimization

Phase 4: Launch

• [ ] Deploy to production
• [ ] Setup monitoring
• [ ] Launch checklist

• Do NOT delete files without confirmation
• Do NOT modify database schemas without backup plan
• Do NOT add features not in current phase
• Do NOT skip tests for "simple" changes
• Do NOT use deprecated libraries

```

CLAUDE.md (Claude Code)

```markdown

# CLAUDE.md - Claude Code Configuration

App: [Name]

Stack: [Stack]

Stage: MVP Development

1. Master Plan: Read AGENTS.md first for current phase and tasks
2. Documentation: Refer to agent_docs/ for details
3. Plan-First: Propose plan, wait for approval
4. Incremental: One feature at a time, test frequently
5. Concise: Be brief, ask clarifying questions when needed

• npm run dev - Start server
• npm test - Run tests
• npm run lint - Check code style

```

.cursorrules (Cursor)

```markdown

# Cursor Rules for [App Name]

App: [Name]

Stack: [Stack]

Stage: MVP Development

1. Read AGENTS.md first
2. Refer to agent_docs/ for details
3. Plan before coding
4. Build incrementally
5. Test frequently

• npm run dev - Start server
• npm test - Run tests

```

GEMINI.md (Gemini CLI / Antigravity)

```markdown

# GEMINI.md - Gemini Configuration

App: [Name]

Stack: [Stack]

1. Read AGENTS.md first
2. Use agent_docs/ for details
3. Plan, then execute
4. Build incrementally

```

Generate each file with content from PRD and Tech Design:

• tech_stack.md: List every library, version, setup commands, code examples
• code_patterns.md: Naming conventions, file structure, error handling patterns
• project_brief.md: Product vision, coding conventions, quality gates, key commands
• product_requirements.md: Core requirements, user stories, success metrics
• testing.md: Test strategy, tools, verification loop, pre-commit hooks

Write all files to the project, then tell the user:

> Files Created:

> - AGENTS.md - Master plan

> - agent_docs/ - Detailed documentation

> - [Tool-specific configs based on selection]

>

> Project Structure:

> ```

> your-app/

> ├── docs/

> │ ├── research-[App].txt

> │ ├── PRD-[App]-MVP.md

> │ └── TechDesign-[App]-MVP.md

> ├── AGENTS.md

> ├── agent_docs/

> │ ├── tech_stack.md

> │ ├── code_patterns.md

> │ ├── project_brief.md

> │ ├── product_requirements.md

> │ └── testing.md

> └── [tool configs]

> ```

>

> Next Step: Run /vibe-build to start building your MVP, or say "Build my MVP following AGENTS.md"