Complete reference for all Vibe CLI commands.

1. Core Workflow Commands
2. Analysis & Tools
3. Utility Commands
4. Slash Commands
5. Global Options
6. Exit Codes

Initialize Vibe in the current project.

Usage:

vibe init [options]

Options:

• --language <lang> - Set language (en/ko), default: en
• --agent <name> - Set default agent, default: auto-detect

What it does:

1. Creates .vibe/ directory structure
2. Creates default config.json
3. Optionally creates CLAUDE.md template
4. Registers MCP server if not already registered

Example:

# Initialize with Korean language
vibe init --language ko

# Initialize with specific default agent
vibe init --agent backend-python-expert

Output:

✅ Vibe initialized successfully

Created:
  .vibe/
  .vibe/config.json
  .vibe/specs/          # SPEC documents (EARS format)
  .vibe/features/       # BDD Feature files (Gherkin)
  .vibe/plans/          # Technical plans
  .vibe/tasks/          # Task breakdowns
  .vibe/guides/         # Implementation guides
  .vibe/reports/        # Verification reports

Next steps:
  1. Create CLAUDE.md to document your tech stack
  2. Run: vibe spec "your feature name"

⚠️ Claude Code Only - This is a slash command, not a terminal command.

Create a specification through natural conversation with Specification Agent.

Usage:

/vibe.spec "feature name"

How it works:

1. Auto-detects project type:

   • Existing project (vibe init): Analyzes source code (package.json, pyproject.toml, etc.)
   • New project (vibe init <name>): Suggests tech stack options

2. Natural conversation:

   • Ask one question at a time
   • Provides numbered choices for quick answers
   • "또는 직접 설명해주셔도 됩니다" for free-form answers

3. Required questions:

   • Tech Stack: Always confirms or suggests stack (2-3 options with pros/cons)
   • Design Reference: Always asks for UI/UX references (suggests 2-3 examples)

4. General questions (flexible order):

   • Why (목적), Who (사용자), What (기능 범위)
   • Constraints (제약사항), Acceptance (성공 기준)

Example:

# Interactive mode
vibe spec "push notification settings"

# Batch mode with pre-filled answers
vibe spec "user authentication" --file answers.json --batch

# Korean language
vibe spec "사용자 인증" --language ko

Output:

✅ SPEC created: .vibe/specs/push-notification-settings.md
✅ Feature file created: .vibe/features/push-notification-settings.feature

Summary:
- Priority: HIGH
- Timeline: 3 days (24 hours development)
- Tech Stack: FastAPI + Flutter + PostgreSQL
- Requirements: 6 (24 acceptance criteria)
- BDD Scenarios: 5 (Gherkin format)

Next step:
  vibe plan "push notification settings"

Output Files:

• .vibe/specs/push-notification-settings.md - SPEC document (EARS format)
• .vibe/features/push-notification-settings.feature - BDD Feature file (Gherkin)

Generate technical implementation plan from specification.

Usage:

vibe plan <feature-name> [options]

Arguments:

• <feature-name> - Name of existing SPEC (must match spec file)

Options:

• --agent <name> - Use specific planning agent, default: auto-detect
• --detail <level> - Detail level (minimal/standard/detailed), default: standard
• --cost-analysis - Include detailed cost breakdown
• --architecture - Include architecture diagrams (Mermaid)

What it generates:

1. Architecture Overview - System design and components
2. Database Schema - Tables, columns, indexes, migrations
3. API Design - Endpoints, request/response formats
4. Frontend Components - UI structure and state management
5. Cost Analysis - Infrastructure and operational costs
6. Timeline - Phase-based breakdown with estimates
7. Risk Assessment - Potential blockers and mitigation
8. Testing Strategy - Unit, integration, E2E tests

Example:

# Standard plan
vibe plan "push notification settings"

# Detailed plan with cost analysis
vibe plan "push notification settings" --detail detailed --cost-analysis

# Use specific agent
vibe plan "user authentication" --agent backend-python-expert

Output:

✅ Plan created: .vibe/plans/push-notification-settings.md

Summary:
- Phases: 3 (Backend → Frontend → Integration)
- Timeline: 28 hours (3.5 days)
- Cost: +$0.50/month (Redis + FCM)
- Stack Reuse: 100% (no new dependencies)
- Files to change: 12 files
- Testing: BDD (pytest-bdd) + Contract Testing (Pact)

Next step:
  vibe tasks "push notification settings"

Output File: .vibe/plans/push-notification-settings.md

Decompose feature into phase-based, executable tasks.

