# Vibe Kanban - Deep Dive

> **TL;DR**: Vibe Kanban is a visual kanban board that lets you orchestrate multiple AI coding agents (Claude Code, Gemini CLI, Codex, etc.) working in parallel. Each task runs in its own git worktree so agents never conflict. You become the conductor, not the coder.

---

## The Paradigm Shift

The Bloop AI team behind Vibe Kanban makes a bold claim:

> "Over 50% of our code is now written by coding agents."

This changes everything about what developers do:

| Before AI Agents | After AI Agents |
|------------------|-----------------|
| Write code | Plan what to build |
| Debug code | Review AI's code |
| Refactor code | Orchestrate multiple agents |
| **Bottleneck**: Speed of typing | **Bottleneck**: Speed of reviewing |

Vibe Kanban is built for this new reality: **"Agent-driven, human-orchestrated"** development.

---

## What Problem Does It Solve?

If you're using Claude Code or similar tools, you've hit these walls:

### Problem 1: One Agent at a Time
You're chatting with Claude Code, working on feature A. But feature B is independent and could be done simultaneously. Too bad - you're stuck waiting.

### Problem 2: Context Switching Nightmare
You switch to a different task, but now you need to re-explain everything to the AI. Or you have multiple terminal windows and lose track of what's happening where.

### Problem 3: Merge Hell
Two AI agents worked on different features. Now you need to merge them. Conflicts everywhere. Which changes are right?

### Problem 4: No Visibility
Your teammate asks "what's the AI working on?" You have no idea. It's all happening in your local terminal.

**Vibe Kanban's solution**: A visual dashboard that manages all your AI agents, each working in isolated git worktrees, with built-in review and merge tools.

---

## How It Works: The Big Picture

```
┌─────────────────────────────────────────────────────────────────────┐
│                     VIBE KANBAN INTERFACE                           │
├────────────────────────────┬────────────────────────────────────────┤
│                            │                                        │
│   📋 KANBAN BOARD          │   💬 AGENT TERMINAL                    │
│                            │                                        │
│  ┌─────────┐ ┌─────────┐   │   Currently working with:              │
│  │ To Do   │ │In Progress│  │   [Claude Code ▼]                      │
│  ├─────────┤ ├─────────┤   │                                        │
│  │ Task 4  │ │ Task 1  │   │   > Implementing user auth...          │
│  │ Task 5  │ │ Task 2  │   │   > Created login component            │
│  │         │ │ Task 3  │   │   > Adding JWT validation...           │
│  └─────────┘ └─────────┘   │                                        │
│                            │                                        │
│  ┌─────────┐ ┌─────────┐   │   [Send Message]                       │
│  │In Review│ │  Done   │   │                                        │
│  ├─────────┤ ├─────────┤   │                                        │
│  │         │ │ Task 0  │   │                                        │
│  └─────────┘ └─────────┘   │                                        │
│                            │                                        │
└────────────────────────────┴────────────────────────────────────────┘
```

**Left side**: Kanban board showing all tasks across states
**Right side**: Direct interaction with the AI agent

---

## The Git Worktree Magic

This is Vibe Kanban's secret weapon. When you start a task:

```
Your Repository
     │
     ├── main branch (your working code)
     │
     ├── .worktrees/
     │   ├── task-1/ ← Agent 1 works here (isolated)
     │   ├── task-2/ ← Agent 2 works here (isolated)
     │   └── task-3/ ← Agent 3 works here (isolated)
     │
     └── (agents can NEVER touch main or each other)
```

**Benefits**:
- Agents can't interfere with each other
- Agents can't break your main branch
- Multiple agents work truly in parallel
- Clean history - each task is its own branch
- Easy to discard failed attempts

---

## Supported AI Agents

Vibe Kanban is agent-agnostic. It works with:

| Agent | Description |
|-------|-------------|
| **Claude Code** | Anthropic's coding assistant |
| **Gemini CLI** | Google's coding agent |
| **OpenAI Codex** | OpenAI's code generation |
| **Cursor CLI** | Cursor's command-line agent |
| **Amp** | Sourcegraph's coding agent |
| **Qwen Code** | Alibaba's coding model |
| **Opencode** | Open-source alternative |
| **GitHub Copilot** | Microsoft's coding assistant |

You can switch between agents without changing your workflow. Same kanban board, same task management, different AI under the hood.

---

## Key Features Explained

### 1. Parallel Execution

Run multiple tasks simultaneously:

