Your AI Agent Just Changed 40 Files... Now What? (Whiteboard)

Author: Better Stack · Watch on YouTube

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: English

Original video: Your AI Agent Just Changed 40 Files… Now What? (Whiteboard) · Channel: Better Stack · 07:42 · Watch on YouTube

Topics: AI agents, Software engineering with AI, AI developer tools, Privacy and data protection

Summary

The video introduces Whiteboard, an open-source app that helps developers review AI-generated code changes by turning them into diagrams linked directly to relevant code. It demonstrates connecting the app to an agent and using it to map a branch’s request flow, while explaining how Whiteboard differs from system-mapping and pull-request review tools. The review emphasizes that diagrams are useful guides, not proof: developers still need to inspect the code themselves. It also covers telemetry and trace-storage privacy considerations, platform limitations, and when the tool may be useful.

Key points

Whiteboard aims to reduce the cognitive effort of understanding AI-generated code changes by mapping them and linking diagram steps to code.
The demonstration connects the Mac app to an agent through a CLI and plugin, then asks it to review a branch against main.
Whiteboard displays structured blocks such as sequence diagrams, flow diagrams, call-stack diffs, code views, and a database lens.
Its diff viewer separates code structure using syntax-tree information, helping distinguish changed logic from tests and documentation.
Unlike system-mapping tools or cloud pull-request bots, Whiteboard focuses on reviewing a change locally with the developer’s own agent.
Decision logs record choices an agent made, and trace archaeology is intended to answer questions about code using the sessions that produced it.
Diagrams can still be wrong; the video recommends treating them as claims and clicking through to verify the relevant code.
Telemetry is on by default, and the video warns that crash dumps may contain process memory, including source text; it recommends disabling telemetry before opening a private repository.
The hosted trace store can upload full agent transcripts, and GitHub sign-on requests repository scope.
The presenter sees Whiteboard as most useful for substantial agent-written branches, not small diffs, and says it does not replace an editor.

Chapters

Start	Chapter	Summary
00:00	The challenge of understanding agent-written changes	The video frames cognitive debt as the work of understanding code that agents can now produce cheaply and introduces Whiteboard as a way to map changes to code.
01:03	Connecting Whiteboard and reviewing a branch	The presenter installs the plugin, discusses telemetry settings, and demonstrates generating a request-flow diagram linked to the relevant code.
03:07	How Whiteboard works and where it fits	The video explains Whiteboard’s structured diagram blocks and code-aware diff viewer, compares it with other tools, and introduces decision logs and trace archaeology.
05:09	Verifying diagrams and protecting data	The presenter cautions that diagrams can be inaccurate and details telemetry, crash-dump, hosted trace-store, and sign-on privacy considerations.
07:11	Limitations and when to use it	The video covers current platform and product limitations and recommends trying Whiteboard on substantial changes while continuing to inspect code and use an editor.

Quotes

Agents made writing code cheap. They didn’t make understanding that though. — 00:00

Instead of reading directions in a paragraph, I have a map and I can check where it actually leads to. — 02:37

A link makes an explanation easier to check. It doesn’t make the explanation automatically true, though. — 05:09

Not how good the map looks, but whether I understand what I’m about to merge. — 07:42

Concepts and entities

Whiteboard, cognitive debt, MCP, decision log, trace archaeology, Claude Code, Better Stack, Archify

Full transcript (original language)

00:00 Your agent just changed 40 files. You’re about to approve the poll request, but could you actually explain what it did? I’m hoping most of us review it, but there’s a better way to do just that. This is Whiteboard, a new open- source app that makes your agent draw a map of those changes and link straight into the code. So, how does this work and where does it fit? Let’s find out. The real issue the creators of this call is cognitive debt. Agents made writing

00:32 code cheap. They didn’t make understanding that though. We still pay for that part in every review. We open the diff and its tests, docs, and logic mixed together. Ask the agent to explain and now you’re reading a wall of markdown. Yeah, sure. That’s fine. But it can be cumbersome and long. We might just need a pretty simple who calls what. What changed in the shortcut to the exact line? Let me show you. If you enjoy coding tools to speed up your workflow, be sure to subscribe. We have videos coming out all the time. All right, now here we are. You download the

01:03 Mac app, open it, and click connect cla. It installs a small CLI and gives you two commands to add to the plugin. Right here is the first plugin, and here’s the second one. Both of these are for whiteboard. So, you’ll paste those in your terminal. Reload cloud code as we do with any new plugin. Now, we have it. Leave the whiteboard app running. That’s the local server the plugin talks to. Before opening a private repo, turn telemetry off. Settings. Disable. Share anonymous usage data. I’m going to

01:33 circle back to that why in a moment. Now, in a real repo, you can ask claw a question. I’m just going to fire off the question here. Review my current branch against up-to-date main. Open the result in whiteboard. Walk the request flow as a sequence diagram and put the relevant code next to each step. Now we’re going to run it and on screen you can keep the short line if that’s what you want. Okay, I did a longer one. If you want to say review the branch against main, use whiteboard. It just picks up whiteboard, right? Approve the

