Skip to content

Navigation Menu

Sign in
Sign up

Command‐Reference

su edited this page Nov 18, 2025 · 2 revisions

Command Reference

Complete reference for all Vibe CLI commands.

Table of Contents

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

Core Workflow Commands

vibe init

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"

/vibe.spec <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)

vibe plan <name>

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

vibe tasks <name>

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

vibe run <task>

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"

vibe verify <name>

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

Analysis & Tools

vibe analyze

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:

Code Quality Analysis

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

Dependency Audit

vibe analyze --deps

Checks:

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

Architecture Analysis

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

vibe ui <description>

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

vibe diagram

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
 }
Loading

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
Loading

Utility Commands

vibe agents

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)

vibe skills

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

vibe help

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

Slash Commands

Use these commands directly in Claude Code:

Slash Command Equivalent CLI Description
/vibe.spec "feature" vibe spec "feature" Create specification
/vibe.plan "feature" vibe plan "feature" Generate plan
/vibe.tasks "feature" vibe tasks "feature" Generate tasks
/vibe.run "Task 1-1" vibe run "Task 1-1" Execute task
/vibe.verify "feature" vibe verify "feature" Verify implementation
/vibe.analyze vibe analyze Analyze project
/vibe.ui "description" vibe ui "description" Preview UI
/vibe.diagram --er vibe diagram --er Generate diagram

Advantages of Slash Commands:

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

Global Options

These options work with all commands:

Option Description Example
--verbose Verbose output vibe spec "feature" --verbose
--quiet Minimal output vibe run --phase 1 --quiet
--no-color Disable colors vibe analyze --no-color
--config <path> Custom config file vibe init --config custom.json
--help Show command help vibe run --help
--version Show version vibe --version

Exit Codes

Vibe uses standard exit codes:

Code Meaning Example Cause
0 Success Command completed successfully
1 General error Invalid arguments, file not found
2 MCP error MCP server not connected
3 Validation error Acceptance criteria not met
4 Network error API timeout, connection failed
130 User interrupt Ctrl+C pressed

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

Tips & Best Practices

1. Use --dry-run First

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

2. Generate Guides Separately

# 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"

3. Use Aliases

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'

4. Chain Commands

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

Next Steps:

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

Clone this wiki locally

AltStyle によって変換されたページ (->オリジナル) /