Vibe-Coder's Complete Guide

CodeBuddy — Everything You Need

A full walkthrough of every feature, how to use the ones that need your attention, and answers to the most common "why isn't this working?" moments.

What CodeBuddy Actually Does

CodeBuddy is a VS Code extension that acts like a traffic controller for AI agents working on your code. When you have multiple AI assistants (Claude, Copilot, Cursor, etc.) touching the same project at the same time, CodeBuddy makes sure they don't step on each other — it keeps track of who's working on what, prevents file conflicts, and helps work get handed off cleanly from one agent to the next.

🚦
Traffic Control for AI
Stop multiple AI agents from editing the same file at the same time and destroying each other's work.
🔗
Structured Handoffs
One AI finishes a chunk of work and formally passes the baton to the next, with full context attached.
📊
Live Dashboard
See every session, lock, and handoff at a glance — right inside VS Code — without leaving your editor.
🤖
70+ Agent Templates
Pre-built agent personalities for design, engineering, marketing, testing, strategy, and more.
💰
Token Budget Tracking
Know exactly how many tokens each AI session has burned so you don't blow your API budget silently.
🔌
MCP Server Built In
External AI clients (Claude Code, Cursor, Windsurf) can connect and use all the same tools over MCP.

Everything CodeBuddy Can Do

Every capability, organized by what they help you accomplish.

▶️
Start a Session
Register a new AI agent work session with a name, goal, and the files it plans to touch. Everything else tracks against this session ID.
You set the goal
⏹️
End a Session
Cleanly close out a session, save a summary of what was accomplished, and optionally trigger a handoff automatically.
You write the summary
⏸️
Pause an Agent
Send a stop signal to a running session. The agent sees the pause directive on its next status check and halts work.
You send the signal
↩️
Redirect an Agent
Change what an active session is doing mid-run by publishing new instructions. No need to cancel and restart.
You write new instructions
❌
Cancel a Session
Hard-stop a session and automatically release all file locks it holds, so other agents aren't blocked.
You initiate the cancel
💓
Heartbeat / Progress Updates
Active sessions ping the system at regular intervals so the dashboard shows live progress notes and which files are being edited.
📡
Workspace Status Snapshot
One call returns every active session, open handoff, current file lock, and overall health in a single JSON response.
🔒
File Locking
An agent "claims" files before editing them. Any other agent that tries to lock the same file gets told it's occupied — no silent overwrites.
🔓
File Lock Release
Release one file, a list of files, or all locks for a session at once. Locks also auto-release when a session ends cleanly.
🔍
Lock Status Check
Ask CodeBuddy whether any given file is locked, who holds the lock, and in what mode (exclusive or shared).
📨
Create a Handoff
Package up completed work — summary, relevant files, required skills, priority, and context hints — and put it in the queue for the next agent.
You define the work
📬
Claim a Handoff
An agent (or you) picks the best open handoff from the queue based on capabilities. First come, first served, with priority ordering.
You or AI picks the task
✅
Complete a Handoff
Mark work as merged, approved, blocked, escalated, or skipped. Blocked or escalated statuses trigger visibility in the dashboard.
You review the status
📋
List Handoffs
Filter the handoff queue by status (open, claimed, merged, blocked…) or by agent to see exactly what's waiting.
🎯
Smart Next-Task Routing
Given an agent's declared capabilities, CodeBuddy finds the best-matching open handoff — no manual hunting through the queue.
📚
Agent Template Catalog
Browse 70+ pre-built agent roles across design, engineering, marketing, testing, product, and more.
🔎
Capability Matching
Ask "which agent can do TypeScript and code review?" and CodeBuddy returns the right templates automatically.
✍️
Prompt Assembly
Combine a template's personality with your task instruction, prior output, and relevant file content into a single ready-to-run prompt.
You write the instruction
🎨
Custom Agent Templates
Drop a Markdown file with YAML frontmatter into templates/agents/ to create your own reusable agent personality.
You author the template
📸
Context Capsule
Snapshot the entire workspace state — sessions, handoffs, locks, events — into a compact JSON file agents can load as context.
🧬
AST Code Context
Extract exports, imports, function signatures, and class names from any source file without reading the whole file into a prompt.
💸
Token Budget Tracking
Record token usage per session, get remaining budget, and see percentage consumed with automatic warnings when you're close to the cap.
🧠
Model Tier Recommendations
Describe a task and get a recommendation: use a fast/cheap "worker" model or a powerful "lead" model, with a justification for the choice.
📋
Clipboard Delivery
Assemble a full agent prompt and copy it straight to your clipboard — paste it anywhere in seconds.
You paste it
📁
Drop-Zone File Delivery
Write the assembled prompt to .codebuddy/agent-prompt.md so any agent with file access can pick it up directly.
💉
Personality Injection
Write an agent's personality directly to CLAUDE.md or AGENTS.md in your workspace root so Claude Code picks it up automatically.
You choose the agent
🖥️
Full Dashboard Panel
Open a rich editor panel inside VS Code showing all sessions, handoffs, locks, and health in one scrollable view.
🌳
Sidebar State Tree
A live tree in the activity bar showing sessions, locks, handoffs, and system health — always visible without opening the full dashboard.
🔁
Quick Refresh
Force the sidebar and dashboard to re-read state if the view looks stale. One command, instant update.
🧭
Built-in Walkthrough
VS Code's native walkthrough system guides you step-by-step through your first session, handoff, and MCP connection — with illustrated diagrams.
⚙️
Workspace Config File
A simple JSON file (.codebuddy.json) in your project root lets you set default models, token budgets, and which tools are enabled.
You configure it
🌐
MCP Server Toggle
Start or stop the built-in MCP server from the Command Palette. External clients connect automatically once it's running.
You toggle it on/off
🔗
External Client Support
Claude Code, Cursor, Windsurf, Codex, and any MCP-compatible client can connect and use all cc_* tools over stdio — no ports needed.
🕰️
Legacy Compatibility
Older .codeconductor.json configs and .codeconductor/ state directories are still read automatically — nothing breaks on upgrade.

