Works beside Claude Code, Codex and OpenCode

Understand the code you didn’t write.

Mira splits a repository into the steps the program takes. Click a step to open its parts, and keep going until you reach the code.

curl -fsSL https://raw.githubusercontent.com/jbw9/understand-slop/main/install.sh | sh
Paste it in a terminal on macOS or Linux.
View on GitHub
109 files · c0c5eac

loading mira…

This is the app, running on maps of real repositories. Click a step to open it, and press Esc to go back.

The writing part has gotten cheap. The verification hasn’t.
Sam Witteveen“What is the Future of IDEs”

Why we’re building this

Code got cheap. Understanding didn’t.

Agents now write in minutes what takes hours to read. A small fix comes back touching a dozen files, and the mistakes that matter are architectural: they surface months later, when fixing them means understanding a lot of code nobody ever read.

The tools we had didn’t help much. A terminal shows a wall of text, an agent panel one message at a time, an editor one file at a time. Asking an assistant “how does this work?” answers one question and loses the big picture. We wanted to see the whole program first, then go straight to the part that changed.

You can’t see what the agent changed.

One task “could be touching 10, 15 different files”, and “from the terminal alone you really can’t see any of that.”
Sam Witteveen, “What is the Future of IDEs”

Miradraws every change on the map: which sections a commit touched, what is new, changed or gone, and the lines under each.

Reviewing takes longer than writing.

45% of developers say debugging AI-generated code takes longer, and 66% say its answers are “almost right, but not quite.”
Stack Overflow, Developer Survey 2025

Miralets you read at the right height: the steps the program takes first, then only the parts that changed, down to the line.

You own what you ship, whoever typed it.

“Accountability doesn’t transfer just because the authorship did.”
Isaac Levin, “Why We Still Need an IDE”, JetBrains

Mirachecks every sentence on the map against the code it cites. What it couldn’t prove is marked, so you know what to read yourself.

Your agent is working blind too.

“An agent that can only grep through files … is often an agent that’s kind of working blind.”
Sam Witteveen, “What is the Future of IDEs”

Mirais the agent’s context as well. Pick a section and it goes into the next prompt; Claude moves your view to the part it’s explaining.

Worth reading

How it works

From the whole repo to one line.

Beside your agent

Keep up with your agent.

Claude Code, Codex and OpenCode open in tabs beside the map. Pick a section and it goes into Claude’s next prompt, so you can ask about the part you’re looking at.

When an agent edits the code, the map redoes only the sections it touched, and marks which ones changed.

Your repo

Map your own repo.

  1. Install the app.

    One line in a terminal, on macOS or Linux. It builds Mira from source, and works through the Claude Code you already use, signed in with your Claude plan.

  2. Import a folder.

    Any git repository on your computer. Your Claude Code makes its map right away: about 20 minutes for a mid-sized repo, counted against your plan's usage.

  3. Open it.

    Start at the steps and go down to the code. The map stays on your computer, in the app's own folder.

curl -fsSL https://raw.githubusercontent.com/jbw9/understand-slop/main/install.sh | sh
Paste it in a terminal on macOS or Linux.

It needs git, Node 20 or newer, Rust and CMake, and tells you if one is missing. The script is install.sh, in the source on GitHub.

Questions.

Is this an IDE?

No. Keep the editor you use. An editor shows one file at a time and an agent panel one message at a time; Mira shows how the whole repository fits together and what a change did to it. It opens the code where you need it, and hands your questions to the agent beside it.

Does my code leave my computer?

Only the way it does whenever you use Claude Code: your own Claude Code reads the files it needs to make the map. The map itself is saved on your computer and nowhere else.

What do I need?

A Mac or a Linux desktop, and Claude Code signed in with a Claude plan. Making a map counts against that plan's usage, like any other Claude Code session.

Which languages does it read?

TypeScript, JavaScript, Python, Go, Ruby, Rust, Java, Kotlin, Scala, Swift, PHP, C# and Elixir, along with Vue, Svelte and Astro components, and the SQL, Prisma, GraphQL and protobuf files around them.

How do I tell what's proven from what's a guess?

A solid line or a plain card came from the code. Anything the map couldn't prove is marked: a dashed line, or a card labelled partial or inferred. Sentences that failed the check are taken out before you see them.

What happens when the code changes?

An update finds the files that changed since the map last looked, redoes only the sections whose code they touch, and moves every other line reference along with the code, so the rest stays true.

Start broad. End at the line.

curl -fsSL https://raw.githubusercontent.com/jbw9/understand-slop/main/install.sh | sh
Paste it in a terminal on macOS or Linux.
View on GitHub