New QA view: see what your tests cover

Open source · macOS · Windows · Linux

Stay part of your codebase while AI writes it.

CodeDiver is a desktop app your coding agent can drive. It walks you through the code, explains functions step by step, draws how execution flows, and puts every change it wants to make in front of you to approve. The agent keeps the speed. You keep the understanding.

Download CodeDiver Connect your agent

Works with Claude Code, Cursor, VS Code, Claude Desktop, Codex — anything that speaks MCP.

Latest release: v0.1.0

A CodeDiver walkthrough: a numbered list of steps, the agent's explanation, highlighted code and a map of the path between steps.
An agent-led walkthrough: steps, narration, highlighted code and a map of the path.

AI made writing code cheap. Understanding it is still on you.

01

Agents out-type you

Hundreds of lines land in minutes. Reading them line by line in a diff can't keep up — so you start skimming, then trusting, then guessing.

02

Diffs show lines, not meaning

A diff tells you what changed. It doesn't tell you which functions are affected, who calls them, or how the request actually flows now.

03

You can't own what you don't understand

When something breaks at 2am, it's your codebase. The mental model has to live in your head — not just in a chat transcript.

CodeDiver gives your agent a screen to show its work — and gives you the tools to see the codebase for yourself.

How it works

Three steps to a codebase you still understand

  1. 1

    Add your repository

    CodeDiver indexes it locally — call graphs, types, control flow, git history. Nothing leaves your machine.

  2. 2

    Connect your agent

    One command adds CodeDiver as an MCP server. Your agent can now see the code the way you do — and show you things.

    claude mcp add --transport http codediver http://127.0.0.1:47474/mcp
  3. 3

    Ask, watch, decide

    Ask “walk me through this” or “fix that bug”. The agent opens views in front of you, explains as it goes, and proposes changes you accept or reject.

Built-in MCP server

Your agent, with a screen

Most agents can only answer in text. With CodeDiver connected, they can open the code you're talking about, draw the graph that explains it, and narrate the logic block by block — while you watch. Turn on Follow agent and every view it shows opens in front of you.

You

Explain the function I have open — what goes in, what comes out, and how it works.

Claude Code
  • get_developer_context→ views.go · Service.Diff
  • get_function_flow→ 16 blocks, 5 inputs, 2 outputs
  • explain_function→ shown in CodeDiver

I've opened the logic view for Service.Diff. Each step on the right is pinned to the block it describes — start at step 1.

You

What actually calls this?

Claude Code
  • trace_toshow: true

Every path from the entry points is on your screen now.

The logic view: inputs and outputs with the agent's descriptions, a control-flow graph with numbered steps pinned to blocks, and the agent's explanation.
What you see: inputs → function → outputs, the control-flow graph, and the agent's narration pinned to each block.

30 tools, five jobs

Understand context

Know what you're looking at before answering.

  • get_developer_context the file, line, selection and function you have open
  • repo_overview languages, entry points, hotspots
  • list_repos · list_files · read_file
  • get_file_summary every function, type and variable in a file
  • search_code · search_symbols · get_symbol

Analyze

Precise answers instead of guesses from grep.

  • trace_to every path that reaches a function
  • get_call_graph callers and callees, interface dispatch resolved
  • get_function_flow the control-flow graph of a function
  • get_dependencies · get_types
  • git_diff · git_log · git_status · get_heatmap

Teach

Put understanding on your screen, not just in chat.

  • start_walkthrough a guided, step-by-step code tour
  • explain_function inputs, outputs and logic, pinned to the graph
  • show_diagram Mermaid or interactive diagrams linked to code
  • annotate_code inline notes in the editor
  • show_code open a file and highlight what matters

Change — with you in charge

Agents propose. You decide.

  • propose_changes a reviewable change set; nothing is written until you accept
  • get_proposal your decision and feedback, back to the agent

Agents can't write files any other way.

Test

Know what's covered before writing more.

  • get_test_overview coverage, tests and the riskiest gaps
  • get_coverage uncovered lines per file and function
  • get_tests_for which tests reach a function, and what they check
  • find_test_gaps untested code ranked by risk, with what makes it hard to test
  • show_test_plan behaviors to cover and refactors needed, on your screen

Agents read results; they can't run commands.

Connect in one line

CodeDiver runs a local MCP server at http://127.0.0.1:47474/mcp. Stdio-only clients use the built-in bridge: codediver mcp.

claude mcp add --transport http codediver http://127.0.0.1:47474/mcp
The Agent panel listing a proposal, a walkthrough, an explained function, a diagram, inline notes and a live activity feed of every MCP tool call.
Every tool call shows up in the live activity feed — you always know what the agent looked at.

Walkthroughs

Onboarding in minutes, not weeks

Ask “walk me through how a request reaches the database” and your agent builds a guided tour you can step through at your own pace.

  • Every step is real code — opened, highlighted and explained in place, with code lenses showing callers and callees.
  • A map of the path shows where you've been and where you're going.
  • Keyboard-driven — arrow keys move between steps; jump into any function's logic or trace from there.
  • Reusable — tours stay in the Agent panel for the session, so you can revisit them.

The point isn't for the agent to know your codebase. It's for you to.

Step 2 of 5 of a walkthrough titled 'How an agent's request reaches your screen', highlighting the AgentRepo function.
Step 2 of 5: the agent explains why every call goes through the sandbox.

Diagrams that point back to code

Agents can draw sequence, flow, class and state diagrams with Mermaid — or interactive graphs whose nodes open the code they describe. Architecture stops living only in someone's head.

A sequence diagram drawn by the agent showing the path from a developer's prompt through the MCP server to the CodeDiver window.
A sequence diagram the agent drew to explain its own workflow.

Proposals & review

