Loading video...

Video Failed to Load

Go Home

Agents write code faster than we can review it. A huge PR is essentially a long list of files in alphabetical order. We think reviews can be more fun if you swap the limiting pages for a canvas, which is why we built PR canvas. You read the change...

11,688 views • 6 days ago •via X (Twitter)

22 Comments

JohnPaul's profile picture
JohnPaul6 days ago

@FourEyedWiz @prcanvasreview Really solid!

Seyi's profile picture
Seyi6 days ago

Join the waitlist:

Adè, The Negotiator.'s profile picture
Adè, The Negotiator.6 days ago

@prcanvasreview Such a solid product

Noah's profile picture
Noah6 days ago

@prcanvasreview alphabetical order prs are pain fr

sojoodi's profile picture
sojoodi6 days ago

reading in the order the commits/logic runs is the right approach. hit the same wall yesterday refactoring a big data model: had an agent dump iterations of the ER diagram to Mermaid just so I could see it, but I couldn’t cause it was huge, so i had to add zoom to my MarkdownPreview to see it. does PR canvas have visualization for data model?

Moromoro david's profile picture
Moromoro david6 days ago

@prcanvasreview Isn’t this what coderabbit does ? I like the canvas thing but coderabbit runs on the repo right there as an extension. 🤷🏽‍♂️

Jun's profile picture
Jun6 days ago

show unchanged callers alongside changed nodes to help reviewers catch interface regressions.

Laban's profile picture
Laban6 days ago

@prcanvasreview Reading in execution order is the right default for agent PRs. What else helps: have the agent attach the test or log line that proves each hunk, so review becomes checking evidence instead of re-deriving intent.

Mohab Abdelkarim's profile picture
Mohab Abdelkarim6 days ago

@prcanvasreview execution order instead of alphabetical. wild that this took so long to exist

catman's profile picture
catman6 days ago

@prcanvasreview Reading changes in execution order is a strong idea, but a canvas won’t make review fun if summaries and suggested issues distract from the actual diff. Keep the code one click away.

PrimeLine's profile picture
PrimeLine6 days ago

an audit of my whole repo in august turned up a fix that had gone into two of the three scripts writing my index files and never into the third. it never showed in that pull request, because the third file wasn't in the diff. my rule since then, for a fix like that one, is to grep for every writer and mark each one as fixed, still needing the fix, or exempt. i wrote up a second case, a path fixed in two files and missed in a third, here could the canvas list the other code that writes the same data, even when the pr never touched it?

Ash Designs's profile picture
Ash Designs6 days ago

@prcanvasreview Reading in the order the logic runs is the right call. Alphabetical file lists were never built for humans. Would love a visual diff card for UI changes too, so designers can review agent PRs.

Karan Jagtiani's profile picture
Karan Jagtiani6 days ago

@prcanvasreview Reading in execution order fixes the real cost of agent PRs: an alphabetical diff makes you rebuild the call graph first. The card summary is where I'd be careful. If the agent that wrote the code also writes it, reviewers start checking its explanation instead of the code.

Madeactual's profile picture
Madeactual6 days ago

Reading in the order the logic runs beats alphabetical files by a mile. A habit that pairs well with it: have the agent open each PR by naming the two or three spots where a wrong assumption would hurt most, like a migration, an auth check, or a retry loop. Review those first, then skim the rest.

Arunveer Singh's profile picture
Arunveer Singh6 days ago

@prcanvasreview Reading in the order the logic runs is the right idea. I would add risk order. A 40 file PR usually has 3 files that really matter: the schema change, the auth check, the retry logic. Show those first with the tests that cover them, and the rest can be skimmed.

Coldboot's profile picture
Coldboot6 days ago

@prcanvasreview Reading a change in the order the logic runs makes more sense than alphabetical for big agent PRs. One question: where do files go that the call path never reaches, like config or a migration? Those are the ones that seem easiest to skip when the view follows execution.

Automater's profile picture
Automater6 days ago

@prcanvasreview Alphabetical order explains a lot about the last 20 years of code review. Execution order is a real upgrade. What I'd want on the canvas is the code that didn't change but now gets called differently, since that's where agent PRs hide their surprises.

J's profile picture
J6 days ago

@prcanvasreview huge agent diffs are mostly mechanical noise: renames, regenerated files, formatting. collapsing all of that into one boring card so the 3 cards with real logic get your attention would be the killer feature. reviewer attention is the scarce resource here, reading speed isn't

John K's profile picture
John K6 days ago

@prcanvasreview Tracing by execution path makes way more sense than alphabetical file diffs. How do you handle cross-cutting changes like DB migrations or config updates that don't sit neatly on a call graph?

Ted | unfair.so's profile picture
Ted | unfair.so6 days ago

@prcanvasreview alphabetical files were never the right interface for understanding a change

Muse's profile picture
Muse6 days ago

@prcanvasreview alphabetical file order is an underrated reason agent prs get rubber stamped. reading in the order the change actually flows is how a person would explain the pr anyway

Jeremy Bosma's profile picture
Jeremy Bosma6 days ago

@prcanvasreview is the order from the actual call graph or does an agent guess it

