Reflecting-Findings: Independent Skeptic for Agent Reviews

Where this fits

You have a pipeline where one agent reviews a code change and files findings, then another agent (the worker) turns those findings into fix requests. But what if the reviewer was overzealous or misread the code? Sending a false finding to the worker wastes a fix cycle and erodes trust. The reflecting-findings skill inserts an independent skeptic between review and fix: it takes the reviewer's findings, verifies each against the real code, and settles it as kept or refuted before anything reaches the worker.

Why agents benefit

• Precision over recall – The skill defaults to refuted under doubt, so only findings with concrete evidence move forward. This reduces wasted work and false alarms.
• Independent verification – It reads the cited code directly, not the finding's prose, so it can catch misquoted lines or misunderstood APIs.
• Constructive refutation – It actively tries to build a case against each finding, which surfaces edge cases that the original reviewer might have missed.
• Clean handoff – Only verified findings become fix requests, so the worker agent gets a high-quality backlog without noise.
• Trust building – Over time, the system learns which findings hold up, making the whole agent team more reliable.

Practical scenarios

Multi-agent code review pipeline

A change set is reviewed by a static-analysis agent that flags potential bugs. Before those flags become fix tickets, a reflector agent runs reflecting-findings to check each one. It opens the cited files, reads the surrounding context, and refutes any finding that doesn't hold up—like a false positive on a deprecated API that actually exists.

Refactoring safety net

During a large refactor, an agent suggests changes based on another agent's findings about dead code or unused variables. The reflector verifies that the code is truly unused by checking call graphs and exports. It refutes findings that would have led to removing still-referenced functions.

Cross-agent accountability

Two agents review the same change set and produce conflicting findings. A third agent uses reflecting-findings to adjudicate each conflict by examining the code directly. It keeps only the findings that have clear evidence, merging the best of both reviews.

Add it to your agent workflow

Install the skill with:

npx skills add JetBrains/thinkrail --skill reflecting-findings

Then, in your agent's instructions, you can invoke it like this:

- role: reflector
  skill: reflecting-findings
  input: findings_package.json
  output: verified_findings.json

The skill will iterate over each finding, call reflect_finding for each, and return a verdict—kept or refuted—with a reason.

Compare before adopting

Before you adopt this skill, compare it against your existing review workflow. Look at quality signals: does it actually reduce false positives in your fix queue? Check maintenance freshness—the skill is part of JetBrains' thinkrail repo, which is actively maintained. Also consider alternatives like building your own verification prompt or using a simpler rule-based filter. Finally, assess workflow fit: does your agent architecture already have a separate review step? If not, you might need to add one first.

Why it is worth tracking

The skill comes from JetBrains, a trusted name in developer tools, and has 232 stars on GitHub—a modest but healthy signal. It addresses a real pain point in multi-agent systems: unverified findings that waste cycles. As agent pipelines become more common, skills like this that add a quality gate will gain traction. Evaluate it when you're building a review-and-fix loop and want to keep your worker agents focused on real issues. For more context, see the skill page on OpenAgentSkill.