VibeCoder Reference

AI-powered desktop code editor built with Tauri 2 and Monaco. VibeCoder provides a VS Code-like editing experience with a native Rust backend, Monaco Editor frontend, integrated AI chat, autonomous agent mode, explicit-chord diff-mode AI editing (⌘.), terminal, Git panel, code review, and a WASM extension system.

What’s new in 0.5.19

• Office documents edit in place. DOCX paragraph and table-cell edits keep run styling; table rows insert and delete from the Word view and blank cells stay typeable; XLSX renders like Excel with Office charts; PPTX keeps run styles and edits through anchored Markdown.
• Document RAG. Workspace PDFs and Office files are indexed for the agent’s search_documents tool; the home directory and filesystem root are refused.
• Git. Commit patch preview in the diff view.
• Polish. PDF zoom no longer flickers; header window dragging restored; SQLite files open to the database tab; “Daily Briefing” replaces “Morning Briefing”.

Added in 0.5.15:

• Charts. Bar, line, pie and area charts, edited as JSON and touched up in the SVG editor; embedded OOXML charts now render in the DOCX/XLSX/PPTX viewers, with series names resolved from live formulas.
• Image and SVG editing. Crop, rotate, resize, brightness and contrast in the image viewer; select, move, resize, rotate and recolor in SVG; diagrams can be touched up and exported as SVG; transparent SVGs sit on a checkerboard.
• Office fidelity. XLSM macros preserved, PPTX shapes movable and resizable inside groups, DOCX run formatting and table-cell edits preserved. Undo/redo is unified across every document editor.
• Baize theme and an editable title bar; chat and terminal state stay alive across panel switches.
• Settings. A shared Embedding Model section and local-provider settings.
• Fixed: dropped files replaced the whole window in VibeCoder and VibeDesk.

Added in 0.5.14: no user-facing feature — release-pipeline hardening and performance fixes. 0.5.12 brought full-duplex voice, the + composer menu and per-model context budgets.

Earlier releases: 0.5.10 brought the four-panel workspace security review, verified findings, “Fix with AI” everywhere, and Settings that can hide and reorder panels; 0.5.9 brought the plugin marketplace, real connectors, and 27 Tauri commands the panels were already calling; 0.5.8 brought voice input, selectable embedding models, the SkillForge panel and signed macOS builds.

Architecture Overview

┌──────────────────────────────────────────────────────────────────┐
│                    Frontend (React + TypeScript)                 │
│  Monaco Editor │ AI Chat │ Agent Panel  │ Manager View           │
│  Git Panel │ Terminal │ Command Palette │ Review Panel           │
│  Checkpoints │ Artifacts │ Hooks Config │ History                │
│  Context Picker │ Memory/Rules │ Theme Toggle                    │
└──────────────────────────┬───────────────────────────────────────┘
                           │ Tauri IPC (invoke / events)
┌──────────────────────────▼───────────────────────────────────────┐
│                   Tauri Rust Backend                             │
│  commands.rs    — 1,367 Tauri commands (files, git, AI, agent …) │
│  agent_executor — ToolExecutorTrait for agent tool calls         │
│  flow.rs        — Flow Awareness Engine (activity tracking)      │
│  memory.rs      — Workspace + global AI rules (.vibecoder.md)    │
└──────────────────────────┬───────────────────────────────────────┘
                           │
         ┌─────────────────┴──────────────────────┐
         │          Rust Library Crates           │
         ├─────────────┬──────────────────────────┤
         │ vibe-core   │ vibe-ai                  │
         │ vibe-lsp    │ vibe-extensions          │
         │ vibe-collab │                          │
         └─────────────┴──────────────────────────┘

Getting Started

Prerequisites

On macOS, also ensure Xcode Command Line Tools are installed:

xcode-select --install

Development Setup

cd vibecoder

# Install JavaScript dependencies
npm install

# Start development server (hot reload for frontend + Rust backend)
npm run tauri dev

Production Build

npm run tauri build

The installer is placed in src-tauri/target/release/bundle/.

Build it this way, not with cargo build --release. The frontend is compiled into the binary, and that only happens when the tauri/custom-protocol feature is on. tauri build passes it; a bare cargo build --release does not, and the app it produces points its window at the dev server instead. With nothing listening on localhost:1420 that is a blank white window — no panic, no log line, nothing on screen to say why.

Both halves of the build now say so rather than leaving you to find out:

