Change Impact Review

    1

    Trace code changes through dependencies to identify contract violations and prioritized regression risks.

    $2.99

    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

    Change Impact Review

    Example session with this skill installed

    Review the impact of changing the calculateTax function in src/finance/calculator.ts where we updated the return type from number to TaxResult object.

    • Read your context and instructions
    • Compiled the change impact review

    I have reviewed the change in src/finance/calculator.ts. The transition from a primitive number to a TaxResult object creates several immediate contract violations in the invoicing module.

    Change Impact Report

    1. Decision Summary

    Status: High Risk.
    The change breaks the primary calculation contract used by the PDF generator and the checkout API. Immediate refactoring of three callers is required.

    2. Prioritized Findings

    PriorityFindingImpactEvidence
    HighType Mismatch in InvoicingServiceRuntime crash during PDF generationsrc/invoice/generator.ts:142 expects a number for total_tax
    HighBroken API ResponseCheckout payload now returns nested object instead of floatsrc/api/checkout.ts:88 passes raw return to JSON response
    MedTest Regressiontax_calc_test.spec.ts uses .toBeLessThan() which fails on objectstests/finance/tax_calc_test.spec.ts:22

    3. Dependency & Contract Map

    • src/finance/calculator.ts (Provider)
      • src/invoice/generator.ts (Consumer: Broken)
      • src/api/checkout.ts (Consumer: Broken)
      • src/reports/eoy_summary.ts (Consumer: Status Unknown - File not provided)

    4. Regression Matrix

    TargetTriggering ConditionExpected Behavior
    PDF GenerationRun generateInvoice(orderId)Property accessor must use .value or .amount
    API CheckoutPOST /v1/checkoutEnsure legacy clients receive flattened numeric value
    Unit TestsRun npm test finance/Update assertions to validate TaxResult schema

    Next steps

    1. Provide src/reports/eoy_summary.ts to check if end-of-year reports are also impacted.
    2. Update the InvoicingService to destructure the TaxResult object.
    3. Implement a legacy wrapper for the Checkout API to maintain backward compatibility.

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

    About this skill

    Code changes often break dependencies in ways that unit tests miss. This skill analyzes diffs against project contracts to identify prioritized regressions and broken callers before they hit production.

    What it does

    • Diff Analysis parses code changes to identify intended behavior versus accidental contract violations.
    • Dependency Mapping traces affected callers, shared types, routes, and data consumers connected to the change.
    • Impact Verification links specific code changes to user consequences with concrete evidence.
    • Risk Prioritization categorizes findings by consequence and reach, distinguishing between code-level contradictions and plausible risks.
    • Regression Planning generates a targeted matrix of checks to verify the fix and prevent future regressions.

    How it works

    1. Supply the diff, head/base revisions, or the specific changed files to be reviewed.
    2. The skill traces implementation details to affected callers and shared data contracts.
    3. It evaluates findings based on triggering conditions and user consequences.
    4. It delivers a prioritized report including a dependency map and regression matrix.

    Frameworks & tools

    This skill is language-agnostic and works with any codebase where diffs and source files are available. It is particularly effective for systems with complex internal APIs, shared types, or strict data contracts.

    Why this beats prompting it yourself

    Standard prompts often hallucinate side effects or miss deep dependency chains. This skill follows a rigorous evidence-based workflow that requires a concrete trace from change to consequence, preventing "finding fatigue" from hypothetical or trivial issues.

    Use cases

    • Reviewing PRs for breaking changes in shared library functions or internal APIs.
    • Assessing the impact of database schema migrations on existing data consumers.
    • Validating type definition changes across large monorepos.
    • Generating focused manual QA scripts for high-risk logic updates.

    Known limitations

    Does not execute tests or perform runtime analysis. Requires access to caller files to provide complete dependency coverage. Findings are limited to supplied artifacts.

    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.

    Cannot execute code or tests. Dependency coverage is labeled incomplete if only changed files are provided without surrounding context or caller files.

    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 10 days ago

    Permissions

    Read Files
    Write Files
    Listed10 days ago
    Updated8 days ago

    What's inside

    Frequently Asked Questions

    While standard LLM prompts often flag trivial or hypothetical issues, this skill uses a rigorous evidence-based workflow to trace logic through your specific dependency chain, ensuring every reported risk has a concrete path from change to consequence.

    The skill is language-agnostic and functions with any codebase where source files and diffs are accessible, though it is particularly powerful for projects using shared types, internal APIs, or strict data contracts like TypeScript or Go.

    The skill requires the code diff (or head/base revisions) and access to the relevant source files for affected callers to map the full dependency chain accurately.

    No, this is a static analysis skill that traces logic and contracts; it does not execute your code or require a runtime environment, making it safe for use in pre-deployment environments.

    You receive the full skill logic as described, designed to be compatible with any AI agent or platform that supports structured multi-step workflows and file-system access.

    The primary output is a prioritized report that includes a visualized dependency map of affected callers and a targeted regression matrix for your QA or automated testing suites.

    New in Code Quality & Review