```
┌──────────────────────────────────────────────────────────────┐
│                   PARALLEL EXECUTION                          │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│  Task 1: "Add user auth"     ──→  Claude Code (worktree-1)  │
│  Task 2: "Create dashboard"  ──→  Gemini CLI (worktree-2)   │
│  Task 3: "Write API tests"   ──→  Codex (worktree-3)        │
│                                                              │
│  All running simultaneously, no conflicts!                   │
│                                                              │
└──────────────────────────────────────────────────────────────┘
```

### 2. Task States & Flow

Standard kanban columns with AI-specific additions:

| State | Meaning |
|-------|---------|
| **To Do** | Tasks waiting to be started |
| **In Progress** | Agent actively working |
| **In Review** | Ready for human review |
| **Rebase Needed** | Base branch advanced, needs update |
| **Rebase Conflicts** | Conflicts detected during rebase |
| **Done** | Merged and complete |

### 3. Built-in Code Review

When an agent finishes, you don't just blindly merge. Vibe Kanban provides:

- **Diff viewer**: See exactly what changed
- **File-by-file review**: Inspect each modification
- **Edit capability**: Fix issues before merging
- **One-click merge**: When satisfied, merge to main

This is like having a built-in PR review for every AI task.

### 4. Conflict Resolution

When your main branch advances while agents work:

```
Scenario:
- Agent working on Task 1 (branched from main@commit-A)
- Meanwhile, Task 0 merged to main (now main@commit-B)
- Task 1 needs to rebase

Vibe Kanban offers:
1. Click "Rebase" button
2. If conflicts → "Insert Resolve-Conflicts Instructions"
3. Agent automatically resolves conflicts
4. Review and merge
```

You can also abort and start fresh if needed.

### 5. MCP Integration

Vibe Kanban works with Model Context Protocol (MCP) in two ways:

**Connect MCP servers TO your agents**:
```json
{
  "mcpServers": {
    "database": { "command": "..." },
    "api": { "command": "..." }
  }
}
```

**Vibe Kanban AS an MCP server**:
```json
{
  "mcpServers": {
    "vibe_kanban": {
      "command": "npx",
      "args": ["-y", "vibe-kanban@latest", "--mcp"]
    }
  }
}
```

This lets you create tasks from Claude Desktop or other MCP clients!

### 6. Remote SSH Support

Running Vibe Kanban on a server? Configure it to open projects in your local VS Code via SSH:

- "Open in VS Code" generates SSH URLs
- Works with cloud hosting, Docker, systemctl
- Edit remotely, review locally

---

## Installation

**One-liner** (requires npm):
```bash
npx vibe-kanban
```

**That's it.** No complex setup. Opens a web dashboard at `localhost:5173`.

### Prerequisites

- Node.js ≥18
- At least one coding agent authenticated (Claude Code, Gemini CLI, etc.)
- Git (for worktree features)

### For Development

```bash
git clone https://github.com/BloopAI/vibe-kanban
cd vibe-kanban
pnpm install
pnpm run dev
```

---

## The Bloop AI Story

Vibe Kanban comes from **Bloop AI**, a Y Combinator company with an interesting history:

### Original Product: Semantic Code Search

Before Vibe Kanban, Bloop built a **semantic code search engine**:

- Find code by meaning, not just keywords
- "What library handles payments?" → finds Stripe/PayPal code
- Built with Rust, Tauri, Tantivy, and Qdrant
- Privacy-focused: runs locally on your machine

### The Evolution

As AI coding agents matured, Bloop's founders noticed their own workflow changing:

> "We now spend more time planning, reviewing, and orchestrating AI agents than writing code ourselves."

Vibe Kanban was born from this realization. The same team that built semantic code understanding now builds AI agent orchestration.

### Tech Stack

| Component | Technology |
|-----------|------------|
| Backend | Rust |
| Frontend | TypeScript/React |
| Database | PostgreSQL + SQLx |
| Package Manager | pnpm workspaces |

---

## Vibe Kanban vs. CCPM

Since we already documented CCPM, here's how they compare:

| Aspect | CCPM | Vibe Kanban |
|--------|------|-------------|
| **Primary Focus** | Spec-driven development | Visual task orchestration |
| **Interface** | Slash commands in terminal | Web-based kanban board |
| **Task Source** | PRDs → Epics → Tasks → Issues | Direct task creation |
| **Persistence** | GitHub Issues | Local database + Git |
| **Agent Support** | Claude Code only | 8+ agents (Claude, Gemini, Codex...) |
| **Parallelization** | Git worktrees | Git worktrees |
| **Philosophy** | "No vibe coding" - everything traced to specs | Visual orchestration first |
| **Best For** | Teams needing traceability | Developers wanting visual control |