warning: vibe-coder@0.5.14: this release build will not embed the frontend — it
will load http://localhost:1420 and open on a blank window. Build it with
`npm run tauri:build` (or `make build-vibecoder`), or add
`--features custom-protocol`.

and the binary repeats it on stderr at startup. If you do want a release build from cargo directly, cargo build --release -p vibe-coder --features custom-protocol embeds the frontend properly — build dist/ first, since that is what gets embedded. The feature is deliberately not a default: embedding brotli-compresses the whole bundle during macro expansion, and every cargo check of the crate would otherwise pay for it.

Features

Editor

• Monaco Editor — same engine as VS Code; full syntax highlighting, IntelliSense, multi-cursor
• Rope-based buffer — built on ropey for efficient O(log n) edits on large files
• Batch edits — apply_batch_edits for bulk insert/delete operations
• Multi-cursor — update_cursors for synchronised cursor state
• DiffComplete (⌘.) — explicit-chord AI editing surface; DiffCompleteModal collects an instruction (with optional user-picked extra files for context), vibe_ai::diffcomplete::generate returns a unified diff, DiffReviewPanel shows per-hunk accept/reject with optional Monaco edit-before-apply and a regenerate-with-refinement loop. A deliberate alternative to keystroke-driven ghost text. Keystroke-driven inline completion was removed on 2026-04-26; inline completion returned later as an explicit-trigger-only surface bound to ⌥\ (vibe_ai::ghost, 12-line cap) — it never fires on a keystroke. See ghost-text.md.
• Diagrams (Mermaid, PlantUML) — a ```mermaid or ```plantuml block in a markdown preview is drawn rather than printed, and a .mmd / .puml file opens as the picture with Source to go back to the text. The preview follows the buffer, so the diagram changes as you type. Mermaid is drawn in the app; PlantUML is a Java program with no browser port, so it is drawn by the PlantUML on your machine and nothing is sent to a remote renderer — if none is installed the diagram says so and how to install it, instead of quietly posting your architecture to plantuml.com. A diagram that will not parse shows the renderer’s own message and the source that produced it, never an empty box.
• Documents (DOCX, EPUB, PDF, Pages) — Word documents, e-books, PDFs and Apple Pages files open in the editor area. Two up puts any of them into a two-page spread: real facing pages for a PDF (drawn here with PDF.js, with page navigation and arrow keys), two columns of a screen for the formats that are text rather than sheets. EPUBs render as books: the publisher’s own stylesheets (scoped and sanitised), images, cover, nested table of contents and working cross-chapter links. All four are view-only — editing is handed to the real application (Open in Word / LibreOffice), because a text edit does not round-trip faithfully into the original container. See documents.md
• Archives (ZIP, TAR, and friends) — a .zip, .jar, .vsix, .tar.gz or .tar.zst in the explorer expands like a folder, and anything inside it opens read-only in the editor with highlighting, search, and image/PDF rendering. Trying to edit one offers the way out: extract the whole archive into a sibling folder named after it (dist.tar.gz → dist/, never merging into an existing one) and reopen the file from there, writable. The archive itself is never rewritten — re-encoding a signed .apk or a .vsix is not a promise worth making. See archives.md
• File watching — auto-detects external changes using notify
• Multi-workspace — open multiple folders simultaneously
• Language detection — automatic language mode from file extension

AI Integration

The AI chat panel supports all 25 providers via the shared vibe-ai crate:

• Local: Ollama (default, no API key), LocalEdit
• Cloud: Claude, OpenAI, Gemini, Grok, Groq, Mistral, Cerebras, DeepSeek, Zhipu, MiniMax
• Platform: OpenRouter, Azure OpenAI, Bedrock, Copilot, Vercel AI
• Inference: Perplexity, Together AI, Fireworks AI, SambaNova
• Meta: Failover (automatic provider fallback chain)

Select the provider from the dropdown in the header, or switch per chat tab in ChatTabManager. Provider configuration is handled through the Keyssettings tab (BYOK), environment variables, or ~/.vibecli/config.toml.

Provider Advanced Options

@ Context System

Type @ in the chat input to open the Context Picker — a dropdown that lets you inject additional context:

The backend resolves references via resolve_at_references() in commands.rs and injects them into the system prompt.

Jirarequires JIRA_BASE_URL, JIRA_EMAIL, and JIRA_API_TOKEN environment variables. GitHubuses optional GITHUB_TOKEN for higher rate limits.

