PR Lens by Coldtea.ai - See code through a new lens
by•
PR Lens is a new way to look at code. It draws animated architecture and data flow diagrams of any codebase and every pull request, so you see the change before you read a single line of code. It runs as a GitHub Action, on the CLI, or as a skill for your coding agent. Open source under MIT.
Replies
Coldtea
Hi PH,
Agents write more code every week, but we still have to understand it, and reading it line by line is no longer an efficient way to do that.
We need new ways to look at code.
What if reading code was visual? A few hundred lines a minute, leaving your attention for the part that's critical: the mental model of the system you maintain, its architecture, how it evolves, and how data moves through it?
This is why we built a custom renderer for agent-written diffs.
Every pull request comes with an animated architecture and data flow diagram. Changes, additions and removals are colour-coded, and it moves, so you watch a request travel through the system rather than a wall of diff.
It's open source under MIT, works with any model you bring, and runs as a GitHub Action, on the CLI, or as a skill for your coding agent. The repo is here: github.com/coldteadotai/pr-lens
I wrote about the reasoning and the design here: reducing cognitive load in AI-generated PRs
PR Lens is built by the team at Coldtea.
It takes a minute to run locally. Try this prompt: "Explain the codebase or the last change to me using pr lens". Send feedback :)
Mastra
@ohansemmanuel neat product - starred!
@ohansemmanuel really interested to see how the production monitoring actually flags issues in real-time.
congrats for second launch🙌
@ohansemmanuel would this work well for huge repositories with thousands of files?
Coldtea
@dipanshu_kushwaha5 Yes, the representations can go from simple to fairly complex. Although for PRs, if its too complex, it's a sign your PR's too large :)
Adjust Page Brightness - Smart Control
@ohansemmanuel Visualizing how the request actually moves through the system beats scrolling through a wall of diff every single time.
@ohansemmanuel Does PR Lens work well with larger codebases, or is it mainly designed for smaller projects?
Coldtea
PR Lens is easy to use.
Install the GitHub app on a repo. Open a PR. The diagram is already there. No key, no config, nothing to learn. https://github.com/apps/coldtea-pr-lens
Or if you live in a coding agent: npx skills add coldteadotai/pr-lens, then ask it to
diagram the change it just made.
We use it in our workflow @Coldtea every day. Agents ship a PR; the diagram lands with it,
and I know what moved before I read a line of the diff.
Cool this will really make review process faster and this is kind of AI showcasing its own code right so how reliable this will be? Like will LLM's intelligence is used to showcase in node base structure or this process are hard coded by PR lens?
Coldtea
@harini_mukesh Good question. If using the Github app, then its a different model to the authoring agent.
If using a local agent to create this (its just JSON), then its a way to make it easier for humans to understand / quickly grasp the changes
Regarding the nodes themselves, do keep an always evolving baseline (with every change to the codebase) and then "diff" and show this visually when there's a PR
What is the max number of files?
Coldtea
@mary_urdahl No max files. The agent works through the change/pull request similar to classic coding agent harnesses (so, no max files)
This solves a real problem with agent PRs. I run a project with AI agents playing games against each other, and after enough agent commits I lose track of what changed.
Coldtea
@wwenioaguiar give it a try! curious to hear your feedback
Keeping an evolving baseline of the codebase and visually diffing each PR against it is such a clever review mechanic, excited to see where this goes!
I'm a visual person - so this looks like an awesome solution for me to understand what's under the hood of my stack code.
GhostWriter by MyHandler
I'm a solo founder, so really don't do PR's ... so the review workflow isn't my problem. My problem is that after a long run of agent written changes across a Rust desktop app, a C# API and a React front end, I quietly start losing the shape of my own codebase. The parts I wrote myself I can still see. The parts I directed, less so.
Does the baseline let you look at the system as it stands right now, rather than at what a particular change moved? And does it cross language boundaries? For ex a Tauri command in Rust and the TypeScript caller on the other side of it? Or is the diagram scoped per language?
Coldtea
@tery_emilson Brilliant question!
1. Q: Does the baseline let you look at the system as it stands right now? A: Yes. We're shipping an update that lets you pull this into a repo, so you have a self-updating representation of the baseline always
2. Q: And does it cross language boundaries? ... A: Yes, it does. Language doesn't matter here. So it'll represent a Tauri command -> called by a webview from a TS handler.
The fastest way to see these is to install the Skill and ask your agent to explain something (doesn't have to be a PR; any sorta code reference works), and it'll return a canvas with a walkthrough you can preview
I think the biggest shift here is treating code review as a comprehension problem, not just a line-by-line comparison problem. That feels increasingly important as AI-generated PRs get larger.