These Claude Code Mods Are ACTUALLY Useful: Filetree, Replay Theater, Blast Radius & More

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: These Claude Code Mods Are ACTUALLY Useful: Filetree, Replay Theater, Blast Radius & More · Channel: AICodeKing · 17:43 · Watch on YouTube

Topics: AI agents, Claude Code, AI developer tools, Model inference and optimization

Summary

The video demonstrates seven Claude Code mods through a task-manager project: File Tree, Replay Theater, Blast Radius, Collision Guard, AgentFlow, Reflect, and Cash Tax. It explains how to install and test each mod, what its interface or safeguards provide, and how to verify the results independently. Several mods do not make their own model calls, while Reflect’s automatic detection and AgentFlow’s delegated agents can add model usage. The video urges viewers to check permissions, understand each mod’s limitations and costs, and start with only the tools that address a real need.

Key points

Mods run inside Claude Code and can respond to events, change the interface, or intervene before a tool runs; verify the publisher and repository before installing.
File Tree provides a project browser and shows which files Claude is reading or changing, but attached file content can still increase token usage.
Replay Theater steps through edit requests from the latest editing turn; it is not a permanent history or undo feature, so verify changes with git diff and tests.
Blast Radius pauses certain risky bash commands for review, but its pattern coverage is limited and it should not replace careful inspection or normal permissions.
Collision Guard warns about overlapping edits from active Claude sessions on the same machine, while separate work trees remain preferable for independent tasks.
AgentFlow displays delegated agents, their states, tools, and elapsed time; the agents themselves still use models and count toward usage.
Reflect lets users review and save reusable project instructions; automatic detection uses Haiku, and saved rules do not guarantee perfect obedience.
Cash Tax attempts to keep a conversation prefix warm, but its effectiveness depends on the provider’s cache duration, and warming requests themselves use tokens.
The presenter recommends testing mods on a small project and disabling any that do not prove useful.

Chapters

Start	Chapter	Summary
00:03	Introduction and setup	The presenter introduces seven Claude Code mods, explains the demo project, and covers version requirements and installation precautions.
02:07	File Tree	File Tree adds an in-terminal project browser for navigating files, following Claude’s activity, and checking changes.
04:13	Replay Theater	Replay Theater lets users step through recent edit requests, with git diff and tests needed to verify the final result.
06:19	Blast Radius	Blast Radius pauses certain risky bash commands so users can inspect affected files before proceeding or canceling.
08:23	Collision Guard and AgentFlow	Collision Guard surfaces overlapping edits between Claude sessions, and AgentFlow displays the status and activity of delegated agents.
12:00	Reflect	Reflect proposes reusable project instructions for review and saving, with automatic detection adding model usage.
14:08	Cash Tax and recommendations	The presenter explains Cash Tax’s cache-warming costs and prerequisites, then summarizes which mods to try and how to evaluate them.

Quotes

The tree helps us navigate and the diff lets us confirm the actual change. — 03:42

This is a session view, not a permanent history or an undo button. — 05:49

Don’t use it as a reason to stop paying attention. — 07:53

This isn’t retraining Claude. — 13:36

Start with the problem you actually have. — 17:13

Concepts and entities

Claude Code, File Tree, Replay Theater, blast radius, Collision Guard, AgentFlow, Reflect, Cash Tax, Anthropic

Full transcript (original language)

00:03 Hi, welcome to another video. So before starting the video, I have been posting many tutorials of open-source projects that I like in membersonly videos as well. I am posting more regularly. So if you want to support the channel, please hit the join button and the videos are available on all tiers from bronze and up. So please go ahead and check them out. Now back to the video. Claude Code can build an entire feature while you’re making coffee. But when you come back, you still have to figure out what it changed, whether two agents edited the

00:34 same file, and why your context suddenly became expensive again. And that’s where some of these new Claude code mods actually become useful. Today, we’re going through seven of them with installation and a practical walkthrough for each. We have a file explorer inside Claude, a way to replay its edits, a warning before certain destructive commands, and a few tools for managing parallel agents and repeated corrections. I’m also including a cash mod that sounds like an obvious moneysaver until you look at how it works. So, we’ll get into the costs as well. For the demos, we’re using one

01:04 small task manager project. We’ll rename a function, review the changes, make two chats touch the same file, and try deleting a folder containing dummy build files that gives us something concrete to check for every mod. So, let’s get right into it. First, a quick setup. Mods are extensions that run inside cloud code. They can react to events, change parts of the interface, and sometimes intervene before a tool runs. They’re installed through plugins, but a plugin containing only a skill isn’t automatically a mod. Open your terminal and run claude- version. For this walkthrough, you want version 2.1.287

