Fin: one skill guides the coding agent and the review agent, and a verifier is graded on its noise
Oct 12, Sonar's write-up of Fin principal engineer Kesha Mykhailov on The Next Commit. Technical plans nearly vanished once agents made code cheap, so Fin made small PRs auto-approvable, harvested senior reviewers' comments into a React skill that both writes and reviews code, and learned that a cheaper review model with identical recall was far noisier.
Source: When agents outpace the organization
Sonar's write-up of Kesha Mykhailov, principal engineer at Fin, on episode 5 of The Next Commit starts from a now-familiar claim: agents made implementation nearly free, and the hard work moved rather than disappeared. Code can now move faster than the organization can think, verify, and learn. Sonar sells code verification, so read the framing with that in mind; the useful part is the Fin detail.
The plan disappeared first
Before agents, a significant change at Fin started with a conversation and a technical plan shared in a Slack channel. Mykhailov says the temptation now is to skip that step, and the plans almost disappeared. The consequence lands on review: reviewers reconstruct intent from a large implementation instead of reviewing against a known plan, and product teams sometimes learn about a change only after it merges.
Make the safe path the fast path
Fin's response was to change the economics rather than lecture. A pull request above a certain size can't be approved automatically, while a small, safe change can, so developers split their own work because small changes merge sooner. Extra review layers cover security, logical correctness, and the quality of the problem statement, and sensitive changes still go to a human. Mykhailov is candid that this is imperfect: no amount of review surfaces the unknown unknowns that only production can.
One source of judgment for both sides
During Fin's move from Ember.js to React, early agents produced large changes that ignored the team's chosen patterns for forms, validation, and API access, and a small group of senior engineers became the final verification layer under an unsustainable volume of reviews. The team harvested their review comments into a React skill, and that same skill now guides the coding agent when it writes and the review agent when it assesses the diff. Separate copies of the standards drift; a shared one lets review feedback shape the next generation attempt.
A verifier is graded on its noise too
Fin's developers made their review agent, Shrek, green before showing a change to a human, so the verifier's quality became an input to delivery. Reviews are expensive, so the team tried moving the logic-error check to a cheaper model and tested it against hundreds of labeled historical PRs. Recall looked identical, but the evaluation never counted wrong findings, and within a week developers asked whether Shrek had become "a lot more picky." Fin now tracks three signals from real PRs: thumbs up or down on comments, suggestions adopted silently in the final diff, and merges that proceed with human approval despite an active agent flag, which it treats as a reliable sign of a false positive.
For teams running agents continuously, this is the volume problem stated plainly: when code gets faster to write, the rest of the process has to keep new code within what the team can verify, and a noisy automated reviewer quietly spends the human attention it was meant to save. Compare Vertrees on gates that cry wolf and the Claude Code team's risk-tiered review.