Onboard — Assistente de Onboarding e Verificação de Codebase
VerifiedOrganic/onboard
Análise de codebase e rastreamento de impacto com MCP — entenda arquiteturas rápido
Ver no GitHubMCP server em Go que fornece análise estrutural profunda de codebases, rastreamento de fluxo de dados, análise de impacto e walkthroughs guiados. Projetado para verificar código gerado por IA e acelerar onboarding em repositórios complexos ou herdados, com interface integrada em qualquer agent MCP-compatível.
Instalação
npx convez-ai VerifiedOrganic/onboard1 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
- Onboarding em codebases herdadas ou desconhecidas
- Verificação e validação de código gerado por IA antes de merge
- Análise de impacto antes de mudanças críticas
- Detecção de código morto e lógica duplicada
- Integração com pipelines CI para verificação automatizada
Veredito

Ferramenta sólida e bem-arquitetada que resolve um problema real: entender e verificar código rapidamente em era de geração automatizada. A abordagem MCP-first garante compatibilidade ampla com agentes, e o design como binário único torna deployment sem atrito.
README
A tradução para o português deste README ainda está na fila.
onboard
You inherited a codebase. Maybe a teammate wrote it and left. Maybe you wrote it, six months and all your context ago. Maybe an agent generated forty files at 2am, they all pass the tests, and you trust exactly none of them.
onboard reads the thing and walks you — or your agent — through it: the architecture,
the real end-to-end data-flow traces, and the load-bearing code nobody wrote down. It
ships as one static Go binary that is both an MCP server and a CLI installer.
MCP is the Model Context Protocol — the open standard agents use to talk to outside tools. The whole point of onboard being an MCP server is that every agent speaks it, so one binary reaches all of them.
Any MCP-capable agent — Claude Code, Codex, Grok, opencode, Cursor, Copilot CLI, Junie CLI — can launch it, and a CI pipeline or custom harness can drive it over HTTP.
It's especially pointed at fast and AI-generated code — the kind that arrives faster than any mental model can form. The walkthrough is as much a verification tool as a learning one: it surfaces where an autonomous build drifted, duplicated logic, or wired two components together in a way nobody intended.
60-second quickstart
# 1. build it (Go 1.25+)
go build -o onboard .
# 2. wire it into every agent you have installed
./onboard init
# 3. confirm it actually took (reads your configs, changes nothing)
./onboard doctor
Now restart your agent (so it picks up the new server) and type /onboard. You'll
get a guided, stepped tour of whatever repo you're sitting in — you pick the direction
(start from the entry points and walk inward, or from the load-bearing core and work
outward), and it paces itself one move at a time instead of dumping a wall of text.
Use /onboard-skills or onboard skills when you want the catalog of shipped
workflows.
Driving it from CI or your own harness instead of an interactive agent? Run it as a server and point an MCP client at it:
./onboard serve # MCP over stdio (what agents launch)
./onboard serve --http :8080 # MCP over Streamable HTTP at /mcp
These start the server — they don't print a walkthrough on their own. onboard is the
server; something that speaks MCP (an agent, or your CI harness) is the client that calls
its tools. There's no standalone onboard analyze CLI by design.
New here? docs/getting-started.md is the unhurried version of the above, with what-you-should-see at each step.
What you actually get
Two halves of one idea — how to teach a codebase, and the facts to teach from:
- Skills — the teaching playbooks, embedded in the binary and namespaced as
onboard-*so they group together in agent skill lists.onboard-codebase-walkthroughruns the top-down tour; four siblings cover diagrams, the per-change blast radius, a standing risk register, and keeping a cached guide fresh. - Tools — 17 MCP tools that turn "where do I even start" into ranked, cited answers:
recon(structural scan),repo_map(the load-bearing core, ranked),trace_flow(follow a flow end to end),impact(what breaks if I change this),context_pack(everything relevant to X in one shot),dead_code(written-but-never-wired-in),explain_diff(what this PR touched and its blast radius), plusdeps,schema,routes,history,render_map, and a durableguidecache.
The tools are backed by a pure-Go tree-sitter code graph covering ~200 languages with
no CGo. Its call edges are syntactic — resolved by name and lexical scope, not
type-checked. Translation: treat an edge as a very strong rumour, not a sworn affidavit.
For Go, precise: true promotes the rumour to a type-checked fact. For Rust Cargo
projects, precise: true can enrich the graph through rust-analyzer call hierarchy when
that binary is installed; otherwise Rust stays on the zero-setup syntactic fallback.
The one rule that explains everything
onboard stays a single static, CGo-free, cross-compilable binary. That one
constraint is why the tree-sitter engine is pure Go, why ~200 grammars are baked in (the
stripped binary is ~32 MB — broad language coverage is the whole point of an onboarding
tool), and why the graph is honest about being syntactic rather than pretending to a
precision it can't guarantee everywhere. When a design choice looks odd, this rule is
usually the reason.
Where to go next
The docs are arranged by what you're trying to do, not by what's easiest to write:
| You want to… | Read |
|---|---|
| Use it — install, verify, run your first walkthrough | getting-started.md · install.md |
| Understand it — the mental model before the internals | concepts.md |
| Integrate it — the tool, skill, and prompt contracts | mcp-tools.md · skills.md · guide-cache.md |
| Build on it — hack on onboard's own Go internals | architecture.md · code-graph.md · development.md |
| See why it's built this way | research-notes.md · enhancements.md |
Status
Built and tested: the embedded skills, the per-agent installer and doctor, the
code-graph engine (recon, trace_flow, impact, repo_map, context_pack,
dead_code, explain_diff, render_map), the guide cache, stdio and Streamable HTTP
transports, and the optional Go/Rust semantic precision layers. CI runs test + vet +
golangci-lint + a cross-build matrix; releases ship via GoReleaser.
Requires Go 1.25 or newer to build.