... Honestly when I am in the middle of a fast prototype, reading through hundreds of lines of generated diffs kills my momentum completely. I usually just keep hitting accept and checking the live preview in the browser. It works great until a weird regression pops up three hours later and i have no idea which prompt caused it. What is your actual review habit when you are deep in a vibe coding session? Comment from George Basov(@gbasovv ... ... idea which prompt caused it" part has a cheap fix that doesn't need reading every diff

... agent had a failing test. It "fixed" it in about ninety seconds. I almost moved on. Then I looked at the diff. It hadn't touched the application code. It had changed the test assertion to match the buggy return value. The test went green because the test was now wrong. The bug stayed in production for three days before a user hit it. Now I review diffs

... colour of what it does. No more actions dressed up as links. The commit list loads its history as you scroll. The "show last N commits" setting is gone. Click a file in a commit and its diff opens in a window of its own: move it, resize it, keep it beside the list. Diffs

... color bleeding into a header. We started running automated headless browser screenshots before and after restyling PRs to catch silent layout breaks. It caught CSS inheritance bugs that our test suite totally ignored. Do you rely on local screenshot diffs in your pipeline or do you use hosted visual testing services like Percy or Chromatic? Comment from George Basov(@gbasovv): Mobile, not web, but the same idea. When my Flutter app got a light theme next to the dark ... ... light and then in dark on the iOS simulator and saves a capture of each, 36 in all, and the rule is to run it again after any theme or palette change. I look at the captures rather than diff

... tried running multiple terminal sessions with different coding agents to speed up feature delivery but I immediately ran into a massive review back log. The AI built things in minutes but context switching between three huge diffs burned through my focus before lunch. Generating code quickly means nothing if the human review process takes three times longer to spot bugs or duplicate functions. Do you cap the number of parallel agents you run or do you have a specific system ... ... review their PRs fast? Comment from Neelagiri Chettiyar(@neelagiri_chettiyar): one worktree per agent helped me more than capping the number.. each diff

... spent an hour reviewing a diff today where the agent decided my database schema needed a modern upgrade even though I just wanted to add a simple validation check. It s exhausting having to babysit the diff

... tabs of terminal window and three different tasks related to the budgeting application that I am building, and the bottleneck immediately changed. My agents finished their task much faster. I became the bottleneck in this case, because analyzing three diffs carefully took me more time than analyzing one, and my concentration was thinning out by the minute. It was a fortunate accident when I found a duplicate helper method. It turned out to be much better when each agent ... ... generation will not matter much in case there is no quick checking. How many parallel agents do you actually generate? Do you have a review process, such as checking tests first, to maintain high quality amid large numbers of diffs

... What slips is side effects: a PR about a new filter that also lowers the max page size from 100 to 50, a default that flips, a new error code, a renamed webhook field. One line in a diff that's mostly about something else. Things I've seen teams try: a "docs needed" label applied in code review writers watching merged PRs in the API repo a spec diff

... asked Cursor to add input validation to a form handler. It reported editing three files. I checked git diff: two files changed. The third was a no-op. The agent had described what it planned to do, not what it did. I only caught it because I diff

... lifesaver but checking massive diffs after every AI prompt gets exhausting real fast. A lot of times the AI introduces subtle bugs that still compile fine, so tests don't catch them immediately. Writing a quick automated test before asking the AI to add a new feature has saved me so many times because the test instantly fails if it messes up existing code. Do you rely on unit tests or just manually review every single line in the diff

... making small one-file edits most AI coding tools feel pretty similar. But as soon as a change touches six or seven files at once, the experience is completely different. In Editor UI tools watching the side-by-side diff file by file feels safer. Working through terminal agents is definitely faster for broad edits but it's much easier to miss subtle breaking changes or bad tests until hours later. How do you decide between visual diff

... using Cursor recently to refactor a component for a client project. The initial bug fix worked instantly, so I skimmed through the diff, trusted the output, and pushed it straight into testing. Everything looked fine on the surface until I realized the AI had silently refactored an underlying state logic that broke a completely unrelated edge case. It took me twice as long to trace and undo that hidden change than it would have to write the fix manually from ... ... scratch. I m definitely not against vibe coding or AI tools they speed up the workflow tremendously. But this experience taught me a valuable lesson: never accept a diff

... done that Comment from Neelagiri Chettiyar(@neelagiri_chettiyar): @konstantin_tikhaev  that one's worse than a crash. a failure you would go and look at.. a green test you just trust. did you catch it from the diff or did something downstream break ? Comment from Neelagiri Chettiyar(@neelagiri_chettiyar): @usa374  the setup i would try is the other way round.. run the sessions on the server inside tmux and ssh in from ... ... changed a strict equality check to assert that the result wasn't null. It couldn't solve the edge case, so it loosened the test. CI stayed green for days while broken payloads hit users. Now check git diff

... Last week I gave Claude Code the task of fixing a broken checkout test in my little Next.js store project. Within 20 minutes, it came back telling me all tests were passing. I was thrilled until I saw the diff. The test file had become 40 lines shorter, and the one test that failed was no longer there. To be fair, I had asked him to make the tests pass, and he did just that. It was my mistake ... ... Second, identify the root cause of the problem in simple language before doing anything else. The second line has proven to be more valuable than the first, as a vague explanation indicates a vague solution. I also began reading diffs

... date in a booking form. It solved the problem. It also, in a subtle way, modified how time zones were stored. I realized it only after three days when a booking was made one day earlier. The diff was forty lines long, and I just skimmed through it because the fix seemed fine and the app was working. I am not blaming the tool. Small requests led to large changes, and I took it as such without even looking closely ... ... Since then, I have developed two new habits: ask for the minimal change and read every line related to data format changes, no matter how boring the rest of the diff

... same can happen with CI workflows and migrations. If the agent can edit them, it can make the gate disappear. One cheap guardrail I ve seen: a CODEOWNERS rule requiring human review on tests/, migrations/ and .github/workflows/, so any diff there needs approval no matter how green the build is. I d love to hear how you handle this: Have you hit this? How did you first notice? Do you review test diffs

... outside it. A selector inside a permitted file sits below every layer's resolution. Whether the blue landed on one button or on every primary button is decided by the sentence you typed and by whoever reads the diff. When your agent overshoots, where does the boundary live in your setup today: the prompt, a rule file, a path rule, a sandbox, or the person reading the diff

... between one and twenty-three items we have to fix, usually four to six, and the hard ones were caught against the pasted sources. If your agent reviews its own change, what does the reviewer get to see: the diff alone, the diff

... been thrown. My tests have passed since I didn t have a test for such a scenario, which was found out when I accidentally kept myself logged in for much longer than expected. Now, I m looking into every diff around any lines related to security on a line-by-line basis regardless of how little the change is supposed to be. Have others developed guidelines as to what you never let the AI touch unattended? Comment from Siarhei Hamanovich ... ... hamanovich): Reviewing every security-adjacent diff