**They're complementary, not competing**:
- Use CCPM's PRD workflow to plan features
- Use Vibe Kanban's board to orchestrate execution
- Both use git worktrees for parallel work

---

## How Vibe Kanban Can Help Us Achieve Our Goals

Looking at our "Software Development in the Age of AI" repository, Vibe Kanban aligns with our mission in several ways:

### 1. **Practical Tool for Our Playbooks**

We have playbooks for implementing features. Vibe Kanban is the *execution layer*:

| Our Playbook | Vibe Kanban Addition |
|--------------|---------------------|
| "Implementing new feature" | Create task, assign agent, track progress |
| "Bug fixing workflow" | Parallel bug investigation across agents |
| "Code review process" | Built-in diff viewer for AI-generated code |

### 2. **Multi-Agent Documentation Opportunity**

Our `model-nuances/` directory documents individual AI behaviors. With Vibe Kanban, we can document:
- Which agents work best for which task types
- How to combine agents effectively
- Agent-specific gotchas in parallel execution

### 3. **Extends Our Automation Philosophy**

We already sync `.claude/` automation to projects. Vibe Kanban adds:
- Visual layer on top of command-line workflows
- Cross-agent orchestration (not just Claude)
- Built-in review process

### 4. **"Tips and Tricks" Goldmine**

Our tips directory could expand with:
- Parallel task decomposition strategies
- When to use sequential vs. parallel execution
- Conflict resolution best practices
- Agent selection guidelines

### 5. **Complements CCPM**

We documented CCPM for spec-driven workflows. Vibe Kanban offers:
- Visual alternative for developers who prefer GUIs
- Multi-agent support (CCPM is Claude-only)
- Quick task creation without PRD overhead

Together they cover the full spectrum from "rigorous spec-driven" to "visual quick orchestration."

### 6. **Real-World Validation**

Vibe Kanban has:
- 10,000+ GitHub stars
- 33 contributors
- Active development

This proves the "orchestrate AI agents" pattern works. Our repo should help people use these tools effectively.

---

## Quick Reference: Common Workflows

### Starting a New Task

1. Open Vibe Kanban dashboard
2. Click "New Task"
3. Describe what you want built
4. Select agent (Claude Code, Gemini, etc.)
5. Click "Start" → Agent works in isolated worktree

### Running Tasks in Parallel

1. Create multiple tasks
2. Start each with different (or same) agents
3. Monitor progress on kanban board
4. Review each when done
5. Merge in any order

### Handling Conflicts

1. Task shows "Rebase Needed"
2. Click "Rebase"
3. If conflicts: Click "Insert Resolve-Conflicts Instructions"
4. Agent resolves automatically
5. Review resolution
6. Merge

### Switching Agents Mid-Task

1. Pause current agent
2. Select different agent from dropdown
3. Continue with new agent
4. (Context may need re-establishing)

---

## Key Links

| Resource | URL |
|----------|-----|
| GitHub Repository | https://github.com/BloopAI/vibe-kanban |
| Official Website | https://www.vibekanban.com/ |
| Documentation | https://www.vibekanban.com/docs |
| Bloop AI (Parent Company) | https://bloop.ai/ |
| Y Combinator Profile | https://www.ycombinator.com/companies/bloop |

---

## Quick Stats

- **License**: Apache 2.0 (fully open source)
- **GitHub Stars**: 10,100+
- **Forks**: 920+
- **Contributors**: 33
- **Commits**: 1,239+
- **Tech Stack**: Rust + TypeScript/React + PostgreSQL

---

## Bottom Line

Vibe Kanban represents a fundamental shift in how we think about development:

**Old model**: Developer writes code, AI assists
**New model**: AI writes code, developer orchestrates

If you're already using AI coding agents and want to:
- Run multiple agents simultaneously
- Keep tasks visually organized
- Review AI code before merging
- Switch between different agents easily
- Never have agents conflict with each other

...then Vibe Kanban is built exactly for you.

The fact that Bloop AI (a YC company focused on code intelligence) built this tells you where the industry is heading. The developers who master **orchestration** will outpace those still typing every line themselves.

---

*Document created: December 2025*
*Sources: [GitHub - BloopAI/vibe-kanban](https://github.com/BloopAI/vibe-kanban), [vibekanban.com](https://www.vibekanban.com/), [Y Combinator - Bloop](https://www.ycombinator.com/companies/bloop)*