Usage:

vibe tasks <feature-name> [options]

Arguments:

• <feature-name> - Name of existing plan (must match plan file)

Options:

• --phases <number> - Number of phases, default: 3
• --granularity <level> - Task size (small/medium/large), default: medium
• --estimate - Include time estimates per task
• --dependencies - Generate dependency graph (Mermaid)

What it generates:

• Phase-based task breakdown
• Each task includes:
  • Description (one sentence)
  • Implementation steps (3-5 concrete actions)
  • Acceptance criteria (testable)
  • Dependencies (if any)
  • Time estimate
  • Files to change

Example:

# Standard task breakdown
vibe tasks "push notification settings"

# Detailed with dependency graph
vibe tasks "push notification settings" --estimate --dependencies

# Custom phases
vibe tasks "user authentication" --phases 4

Output:

✅ Tasks created: .vibe/tasks/push-notification-settings.md

Task Breakdown:
- Total: 23 tasks
- Phase 1 (Backend): 9 tasks (9 hours, includes Contract Provider)
- Phase 2 (Frontend): 9 tasks (9 hours, includes Contract Consumer)
- Phase 3 (Integration): 5 tasks (6 hours, includes BDD Steps + Contract Verification)

Dependency Analysis:
- 15 tasks can run sequentially
- 8 tasks can run in parallel
- Critical path: 18 hours

Testing:
- BDD Step Definitions for all scenarios
- Contract Tests (Provider + Consumer)
- Contract Verification

Next step:
  vibe run "Task 1-1"
  or: vibe run --phase 1

Output File: .vibe/tasks/push-notification-settings.md

Execute a specific task or phase with AI assistance.

Usage:

vibe run <task-id> [options]
vibe run --phase <number> [options]
vibe run --all [options]

Arguments:

• <task-id> - Task identifier (e.g., "Task 1-1")

Options:

• --phase <number> - Execute all tasks in phase N
• --all - Execute all tasks sequentially
• --agent <name> - Use specific agent, default: auto-detect
• --guide-only - Generate guide without executing
• --skip-verify - Skip acceptance criteria verification
• --dry-run - Show what would be done without executing

What it does:

1. Reads task from .vibe/tasks/feature-name.md
2. Selects appropriate AI agent
3. Generates implementation guide (.vibe/guides/task-id.md)
4. Executes implementation steps
5. Verifies acceptance criteria
6. Updates task status (⬜ → ✅)

Example:

# Run single task
vibe run "Task 1-1"

# Run entire phase
vibe run --phase 1

# Run all tasks (not recommended)
vibe run --all

# Generate guide only
vibe run "Task 2-3" --guide-only

# Dry run
vibe run --phase 2 --dry-run

Output:

🔄 Executing: Task 1-1 - Database Migration

Agent: Backend Python Expert
Guide: .vibe/guides/task-1-1.md

Steps:
  ✅ 1. Create Alembic migration file
  ✅ 2. Add 6 boolean columns for categories
  ✅ 3. Set default values
  ✅ 4. Add foreign key to users table

Verification:
  ✅ Migration file created
  ✅ All 6 columns present
  ✅ Defaults match SPEC
  ✅ Foreign key constraint added

Files changed:
  + backend/alembic/versions/xxx_add_notification_settings.py

✅ Task 1-1 completed (1.2 hours)

Next task: Task 1-2 (Settings Repository)
Run: vibe run "Task 1-2"

Verify implementation against original specification.

Usage:

vibe verify <feature-name> [options]

Arguments:

• <feature-name> - Name of feature to verify

Options:

• --report <format> - Report format (markdown/json/html), default: markdown
• --fix - Suggest fixes for failed criteria
• --coverage - Include test coverage analysis

What it checks:

1. All requirements implemented
2. All acceptance criteria met
3. Code quality standards (via MCP tools)
4. Test coverage (if --coverage specified)

Example:

# Standard verification
vibe verify "push notification settings"

# With fix suggestions
vibe verify "push notification settings" --fix

# With coverage analysis
vibe verify "user authentication" --coverage

Output:

📊 Verification Report: push-notification-settings

BDD Scenarios: 5/5 passed ✅
✅ Scenario 1: Enable notification category
✅ Scenario 2: Disable notification category
✅ Scenario 3: Save settings
✅ Scenario 4: Load default settings
✅ Scenario 5: Verify response time

Contract Tests: 2/2 passed ✅
✅ Provider Contract: Backend API schema validated
✅ Consumer Contract: Frontend expectations met

