the diff is the new editor
agents write more of the code now, and your day goes to reading what changed. watch a repository’s pulse, open a live room on any pull request, and read it with your team and your agents on the same lines. agents propose; people decide. and every dependency a change brings in is checked against today’s known exploits.
recent rooms
the rooms opened lately, newest first.
review is a conversation
github holds the code. the room holds what everyone thought about it, people and agents alike.
every message points at the lines it is about, and you see who is reading which line, or follow a teammate through the change. push again and the anchor follows the code, or says plainly that the lines are gone.
select lines and ask any agent that speaks a2a 1.0. they work in the open, in the same stream, each in its own lane: working, waiting on a person, done. they answer with proposals. agents propose; people decide.
send what your team accepts to the pull request as one review, as yourself, each patch a one-click suggestion. github’s review threads show on their lines in the room, and replies go back as you; resolve one on github and the room follows.
the room reads what your ci and your history already know. the mutation report your ci uploads marks the changed lines no test would notice breaking, with a way to ask an agent for that test. history names the files that usually change with these and are missing, and the ones that need a careful eye. none of your code runs on our side.
watch a repository: every workflow run as it happens, every room opened on it, and the runs that took far longer than the rest.
a key seen once is cached forever. should the window expire it?
mutation testing
what the tests miss
coverage tells you a line ran under the tests. it can't tell you whether any test would notice that line being wrong. mutation testing can.
- break it on purpose
- a mutation tool makes one small change to your code at a time: min becomes max, < becomes <=, a line goes missing. each change is a mutant, and your tests are run against every one.
- caught or survived
- a test that fails has caught the mutant: that line is pinned down. a mutant every test passes has survived: the code could be wrong there and ci would stay green.
- why it matters now
- agents write code fast, and its tests too. a test can run every line and check nothing, and coverage still reads 100%. mutation testing tells the tests that pass from the tests that protect.
- decide with evidence
- agents propose; people decide. before you accept a change, the room shows which of its lines no test would notice breaking, from the report your own ci makes, and one click asks for the test that would.
on our own repository, one pull request's changed lines made 10 mutants: 8 caught, 2 that did not build, none missed. mutation testing on pull requests ›
- run the tests
- break it on purpose
- survived
- ask for the test
- caught
- ✓retries a failed payout
- ✓gives up after 10 attempts
- ✓returns the receipt
- ✓passes a fatal error through
- ✗never waits longer than MAX_WAITnew
- coverage
- 100% of changed lines
- mutant on L44
- caught
the cap is pinned down now. break it again and ci goes red.
illustration · a scripted run, not live data
pricing
start a team for free on public code, and pay per seat to open private repositories. agents always run on your own model key.
- rooms for every pull request, commit and compare on public repositories
- every agent, on your team’s own openrouter, openai or anthropic key
- flags, history, mutation evidence from your ci, and the suggested reading order
- everything in free
- private repositories, through a github app; each person sees only what their own github can read
- seats follow your members, prorated; cancel any time
sold through link, stripe's seller of record, which adds and remits sales tax. terms · refunds
questions
- is ai code review worth it if most of the comments are noise?
- not when a bot comments on every pull request: reading its guesses costs more than it finds. in diff social an agent never comments on your pull request. a person selects lines and asks; the agent answers that question in the room, and its answer is a proposal someone accepts or rejects. only what people accept can reach the pull request, sent by one of them as their own review.
- can ai replace code review?
- not here, by design. agents read, flag and propose patches; only a person can accept one, and people stay responsible for what ships. agents make review faster, not optional.
- can my team review a pull request together in real time?
- yes. everyone who opens the same pull request, commit or compare is in the same room: you see who is reading which line and can follow a teammate through the change, replies arrive as they are written, and every message points at the lines it is about, following the code when the branch moves.
- where does my code go?
- diff social reads code from github when a room opens, and writes there only what a person sends from a room, as that person. the flags, history and semantics agents send code nowhere else. the reviewer and patcher agents send the lines they are asked about to your own model provider, on your key.
- how much does it cost?
- free for a team on public repositories. a team plan is $12 a seat a month, plus tax where it applies, and opens private repositories; seats follow your members and you can cancel any time. on either, agents run on your own model key.
- whose model key do the agents use?
- always yours. diff social runs no model work of its own: a team admin adds an openrouter, openai or anthropic key in team settings, and the reviewer and patcher agents run on it, billed by your provider. the other agents need no key.
- how is it different from coderabbit or github copilot code review?
- those are reviewers that comment on each pull request. diff social is a room where your team and agents review together; agents answer when asked, with proposals, and only what your team accepts reaches the pull request: one review, posted by the person who sends it, with patches as one-click suggestions.
- does it work with the review comments already on my pull request?
- yes. the pull request’s github review threads show in its room on the lines they are about, and follow github as people comment and resolve them there. you can reply to a thread from the room; it goes to github as you.
- does it work with private repositories?
- yes, on a team plan, through a github app. each person sees a private repository only if their own github account can read it; to anyone else it answers exactly as a missing repository does.
- what is the a2a protocol, and how is it different from mcp?
- a2a (agent2agent) lets independent agents find each other through agent cards and work together; mcp connects one ai application to tools and data. diff social's agents are a2a agents, and any a2a agent can join a review.
guides
open the first room
paste a pull request. everyone who opens the same link is in the same room.