The CLI for Vibe Coding

Code the way
you actually think.
Not the way git wants you to.

v-cli is a family of lightweight tools built for the age of AI-assisted coding — where your biggest challenge isn't writing code, it's staying in flow without drowning in version control ceremony.

$ Build from source See the tools →

v-cli — quick taste

# Snapshot your work in one line

user@mbp:~/myapp $vv snap -m "login feature works!"

Creating snapshotDone

✅ v20260422-153041 · 284 KB · 2 sensitive items auto-redacted

# Ask for it back in plain English, days later

user@mbp:~/myapp $vv ask "the version where login worked before I broke it"

AI Matchvibe-core::ai

Found it — v20260422-153041 ● 98% match
"login feature works!" · 4 days ago · src/auth/login.rs +312

user@mbp:~/myapp $

The Problem

Vibe coding is fast.
Your tooling shouldn't slow it down.

AI can now write a working feature in minutes. But saving your progress, recovering a past version, or juggling multiple AI tasks in parallel? That still requires deep git knowledge most builders don't have — and shouldn't need.

The Old Way

git is powerful. Also overwhelming.

Git was designed for teams of engineers coordinating large codebases. It's a powerful distributed version control system — but that power comes with a steep learning curve and a lot of ceremony.

✗Stage, commit, stash, rebase, cherry-pick — just to save your work

✗Merge conflicts stop you cold when things go sideways

✗Finding "the version that worked" requires knowing git log syntax

✗No built-in AI coordination — managing multiple AI tasks is manual

✗Accidentally committing API keys is a real risk

The v-cli Way

Designed for the AI-assisted builder.

v-cli isn't a git replacement — it's the layer on top that makes version management frictionless, so you can stay focused on building rather than managing your tools.

✓One command to snapshot everything, no staging ceremony

✓Restore any version in plain English — no commit hash lookup

✓Run 3+ AI agents in parallel, switch between them instantly

✓Sensitive data redacted automatically — every snapshot, every time

✓Consistent experience across every tool in the family

Side by Side

Same goal. Very different experience.

Recover a version you made 3 days ago where the button animation worked.

git · traditional approach

git workflow

# First, remember the right command syntax

$git log --oneline --all --since="3 days ago"

a3f9c1e feat: update button styles

8b2d7a4 WIP: button animation attempt

5e1c9b3 fix: padding issue

2c8f4d0 feat: add animation

f7d2c09 various changes

# Guess which one? Check each diff...

$git diff 2c8f4d0 5e1c9b3 -- src/

# Found it. Now stash current work...

$git stash && git checkout 2c8f4d0

Detached HEAD state. Remember to:

git checkout -b recovery-branch 2c8f4d0

# ...and hope you don't lose your stash

v-cli · vv ask

vv workflow

# Just describe what you remember

$vv ask "version where button animation worked"

Searching snapshots from last 7 days…

AI Foundvibe-core::ai

v20260419-143022 ● high match
"feat: add animation" · 3 days ago · src/Button.tsx +47

✅ Workspace restored. Your current work was auto-saved.

The Family

Two tools. One consistent experience.

Built on a shared core so every tool feels like home. Learn one, know them all.

VibeCommand

Your AI-powered command center. Interact with your project through natural language — from running tasks and scanning your codebase to managing git workflows without memorizing every flag.

vc run — AI-assisted command execution with context awareness

vc git — explain, generate commit messages, diagnose errors

vc scan — understand your project structure instantly

vc agent — parallel multi-agent TUI with live coordination

VibeVersion

Zero-learning-curve version management. Snap your work at any moment, find it later in plain English, and restore without fear. Like a safety net that's always there, never in the way.

vv snap — instant compressed snapshot, sensitive data auto-redacted

vv ask — find any past version with natural language queries

vv restore — restore with risk-aware confirmation dialogs

vv diff — AI-explained changes between any two snapshots

vv snap — zero friction version saving

# Working on a new feature? Snap it.

$vv snap -m "auth modal done"

Scanning 312 files✓

Redacting secrets✓

✅ Snapshot saved

v20260422-1530 · 284 KB · 2 secrets hidden

# Broke something? Find the good version.

$vv list

a3f9c1e auth modal done now

8b2d7a4 login form layout 2h ago

5e1c9b3 button animation 1d ago

$vv restore --snap 8b2d7a4

✅ Restored · zero data lost

vc agent

Run multiple AI agents. In parallel.

Modern vibe coding often means spinning up several AI tasks at once — refactoring one module while another writes tests while a third fixes a bug. vc agent gives each task its own dedicated AI session in a full-screen TUI, all running simultaneously.

① Auth Refactor ⠴ ② i18n Setup ✓ ③ Security Fix ⠴ ＋ New Agent

