Vibe Ensemble - Your Personal Development Team

Coding agents are becoming an everyday tool for developers. But they come with inherent limitations, and the main ones are context drift and focus dilution.

The issue is directly related to the context window - how much context the model can safely keep active. As soon as incoming information overflows the context window, the model starts behaving as if it went through unsuccessful brain surgery. Everyone working with the LLMs is well aware of this issue and trying to find some solutions or workarounds. For example, Claude Code tracks the context size and automatically performs context compaction. Unfortunately, compaction is not a lossless procedure, and often important information, especially not very often mentioned but necessary rules or guidance, gets washed out.

Let’s take a look at where additional context comes from when a coding agent works on some larger task.

We start from the high-level context: planning, providing important details, rules, patterns, requirements, etc., etc. But then the coding agent starts working on tasks one by one. Each task contains numerous lower-level details, which also add to context. This causes context drift towards minor details. This also causes focus dilution: instead of focusing on high-level aspects, the coding agent focuses on the actual task at hand, and high-level rules are no longer actual and important. Context compaction somewhat helps, but with each new task, context drift and focus dilution get more and more obvious.

Vibe Ensemble is my attempt to address this issue. Instead of trying to fit everything into the context window, it prevents low-level details from coming into the context window in the first place. This is done by implementing “team mode”: there is a coordinator - a user-facing Claude Code instance, which performs high-level tasks like planning or coordination. It does not do individual tasks, though. Instead, it configures workers - headless coding agents (also Claude Code), which handle individual tasks. Each task is split into stages. The system maintains specialized workers for each stage. The worker handles only one stage, starts with a fresh context, and exits when the stage is finished. No low-level detail ever leaks into coordinator context. And this enables management of several projects using the single coordinator.

How Vibe-Ensemble Works

The Big Picture

When you describe a project to Vibe-Ensemble, here’s what happens behind the scenes:

1. You describe your project → Coordinator breaks it into major pieces (epics/stories).
2. Planning worker creates detailed tickets → Each with a step-by-step pipeline.
3. Workers automatically execute the pipeline → Moving tickets from stage to stage
4. Progress is tracked and reported → Every step is documented with comments.

Think of it like an assembly line where each worker is a specialist who does their part and passes the work to the next specialist.

The Ticket System

What is a Ticket?

A ticket represents a specific piece of work that needs to be done. Examples:

• “Create user login page”
• “Set up database schema”
• “Write API documentation”
• “Deploy application to production”

What is a Pipeline?

Each ticket has a pipeline - a series of stages it goes through from start to finish:

Ticket: "User Login Page"

Pipeline: Planning → Design → Implementation → Review → Testing → Complete

Each stage is handled by a different type of worker with specific expertise.

The Workflow Process

Step 1: Project Breakdown

When you describe your project, the Coordinator works with a Planning Worker to:

• Break your project into major components (epics)
• Create specific work items (stories/tickets) for each component
• Design the pipeline each ticket will follow

Example:

Your request: "Build a todo app with user accounts"

Coordinator creates:

├── Epic: User Authentication

│ ├── Ticket: "User registration system"

│ └── Ticket: "Login/logout functionality"

├── Epic: Todo Management

│ ├── Ticket: "Todo CRUD operations"

│ └── Ticket: "Todo list UI"

└── Epic: Deployment

└── Ticket: "Production deployment setup"

Step 2: Pipeline Design

The Planning Worker designs a custom pipeline for each ticket based on its complexity:

Simple Ticket Pipeline:

Planning → Implementation → Review → Complete

Complex Ticket Pipeline:

Planning → Design → Implementation → Review → Testing → Documentation → Complete

Critical System Pipeline:

Planning → Research → Design → Implementation → Security Review → Testing → Deployment → Complete

Step 3: Automatic Execution

Once tickets and pipelines are created, Vibe-Ensemble automatically:

1. Spawns the right worker for each stage (planning worker, implementation worker, etc.)
2. Moves tickets through their pipeline as each stage completes
3. Handles handoffs between different types of workers
4. Tracks all progress with detailed comments

How Workers Collaborate

Worker Types and Responsibilities

Planning Worker:

• Analyzes requirements and breaks down complex tasks
• Creates detailed implementation plans
• Designs the pipeline for each ticket

Implementation Worker:

• Writes the actual code
• Follows the specifications from planning
• Documents what was implemented

Review Worker:

• Checks code quality and adherence to standards
• Identifies issues that need fixing
• Can send tickets back to implementation if problems are found

Testing Worker:

• Creates and runs tests
• Validates that everything works correctly
• Reports any bugs found

The Comment Trail

Every worker leaves detailed comments on tickets, creating a complete history:

Ticket: "User Login Page"

[Planning Worker]: "Analyzed requirements. Will implement using React components

