Most of the code on my team is written with Claude Code now. That part has gone better than I expected, and the code usually looks fine.
Reviewing it is where things went wrong for us.
A normal pull request on our team touches 40 to 70 files. An AI reviewer leaves a pile of comments, and some of them disagree with each other. Another Claude Code session fixes them, the threads get resolved, and then a person sees a green check and a list of resolved conversations and presses Approve. Often that person was me.
A few weeks later something breaks, and nobody on the team really knows how that part works. The person who prompted it asked for a feature and got 60 files back. The reviewer skimmed. It was merged with everyone's approval, and I don't think anyone had read it.
What I tried first
Smaller pull requests. This helps when it's possible, but a feature that adds a table, an endpoint and a page often has to land together.
More AI review. Every extra bot comment is one more thing to read and weigh. The comments answer "is this line a problem?", which is a useful question. They don't answer "what does this pull request do?", and that's the question I need answered before I can approve it.
Reading it properly on GitHub. GitHub lists the files alphabetically, so the page component comes before the migration it depends on. On a 70-file change I spent most of my time building a map in my head, and by the time I had it I was tired of reading.
What I wanted instead
I wanted what you get when the author sits next to you and walks you through the change. They say what it does in a sentence or two, then take you through it in the order the code runs, data first and tests last, telling you what changed and why. The decision stays yours.
With AI-written code there often isn't an author who can do that from memory, so I built something that does a first draft of it. The method behind it is in how to review a pull request that AI wrote.
What Hyperpowers does
Hyperpowers is a free VS Code extension. It also works in Cursor, Windsurf, Antigravity and other editors built on VS Code.
- In VS Code, click Create Walkthrough and paste a pull request link.
- Your own Claude Code reads the pull request and explains it.
- Open the walkthrough from the Code Reviews list in the sidebar.
- A short summary comes first: what the pull request does, and how it flows in numbered steps.
- Then you go change by change, with What changed and Why next to the real diff in the editor. The changes are grouped by area and ordered by the way the code runs.
- You comment on lines the way you do on GitHub. Nothing is posted until you press Submit review.
The explanations are written by a model, and they can be wrong. Each one sits next to the code it describes, so you check it as you read.
Where the "why" comes from
The "what changed" part is the easy bit. The "why" is harder, because the reason usually lives in a chat with an agent that nobody will reread.
If the code was written with Claude Code on the machine that creates the walkthrough, Hyperpowers reads those session logs and finds the request that came just before each file was edited. That request becomes the reason shown next to the change, so you can compare what the code does with what was asked. Passwords and keys are removed first, and you can turn session reading off in the settings.
When no session explains a file, it falls back to the brief a subagent was given, labelled as an agent brief. With no sessions at all, the explanation comes from the diff and the pull request's text.
Things I added after using it for a while
Review one part. Pick one area on the start page, such as the frontend, and the review keeps to it. Generated files are left out of Claude's review.
Review with Claude. I held off on this for a while, because more AI comments was the problem I started with. The version I kept is optional and scoped. You pick this file, this area, the files you haven't read yet, or all of it. Findings come one at a time, and each one waits for you to press Add as comment or Skip. Nothing it finds goes to the pull request unless you add it.
New commits. When the author pushes while you're mid-review, Update re-explains only the files that changed. You stay on the change you were reading, and your comments stay too.
Finish anytime. Before anything is sent, Finish the review shows how much you read and which files you haven't opened. It never blocks you. It just makes it hard to pretend you read the whole thing.
Share it. A walkthrough exports as one file. A teammate opens it in VS Code and reads the same tour, without needing Claude Code.
What it costs
The extension is free. It runs on your own Claude Code, so the usage counts against your Claude plan, or is billed to your API key if you use one. There's no Hyperpowers account and no server of ours in the middle.
On a small sample pull request, explaining it took about a minute and cost $0.21, and Review with Claude on all of it took 43 seconds and cost $0.37. A bigger pull request or a different model will give different numbers.
What it doesn't do
It doesn't run your code or your tests, and it doesn't approve anything. Creating a walkthrough needs Claude Code, and posting your review needs GitHub. For now you install it from a .vsix file on the site.
It also doesn't make a 70-file pull request small. You still have to read it. What changes is that you read it in an order that makes sense, with a reason next to each change, and at the end you know what you're approving.
Try it
You can try it in your browser with nothing to install, on an example pull request: hyperpowers.dev/try. It needs a desktop browser. To use it on your own pull requests, install it from hyperpowers.dev.
So far it has been used by me and by a colleague who tried it on a small pull request. I'd like to know how it holds up on yours, especially the big ones, and where the explanations get things wrong.