Features That Need Your Input

These features have a yellow "You're in control" tag because they require a human decision or action. Click each one to see the exact step-by-step flow.

▶️ Starting a Session You name the agent and define the goal before anything starts ▼

A session is the container for all the work one AI agent is doing right now. You start it, name it, and tell it what to achieve. Nothing is locked or tracked until a session exists.

1
Open the Command Palette
Press Ctrl+Shift+P (Windows/Linux) or Cmd+Shift+P (Mac).
2
Run "CodeBuddy: Start Session"
Type "start session" and select the command. A prompt will appear asking for an agent name (e.g., claude-frontend) and a goal (e.g., Refactor the login component to use React hooks).
3
Confirm in the sidebar
The new session appears in the State Tree in the CodeBuddy sidebar. The session is now live and can acquire file locks.
4
Let the agent work
Hand off the session ID to your AI tool. The agent uses it to lock files, send heartbeats, and create handoffs when it's done.
Tip: Give sessions descriptive names like claude-auth-refactor rather than agent1. It makes the dashboard much easier to read at a glance.
⏹️ Ending a Session You write the closing summary so the next agent has full context ▼

Ending a session properly releases all file locks and saves a record of what was accomplished. Skipping this step leaves locks dangling and can block other agents.

1
Open the Command Palette and run "CodeBuddy: End Session"
You'll be asked to select the active session from a list if more than one is running.
2
Write a summary
Describe what the agent finished — e.g., Replaced class component with functional hook version, all tests pass. This gets stored and can be read by the next session.
3
(Optional) Describe next work
If you know what should happen next, add a next_work note. CodeBuddy can automatically create a handoff from it.
4
Verify locks are released
Check the sidebar tree — the session should disappear and any locked files should show as free.
Watch out: If VS Code closes unexpectedly, sessions can be left open. Run CodeBuddy: Cancel Session to force-close them and release their locks.
📨 Creating a Handoff You package up work-in-progress and queue it for the next agent ▼

