Vcode – Agent de Codificação Terminal em Vanta
Juanshep1/vcode
Agent terminal para codificação Vanta com visão e execução live
Ver no GitHubAgent inspirado em Claude Code que lê, escreve, edita, executa e depura programas em Vanta (linguagem de programação) diretamente do terminal. Oferece visão computacional, streaming em tempo real, checklists de tarefas, subagents para operações complexas e integração com múltiplos provedores de API.
Instalação
npx convez-ai Juanshep1/vcode1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Desenvolver e debugar programas Vanta interativamente no terminal
- Processar screenshots e mockups visuais para gerar código
- Automatizar tarefas de programação com subagents em paralelo
- Integração com IDE nativa iOS (Vanta Pocket)
Veredito

Ferramenta madura e bem-integrada para quem trabalha com Vanta. Destaca-se por visão computacional, streaming e orquestração de subagents, mas requer instalação local e conhecimento prévio da linguagem Vanta.
README
A tradução para o português deste README ainda está na fila.
██╗ ██╗ █████╗ ███╗ ██╗████████╗ █████╗
██║ ██║██╔══██╗████╗ ██║╚══██╔══╝██╔══██╗
██║ ██║███████║██╔██╗ ██║ ██║ ███████║
╚██╗ ██╔╝██╔══██║██║╚██╗██║ ██║ ██╔══██║
╚████╔╝ ██║ ██║██║ ╚████║ ██║ ██║ ██║
╚═══╝ ╚═╝ ╚═╝╚═╝ ╚═══╝ ╚═╝ ╚═╝ ╚═╝ c o d e
A Claude Code–style terminal coding agent that speaks Vanta.
It reads, writes, edits, runs, and debugs .va programs for you from a chat
prompt — with live diffs, a thinking spinner, themes, and your choice of model.
✨ New in v5.1
- Vanta 5.0 fluency — the agent now knows the whole Vanta 5.0 standard
library (
unique,zip,flatten,merge,get(m, k, fallback),clamp,format_number,format_date/parse_date,sort(xs, "desc")and friends) and reaches for them instead of reinventing them. - 📱 vcode in your pocket — Vanta Pocket, the native iOS IDE for Vanta, ships vcode as a chat panel: same bring-your-own-key setup (Anthropic or OpenRouter), and it writes, runs, and fixes programs right on the phone.
✨ New in v5.0
- 👁 Vision — drag an image into the terminal, or copy one and press
Ctrl-V right in the prompt (an
[image #1]tag appears), and vcode sees it: screenshots, UI mockups, error photos. The agent can alsoread_fileany.png/.jpgitself to look at charts and assets it generated. Works on Anthropic and on vision models via OpenRouter/Ollama Cloud. - ⚡ Streaming — replies render live, token by token, like Claude Code
(
/streamtoggles; falls back to blocking automatically). - ☑ Task checklists — on multi-step builds the agent puts up a live
☐ / ▸ / ✔ todo list and updates it as it works (
/todosre-shows it). - ◇ Subagents — big side-quests (broad searches, analyzing many files) run in a spawned subagent that reports back, keeping your context lean.
- ⚗
vanta_eval— the agent test-runs Vanta snippets in-place before committing them to files. - 🩺
/doctor— one command checks your whole Vanta toolchain (vanta · vc · vself · vanbrew), key, vision support, and terminal. - A fresh coat of paint — new default
dusktheme (violet → gold), toolchain and git branch in the banner, a context meter above the prompt, andclaude-fable-5as the default Anthropic model.
Install
vanbrew install vcode # or: curl -fsSL https://raw.githubusercontent.com/Juanshep1/vcode/main/install.sh | sh
vcode # first run walks you through adding an API key
That's it. On first launch vcode asks you to pick a provider and paste an API
key right in the terminal (saved locally to ~/.vanta-code/config.json) — no
export needed. Change it anytime with /provider or /key. Prefer env
vars? You can still set ANTHROPIC_API_KEY / OPENROUTER_API_KEY /
OLLAMA_API_KEY and vcode will use them.
For the Run features (
run_vanta/run_app) you need thevantaCLI:vanbrew install vanta. Everything else works without it.
🧩 Skills (Claude Code compatible)
Skills are reusable expertise the agent loads on demand. A skill is just a
folder with a SKILL.md (YAML frontmatter name/description + markdown
instructions, optionally bundling scripts). vcode reads them from:
~/.vanta-code/skills/<name>/SKILL.md(and./.vanta-code/skills/per-project)~/.claude/skills/<name>/SKILL.md— so your existing Claude Code skills work as-is.
The agent sees each skill's name + description, and calls the use_skill tool to
load a skill's full instructions when a task matches. Browse them with /skills.
⭐ My Skills — your favourites, one keystroke away. With hundreds installed, you
don't want to scroll the whole list every time. In /skills, highlight a skill
and press Enter to pin it to My Skills (pinned ones show a ★). Then:
/myskillsopens a short browser of just your pinned skills — press Enter on one to load it into the conversation, so the agent applies it to your next request.- Your pinned skills also appear right in the
/menu and are typeable directly — e.g. just type/pdfto load the pdf skill./skills remove <name>unpins.
Pins persist to ~/.vanta-code/myskills.json.
Reference a skill right in your prompt with #skill-name — no need to load it
first. Writing "make a #pdf invoice generator" inlines the pdf skill's
instructions into just that message. Tab-completes (#pd→#pdf), and only expands
when the name matches an installed skill, so ordinary # (issue #5, C#) is left alone.
Grab a pile in one command: /skills install clones Anthropic's official
skills (pdf, docx, xlsx, pptx, frontend-design, mcp-builder, skill-creator,
webapp-testing, canvas-design, brand-guidelines, …) into your skills folder. Add
any other repo with /skills install owner/repo (or a full git URL). With hundreds of skills installed, vcode keeps the prompt lean (it lists names only and the agent uses find_skill to search them on demand). vcode also
ships vanta-web-app and vanta-game skills, so it's an expert at building Vanta
apps and games out of the box.
mkdir -p ~/.vanta-code/skills/my-skill
cat > ~/.vanta-code/skills/my-skill/SKILL.md <<'EOF'
---
name: my-skill
description: What this is for and when to use it.
---
Step-by-step instructions the agent should follow...
EOF
📱 On a phone (Android or iPhone)
vcode and Vanta are pure Python, so they run in a mobile terminal app. You'll need an API key and internet.
Android — Termux
Install Termux from F-Droid (the Play Store build is outdated). Then:
pkg update -y && pkg install -y python curl
curl -fsSL https://raw.githubusercontent.com/Juanshep1/vanbrew/main/install.sh | sh
. ~/.bashrc 2>/dev/null ; . ~/.profile 2>/dev/null
vanbrew install vcode # pulls vanta automatically
vcode # it'll prompt you for an API key
vcodenot found / "no formula named vcode"? You have an older bundled catalog — re-run the installer line above (it fetches the latest Vanbrew), or runvanbrew updatefirst, thenvanbrew install vcode.
iPhone / iPad — iSH
Install iSH from the App Store (a tiny Linux shell). Then:
apk update && apk add python3 curl ca-certificates # ca-certificates is REQUIRED (else HTTPS fails)
curl -fsSL https://raw.githubusercontent.com/Juanshep1/vanbrew/main/install.sh | sh
. ~/.profile
vanbrew install vcode # pulls vanta automatically
vcode # it'll prompt you for an API key
vcodenot found / "no formula named vcode"? Your bundled catalog is old. Re-run the installer line above (it fetches the latest Vanbrew), or runvanbrew updatefirst, thenvanbrew install vcode. iSH ships without CA certs, so if downloads fail with a TLS/SSL error, runapk add ca-certificates.
Any terminal with Python (fallback — also works in a-Shell on iOS)
If a package manager or the installer isn't available, download the two files with Python itself and make them commands with aliases:
mkdir -p ~/bin
python3 -c "import urllib.request as u;[u.urlretrieve(a,b) for a,b in [('https://raw.githubusercontent.com/Juanshep1/vcode/main/vcode.py', __import__('os').path.expanduser('~/bin/vcode.py')),('https://raw.githubusercontent.com/Juanshep1/vanta/main/vanta.py', __import__('os').path.expanduser('~/bin/vanta.py'))]]"
echo "alias vcode='python3 ~/bin/vcode.py'" >> ~/.profile
echo "alias vanta='python3 ~/bin/vanta.py'" >> ~/.profile
. ~/.profile
export OPENROUTER_API_KEY="sk-or-..."
vcode
To keep your key, append it too: echo 'export OPENROUTER_API_KEY="sk-or-..."' >> ~/.profile.
On phones (servers + web apps work on-device):
serve()is pure Python sockets, so Vanta runs a real web server right on your phone. When you ask vcode to build a visual app, it serves it and openshttp://localhost:<port>/in your phone's browser (and prints a tappable link). On Termux,pkg install termux-apilets it auto-open; otherwise just tap the printed URL. (For visual apps on a phone, prefer aserve()app over thefile://pattern — mobile browsers restrictfile://.) The only desktop-only bit is the movable app window; iSH is emulated, so it's slower than Termux.
Phone-keyboard tips
The terminal UI is mobile-hardened (it survives laggy/split key input and the app being backgrounded, uses narrow-screen layout, and ASCII-safe glyphs). To reach keys a soft keyboard lacks, use your terminal's extra-keys row (Termux shows one above the keyboard; Terminus/Termius has an accessory bar) for Esc, Tab, Ctrl, and the arrow keys.
- Permission modes: Shift+Tab cycles them — but if your keyboard can't send it,
just run
/mode(cycles default → auto-accept → plan), or/auto//plan. - Slash commands: press
/on an empty line to open a dropdown — arrow ↑/↓ to browse (your pinned skills are at the top), Enter/Tab to pick. Or just keep typing and it collapses to an inline autosuggest (command in blue, rest as faint ghost) you accept with Tab. - Long prompts word-wrap onto aligned continuation lines instead of scrolling off to the right.
@fileand#skillcompletion work with the Tab key from the extra-keys row.
What it does
╭──────────────────────────────────────────╮
│ ✻ Welcome to Vanta Code │
╰──────────────────────────────────────────╯
› build a draggable tip calculator and run it
⏺ I'll write it and pop it open.
⏺ Write(tipjar.va)
⎿ +38 lines
⏺ Open app(tipjar.va)
⎿ window opened
⏺ Done — drag it by the header.
- Speaks Vanta natively — its system prompt is a compact, accurate Vanta
reference (plain-English syntax,
serve/http_get/filesystem builtins, the{{ }}brace rule), so the code it writes actually runs. - Real tools (17) —
read_file(text and images),write_file,edit_file(surgical find/replace),search(grep),glob,make_dir,move_path,delete_path,run_vanta,run_app(pops the app in a movable window),bash,use_skill/find_skill,set_todos(live checklist),vanta_eval(snippet runner), andagent(subagents). Full filesystem access; writes are frictionless, deletes/shell confirm once. - Live diffs — every write/edit shows a Claude-Code-style diff (
+green,-red, with line numbers). - Builds from scratch — ask for an app and it writes fresh
.vacode, makes a folder for it, runs it, and fixes its own errors. - Looks the part — welcome wordmark,
⏺/⎿tool lines, a thinking spinner, markdown-rendered replies, and a bordered prompt.
Bring your own key
vcode thinks with an LLM, so it uses your API key from the environment — nothing is hard-coded or stored on a server:
| Set this | Provider |
|---|---|
ANTHROPIC_API_KEY | Claude, directly |
OPENROUTER_API_KEY | OpenRouter (all ~337 models) |
OLLAMA_API_KEY | Ollama Cloud (full cloud catalog) |
Switch live with /provider. The /model picker fetches the provider's
full live model list — just type to filter (e.g. claude, qwen).
Commands & shortcuts
/help | show help |
/provider [name] | switch Anthropic / OpenRouter / Ollama |
/model [n|name] | pick a model (type to filter the full list) |
/themes | color theme: dusk · ember · synthwave · matrix · ice · gold · mono |
| Ctrl-V | paste an image from the clipboard into the chat (text pastes too) |
/paste | same as Ctrl-V, as a command |
/doctor | health-check the Vanta toolchain, key, vision, terminal |
/stream | toggle live streaming output |
/todos | re-show the agent's current checklist |
/init | scan the project and write a VANTA.md (auto-loaded next time) |
/skills | browse skills; Enter pins one to My Skills (★) |
/myskills | your pinned skills; Enter loads one to use (also: /<skill-name>) |
/resume | reload your last session (or start with vcode --continue) |
/compact | summarize the conversation (also automatic) |
/auto, /cwd, /clear, /exit | … |
| Esc | interrupt the agent mid-task |
!command | run a shell command directly |
@path | inline a file's contents into your message |
#skill-name | reference a Skill inline in your prompt (e.g. make a #pdf invoice) |
""" | start a multi-line message (end with """) |
| ↑ / ↓ | recall previous prompts |
Themes
Seven gradient themes, set with /themes and remembered across sessions:
dusk (default) · ember · synthwave · matrix · ice · gold · mono
Honest scope
A single self-contained Python file, standard library only. It's a clean,
line-based REPL styled to look like Claude Code — banner, tool rendering,
spinner, diffs, streamed replies, vision input — not a full raw-mode TUI.
It runs Vanta programs to verify them and pops visual/web apps in a movable
window. Images attach via dragged-in paths, Ctrl-V, or /paste (the
terminal provides drag-and-drop as a pasted path; vcode detects and reads the
file, and Ctrl-V reads the clipboard through pbpaste/osascript/xclip).
Requirements
- Python 3 (no third-party packages)
- An API key (above)
- Optional: the
vantaCLI for running programs; Chrome for the movable app windows.
License
MIT — see LICENSE.