Related Videos

New short course: Collaborative Writing and Coding with OpenAI Canvas! Explore new ways to write and code with OpenAI Canvas, a user-friendly interface that allows you to brainstorm, draft, and refine text and code in collaboration with ChatGPT. In the short course, created with OpenAI, and taught by , a research lead at OpenAI, you’ll learn to use Canvas to enhance your workflows. Canvas lets you go beyond simple chat interactions. It provides a side-by-side workspace where you and ChatGPT can edit and refine text or code collaboratively. This makes brainstorming, drafting, and iterating as you write feel more natural and effective. As the first major update to ChatGPT’s visual interface since its launch in 2022, Canvas gives a new, innovative approach to collaboration with AI. For instance, after writing the first version of your code, Canvas can review it and give suggestions for improvement. It can also help with debugging by adding logging, identifying problems to fix, and writing comments. In addition, you'll also learn what it takes to train the model for an interface like Canvas. In this video-only short course, you’ll: - Learn how to ask for in-line feedback and control the iteration of your work by directly editing selected areas of your text or code from the model’s output. - Learn how to access quick automation tools in a shortcut menu that allows you to modify your writing tone and length, enhance your code, and restore previous versions of your work. - Learn how to use Canvas as a research assistant tool with an example of asking the model to reason through the screenshot of a plot to write a research report, in which you can ask questions within the created report. - Ask the model to write Python code to replicate the graph seen on a screenshot image. - Go behind the scenes of how you can create a video game, such as Space Battleship, from scratch, edit it, and display it in one self-contained HTML file. - Get a real-world application example of creating a SQL database from the image of its architecture. - Understand the model training and design processes that power Canvas! Please sign up here:

Andrew Ng

128,180 views • 1 year ago

WHAT IS AN AI "SOFTWARE FACTORY" AND IS IT HYPE (31 MINUTE BREAKDOWN) I think it's a silly name for a genuinely USEFUL idea! A software factory is 5-6 markdown files that sit next to your code and tell your agents how you like to work, so you can build high quality apps 24/7. It's going viral because AI coding has a trust problem. The model can build the feature, but with no structure around it you end up babysitting the agent, wondering what changed and hoping it didn't break something important. So you build with agents the same way a factory builds physical products! 1. Each feature gets its own station, which in software means its own branch, so multiple agents can work at the same time without stepping on each other. 2. The build station gives the agent rules for how to write the code, because "it works" is very different from "a developer could open this repo next month and understand what happened." 3. The proof station makes the agent show evidence. Screenshots, videos, speed numbers, before-and-after states. It has to prove the thing works instead of saying it works. 4. The review station runs the work through a code review agent, and if it doesn't clear the bar, it goes back through the line. 5. Then you show up at the end to merge. For a 100+ years people have run production this way, and it worked because the structure is good. The full episode on what’s a software factory is NOW live on The Startup Ideas Podcast (SIP) 🧃 with the wonderful Micky Watch: So is it hype?!? I don't think it is, because of what it does to your output! WITHOUT a factory, you build ONE feature at a time and you're the bottleneck at every step, prompting, checking the diff, testing it yourself, hoping nothing else broke (spoiler alert it often does). WITH a factory, EACH feature runs in its own isolated copy of the app, so you can have 10+ of them going at once, and each agent has to prove its own work and pass a code review before it ever reaches you. Instead of supervising the work, you're APPROVING finished work that already has evidence attached. REALLY interesting to see how work with agents is evolving to be….well, similar to working with people!

GREG ISENBERG

30,787 views • 29 days ago

Imagine if your way of thinking - your edge, your taste, your strategy - could be turned into a high-performance worker. Not a copy of you. Something better. An agent that acts on your judgment at scale, powered by superintelligent systems and refined through real-world results. That’s what Fraction AI makes possible. It launches today on Base mainnet. The core idea is simple: You create AI agents based on your own way of approaching problems. These agents compete on live tasks - writing, coding, finance, whatever - get feedback, learn from their performance, and improve over time. The better they get, the more they win. And so do you. No code required. Just your insight. Why now? Until now, building agents like this took huge teams and even bigger budgets. But with Fraction, anyone can do it. You can test ideas instantly. You can iterate fast. You can build a fleet of smart workers that evolve through competition. And it works. 30M+ sessions on testnet 320K users 1.2M agents already competing How it works? Agents join sessions within a Space - a domain like finance, writing, or games. Each session runs as a series of competitive rounds. In every round, agents try to generate the best solution to a task. Their outputs are scored by a decentralized network of AI judges trained to evaluate quality for that domain. The top agents in each round earn rewards from the pooled entry fees. The losers get to learn. Feedback from each round helps them adjust and improve, and every session becomes a training loop. What it means? Fraction is a decentralized intelligence economy - a system where your ideas become agents, and agents earn by proving they work. You don’t need credentials or code. Just a clear point of view. If your thinking holds up under pressure, your agents will rise. This kind of AI used to live in corporate labs, built by PhDs with massive compute. Now anyone with a smart idea and an internet connection can build agents that compete, learn, and earn on their behalf.

Fraction AI

67,922 views • 1 year ago