A handoff is like a sticky note left for the next person on the job — except it's structured, searchable, and can include file lists, required skills, and priority levels. The richer you make it, the less context the next agent has to re-discover.

1
Run "CodeBuddy: Create Handoff"
From the Command Palette. You'll be prompted for the handoff details.
2
Write a summary of what was done and what needs to happen next
Example: Refactored LoginForm to hooks. Next: update the unit tests in LoginForm.test.tsx to match the new prop interface.
3
List the relevant files
Point the next agent at src/components/LoginForm.tsx and src/components/LoginForm.test.tsx so they don't have to search.
4
(Optional) Set priority and required capabilities
Mark it high priority if it's blocking other work. Add capabilities like testing, react so smart routing picks the right agent.
5
Handoff enters the queue as "open"
It appears in the dashboard and sidebar. Any agent — or you — can claim it next.
Tip: You can create a handoff automatically when ending a session by providing the handoff payload in the End Session command — one less step.
📬 Claiming a Handoff You or an AI picks up the next open piece of work ▼

Claiming reserves a handoff so two agents don't start the same task at the same time. Once claimed, the handoff status changes to "claimed" and the queue updates immediately.

1
Run "CodeBuddy: Claim Next Handoff"
CodeBuddy finds the highest-priority open handoff that matches the current agent's capabilities and claims it automatically.
2
Read the handoff context
The returned handoff includes the summary, file list, context hints, and any notes from the previous agent. Pass this to your AI tool.
3
Do the work
Lock the files you'll edit, make the changes, run tests — the usual flow.
4
Complete the handoff
Mark it merged (done), blocked (stuck), or escalated (needs human review). A reason is required for blocked or escalated.
Watch out: A handoff marked blocked or escalated means it needs a human to look at it. Check the dashboard regularly for red or orange statuses — those are calls for help.
⏸️ Pausing or Redirecting a Running Agent You send mid-flight instructions without killing the session ▼

Sometimes an agent goes off in the wrong direction, or you need to stop it temporarily. Instead of cancelling the whole session (which releases locks and loses state), you can pause or redirect it.

1
Identify the session ID from the sidebar
Click on the session in the State Tree to see its ID and current status.
2
Send a pause directive (to halt) or redirect directive (to change course)
Pause: requires a reason like Waiting for design review before continuing.
Redirect: requires a new instruction like Switch to fixing the mobile layout bug instead.
3
Wait for the agent to acknowledge
The agent sees the directive on its next status poll. If it's well-configured, it stops or pivots. If not, you may need to manually cancel.
4
Resume or cancel from the dashboard
After a pause, you can let the agent continue by ending the pause directive, or cancel the session entirely if the work is no longer needed.
Tip: Not all external AI clients respect pause directives automatically — check your client's documentation to confirm it polls cc_get_status during execution.
🚀 Preparing and Delivering a Prompt to an Agent You choose the agent template, write the instruction, and pick how to deliver it ▼

The prompt assembly system takes the messy work out of crafting agent prompts. You describe what you need, pick a template, and CodeBuddy combines everything into a ready-to-run prompt delivered however you want.

1
Find the right agent template
Use cc_list_agents or cc_match_agents to browse templates by category or capability. See the full catalog below.
2
Write your task instruction
This is the plain-language description of what you need done — e.g., Review the new payment flow for security vulnerabilities.
3
(Optional) Add context files and previous output
List files whose content should be embedded. If this is step 2 of a multi-step task, paste in what step 1 produced.
4
Choose a delivery channel
Clipboard — copies to clipboard; paste into Claude, ChatGPT, etc.
Drop-Zone — saves to .codebuddy/agent-prompt.md for file-reading agents.
Inject Personality — writes the agent role to CLAUDE.md or AGENTS.md for Claude Code.
Tip: Use Inject Personality when working with Claude Code so you don't have to paste the same system prompt every session. It stays in the file until you change it.
⚙️ Setting Up Your Workspace Config A one-time JSON file that sets your defaults for every session ▼