Requirements:
✅ REQ-001: Notification Category Toggles (3/3 criteria)
✅ REQ-002: Default Settings (6/6 criteria)
✅ REQ-003: Update API (4/4 criteria)
⚠️ REQ-004: Performance Target (2/3 criteria)
  ❌ P95 latency: 620ms (target: <500ms)
  ✅ Rate limiting: 100 req/min
  ✅ Audit logging enabled

Overall: 85% complete (15/17 criteria)

Code Quality: 88/100 (B+)
- Complexity: Good (avg CC: 4.2)
- Coverage: 92%
- Security: All checks passed

Recommendations:
1. Add Redis caching to reduce latency
2. Optimize database query in get_settings()

Report saved: .vibe/reports/verification-2025-11-17.md

Next steps:
  vibe run "Task 1-6" (Redis caching)
  vibe analyze --code

Output File: .vibe/reports/verification-YYYY-MM-DD.md

Comprehensive project analysis using MCP tools.

Usage:

vibe analyze [options]

Options:

• --code - Code quality and complexity analysis
• --deps - Dependency and security audit
• --arch - Architecture and coupling analysis
• --all - Run all analyses (default if no option specified)
• --format <type> - Output format (markdown/json), default: markdown
• --output <path> - Save report to file

Sub-analyses:

vibe analyze --code

Checks:

• Cyclomatic complexity (target: ≤10)
• Cognitive complexity (target: ≤15)
• Function length (target: ≤20 lines)
• Nesting depth (target: ≤3 levels)
• Code duplication
• Type hint coverage (Python)
• Documentation coverage

vibe analyze --deps

Checks:

• Outdated packages
• Security vulnerabilities (CVE)
• License compatibility
• Unused dependencies
• Circular dependencies

vibe analyze --arch

Checks:

• Module coupling (target: <0.5)
• Module cohesion (target: >0.7)
• Circular dependencies
• Layer violations
• Dependency graph

Example:

# All analyses
vibe analyze

# Code quality only
vibe analyze --code

# Architecture with JSON output
vibe analyze --arch --format json --output report.json

Output:

📊 Project Analysis Report

Overall Score: 85/100 (B+)

Code Quality: 88/100
  ✅ Complexity: Good (avg CC: 4.2)
  ⚠️ High complexity: src/service.py (CC: 15)
  ✅ Function length: Good (avg: 12 lines)
  ⚠️ Low cohesion: src/utils.py (0.3)

Dependencies: 92/100
  ✅ No security vulnerabilities
  ⚠️ 3 outdated packages
  ✅ No circular dependencies

Architecture: 78/100
  ⚠️ Strong coupling: Controller ↔ Service (0.8)
  ✅ Clear layering
  ⚠️ One circular dependency detected

Recommendations:
1. Refactor src/service.py into 3 modules
2. Update outdated packages (fastapi, pydantic, sqlalchemy)
3. Apply Dependency Injection pattern
4. Extract unrelated utilities from src/utils.py

Report saved: .vibe/reports/analysis-2025-11-17.md

Generate ASCII UI mockup from text description.

Usage:

vibe ui <description> [options]

Arguments:

• <description> - Text description of UI (quoted)

Options:

• --width <number> - Canvas width in characters, default: 80
• --components - List required components
• --interactive - Show interactive elements
• --save <path> - Save to file

Example:

# Simple login form
vibe ui "login form with email, password, and submit button"

# Notification settings with toggles
vibe ui "notification settings screen with 6 category toggles"

# Custom width with components
vibe ui "dashboard with sidebar and chart" --width 120 --components

Output:

┌─────────────────────────────────────────┐
│      Notification Settings              │
├─────────────────────────────────────────┤
│                                          │
│  Likes                    [●────] ON    │
│  Comments                 [●────] ON    │
│  Follows                  [●────] ON    │
│  Mentions                 [●────] ON    │
│  Feed updates             [────○] OFF   │
│  Marketing                [────○] OFF   │
│                                          │
│         ┌─────────────────────┐          │
│         │    Save Changes     │          │
│         └─────────────────────┘          │
└─────────────────────────────────────────┘

Required Components:
- Header.tsx (Title: "Notification Settings")
- ToggleSwitch.tsx (6 instances with labels)
- Button.tsx (Primary: "Save Changes")
- SettingsScreen.tsx (Container with state management)

State Management:
- useState for each toggle (6 boolean states)
- handleToggle(category: string) callback
- handleSave() API call on button click

Generate architecture diagrams in Mermaid format.

Usage:

vibe diagram [options]

Options:

