Visual change intelligence for AI-generated code
Understand what your AI changed before you merge it.
Claude Code and Codex can modify your codebase faster than you can review it. See how every PR changes your architecture, where new files fit, what existing components are affected, and whether your system is slowly becoming more complex.
GitHub first. TypeScript, JavaScript and Python.
Before
After
System impact
- files changed
- 11
- new components
- 2
- existing components affected
- 3
- database change
- 1
- downstream dependencies
- 7
- new external dependency
- 1
The problem
AI can write more code than humans can comfortably understand.
Traditional code review assumes the reviewer can mentally reconstruct the system from individual file changes. That assumption gets harder to defend every month, because a coding agent can produce a change of that size in minutes.
The question is no longer whether the code can be written. It is whether a human can understand, review and take ownership of everything the agent changed.
What the diff shows
GitHub tells you what lines changed.
- 18 files changed
- 1,700 lines
- 4 modules touched
- 2 API endpoints
- 1 schema migration
- 1 new dependency
What you actually need
Cutplane tells you what changed in the system.
- Session handling moved out of Auth into a new component
- Checkout now depends on authentication at request time
- A new external dependency sits in the login path
- A second token abstraction appeared next to the existing one
The product
See the PR as a system change.
A cut plane is the plane you pass through a building to draw a section. Four of them, each answering one question completely, instead of ten shallow features.
Architecture Diff
Compare the architecture before and after the pull request. Components and relationships that were introduced, removed or modified are obvious at a glance, and only the affected part of the system is drawn.
How did this PR change how this repository works?
Before
After
New File Integration
Agents create files very easily. For every meaningful new file, see the component it belongs to, the responsibility it introduces, who calls it, what it calls, and which existing flow it became part of.
Why does this file exist and how does it integrate into the architecture?
- Belongs to
- Authentication domain
- Used by
- AuthServiceSessionManager
- Calls
- RedisClient
- Introduces
- A new caching responsibility
Change Impact
Not “37 imports found”. Impact is grouped at the architectural level first: the flows and components that may behave differently. Only then does it drill into why.
What existing parts of my application could this change affect?
- Authentication
- Sessions
- Checkout
- Subscription renewal
Changed public interface reaches four components downstream.
Architecture Drift
Individual AI-generated pull requests can each look reasonable while the architecture slowly deteriorates. A small number of interpretable structural signals, tracked across merged PRs.
Is AI gradually making my system harder to understand?
January
4 modules
August
11 modules
- Coupling
- +34%
- Public interfaces
- +27%
- Dependency depth
- 3 → 6
- Overlapping abstractions
- 3 detected
Progressive disclosure
Start at the system. Drill down only when you need to.
You should never be forced to start from raw code. Every level is one step closer to the diff, and you stop as soon as you understand the change.
- Architecture2 meaningful system changes
- ComponentAuth Service
- FlowPOST /forgot-password
- Filepassword-reset-service.ts
- FunctionrequestReset()
- Diff+18 −2
+ const token = await resetTokens.issue(user.id)
+ await email.send(user.email, resetTemplate(token))
- throw new Error('not implemented')
No spaghetti graphs
Show me what matters. Hide what doesn’t.
The product never draws your whole repository at once. It collapses the codebase until only the change is left standing.
- 2,400files
- 76modules
- 12architectural components
- 4components affected by this PR
- 2important system changes
Changed components, new components, direct dependencies and important downstream effects come first. Everything else stays hidden until you ask for it.
Grounded, not guessed
Every diagram is grounded in your code.
Nobody should trust an architecture diagram an LLM invented from source it skimmed. Structure comes from real static analysis; the model only organises and explains what the analysis found.
Determined by static analysis
- Imports and exports
- Function calls
- Class relationships
- API routes
- Database access
- Schema changes
- Dependency changes
Decided by the model
- Grouping files into components
- Naming architectural concepts
- Explaining relationships
- Summarising intent
- Deciding what is important enough to surface
checkout-service.ts:84
sessionManager.validate()
Click any claim and you land on the line of code behind it.
Across pull requests
One PR looks fine. One hundred AI-generated PRs change your architecture.
Cutplane keeps the architectural shape of each merged PR, so structural growth shows up as a trend instead of a surprise during a rewrite.
- Week 14 nodes
Auth, Sessions, Users, Email
- Week 67 nodes
Two token helpers, one cache layer
- Week 1211 nodes
Three token abstractions, two session managers
Architecture drift detected
Authentication now contains
- 3 token abstractions
- 2 overlapping session managers
- 4 new cross-domain dependencies
See problems before they become rewrites.
Your AI already writes the code.Make sure your team still understands it.
Built initially for GitHub repositories using TypeScript, JavaScript and Python.