Drop a .codebuddy.json file in your project root and CodeBuddy will use your custom defaults instead of the system defaults. You only need to do this once per project.

1
Create .codebuddy.json in your project root
Right-click the root folder in the Explorer panel → New File → name it .codebuddy.json.
2
Paste in your settings
Minimal example:
{ "agentCoordination": { "budget": 60000 }, "tools": { "fileLocking": true } }
3
Reload the VS Code window
Press Ctrl+Shift+P → Developer: Reload Window. The extension re-reads your config on startup.
Tip: Set budget to a number lower than your AI plan's monthly token limit divided by the number of projects you're running simultaneously. This prevents any single project from consuming everything.
Watch out: Config changes don't take effect until you reload the window. If behavior seems unchanged after editing the file, always reload first.
🔌 Connecting an External AI Client via MCP Wire Claude Code, Cursor, or Windsurf into CodeBuddy in under 2 minutes ▼

MCP (Model Context Protocol) lets external AI tools call CodeBuddy's tools directly — the same tools available in VS Code, accessible to any connected client. No ports, no background servers required beyond the one CodeBuddy manages.

1
Create .mcp.json in your project root
Right-click → New File → .mcp.json
2
Paste this configuration
{ "mcpServers": { "codebuddy": { "command": "npx", "args": ["codebuddy-server"], "env": {} } } }
3
Run "CodeBuddy: Toggle Server" to start the MCP server
The status bar shows the server is running. External clients can now discover the cc_* tools.
4
Point your AI client at the config
Claude Code, Cursor, and Windsurf each have a way to load MCP configs — usually via their settings or a file they watch. Consult the built-in walkthrough ("Connect External Agents") for client-specific screenshots.
Tip: Run the built-in walkthrough for the MCP setup — it has illustrated diagrams for each client. Open it: Ctrl+Shift+P → Welcome: Open Walkthrough → CodeBuddy: Get Started.
Watch out: Old configs might say codeconductor-server — update any references to codebuddy-server or the client won't connect.
🎨 Creating a Custom Agent Template Write a Markdown file to define your own reusable AI persona ▼

Agent templates are just Markdown files with a short header block of metadata. Drop one in the right folder and CodeBuddy automatically adds it to the catalog — no code changes needed.

1
Create a new .agent.md file in templates/agents/
Name it something descriptive, e.g. templates/agents/engineering/my-security-reviewer.agent.md. You can put it in any subfolder to organize by category.
2
Add the YAML frontmatter header
Copy this structure and fill in your details:
---
name: My Security Reviewer
category: engineering
description: Reviews auth and data handling.
capabilities:
- security-review
- code-review
model_tier: lead
---
3
Write the agent's personality and instructions below the header
This is the system prompt body — write in plain English how the agent should behave, what it should focus on, and any rules it should follow.
4
The template is live immediately
CodeBuddy loads templates from the directory dynamically. Call cc_list_agents to confirm it appears in the catalog.
Tip: Use model_tier: lead for templates that do planning, review, or ambiguous reasoning. Use model_tier: worker for templates with well-defined, bounded tasks like formatting or test generation.

All VS Code Commands

Every command available from the Command Palette (Ctrl+Shift+P).

Command What It Does
CodeBuddy: Start Session Register a new agent session with a name and goal.
CodeBuddy: End Session Close a session cleanly, save a summary, release all locks.
CodeBuddy: Create Handoff Package up work-in-progress and put it in the handoff queue.
CodeBuddy: Claim Next Handoff Grab the best open handoff for the current agent based on capabilities.
CodeBuddy: Open Full Dashboard Open the rich editor panel showing all sessions, handoffs, locks, and health.
CodeBuddy: Toggle Server Start or stop the built-in MCP server for external client connections.
CodeBuddy: Quick Refresh Force the sidebar tree and dashboard to re-read current state if the view looks stale.
Welcome: Open Walkthrough… Open VS Code's guided walkthrough. Choose CodeBuddy: Get Started for the illustrated tutorial.