02:04 tool calls. Don’t approve rights. This pass is review only. Now watch the canvas here. A sequence diagram of the request flow streams in in the code next to each step as well. That’s not a mermaid block in Chad. Claude is authoring a review on the local whiteboard server. I click a step and it takes me into that function. Now I can follow the explanation and check it out without hunting through the files. Switch to the diff. Tests and

02:37 docs are folded away. Big functions are summarized as pseudo code. What’s left is the logic that actually changed. Instead of reading directions in a paragraph, I have a map and I can check where it actually leads to. That click into the function is key to really all this really. Whiteboard is a fork of VS Code Code OSS that is just running on Electron. Our agent talks to it through an MCP server installed as a clot code plugin. And the agent doesn’t just draw whatever it wants. It fills in typed

03:07 blocks, sequence diagrams, flow diagrams, call stack diffs, code peaks, even a database lens. Think of forms instead of a blank page. Each block has a defined structure and connects to real code. The diff viewer has its own engine that’s actually written in Rust. It reads the code’s structure, the syntax tree, not just the lines of text. That’s how it separates everything out. Now, if you watched the video I did on Archifi recently, you’re probably thinking, “Didn’t I just cover that?” Well, kind

03:37 of, but not quite. Archify maps your system. Whiteboard reviews a change. Whiteboard’s team actually started with HTML artifacts, then moved to VS Code because connecting diagrams to code was difficult and pure HTML. Mermaid Diagrams are great for docs. They live in Markdown and Git, but you don’t get that click from a box into a function. And sure, code rabbit or graphite, those are cloud bots commenting on your pull request. Whiteboard runs on your machine, uses your own agent, and posts

04:08 nothing into GitHub. It supports cloud code, codeex, cursor, open code, pi, oh my pi, all that stuff. It is MIT licensed from a company in YC’s winter 2026 batch. But understanding what changed throws us another question to be answered. Why did the agent choose to do it in that way? Whiteboard has a decision log built in, a running list of choices the agent made without asking you or I. That’s the stuff that often never reaches a commit message. Then there is what they call trace

04:38 archaeology, not the dinosaur stuff. Okay, this is the code stuff. Point at a piece of code and ask it why it exists. And it’s meant to answer using the agent sessions that wrote it. Think uh get blame but for the conversation behind the commit. I haven’t tested this one. Trace capture is off by default and traces can live locally or in their hosted store. Check which one you’ve selected because that is going to matter depending on how this kind of plays out. Now back to the first question here. Who checks the map? Now some devs actually

05:09 noticed the launch demo showed a flow that wasn’t actually in the code. The creator of whiteboard said real diagrams are linked to code. So hallucinations don’t really happen in practice, but AI, okay, they do happen. Again, that’s just the creator of this talking, so test it out. A link makes an explanation easier to check. It doesn’t make the explanation automatically true, though. So, treat any diagram as a claim. Click through and read the relevant code. Some also worried this would become one more

05:39 source of truth that just slowly dies off, right? That’s why I wouldn’t treat it as this is the answer. You still have to read through it. I use it to find my way through the code. This is a tool to help with just that. And circling back again, here’s why you may want to turn telemetry off. Anonymous telemetry is on by default. Their privacy dock is clear about crashes. Electron crash dumps can contain process memory, including source text that you have opened. Those dumps get unlocked on the next launch and kept

06:10 for 30 days. Turn telemetry off in settings or set do not track. Their docs say that with telemetry off, crash dumps are deleted without being uploaded. do that before opening a private repo. There are also two optional features to understand before using them. If you turn on the hosted trace store, it uploads full agent transcripts and DevFast can decrypt them and GitHub sign on asks for repo scope. Whiteboard runs on your machine. That doesn’t mean every optional feature keeps your data on your

06:40 machine though. If you still want observability, don’t turn on their telemetry. Pointcloud codes open telemetry at better stack. your source, your token, your account. You get cost usage and failures. Crash dumps and decryptical transcripts stay out of the canvas whiteboard. Leave prompt logging off unless you mean to send that, too. Now, the Mac download is 340 megabytes and Apple silicone only. It’s VS Code underneath, but you can’t edit files in it. The issue tracker has 13 open issues, including a Codeex startup

07:11 crash, a flow diagram error, and requests for Intel Max, Copilot, and GitHub Enterprise. Today, as I’m filming this, whiteboard is free, open source, and local, but who knows with these projects that may change or get paywalled. The MIT license matters, too. Another pivot doesn’t take away the code you already have. Okay. Now, for big agent written branches that actually need understood in more detail. Yeah, sure. I’d use this. I like these kind of tools. Try it on a real review. Click through the important parts. For a 10-line diff, come on. Just skip this.

07:42 And either way, keep your editor. A diagram doesn’t solve that just by looking convincing. It helps when you can follow the explanation, check the code, and explain the change yourself. That’s what I judge whiteboard on. Not how good the map looks, but whether I understand what I’m about to merge. If you enjoy coding tips and tricks like this, be sure to subscribe to the Better Stack channel. We’ll see you in another video. [music]