Smart Context Builder

The ContextBuilder in vibe-core builds a ranked, token-budget-aware context by combining:

1. Git branch + changed file list — always included
2. Git diff — up to 25% of budget
3. Top-ranked symbols (via codebase index) — up to 30% of budget
4. Open file contents — remaining budget

Flow Awareness

The Flow Awareness Engine (flow.rs) tracks developer activity (file opens, edits, saves, terminal commands) in a 100-event ring buffer. Recent activity is injected into AI context via get_flow_context().

Agent Mode

The Agent Panelprovides autonomous multi-step task execution:

• Plan mode — agent generates a plan before executing
• Approval tiers — auto, suggest, always-ask policies
• Tool execution — TauriToolExecutor supports: read_file, write_file, bash, search_files, list_directory, web_search, fetch_url, get_weather, task_complete
• Step timeline — each tool call emits agent:step events rendered in the UI
• Pending approval — destructive operations emit agent:pending for user review
• Streaming — LLM output streamed via agent:chunk Tauri events
• Diff review — pending writes shown in a Monaco DiffEditor with Accept/Reject

Multi-Agent Orchestration (Manager View)

The Manager Viewenables running multiple agents in parallel:

• Task board — submit multiple tasks simultaneously
• Git worktrees — each agent operates on an isolated worktree branch
• Parallel execution — start_parallel_agents spawns concurrent agent loops
• Status tracking — manager:agent_update and manager:agent_step events
• Branch merging — merge_agent_branch with merge/squash/rebase strategies
• Status polling — get_orchestrator_status for initial render

Code Review (Review Panel)

AI-powered code review via the Review Panel:

• Compares base_ref vs target_ref (defaults to HEAD vs working tree)
• Returns structured ReviewReport with:
  • Issues — file, line, severity (hint/warning/error/critical), category (security/performance/correctness/style/testing), description, suggested fix
  • Suggestions — general improvement recommendations
  • Scores — overall, correctness, security, performance, style (0–100)
• Color-coded severity badges and score bars in the UI

Git Panel

Source Control is four tabs, so the working tree and the things you do to it stop competing for one scrolling column:

Modified files appear yellow (M), new files green (N), deleted files red (D).

What the diff compares. From the Changes list, a file is shown as HEAD against your working copy. From a commit in History, it is shown as that commit against its first parent — which is what the commit itself changed, not what has happened since. The header names the comparison, including the short hash when you are looking at a commit.

Both sides come from git’s object store. A file with no previous version — new in the working tree, added by the commit you are inspecting, or any file in a repository’s first commit — compares against empty, which is correct: every line really is an addition. A binary file is reported as binary rather than decoded into a pane full of replacement characters.

Commit messages are clipped in the history list to their subject line, or 100 characters, whichever comes first. more expands the body; it appears only when there is a body to show.

Starting a review is on the Changes tab, because reviewing is an action on the changes you are looking at. The findings land on Review, and pressing Run Review takes you there.

Checkpoints

The Checkpoint Panelprovides a timeline of AI checkpoints backed by Git stashes:

• Create checkpoint — create_checkpoint(label) saves current workspace state
• List checkpoints — browse all stash entries with labels and timestamps
• Restore checkpoint — apply a stash without dropping it
• Auto-checkpoint — agent mode can auto-create checkpoints before destructive operations

Artifacts

The Artifacts Paneldisplays structured AI output:

• Rich artifact cards with metadata
• Annotations and inline comments
• Async feedback mechanism

Hooks Configuration

The Hooks Panelprovides a UI for configuring event-driven hooks:

Each hook can be configured with:

• Handler type — command (runs a shell command) or llm (sends a prompt)
• Tool filters — restrict to specific tools
• Async exec — run hook in background

Configuration is saved to .vibecoder/hooks.json (workspace or global).

Memory & Rules

The Memory Panelprovides editors for AI rules:

• Project rules — .vibecoder.md in workspace root (committed alongside code)
• Global rules — ~/.vibecoder/rules.md (personal defaults)
• Both are injected into every AI system prompt via combined_rules()

Agent History

The History Paneldisplays an audit log of past agent sessions:

• Session list — list_trace_sessions() enumerates JSONL trace files
• Session detail — load_trace_session() returns all entries (tool calls, LLM turns, approvals)
• Expand and browse individual trace entries

Terminal