70+ Ready-Made Agent Roles

Every template gives an AI a specific personality, focus, and set of capabilities. Browse by category to find the right one for your task, or use capability matching to find it automatically.

🎨 Design
  • Brand Guardian
  • Image Prompt Engineer
  • UI Designer
  • UX Architect
  • UX Researcher
  • Visual Storyteller
  • Whimsy Injector
⚙️ Engineering
  • AI Engineer
  • Backend Architect
  • DevOps Automator
  • Frontend Developer
  • Mobile App Builder
  • Rapid Prototyper
  • Senior Developer
📣 Marketing
  • App Store Optimizer
  • Content Creator
  • Growth Hacker
  • Instagram Curator
  • Reddit Community Builder
  • Social Media Strategist
  • TikTok Strategist
  • Twitter Engager
📦 Product
  • Feedback Synthesizer
  • Sprint Prioritizer
  • Trend Researcher
🗂️ Project Mgmt
  • Experiment Tracker
  • Project Shepherd
  • Senior Project Manager
  • Studio Operations
  • Studio Producer
🥽 Spatial / XR
  • macOS Metal Engineer
  • Terminal Integration Specialist
  • visionOS Spatial Engineer
  • XR Cockpit Interaction
  • XR Immersive Developer
  • XR Interface Architect
🔬 Specialized
  • Agents Orchestrator
  • Data Analytics Reporter
  • Data Consolidation
  • LSP Index Engineer
  • Report Distribution
  • Sales Data Extraction
🏛️ Strategy
  • Executive Brief
  • Nexus Strategy
  • Quickstart Guide
🛎️ Support
  • Analytics Reporter
  • Executive Summary Generator
  • Finance Tracker
  • Infrastructure Maintainer
  • Legal Compliance Checker
  • Support Responder
🧪 Testing
  • API Tester
  • Evidence Collector
  • Performance Benchmarker
  • Reality Checker
  • Test Results Analyzer
  • Tool Evaluator
  • Workflow Optimizer

Common Problems & Mistakes

The most common "why isn't this working?" moments — and exactly how to fix them.

SetupThe CodeBuddy sidebar icon isn't showing up after I installed it. ▼

The extension wasn't loaded or VS Code needs a restart. Try these steps in order:

  1. Press Ctrl+Shift+P → Developer: Reload Window.
  2. If still missing, open the Extensions view (Ctrl+Shift+X), find CodeBuddy, and check if it shows "Enable" instead of "Disable." Click Enable.
  3. If you installed a .vsix file manually, make sure you reloaded VS Code after the install completed.
  4. Confirm your VS Code version is 1.86.0 or newer. Older versions are not supported.
SetupThe dashboard opens blank or shows a loading spinner forever. ▼

This was a known bug fixed in version 0.1.2. Make sure you're on the latest version.

  1. Open Extensions (Ctrl+Shift+X) and check the CodeBuddy version number.
  2. If it's older than 0.1.2, click the update button or reinstall from the Marketplace.
  3. After updating, run Developer: Reload Window.
  4. Try CodeBuddy: Open Full Dashboard again.

If still blank after updating: uninstall the extension completely, reinstall it, and reload.

SetupThe status bar says "CodeBuddy disconnected" or shows a server error. ▼

The MCP server process failed to start. Common causes:

  • Node.js is missing or the wrong version. Open a terminal and run node --version. You need 18.0.0 or higher. If you get an error or a version below 18, install the latest LTS from nodejs.org.
  • Hover over the status bar item to read the disconnect reason — it usually tells you exactly what failed.
  • Run CodeBuddy: Toggle Server to manually restart the server process.
  • If you cloned from source and made changes, run npm run compile in the project folder first.
SessionI started a session but nothing shows in the sidebar. ▼