• --er - Entity-Relationship diagram
• --flow - Flowchart
• --sequence - Sequence diagram
• --arch - Architecture diagram (default)
• --feature <name> - Diagram for specific feature
• --output <path> - Save to file

Example:

# Architecture diagram
vibe diagram

# ER diagram
vibe diagram --er

# Flowchart for specific feature
vibe diagram --flow --feature "user authentication"

# Save to file
vibe diagram --er --output docs/database.mmd

Output (ER Diagram):

erDiagram
    users ||--o{ user_notification_settings : has
    users {
        uuid id PK
        string email
        datetime created_at
    }
    user_notification_settings {
        uuid id PK
        uuid user_id FK
        boolean likes
        boolean comments
        boolean follows
        boolean mentions
        boolean feed_updates
        boolean marketing
        datetime updated_at
    }

Output (Architecture Diagram):

graph TB
    Client[Flutter App]
    API[FastAPI Server]
    DB[(PostgreSQL)]
    Cache[(Redis)]
    FCM[Firebase Cloud Messaging]

    Client -->|HTTPS| API
    API -->|SQL| DB
    API -->|Cache| Cache
    API -->|Push| FCM
    FCM -->|Notification| Client

List available AI agents and their specializations.

Usage:

vibe agents [options]

Options:

• --detail - Show detailed agent capabilities
• --current - Show currently active agent

Example:

# List all agents
vibe agents

# Detailed view
vibe agents --detail

Output:

Available AI Agents:

1. Specification Agent
   Specialization: Requirements gathering
   Tech Stack: Language-agnostic
   Use: vibe spec

2. Planning Agent
   Specialization: Technical architecture
   Tech Stack: Cross-stack
   Use: vibe plan

3. Backend Python Expert
   Specialization: Python/FastAPI implementation
   Tech Stack: Python 3.11+, FastAPI, SQLAlchemy
   Use: Backend tasks

4. Frontend Flutter Expert
   Specialization: Flutter/Dart implementation
   Tech Stack: Flutter 3.24+, Dart 3.5+
   Use: Frontend tasks

5. Quality Reviewer
   Specialization: Code review
   Tech Stack: Multi-language
   Use: vibe verify

Current Agent: backend-python-expert
(Set in .vibe/config.json)

List installed skill modules.

Usage:

vibe skills [options]

Options:

• --category <name> - Filter by category
• --search <term> - Search skills by keyword

Example:

# List all skills
vibe skills

# Language skills only
vibe skills --category languages

# Search for Python skills
vibe skills --search python

Output:

Installed Skills:

Core:
  - communication-guide.md
  - development-philosophy.md
  - quick-start.md

Languages:
  - python-fastapi.md
  - typescript-react.md
  - typescript-nextjs.md
  - dart-flutter.md

Quality:
  - testing-strategy.md
  - checklist.md

Standards:
  - code-structure.md
  - naming-conventions.md
  - complexity-metrics.md
  - anti-patterns.md

Total: 13 skills

Show command help.

Usage:

vibe help [command]

Arguments:

• [command] - Show help for specific command (optional)

Example:

# General help
vibe help

# Help for specific command
vibe help spec
vibe help run

Use these commands directly in Claude Code:

Advantages of Slash Commands:

• No terminal switching
• Inline results in chat
• Access to 38 MCP tools
• Memory preservation across sessions

These options work with all commands:

Vibe uses standard exit codes:

Usage in scripts:

#!/bin/bash
vibe run --phase 1
if [ $? -eq 0 ]; then
    echo "Phase 1 completed successfully"
    vibe run --phase 2
else
    echo "Phase 1 failed"
    exit 1
fi

# See what would be done
vibe run --phase 2 --dry-run

# Then execute
vibe run --phase 2

# Generate implementation guides without executing
vibe run "Task 1-1" --guide-only
vibe run "Task 1-2" --guide-only
vibe run "Task 1-3" --guide-only

# Review guides, then execute
vibe run "Task 1-1"

Add to your ~/.bashrc or ~/.zshrc:

alias vs='vibe spec'
alias vp='vibe plan'
alias vt='vibe tasks'
alias vr='vibe run'
alias vv='vibe verify'
alias va='vibe analyze'

# Full workflow in one line
vibe spec "feature" && \
vibe plan "feature" && \
vibe tasks "feature" && \
vibe run --phase 1

Next Steps:

• MCP Integration - Explore 38 development tools
• Agents Guide - Master specialized agents
• Examples - See commands in action

← Back to Core Concepts | Home | Next: MCP Integration →