An integrated terminal panel using portable-pty:

• Full PTY — supports interactive programs (vim, htop, etc.)
• Powered by xterm.js on the frontend
• Multiple terminal instances (spawn_terminal returns terminal IDs)
• Terminal resize support (resize_terminal)
• Accessible via the status bar “Show Terminal” button

Command Palette

Press Cmd+P (macOS) / Ctrl+P (Windows/Linux) to open the Command Palette:

• Fuzzy file search (powered by fuse.js)
• Editor command list
• Quick navigation

Theme System

• Dark and light themes
• Toggle via moon/sun icon in the status bar
• Theme persists across sessions (stored in localStorage)
• All UI elements (editor, panels, status bar) respect the active theme

AI Panel Tabs

The AI panel (toggle with AI Chat in the header) has 246 panel components + 41 composites across categories:

Core AI & Chat

Delivery

Development & Code

Testing & Quality

Security

Agent Teams & Orchestration

Context & Memory

Infrastructure & DevOps

Data, AI & ML

Git & Collaboration

MCP & Extensions

Developer Toolbox

UI & Design

Converters & Utilities

Monitoring & Admin

Agents

Integration & Migration

UI Components

Tauri Commands (Backend API)

The React frontend communicates with the Rust backend using Tauri’s invoke() IPC and Tauri event emitters.

File Operations

Workspace Operations

Text Buffer Operations

Search

Git Operations

LSP Operations

IntelliSense in the editor. vibecoder/src/lib/lsp.ts bridges these to Monaco: completion (with snippets, auto-imports and resolved docs), hover, go-to-definition, signature help, and diagnostics as squiggles. Four non-obvious invariants hold it together — all four have failed in the past, and each one alone makes IntelliSense look broken:

1. Model URIs must be real file URIs. The <Editor> needs a path prop, or every file shares one model at inmemory://model/1 — a URI no server has heard of. fileUri() and vibe_lsp::path_to_uri must encode identically.
2. Edits must be pushed with lsp_did_change, debounced but always flushed before a request; otherwise the server answers against the text as it was when the file opened.
3. Completion kinds are mapped by name, not by number: LSP Text is 1, Monaco’s is 18, and Monaco renumbers between versions.
4. Trigger characters come from the server and are registered up front. Without them foo. shows nothing while mid-identifier completion works.

Servers are found at their install locations, not just on PATH — a Finder-launched app inherits launchd’s bare PATH and would find none of them. Languages Monaco already services in-browser (TypeScript, JavaScript, JSON, CSS, HTML) deliberately get no LSP providers: Monaco’s cannot be unregistered, so adding ours would duplicate every suggestion. The status bar shows which source is active for the current file, and offers a retry with the install hint when a server is missing.

Language coverage — TIOBE top 30

28 of 30 have a language server; the 2 that don’t, can’t. Coverage is pinned by tests on both sides — manager.rs::every_tiobe_top_30_language_has_a_configured_server (language id → server binary) and lsp.test.ts → “TIOBE top-30 coverage” (file extension → language id). Both halves are required: an extension that routes nowhere gets no IntelliSense however many servers are configured.

† PL/SQL and T-SQL get generic SQL analysis — no dialect-aware server for either exists. They keep their own language ids so the status bar names the dialect and a real server can be dropped in later.

‡ The two exemptions are not gaps we intend to close: Scratch is a block language whose .sb3 is a zip archive, not source text, and VB6 has no LSP implementation in existence. Both are asserted as deliberate in the tests, so adding a third exemption requires stating a reason.

Beyond the top 30, ranks 31–50 add servers for Lisp, Julia, ML/OCaml/Caml, TypeScript, Haskell, ABAP, Zig, Erlang, Scala, T-SQL, PowerShell and Solidity. Four have no LSP in existence (VBScript, X++, GML, FoxPro) and two more are visual languages (LabVIEW, Ladder Logic).

Beyond TIOBE

84 languages get IntelliSense: 79 through a language server, plus the 10 Monaco services in-browser (some overlap). Two invariants are enforced by tests: every configured server is reachable from at least one file extension, and every routed extension has a server — the halves cannot drift apart.

Svelte, Vue and Astro are a deliberate exception to the built-in-service rule. All three highlight as html, and html is Monaco-serviced — so the check is keyed on the LSP language, not the Monaco one. Keying it on the Monaco language (as it originally was) silently skipped Volar and svelteserver, the only things that understand script blocks, props and typed templates. Those files therefore get some HTML suggestions alongside the framework server’s: a little overlap beats no framework IntelliSense.