01:34 or newer. If you’re using the native installation, run clawed update when you need to update it. Mods are enabled by default on these versions. You don’t need the old experimental environment variable that you might see in some installation guides. I’m showing the terminal workflow. Make the window wide because several of these mods use a side panel. And after installing a mod, start a fresh claw session. Then use /plugin to check that it loaded. These extensions run code with your permissions. So check the publisher and repository before installing. I’ll include the exact commands and original project links below. Now the first one

02:07 is file tree. And this is probably the easiest one to understand immediately. If you’re using claude code in a terminal, you can spend a surprising amount of time switching back to your editor just to find a file or check where Claude is working. Filetree puts a project browser right next to the conversation. To install it, run claude plug-in marketplace add followed by the data goblin claude code filetree repository shown on screen. Then run claude plug-in install followed by file tree at claude code file tree. I’m using the- scope user option which makes the

02:39 installation available across my projects. Once that’s installed, open claude in the demo project. Type /2e fullcreen then /filetree. The mod needs full screen mode and a terminal at least 110 columns wide. So widen the window if the panel doesn’t appear. Now we can browse the source folder, the command line entry point, and the tests without leaving the conversation. If you only want the source folder, use /filetree followed by/src. Let’s give Claude a small inspection task. I’m asking it to explain how

03:10 adding a task works and to read the implementation and the corresponding test without changing anything. As it works, watch the activity in the tree. The useful part is being able to connect the files you’re looking at with the files Claude is actually reading. You can also select a file to accompany your next prompt as context. So, select the task implementation and ask which inputs it validates. That is a much nicer interaction than repeatedly typing the same B. For the editing check, ask Claude to change the project label in the configuration file to task lab. Then compare the change marker in file tree

03:42 with git diff in the terminal. The tree helps us navigate and the diff lets us confirm the actual change. This isn’t going to replace every feature of your editor, but if you prefer staying in Claude’s terminal, I think this is a really useful addition. There’s no separate model request needed just to draw the tree. Of course, if you attach more file content to a prompt, that content can still increase your token usage. So, a visual panel and the context you send are two different things. Now, seeing the files is useful, but what about understanding how Claude changed them? That’s where replay theater comes in. This is one of the

04:13 examples in anthropics cla playground repository. It lets you step through the file edit requests from the latest editing turn instead of trying to reconstruct everything from the conversation. The setup is slightly different here. First clone the clawed code playground repository using the command on screen. Then move into its clawed code folder and inside that the mods folder. From this directory, run claude plug-in marketplace. Add dot slash that registers the local sample marketplace. Then run claude plug-in install followed by replay theater at

04:44 claude code playground mods with d–scope user. Keep that downloaded repository around because this installation uses a local marketplace. We’ll use it again for the next mod. Now return to the task manager folder and start a fresh claude session. Don’t accidentally launch the coding demo inside the mod’s own source directory. For this test, I’m asking Claude to rename the add task function to create task everywhere it’s used. Update the implementation, the command line entry point, and the tests while keeping the behavior the same. I’m also asking it to use its file editing tools so we have edits for the mod to observe. Once the editing turn finishes, type /re replay.

05:17 Move through the steps using next and previous or the N and P keys. Check the implementation rename the import in the command line file and the test references. This is much easier to follow than jumping around a long transcript. But there’s an important detail here. Replay theater records edit requests. A failed or denied edit can still appear. So the replay alone doesn’t prove that the change reached your files. To finish the check, close the panel, run git diff, and run npm test. We’re looking for the same rename across the relevant files with the

05:49 existing behavior tests still passing. Also, this is a session view, not a permanent history or an undo button. A new editing turn replaces the previous replay. Restarting loses it and longer changes can be truncated in the panel. For a small refactor, though, I like this approach. You get a quick explanation of the steps. Then you verify the final result with the tools you already use. The mod itself doesn’t call another model, so it doesn’t add a separate AI review bill. The coding task still uses your normal clawed allowance. Anyway, now let’s come to blast radius.

06:19 This is the one I would demonstrate before letting an agent clean up anything important. You know those moments where Claude decides the best solution is to remove a folder or reset something. Sometimes that’s completely reasonable. I still want to see what the command is about to affect. Blast Radius watches for certain risky bash commands and holds them while it shows a report with proceed and cancel controls. Since we’ve already added the playground marketplace installation is just claude plug-in install followed by blast radius at claude code playground mods again with dash- scope user restart claude in the demo project after installing it.

06:49 For the walkthrough, we’re using the build folder containing three disposable text files. There is nothing valuable in this folder. We’ll also keep this command separate from any other shell operation so the report is easy to interpret. Ask Claude to remove that build folder using rm-rf build through bash. When the mod recognizes the command, it should hold the call and show the affected folder and its contents before execution. First, choose cancel. Then, inspect the folder from another terminal and confirm the three files are still there. That’s our cancellation check. Next, repeat the