agents in parallel

⌘

Ctrl+1/2/3 to switch

zero

context switching cost

⬡ vc agent

①Auth Refactor⠴

②i18n Setup✓

③Security Fix⠴

Extract all auth logic from main.rs into src/auth/ module. Keep interfaces unchanged.

Reading main.rs to identify auth boundaries.

🔧fs::read_file("src/main.rs")✓

Auth logic found at lines 48–132: login(), verify(), session_create()

🔧fs::write_file("src/auth/mod.rs")writing…

→ src/auth/mod.rs → src/auth/session.rs

Migrating three functions…

All Agents · Log

15:30:01①Reading main.rs

15:30:02③Scanning patterns…

15:30:03②✓ zh.toml saved

15:30:04②✓ en.toml saved

15:30:05①✓ src/auth/ created

15:30:06②✓ i18n complete

15:30:07③⚠ Missed pattern

15:30:08①Writing mod.rs…

15:30:09③Patching +42 lines

15:30:10①cargo build…

▶ Continue with session manager refactor…

Ctrl+1

Auth

Ctrl+2

i18n

Ctrl+3

Security

Ctrl+N

New 3 agents · AGENT MODE

vibe-core

One foundation. Every tool benefits.

vibe-core is the shared library that powers every tool in the family. Fix a security bug once — every tool gets it automatically. Build a new Vibe tool? Three steps to get a production-quality CLI.

🎨

ui — Unified Components

Confirm dialogs, progress bars, success/warn/error panels. Same look, same feel across every tool. Learn once, use everywhere.

🚫

ignore — .vibeignore Engine

Shared file filtering rules for snapshots and file operations. node_modules, .git, .env — excluded by default, always consistent.

🔒

security — Auto-Redaction

API keys, Bearer tokens, database URLs, private key paths — detected and hidden automatically. Fix the pattern once, every tool benefits.

⚙️

config — Unified Settings

All Vibe tools live in ~/.config/vibe/. One directory to manage them all, consistent read/write patterns.

🌐

i18n — Shared Translations

Add a language once and every tool speaks it. Currently supporting English and Chinese, more coming.

vibe-core architecture

CORE

# github.com/v-cli/

vibe-core ← shared library

├ ui/ confirm, progress, panels

├ ignore/ .vibeignore engine

├ security/ redactor + risk

├ config/ unified settings

└ i18n/ multilingual

vc ← VibeCommand

vibe-core = { tag = "v0.1.0" } ✓

vv ← VibeVersion

vibe-core = { tag = "v0.1.0" } ✓

vibe-xxx ← your next tool

vibe-core = { tag = "v0.1.0" } 3 steps

# Fix once, all tools benefit automatically

$ git tag v0.2.0 && git push origin v0.2.0

✅ vc and vv will pick up on next build

vibe-core $

Design Philosophy

Built on three beliefs.

Tools should
disappear.

The best tool is the one you forget you're using. v-cli is designed to stay out of your way — fast commands, zero ceremony, consistent behavior that becomes muscle memory after the first use.

Safety shouldn't
require expertise.

Sensitive data redaction is automatic, not optional. Risk-aware confirmation dialogs match the stakes of each action. The safest path should always be the easiest path — not something you configure after a mistake.

The family
grows together.

Every new Vibe tool inherits the same UI, the same security, the same config location. One fix benefits everyone. Extending the ecosystem costs the same whether you have two tools or twenty.

Get Started

Up and running in two minutes.

No config files, no accounts, no setup ritual. Just clone, build, and go.

STEP 01

Build from source

Clone the source and build locally. vc and vv are standalone binaries with no runtime dependencies.

# Clone the source
git clone https://github.com/v-cli/v-cli.git
cd v-cli
# Build vc and vv
cargo build --release

STEP 02

Initialize

Run the setup wizard. Takes 60 seconds. Configures your AI provider, language, and security settings.

# Setup VibeCommand
vc init
# Setup VibeVersion
vv init

STEP 03

Start vibing

Snap your first version, ask git questions in English, launch an AI agent. You're in the flow.

# Save your work
vv snap -m "it
                works!"
# Start an AI session
vc agent

Essential Commands

vc — VibeCommand

vc agent — multi-agent TUI

vc git "..." — AI git help

vc scan — project overview

vc config — settings

vv — VibeVersion

vv snap -m "msg" — snapshot

vv ask "..." — NL search

vv restore --snap — restore

vv list — show history

Global Flags

--verbose — detailed output

--quiet — results only

--lang en — override language

--help — show subcommands

Code the way you actually think. Not the way git wants you to.

Vibe coding is fast.Your tooling shouldn't slow it down.