Agents can create PRs in minutes, but understanding them still takes work. CodeRabbit Change Stack connects a PR's purpose, behavior, dependencies, and code so reviewers can really verify it before approving. Do you understand what you're about to merge?

creating the PR takes 2 minutes. reading it properly takes 20. this makes sense.

The gap was never generating the change, it was understanding it. Curious whether the explanation gets better with team-specific rules over time or is mostly generic on day one.

Connecting purpose → behavior → deps before merge is the right instinct. Agents that open PRs in minutes still need the third check: was this change inside the grant, or just inside the model’s confidence.

Does the conversation layer support async well? Half my reviews happen across timezones and the context gets lost between handoffs. If Change Stack keeps the thread attached to the diff that's a big deal.

My most used feature, understanding the why without getting lost in the files is a big help.

Glad to hear it!

@igus_ai Review conversation next to the diff instead of scattered across GitHub, Slack, and Linear

Most big AI PRs get an LGTM because nobody has time to actually read them. Triage changes that by showing you which PR needs eyes first. well done

Would love to see this on a real multi-PR agent run. Take a 6-PR feature, open PR 4, and show what a reviewer sees. That's the demo that would sell it to my team.

That can be arranged 👀

Explainability for code review is overdue.. My question is: when the diff and the surrounding context disagree, what does Change Stack surface?

Not an engineer, but I run teams that ship with AI now. The scary part was never the speed, it was nobody being able to tell me what actually changed. This seems built for that conversation. Excited to be working with y'all.

excited to have you!

Rules, decisions, related work, and conversations pulled in around the diff. Where do the 'decisions' come from?

This looks cool!

😼🧡🐰

Wow you are shipping like anything Triage last week and now Change Stack. Keep it up rabbit

I think seeing the story behind the diff makes the review much easier.

1000%

Explaining a change is one thing, explaining it to the right person is another. Does the explanation adapt if the reviewer is a backend engineer vs. a security reviewer vs. a PM?

See the diff that supports a conclusion' is the right design. Summaries without receipts are how trust erodes. Does every claim in the explanation link to specific lines?

review time's the real bottleneck now.

Blast radius before merge is the feature I'd have paid for two incidents ago. Does it cover infra-as-code changes too or only application code?

That hits hard. Linking purpose and dependencies sounds like the missing piece for fast PR

ok but how do you stop explanation from just echoing agent’s own farming

mmm...a pull request post-mortem. me likey.

But you know summaries without receipts are the problem so does every claim link back to the lines that prove it.

okay sounds good bt does it work on PRs that were opened before you installed it or only new ones.

The 'without losing the thread' problem is real. Currently I have 6 tabs open per PR. Does the connected view replace those or sit alongside them?

This is exciting, can't wait to try it 🚀

would it generate as soon as the PR opens, or only when someone asks for it? curious how long it takes on a big diff.

Reviewed an agent PR last week where the description said refactor and the diff changed auth logic. Would Change Stack have flagged that mismatch or just explained what the diff did.

Starting from the diff and adding context afterward makes a lot of sense to me. Many tools start with the PR description and then try to fit the code to it. I'm curious how you handle it when the context and the code point in different directions.

but to understand why that change made sense at the time and make it reconstructable later.

The change stack approach gives reviewers deeper context before merging agent-generated code

The bottleneck keeps moving. First it was writing, then prioritizing, now understanding. Wondering what the next one is after this. Probably deciding who's accountable when an agent PR ships a bug.

The next problem is what happens when that context changes after the PR is created. Can a reviewer still reconstruct what the agent knew when it made the change, or are we only verifying the final diff?

@ekosproject is building the layer behind this — connecting code changes to the knowledge, dependencies, evidence, and system state that produced them. The goal isn’t just to review what an agent changed,🧵