07:21 same request and choose proceed. This time, check that only the dummy build folder is gone. Don’t judge this test just by the button animation. Check the file system afterward. On a wide terminal, the report uses a side pane. On a narrow one, it can use the area above the prompt. If several mods are competing for that space, show this one by itself so its controls stay visible. Now, this is helpful, but don’t treat it as complete protection. It recognizes particular bash patterns. A script, an alias, a different tool, or a more complicated command can fall outside its coverage. And if you combine multiple

07:53 operations into one shell line, the report doesn’t necessarily measure everything on that line. Keep normal permissions in place and read the actual command. My recommendation is pretty simple. Use this as another opportunity to catch an expensive mistake. Don’t use it as a reason to stop paying attention. Like Replay Theater, this is an example shared in Anthropics Playground and the mod doesn’t make its own model calls. Treat it as an example extension you need to evaluate for your workflow. Now, let’s move to a different problem. You have two Claude sessions working in the same project and both decide to edit the same file. Collision Guard gives you a decision before that second session

08:23 proceeds with a conflicting edit. To install it, add Nate Herks Claude Code mods repository as a plug-in marketplace using the command shown here. Then run Claude plug-in install followed by collision guard at Nate Herkmods with-scope user. For this demo, open two fresh clawed sessions in the same disposable git repository. Both sessions need to have the mod loaded. This is important because a session that isn’t participating can’t contribute the same tracking information. In the first session, ask claw to use its edit tool

08:55 to change the project label in the configuration file to starter. Keep that session open. Now switch to the second session and ask it to use edit on that same label, changing it to pro. The thing we’re checking is whether the second edit brings up a collision decision. Choose cancel first, then inspect the configuration file. The label should still be the value written by the first session. You can type /guard to inspect the guard status. By default, it looks for another active chat’s recent edits using a 30-minute look back. For a tracked git file, the dialogue can also offer a work tree

09:26 route. That’s useful because the second task can continue in an isolated checkout, but this isn’t a magic migration of everything you’ve already changed. The pending edit is refused and Claude gets instructions to list its existing changes and enter a work tree. Changes already sitting in the original checkout still need to be handled deliberately. There are limits here as well. It tracks certain clawed editing tools on the same machine. A formatter running through bash edits from your normal editor or another machine can be outside that view. So I would use it when running parallel clawed chats in one checkout

09:57 and still prefer separate work trees for independent tasks. The warning is useful precisely because it makes an overlapping edit visible before you casually approve it. The mod doesn’t call an extra model to make this comparison. It uses local tracking information. Your two coding sessions still consume their normal usage. Now, Collision Guard deals with overlapping work. Agent Flow helps you see the work happening in the first place. When Claude delegates a task, I want to know which agent is still running, what tool it’s using, and whether something is

10:27 waiting for approval. Otherwise, the parent conversation can look quiet while there’s a lot happening underneath. For this one, add the author’s Claude agentflow repository as a marketplace using the command on screen. Then install AgentFlow at Claude AgentFlow. The exact spelling is in the copyable command below the video. Restart Claude. Open the task manager project and type /flow to toggle its panel. Use a wide terminal for the full view. There’s also/flow text if you need the text version. For the walkthrough, ask Claude to use three parallel agents. One should

10:59 inspect input validation. One should review the tests for missing cases. and one should look at error handling in the command line entry point. Ask for readonly reviews and one combined summary. Open the panel while they’re working. Look for the individual agent rows, their states, the current tool, and the elapsed time. Expand a row to inspect it. Then compare the finished rows with the summary that comes back to the main conversation. We’re checking whether the display helps us understand an actual delegated task. The panel doesn’t create the agents for us, and installing it doesn’t make the same code run faster. Also, three agents

11:29 inspecting a tiny project is mainly a demonstration of the display for actual work. Split tasks when the independent reviews are worth the additional usage. That’s the cost distinction with this one. Agent Flow doesn’t make its own model request just to draw the panel. The agents you’re watching are still using models and those calls count. If you often delegate substantial work, I think this is a useful addition. If you mostly have one short conversation at a time, you’ll probably get more value from file tree and replay the first. Now, let’s talk about reflect because

12:00 constantly repeating the same coding preference gets annoying very quickly. Maybe you keep telling Claude which package manager to use, how your test should be written, or where a certain kind of code belongs. Reflect can turn a reusable correction into a proposed instruction that you review and save. There are two different implementations in this repository. So pay attention to the plug-in name. For this video, we’re installing reflect mod, which is the actual mod rather than the older Claude Reflect plugin. Add Bayram Anakov’s Claude Reflect repository as a

