feedback additive changes

    1

    Enforce additive-only changes and dormant code annotations to prevent regressions during refactors and migrations.

    Free

    1 useSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    feedback additive changes

    Example session with this skill installed

    I need to refactor the payment processing logic to use the new Gateway class and remove the old unused helper methods in payments.py.

    • Read your context and instructions
    • Compiled the feedback additive changes

    I have analyzed the request to refactor the payment processing logic. Following the additive-first protocol, I will preserve the existing helpers by marking them as dormant and implement the new Gateway logic in a parallel path to ensure zero impact on the current production flow.

    Refactor Plan: Additive Payment Logic

    ComponentActionAdditive Status
    payments.pyAnnotate _legacy_format_request and _old_validate as DORMANT✅ Additive
    gateways/new_gateway.pyCreate new implementation class✅ Additive
    api/v2/payments.pyCreate new endpoint for the new logic✅ Additive
    migrations/Add gateway_ref_id as a NULLABLE column✅ Additive

    Code Implementation

    
    # payments.py
    
    # DORMANT — legacy helper; kept for compatibility with v1 mobile clients 
    # that bypass the main gateway logic.
    def _legacy_format_request(data):
        return {"amt": data.amount, "cur": "USD"}
    
    class PaymentProcessor:
        def process(self, data):
            # DORMANT — legacy validation branch; no active providers 
            # use this path, but it is preserved for future failover.
            if hasattr(data, "legacy_mode"):
                return self._old_validate(data)
            return self._new_gateway_process(data)
    

    Next steps

    • Verify that the linter passes with the new DORMANT comments.
    • Deploy the additive migration to create the nullable gateway_ref_id column.
    • Route a small percentage of traffic to the new v2 endpoint to validate the pattern.

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

    About this skill

    Refactoring production code often introduces regressions through accidental deletions or breaking changes to legacy dependencies. This skill enforces a strict additive-first methodology to ensure every modification is reversible and has a low blast radius. It prevents the common pitfall of "while I'm here" cleanups that destabilize existing systems.

    What it does

    • Enforces additive logic by ensuring new capabilities live alongside legacy code rather than replacing it.
    • Protects dormant code by requiring explicit DORMANT annotations instead of deletions for seemingly unused paths.
    • Guided decision-making using a tree to determine if a change is safe (additive) or high-risk (destructive).
    • Strangler-fig migration support for moving toward new architectures without breaking the old ones.
    • Safe schema evolution by defaulting to nullable additions and deferred constraints.

    How it works

    1. Analyze the change request against the additive/destructive decision tree before any code is written.
    2. Apply the dormant protocol to annotate unreachable code paths with specific intent comments.
    3. Execute low-impact proofs by choosing minimal aggregates and new endpoints for pattern validation.
    4. Validate against the refactor checklist to ensure no existing shapes or paths were modified.

    Frameworks & tools

    This skill is framework-agnostic and works with any codebase using REST/GraphQL APIs, SQL databases, or modular file structures. It is particularly effective for teams managing high-uptime production systems or complex legacy migrations.

    Why this beats prompting it yourself

    Standard LLMs tend to be overly aggressive with "cleaning up" code, often deleting vital but dormant logic or breaking backward compatibility. This skill overrides that bias with a rigid safety-first protocol that prioritizes system stability over aesthetic purity.

    Use cases

    • Migrating a legacy API endpoint to a new architecture without breaking existing clients.
    • Proving a new design pattern like Unit of Work on a low-risk subset of the domain.
    • Performing database schema updates that require zero-downtime expand-contract cycles.
    • Documenting the intent of unused code to prevent future accidental deletion.

    Known limitations

    This skill is not for greenfield projects where destructive changes have no blast radius. It requires manual confirmation for backfill logic in complex migrations.

    Explicitly avoids greenfield projects where additive rules are redundant. Does not automate the backfill phase of migrations.

    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 any payment.

    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

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 28 days ago

    • Free with an Agensi account

    Permissions

    No special permissions declared or detected

    Listed28 days ago

    What's inside

    Frequently Asked Questions

    This skill enforces a strict safety protocol that prevents the AI from deleting or modifying legacy code during refactors. Instead, it guides the agent to implement new logic alongside the old and use annotations to mark dormant code, ensuring every change is reversible and stable.

    It is framework-agnostic and compatible with any AI agent that handles code generation or reviews. It works across various architectures, including REST/GraphQL APIs and SQL databases, making it ideal for complex legacy systems.

    By enforcing the 'Strangler-fig' and 'Expand-Contract' patterns, the skill ensures that new features or schema changes are added without breaking existing dependencies. This allows you to migrate systems incrementally while keeping production environments fully operational.

    You will receive the specialized logic set, the additive/destructive decision tree, and the 'DORMANT' protocol guidelines. These assets work together to override an AI's natural tendency to 'clean up' or delete code during tasks.

    No, this skill is specifically designed for high-stakes production environments where stability is the priority. For greenfield projects where you want the AI to iterate and delete code freely, this safety-first protocol would be unnecessarily restrictive.

    New in Code Quality & Review