The sidebar view may be stale. Run CodeBuddy: Quick Refresh from the Command Palette to force it to re-read the current state. If the session still doesn't appear, the session may have failed to register — try starting a new one and check the VS Code Developer Tools console (Help → Toggle Developer Tools) for errors.

SessionVS Code crashed and now I have sessions stuck "open" that I can't end. ▼

Stale sessions happen when VS Code closes before the extension can clean up. To fix:

  1. Reopen VS Code and your workspace.
  2. Run CodeBuddy: Open Full Dashboard and look for sessions with old timestamps.
  3. Use Cancel Session for each stale session — this releases all locks without needing a summary.
  4. If Cancel Session doesn't work, delete the .codebuddy/ folder from your project root and reload the window. Warning: this resets all local state including handoffs and lock history.
LocksAn agent says a file is locked and it can't edit it, but no one is using that file. ▼

The lock belongs to a session that ended without releasing its locks — usually because VS Code crashed. Here's how to clear it:

  1. Open the dashboard and find which session holds the lock (the lock entry shows the session ID and agent name).
  2. Cancel that session using Cancel Session — it releases all locks automatically.
  3. If the session is gone but the lock persists (rare), delete the .codebuddy/ folder and reload VS Code. This is a full state reset, so note down any open handoffs first.
Prevention: Always end sessions cleanly with CodeBuddy: End Session instead of just closing VS Code. It takes 5 seconds and saves a lot of headaches.
LocksTwo agents want to edit the same file. How does that work? ▼

CodeBuddy uses exclusive locks by default. Only one agent can hold an exclusive lock on a file at a time. Here's the flow:

  • Agent A locks App.tsx → exclusive lock granted.
  • Agent B tries to lock App.tsx → gets a LOCK_CONFLICT error with the name of the session holding the lock.
  • Agent B should wait or work on something else until Agent A releases the lock.

There's also a shared lock mode for read-only access. Multiple agents can hold shared locks on the same file simultaneously — but a shared lock blocks exclusive locks until all shared locks are released.

HandoffsI created a handoff but nothing shows up in the dashboard. ▼

The dashboard may be stale. Run CodeBuddy: Quick Refresh first. If the handoff still doesn't appear, check whether the session that created it is still active — a handoff requires an active session to be created through the VS Code commands. If you're using the MCP tools directly, verify the tool returned a handoff_id in its response with status "open".

HandoffsA handoff is stuck in "blocked" or "escalated" status. What do I do? ▼

Blocked means the AI agent couldn't proceed — there's something stopping it that requires human judgment. Escalated means the agent identified a situation beyond its capability and is asking for a higher-level decision.

Your action steps:

  1. Open the dashboard and read the reason field on the blocked/escalated handoff — the agent should have left a description of what it's stuck on.
  2. Resolve the blocker yourself (e.g., make a design decision, provide missing information, fix a failing test manually).
  3. Create a new handoff with the resolved context and put it back in the queue for an agent to pick up.
HandoffsTwo agents claimed the same handoff at the same time. ▼

This shouldn't happen — claiming is atomic and the first claimant wins. But if you see duplicate work, check whether both agents called cc_claim_handoff almost simultaneously. The system will have rejected one of them with a HANDOFF_NOT_FOUND error (because it was already claimed). The agent that got the error should call cc_get_next_task to find a different open handoff instead of retrying the same one.

ErrorI'm getting "BUDGET_EXCEEDED" errors. My agent keeps stopping. ▼

Your session has burned through its token budget. The default budget is 120,000 tokens per session. To fix:

  1. End the current session and start a new one — the budget resets.
  2. Or increase the budget in .codebuddy.json: set "agentCoordination": { "budget": 250000 } and reload the window.

You can check how much budget is remaining at any time with cc_get_budget_status before you hit the wall.

ErrorMy AI agent can't find the session ID — what am I supposed to give it? ▼