12:32 marketplace. Then install reflect mod at Claude Reflect Marketplace. Don’t enable both implementations for the same capture workflow. After restarting, let’s use a deliberate example. Type remember followed by a colon and then use node’s built-in testr runner for new tests in this repository. Do not add a separate test framework unless I ask that matches the small project we’re using. So it’s a sensible instruction to keep locally. The explicit remember prefix sends the candidate straight to the review interface without the detection model. Choose the repository scope. Read the proposed text. Edit it if necessary and click save. Now inspect

13:04 the project’s claw.md file and its git diff. That’s the actual outcome. We’re checking an approved instruction written to the right place with the wording we intended. The scope matters, a rule for this little node project shouldn’t become a global preference that changes how claude works in every other repository. For another check, submit a second candidate and choose skip. Confirm that the skipped rule was not added. A memory tool needs a useful rejection path, too. Reflect can also look at eligible short prompts and use Haiku to detect reusable corrections

13:36 automatically. That detection adds model usage. The explicit remember example we just walked through doesn’t prove that automatic detection will catch every correction. You can inspect pending candidates with /reflect Q and/reflect pause toggles checking when you don’t want it running. I like the approval step here. You can capture an instruction while it’s fresh, but you’re still responsible for deciding whether it’s useful and where it belongs. This isn’t retraining Claude. And writing a rule doesn’t guarantee perfect obedience. It’s maintaining an instruction file. So, keep the rules

14:08 concise and revisit them when the project changes. Now, the last one is cash tax. And this needs a little more explanation because the money-saving angle is easy to oversell when Claude reuses a cashed conversation prefix that can be cheaper than writing that prefix into the cache again. Cash tax estimates the cost of returning to a cold conversation and it can make small requests to try to keep the existing prefix warm. To install it, add Karan Bansel’s Claude Codemods marketplace, then install cash at claude codemods. Restart Claude afterward. Start with slashtags to inspect its information.

14:39 For this demonstration, use /cashtags guard warn which changes the guard to a warning. The guard is intended for large conversations it estimates have gone cold. So don’t expect every small test prompt to trigger it. For a limited warming window, you can use /kewarm 90mm that arms it for 90 minutes. A bare/ke keepwarm defaults to 6 hours, so I prefer being explicit while trying it. There is a major prerequisite here. Its normal 50-minute ping interval assumes a 1-hour conversation cache. subscription included. Usage currently uses that longer duration, while API key, usage

15:10 credit, and cloud provider paths normally default to 5 minutes. If your actual cache expires after 5 minutes, a ping 50 minutes later doesn’t keep it warm. Check the official caching settings for your provider before enabling this. The longer cache lifetime has a higher cash price. For a short functional demo, the project documents a 1 minute test interval. Send a small normal message first, then run/keepwarm1h everyone m keep claude open. Wait for a ping and inspect the reported usage. We’re looking for evidence that the

15:41 request reused cached input. When you’ve captured that run/ke keep warm off. Don’t leave a rapid demonstration interval running after the test. A successful short ping still doesn’t establish the savings from leaving a real conversation idle for an hour. That requires a longer check with the actual context provider and later request. I also ran the mods included automated tests. 56 passed. Those use a mocked engine and clock. So they check the mod’s logic. They don’t prove that a live server retained the cache or that my subscription allowance lasts longer. And the warming request itself costs

16:13 tokens. It asks a model to reply. So there is input and output usage to account for. If you pay to keep warming a conversation and never come back to it, those requests didn’t save you money on a later turn on a subscription. The dollar numbers are API equivalent estimates. They are not automatically an extra charge on your subscription bill and they are not a direct measurement of your remaining plan quota. Personally, I’d consider this for long conversations that I genuinely expect to resume for short sessions or a project I’m finished

16:43 with. I wouldn’t keep warming it just because a panel says I can. So, which of these would I start with? File Tree is an easy choice if you want to navigate a project without leaving the terminal. Replay theater is useful for reviewing small changes and blast radius gives you another checkpoint before the particular risky commands it recognizes for parallel work. Collision guard and agent flow solve different problems. overlapping file edits and visibility into the agents. Reflect is useful when repeated corrections should become

17:13 reviewed project instructions. Cash tax is the one I’d evaluate most carefully against my actual usage. You don’t need all seven running together. Start with the problem you actually have. install that mod and check its behavior on a small project. You can disable a mod from the installed section of /plugin if it isn’t earning its place. Overall, this is the direction I like for Claude Code mods. Useful controls around real coding work with results you can inspect yourself. Overall, it’s pretty cool. Anyway, let me know your thoughts in the comments. If you like this video, consider donating through the super

17:43 thanks option or becoming a member by clicking the join button. Also, give this video a thumbs up and subscribe to my channel. I’ll see you in the next one. Until then, bye.