Nothing touches your code until you say so

Agents submit changes as proposals. You get a visual review — not a wall of text in a chat.

  • Side-by-side diffs with the agent's rationale for every file.
  • Blast radius — the functions it touches and everything that calls them.
  • Accept or reject per file, with feedback that goes straight back to the agent.
  • Conflict-safe — if the file changed since the proposal, CodeDiver refuses to overwrite it.
A proposal review: summary, per-file list, the agent's rationale and a side-by-side diff with Accept and Reject buttons.
An agent's proposal, waiting for you.
The blast radius of a proposal: the changed function and its callers up the chain.
Blast radius: who is affected by the change.
Reviewing working-tree changes: changed files with the functions they touch, a diff, and the blast radius graph.
Your own changes get the same treatment — any branch, commit or the working tree.

QA view New in v0.1.1

Know what your tests actually cover

Agents write tests fast. CodeDiver shows you whether they test what matters, and what's still exposed.

  • Real line coverage from your own tooling: Go, Vitest, Jest, pytest, Cargo, Maven, Gradle and .NET are detected, or import an LCOV, Cobertura, JaCoCo or Go report you already have.
  • Gaps ranked by risk: uncovered code weighted by complexity and how many callers depend on it.
  • Why it's hard to test: hard-wired clocks, network, filesystem, env vars, processes and sleeps, each with the refactor that fixes it.
  • Tests that reach it, directly or through its callers, so you don't write the same test twice.
The QA view's Gaps tab: functions ranked by risk with coverage bars, and the selected function's uncovered lines, a filesystem testability hint and the tests that reach it.
Gaps: the riskiest untested code, with uncovered lines and what makes it hard to test.
The code editor with coverage markers: green bars on lines that ran, red on lines that never ran, amber on partially covered branches, and a '70% covered · 1 test' lens on the function.
Coverage in the editor: green ran, red never ran, amber only some branches ran.
The Behaviors tab: test files rendered as readable specs, with describe blocks, each behavior and chips naming the code it calls.
Behaviors: every test as a readable spec, linked to the code it exercises.

Your agent plans the tests. You approve them.

Ask “what isn't tested here?” and your agent reads coverage over MCP, then puts a test plan on your screen: the behaviors to cover as given / when / then, tied to the lines they exercise, plus any refactor the code needs first. When you agree, it proposes the tests as a change set you review.

Coverage runs happen only when you click Run. Agents read the results; they can't run commands.

An agent's test plan for Repo.Diff: four behaviors with happy, edge and error badges in given/when/then form, and a refactor to build git arguments in a pure function.
A test plan posted by the agent with show_test_plan.

On your own, too

A map of the code you can explore yourself

Everything the agent can show you, you can open with a click.

Trace to here: every caller path from entry points to a function.
Trace to here Click any function and see every path from the entry points — including handlers registered as callbacks.
The code view with code lenses, an agent message, an inline agent note and the file summary panel.
Code, annotated Code lenses show callers and calls; the file summary lists every function's inputs and outputs; agents leave notes inline.
A treemap heatmap of the repository by complexity, with per-function heat for the selected file.
Heatmaps Churn, complexity, uncovered lines, your diff, pending proposals or where the agent has been looking — down to individual functions.
The repository overview: stats, languages, entry points and hotspots.
Overview Entry points, hotspots and structure the moment you open a repository.
  • Command palette jump to any symbol, file or view with Ctrl/⌘ K
  • Call, dependency & type graphs laid out automatically, interactive
  • Git history per file, with diffs of every commit
  • Ten themes from Deep Dive to Paper, light and dark

Safety model

You decide what the agent sees and changes

  • 01
    Only the repos you add. Each one can be hidden from agents with a switch.
  • 02
    A real sandbox. No .. or symlink escapes; .git, .env*, keys and your own globs are invisible.
  • 03
    No silent writes. The only way to change code is a proposal you accept.
  • 04
    No commands from agents. Test and coverage runs start only when you click Run; agents just read the results.
  • 05
    Local only. Bound to 127.0.0.1, protected against DNS rebinding and cross-site requests. Your code never leaves your machine.

Language support

Precise

Go

Type-checked call graphs with interface dispatch, control-flow graphs, types, variables — no Go toolchain needed.

Lexical

15 languages

TypeScript, JavaScript, Python, Rust, Java, Kotlin, C#, C, C++, Ruby, PHP, Swift, Scala, Dart, Lua — functions, classes, parameters, docs, call edges and imports.

Everywhere

~80 languages

Syntax highlighting, search, git history and diffs, heatmaps, proposals, walkthroughs and agent explanations.

Releases

What's new

Every release is built and tested in CI on macOS, Windows and Linux, with checksums for every download.

v0.1.0

Latest October 16, 2026

The first release.

  • Desktop app with a built-in MCP server for Claude Code, Cursor, VS Code, Claude Desktop and Codex
  • Walkthroughs, function logic, trace-to-here, call graphs, heatmaps and visual review of agent proposals
  • Installers for macOS, Windows and Linux (x64 and ARM64), plus a headless server
All downloads

All releases on GitHub · RSS feed

Get CodeDiver

Free and open source under the MIT license.

macOS & Linux

curl -fsSL https://raw.githubusercontent.com/aitakemyjob/codediver/main/scripts/install.sh | sh

Universal app for Apple Silicon & Intel. Linux: .deb, .rpm, .tar.gz (x64, ARM64).

Windows

irm https://raw.githubusercontent.com/aitakemyjob/codediver/main/scripts/install.ps1 | iex

Installer or portable .exe. Uses the WebView2 runtime built into Windows.

Server / headless

codediver serve

The same UI in your browser — great for remote dev boxes. Binaries for every OS and architecture.

All downloads Star on GitHub