... made Agent Diff Sentinel, a small CLI that scans a git diff

... OpenCode, with local conversation resume, model and reasoning controls, /usage allowance and live activity status. This release also adds vendor Windows installer choices for supported CLIs, a direct install entry when an agent is missing, change-block diff navigation (Alt+Up/Down), and fixes long lines crossing split-diff

... workflow whose contents changed. It couldn't see the other half: a dependency that starts running code the moment you npm install. That isn't a new file and it isn't a code change, it's a lockfile diff. Branch protection and required reviews do nothing about it, because there's nothing in there a reviewer would recognise as suspicious. Now the scan reads package-lock.json on your default branch and compares the subset of dependencies that carry an install ... ... same version was republished zero times. That zero is what lets the sharp case carry real weight instead of teaching you to skip the axis brew upgrade gfazioli/tap/octoscope What does your team actually do with a lockfile diff

... service got slow and found four ways of making an HTTP request in it. A fetch wrapper, axios, and two hand rolled retry loops. Nobody added them in one sitting. Each one arrived in a different session, in a diff that was correct on its own, and I approved all four. That's the failure mode I didn't see coming with agents. They're good at the task in front of them and they have no opinion about what ... ... repo already does, so every session starts from a blank slate even when the codebase doesn't. Bad code you catch in review. A second correct implementation of something you already have reads fine in a diff

... build SlimSnap.ai mostly with AI agents these days. This week I asked for a small change to annotations and the diff came back way too big for what I asked, so I asked why. The answer, word for word: "You're right, and it's my fault I wrote a second drawing engine instead of using the one that exists. Let me check what it takes to mount the real one." We already had a drawing engine. It wrote another ... ... whatever. What worries me is that I only caught it because I know what the app contains. Someone vibecoding their first product ships both engines and never finds out. Curious how other makers handle this. Do you review every diff

... noticed a pattern with AI coding agents that bothered me more than the actual code quality. I'd ask for a small change. The change would work. Then I'd look at the diff and realize the agent had touched: 11 files for what I thought was a 2-file task. Sometimes there was a good reason. Sometimes it was just architecture drift disguised as cleanup. So I started experimenting with a simple rule: Every task gets a change budget ... ... needs more, stop and explain why before continuing. That has created a useful checkpoint. If the agent suddenly says: I also need to refactor these 7 other files I can decide whether that is actually necessary before the diff