.v stays V (vlang); SystemVerilog is reached through the unambiguous .sv / .svh. See the ambiguity table above for .pl and .m.

Two extensions are genuinely ambiguous, and IntelliSense follows the same choice detectLanguage makes for highlighting, so a file never highlights as one language and completes as another:

Syntax highlighting

Monaco ships grammars for ~91 languages. VibeCoder supplies 27 more from vibecoder/src/lib/monarch — Zig, Nim, Crystal, V, D, Vala, Odin, Gleam, Haskell, Elm, PureScript, ReScript, Erlang, Nix, CMake, Protobuf, LaTeX, PostScript, MATLAB, Assembly, COBOL, SAS, Ada, Fortran, Prolog, VHDL, FoxPro and Astro. Each is a declarative LanguageSpec (keywords, comment markers, string forms) that a shared factory turns into a Monarch tokenizer plus a language configuration, so ⌘/ comments correctly and brackets match too.

Registration happens at editor mount and never overrides a Monaco built-in — if Monaco gains one of these, theirs wins and ours is skipped (a test enforces it). Grammars are built lazily via onLanguage, so mount cost stays flat.

Two invariants are test-enforced, both of which were silently broken before:

• Every id detectLanguage can return is registered. Monaco rejects an unknown language id, so matlab, cobol, sas and cmake files got neither highlighting nor IntelliSense — the LSP providers are keyed on the same id.
• Every server-backed extension has a highlighting entry. A file with a language server and no detectLanguage mapping renders as plain text.

Zig, Nim, Crystal, D and V no longer borrow C++/Python/Ruby highlighting. The approximation mis-coloured the keywords each language actually has, and left their LSP providers registered against cpp.