with form validation and JWT authentication. Estimated 4 hours of work."[Implementation Worker]: "Created LoginForm component with email/password fields.

Added validation for email format. Integrated with authentication API.

Code is ready for review."[Review Worker]: "Code looks good overall. Minor suggestion: add loading state

during login. No blocking issues. Approved for testing."[Testing Worker]: "All tests passing. Verified login works with valid credentials,

shows errors for invalid ones and handles network failures gracefully. Ready for deployment."

Dependencies and Coordination

When Tickets Need Each Other

Sometimes one ticket can’t start until another is finished:

Ticket A: "Database Schema Setup" → Must finish first

Ticket B: "User API Endpoints" → Waits for Ticket A

Ticket C: "Frontend Login Form" → Waits for Ticket B

Vibe-Ensemble automatically:

• Holds tickets that are waiting for dependencies
• Releases tickets when their dependencies are complete
• Runs independent tickets in parallel to save time

Quality Gates

Workers can send tickets backward in the pipeline when issues are found:

Implementation → Review → ❌ Issues Found → Back to Implementation

Implementation → Review → ✅ Approved → Testing

This ensures quality while allowing for iterative improvement.

What You See as the User

Real-Time Monitoring

You can track progress using coordinator commands:

• /vibe-status - See overall project health and ticket progress
• /vibe-events - Handle any issues or worker requests for guidance
• /vibe-poll - Continuously monitor until all work is complete

Transparent Process

You can see:

• Which tickets are in which stages
• What each worker accomplished
• Any blockers or issues that need attention
• Estimated completion times

Minimal Intervention Required

Most of the time, the system runs automatically. You only need to:

• Provide initial project requirements
• Answer clarifying questions from workers
• Approve major decisions when requested
• Monitor progress and address any escalated issues

The Power of Specialization

Each worker type is optimized for their specific role:

• Planning workers excel at breaking down complex requirements
• Implementation workers focus on writing quality code efficiently
• Review workers catch issues and maintain standards
• Testing workers ensure everything works reliably

This specialization means each piece of work gets expert attention while maintaining coordination across the entire project.

How to Use Vibe Ensemble

For convenience, Vibe Ensemble uses a simple script-based installation procedure (for Windows, you can find instructions on the site):

curl -fsSL https://vibeensemble.dev/install.sh | sh

Ensure that you have ~/.local/bin in PATH, and then create the Vibe Ensemble working directory and change the working directory to it:

mkdir vibe-ensemble && cd vibe-ensemble

Now let’s start Vibe Ensemble

vibe-ensemble-mcp

Now we need to set up the coordinator working directory:

mkdir coordinator && cd coordinator

Convenient integration between Claude Code and Vibe Ensemble requires several configuration files. To simplify this task, there is a dedicated command for the generation of all these files. Let’s use it to configure the coordinator:

vibe-ensemble-mcp --configure-claude-code

Now we can start Claude Code.

claude

To configure Claude Code as coordinator, use the /vibe-ensemble slash command. Claude responds with something like that:

⏺ I'm now initialized as your vibe-ensemble coordinator! I'm ready to help you manage projects through intelligent task delegation and real-time monitoring.  

  Before we start, I need to understand your project scope to provide the right level of coordination:  

  What type of project are you working on?  
  - 🔧 Local-only development (simple scripts, personal tools, quick prototypes)  
  - 🚀 Startup-level (minimal DevOps, lean approach, rapid iteration)  
  - 🏢 Enterprise-grade (comprehensive testing, monitoring, documentation)  
  - 🎯 Something in between (let me know your specific needs)  

  Is this an existing project or something new?  
  - If existing: Please provide the project path so I can understand the structure  
  - If new: I'll help you set it up from scratch  

  Once I understand your scope, I'll break down your requests into focused tickets and coordinate specialized workers to handle all the technical implementation. I'll  
   monitor progress in real-time and ensure everything moves smoothly through the pipeline.  

  What would you like to work on?

From this point we can use traditional workflow: just type a prompt or perform detailed planning and then start execution - just like you did it before. The main difference is that the coordinator does not do tasks by itself (if it tries, stop it and refresh its memory: “You're the coordinator; delegate tasks”). To monitor the process and address ongoing issues, use the two following slash commands:

/vibe-events  
/vibe-status  
/vibe-poll

The /vibe-events handles events happening in the system. Some of them are just notifications (like tickets transitioning between stages). Some require coordinator attention. I hope to eventually make this done automatically, but at this point event processing requires manual intervention.

The /vibe-status generates comprehensive reports about the progress and current status of each project.

The /vibe-poll enables continuous polling of events and status until all active projects are completed.

Some links:

Web: https://vibeensemble.dev/

Sources: https://github.com/siy/vibe-ensemble-mcp/

Happy coding!