review to resolution

    1

    Verifies code review comments against current source to implement verified fixes and triage outdated feedback.

    $1.97

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    review to resolution

    Example session with this skill installed

    Review the comments in PR #42 regarding the pagination logic and fix any verified bugs found in the current buffer_manager.c file.

    • Read your context and instructions
    • Compiled the review to resolution

    I have analyzed the 3 review comments against buffer_manager.c. One comment was outdated due to a previous refactor, one was a valid boundary condition bug, and one was a stylistic preference. I have implemented the fix for the boundary bug and verified it with a new test case.

    Resolution Summary

    Issue IDLocationStatusFindingAction Taken
    REV-01buffer_manager.c:142ResolvedOff-by-one error when page_count equals MAX_BUFFER.Applied boundary check; added test_buffer_limit.
    REV-02buffer_manager.c:89OutdatedComment suggested NULL check, but line 89 was removed in feat/atomic-ops.None (Code no longer exists).
    REV-03buffer_manager.c:210InvalidSuggestion to use memcpy instead of loop; loop is required for volatile hardware registers.Retained loop; added explanatory comment.

    Verified Fixes

    // buffer_manager.c
    // Fixed off-by-one error in page allocation logic
    int request_page(int index) {
    -   if (index > MAX_BUFFER) {
    +   if (index >= MAX_BUFFER) {
            return ERR_OUT_OF_BOUNDS;
        }
        return buffer_pool[index].id;
    }
    

    Next steps

    1. Review the generated test_buffer_limit case in tests/buffer_tests.c.
    2. Stage the changes in buffer_manager.c for your next commit.
    3. Reply to REV-03 in the PR explaining the hardware register constraint.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Software development suffers from a feedback loop gap where code review comments sit unaddressed or are blindly implemented without verification. This skill bridges the gap by verifying review feedback against the current codebase, triaging outdated suggestions, and implementing verified fixes with regression testing.

    What it does

    • Feedback verification validates whether a reported defect exists in the current code state to prevent chasing phantom bugs.
    • Causality mapping identifies the specific trigger conditions, affected paths, and user-visible consequences for every valid finding.
    • Scope control distinguishes between regression fixes and new requirements to prevent scope creep during the review phase.
    • Automated remediation implements minimal, complete fixes for verified issues while ignoring unnecessary implementation details from comments.
    • Regression testing creates or updates test cases to verify that a fix works and that the original trigger path no longer fails.

    How it works

    1. Analyze input by scanning provided diffs, PR comments, or local changes against the repository's ground truth.
    2. Triage findings using the resolution template to categorize items as active, outdated, invalid, or out-of-scope.
    3. Execute fixes by modifying code only for verified issues, ensuring the implementation aligns with actual constraints rather than just comment preferences.
    4. Verify closure through local execution or path analysis to confirm the defect is resolved.

    Frameworks & tools

    This skill is platform-agnostic and works with any Git-based workflow, supporting localized verification through existing test suites or manual path analysis.

    Why this beats prompting it yourself

    Generic prompts often lead to "mechanical fixing" where the AI blindly follows a reviewer's bad advice. This skill enforces a verification layer that checks if the code has already changed, preventing redundant edits and ensuring every change is backed by a verified impact chain.

    Use cases

    • Post-review cleanup to process 20+ mixed quality comments into a single verified fix set.
    • Stale PR refresh to identify which old review comments are still relevant after a rebase.
    • Draft audit to find defects in a local diff before officially submitting it for peer review.

    Known limitations

    Does not automatically push commits or resolve PRs in external hosting platforms without explicit tool authorization. Requires access to the local workspace for verification.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Code Quality & Review.

    Requires local workspace access for code verification. Cannot perform external API actions like merging PRs or resolving comments without specific tool authorization.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 25 days ago

    Permissions

    No special permissions declared or detected

    Listed25 days ago

    What's inside

    Frequently Asked Questions

    This skill prevents 'mechanical fixing' by cross-referencing PR comments against the current source code to ensure you only apply changes for issues that actually exist, ignoring outdated or invalid suggestions.

    It is platform-agnostic and designed to work with any Git-based environment; you can integrate it with any LLM-based agent that has access to your local workspace and file system.

    Unlike basic prompting, this skill uses a verification layer and causality mapping to ensure every fix is backed by a confirmed defect, preventing the AI from blindly following incorrect reviewer advice.

    The skill identifies which comments are genuine bugs versus new feature requests, allowing you to categorize the latter as 'out-of-scope' to maintain your project timeline and prevent scope creep.

    You receive the complete skill configuration and the resolution logic templates, ready to be imported into your preferred AI agent framework to begin triaging and fixing code.

    The skill requires read/write access to your local repository to verify the code state and execute fixes, though it does not automatically push to remote branches without your explicit authorization.

    New in Code Quality & Review