Grammar tests run Monaco’s own Monarch engine and assert on real tokens, not on the shape of the definition — the only way to catch the cases that actually break: nested comments that un-comment the rest of the file ({- -}, /+ +/, #[ ]#), MATLAB’s A' transpose versus 'a char array', Ada’s Obj'Length attribute versus 'x', PostScript’s nested (a (b) c) strings, and case-insensitive keywords in COBOL/Ada/Fortran/VHDL/SAS/CMake.

Installing a missing server

The status bar shows the active server, or the missing one with its install command and a Copy install button. parseInstallHint splits the backend’s hint into a runnable command and a documentation link — 51 of the 79 servers yield a copyable one-liner, 23 a project URL, and 5 are genuinely prose (“Included with Xcode”). A test runs the parser over the real hint table and rejects any command that could not be pasted as-is, which is how cargo install --git — plausible-looking and inert — was caught.

The command is copied, never run: installing software is the user’s decision, and several hints need a platform choice first.

AI Operations

Agent Operations

Agent events emitted:

Multi-Agent Orchestration

Orchestrator events emitted:

Memory & Rules

Checkpoints

Trace / History

Hooks Configuration

Code Review

MCP Server Management

MCP OAuth Flow

The MCP panel supports OAuth 2.0 for authenticating with MCP servers:

1. Click OAuthon a server → enter Client ID, Auth URL, Token URL, and Scopes
2. Click Open Browser → authorize in your browser
3. Paste the authorization code back into the modal
4. Token is exchanged and stored encrypted in the ProfileStore (~/.vibecli/profile_settings.db) under mcp.oauth.<server>. A pre-0.5.9 ~/.vibecoder/mcp-tokens.json is migrated into the store and deleted on first read.

Connected servers show a green OAuthbadge.

Deploy & Custom Domains

Custom Domain Support

After deploying, enter a custom domain in the Custom Domainfield:

• Vercel: calls the Vercel REST API (requires VERCEL_TOKEN env var)
• Other targets: returns CNAME record instructions for manual DNS configuration

Code Complete Workflow

Test Runner

Code Coverage

Multi-Model Comparison

HTTP Playground

Cost & Performance Observatory

AI Git Workflow

Codemod & Lint Auto-Fix

Arena Mode (Blind A/B Comparison)

Multiplayer Collaboration

Flow Tracking

Terminal Operations

Counsel (Multi-LLM Deliberation)

Counsel events emitted:

SuperBrain (Multi-Provider Routing)

SuperBrain events emitted:

Utility

Rust Crates

vibe-core

Foundational editor primitives:

vibe-ai

AI abstraction layer:

vibe-collab

CRDT-based multiplayer collaboration:

vibe-lsp

Language Server Protocol client:

• JSON-RPC message framing via jsonrpc-core and tokio-util
• Async LSP server process management
• LSP types from lsp-types
• Full document lifecycle notifications (didOpen, didChange, didSave)
• Wired to Monaco for go-to-definition, hover, completions, diagnostics

vibe-docfmt

Rich document formats read and written as text — see documents.md:

vibe-sheetfmt

Spreadsheet formats read and written as a grid, not a text buffer — a Workbook of Sheets of Cells, reusing vibe-docfmt’s xmltree/zipedit for OOXML package handling:

vibe-slidefmt

Slide-deck formats read and written as positioned shapes, not a text buffer — a Deck of Slides of Shapes with an EMU Frame:

vibe-extensions

WASM extension system:

• Powered by wasmtime 27
• Auto-loads *.wasm files from ~/.vibecoder/extensions/
• Host functions: host_log, host_notify, host_read_file, host_write_file
• String ABI: extensions export alloc(size) → ptr and memory
• Extension lifecycle callbacks: init(), on_file_save(path), on_text_change(path, content)
• Extension Manager — frontend ExtensionManager.ts + ExtensionHost Web Worker
• VS Code API shim — partial vscode namespace compatibility layer

Writing an Extension

Extensions are compiled to wasm32-unknown-unknown. A minimal Rust extension:

// In your extension's lib.rs (target: wasm32-unknown-unknown)
extern "C" {
    fn host_log(ptr: i32, len: i32);
}

#[no_mangle]
pub extern "C" fn init() -> i32 {
    let msg = "Hello from extension!";
    unsafe { host_log(msg.as_ptr() as i32, msg.len() as i32); }
    0
}

#[no_mangle]
pub extern "C" fn alloc(size: i32) -> i32 {
    let mut v: Vec<u8> = Vec::with_capacity(size as usize);
    let ptr = v.as_ptr() as i32;
    std::mem::forget(v);
    ptr
}

Backend Modules

agent_executor.rs

TauriToolExecutor implements ToolExecutorTrait for the desktop environment:

Note: apply_patch is not supported — the agent is instructed to use write_file with full contents instead.

flow.rs — Flow Awareness Engine

Tracks developer activity in a 100-event ring buffer:

context_string(limit) returns a formatted summary: recently opened files, recently edited files, and recent terminal commands.

memory.rs — AI Rules

counsel.rs — Multi-LLM Deliberation

Structured multi-round debates between AI providers:

superbrain.rs — Multi-Provider Query Routing

Intelligent query routing and multi-model synthesis:

web_client.rs — Browser-Based Web Client

Self-contained single-page web client for zero-install access (similar to Bolt.new/v0):

• No external CDN dependencies (air-gap safe)
• Chat and Agent modes with SSE streaming
• Markdown rendering with syntax highlighting
• Dark/light theme support, responsive design
• Served from the VibeCLI serve command

Keyboard Shortcuts

Source of truth: vibecoder/src/constants/shortcuts.ts, which the welcome screen renders from and shortcuts.test.ts checks against the handlers in App.tsx. Update that file first, then this table.

Global — a window listener, so these work anywhere in the app:

In the editor — Monaco commands, so they need a file open and the editor focused. They do not fire from the welcome screen, the AI panel, the terminal, or the sidebar:

Accessibility (WCAG 2.1 AA)

VibeCoder implements WCAG 2.1 Level AA accessibility:

Testing

17,170 test functions across the workspace (counted at v0.5.14 by #[test] / #[tokio::test] attribute).

Benchmarks: 8 Criterion benchmarks covering cosine similarity (384d/1536d/batch), symbol extraction (50/500 fns), index build (100 files), symbol search, and relevance scoring.

# Rust unit tests
cargo test --workspace

# Specific crates
cargo test -p vibe-core
cargo test -p vibe-ai
cargo test -p vibe-collab

# TypeScript type check
cd vibecoder && npx tsc --noEmit

# End-to-end tests
cd vibecoder/e2e && npm test

See TESTING.md for manual testing checklist.

Debugging

Open DevTools in the running app:

• macOS: Cmd + Option + I
• Windows/Linux: Ctrl + Shift + I

Or right-click anywhere and select Inspect.

See DEBUG.md for common troubleshooting steps.