The session ID is generated by CodeBuddy when you run Start Session. It's returned in the response and visible in the dashboard under the session entry. It looks like a UUID — e.g., sess_a1b2c3d4e5f6. Copy it from the dashboard and include it in your instructions to the AI agent. The agent needs it to lock files, send heartbeats, and create handoffs.

MCPMy external client (Claude Code / Cursor / Windsurf) can't connect to the MCP server. ▼

Work through this checklist:

  1. Is the server running? Check the VS Code status bar for "CodeBuddy" status. If it shows disconnected, run CodeBuddy: Toggle Server.
  2. Is .mcp.json in the right place? It must be in the workspace root folder, not a subfolder.
  3. Does .mcp.json say codebuddy-server? Older configs say codeconductor-server — update the args to use codebuddy-server.
  4. Is npx accessible? Open a terminal and run npx --version. If it fails, Node.js or npm isn't in your PATH.
  5. Check your client's MCP logs — Claude Code shows server startup errors in its output panel.
MCPThe cc_* tools aren't showing up in my AI client's tool list. ▼

The client connects to the server but isn't discovering the tools. Try:

  1. Restart the AI client application entirely — not just the chat session.
  2. Confirm the server process is running (status bar in VS Code).
  3. Some clients require you to explicitly reload or rescan MCP servers after config changes — check your client's documentation for a "reload tools" or "refresh MCP" action.
ErrorThe config file change I made isn't having any effect. ▼

CodeBuddy reads .codebuddy.json at startup, not on the fly. After every config change:

  1. Save the file.
  2. Press Ctrl+Shift+P → Developer: Reload Window.

The extension will re-read the config when it activates on the next window load.

ErrorI deleted the .codebuddy/ folder and now everything is gone. How do I start fresh? ▼

That folder contains your local session/handoff database. Deleting it is a full reset — there's no undo. Your code files are completely untouched, only CodeBuddy's internal coordination state is gone. To start fresh:

  1. Reload VS Code (Developer: Reload Window).
  2. CodeBuddy will recreate the .codebuddy/ folder and a fresh database on first use.
  3. Start a new session and continue from there.

Going forward: if you need to clear state but keep your code, this is actually the correct approach. Just note down any open handoffs manually before you do it.

SetupI'm using an older .codeconductor.json config from before the rename. Do I need to update it? ▼

No — CodeBuddy reads .codeconductor.json automatically as a fallback. You can continue using it indefinitely. However, if you create a new .codebuddy.json alongside it, the new file takes priority. The recommended path for new projects is .codebuddy.json, but there's no rush to migrate.

SessionWhat's the difference between "End Session" and "Cancel Session"? ▼

End Session is the clean path: you provide a summary of what was accomplished, the session closes gracefully, locks are released, and a record is saved for future reference. Use this whenever the agent finished its intended work.

Cancel Session is the emergency stop: it immediately terminates the session and releases all locks with no summary required. Use this when a session is stuck, the agent went off the rails, or VS Code crashed and left a zombie session behind.

HandoffsDo I need to use handoffs at all? Can I just use sessions? ▼

Handoffs are optional but strongly recommended for anything that spans more than one agent or more than one work block. Without handoffs, the only way to transfer context between agents is by manually copying and pasting — which is exactly the kind of friction CodeBuddy is designed to eliminate.

For quick one-off tasks with a single agent, sessions alone are fine. For multi-step workflows, multi-agent pipelines, or any work that might need to be resumed later, handoffs are worth the 30 seconds it takes to create them.

MCPWhat's the difference between the VS Code extension and the MCP server? Do I need both? ▼

The VS Code extension gives you the sidebar, dashboard, commands, and status bar — the visual, human-facing part you interact with directly in VS Code.

The MCP server is the API layer — it exposes the same coordination features as cc_* tools over the Model Context Protocol, so external AI clients like Claude Code, Cursor, and Windsurf can call them programmatically.

You need the extension to use CodeBuddy at all. The MCP server is only needed if you want external AI clients to connect and use the tools without going through the VS Code UI. Most vibe-coding workflows use both.