More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Approval Gated Integration

    1

    Move complex code changes forward with clear checkpoints and human approval.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Approval Gated Integration

    Approval Gated Integration

    Example session with this skill installed

    Use $approval-gated-integration to refactor email delivery behind an interface. Inspect the existing code, propose small steps, and wait for my approval before applying each step. Preserve current behavior and run focused checks after every approved change.

    • Read your context and instructions
    • Compiled the approval gated integration

    I have inspected the current email-delivery code, SMTP integration, and existing tests. I have initialized a progress ledger in this conversation to track the refactor. No implementation changes have been applied.

    Implementation Plan: Email Delivery Refactor

    IDStepScopeStatus
    1Add Delivery InterfaceDefine the delivery contract, wrap the existing SMTP implementation, and add focused adapter testsproposed
    2Migrate Password-Reset EmailsUpdate password-reset callers to use the delivery interface and verify existing behaviorproposed
    3Migrate Billing Emails and Clean UpUpdate billing callers, verify their behavior, and remove obsolete direct SMTP references from migrated callersproposed

    Step 1 is the next approval decision. Steps 2 and 3 are proposed follow-up work and remain unapproved.

    Step 1: Add Delivery Interface

    • Objective: Establish a delivery contract backed by the existing SMTP implementation.

    Behavioral changes: No observable change to email delivery. Existing callers keep their current delivery path until their migration is approved.

    • Affected files: sender.ts, smtp-adapter.ts, sender.test.ts.
    • Schema or migration implications: None; no database changes.

    Validation: Run the project's type check and focused sender/adapter tests to verify that the adapter preserves existing SMTP behavior and error handling.

    Risks: Low. The interface and adapter do not replace existing callers in this step. Tests must confirm that SMTP errors still reach the caller.

    Tradeoff: The existing delivery path and new adapter coexist until the caller migrations are approved and completed.

    Next steps

    1. Say "Approve step 1" to begin adding the interface, adapter, and focused tests.
    2. Provide feedback if you want to change the scope or include additional delivery methods in the contract.
    3. Ask to see the proposed interface definition before I write the files.

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

    About this skill

    Move complex code changes forward with clear checkpoints and human approval.

    Approval-Gated Integration guides your coding agent through small, reviewable steps. It inspects the existing repository before proposing a change, follows the project's conventions, and explains what each step will do, which areas it affects, how it will be checked, and what tradeoffs matter.

    You approve the scope before implementation. The agent applies only the approved step or explicitly approved group of steps, preserves unrelated work, and keeps optional improvements separate. If a newly discovered dependency materially changes the scope or risk, it stops and brings that decision back to you.

    After each implemented step, the agent runs focused checks and updates a progress ledger with the status, validation, and result. You can see what is finished, what is blocked, and what still needs approval. Approved groups of steps are implemented and checked sequentially.

    Use it to add a feature incrementally, refactor a module, migrate persistence, or introduce an architectural change while retaining oversight. Full integration checks, production builds, and full test suites run after the final implementation step only when you explicitly request them. Documentation is created only when requested.

    The outcome is an implementation you have reviewed as it develops, with validation evidence at each step and a concise final handoff.

    Requires a local environment capable of running tests/linters. Does not automatically generate documentation or PRs without explicit user instructions.

    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

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

    Permissions

    Read Files
    Write Files

    File Scopes

    **/*

    Works across the codebase. Only files within each approved step’s scope are modified.

    Listed27 days ago

    What's inside

    Frequently Asked Questions

    It gives your coding agent a workflow for making changes with your approval. Instead of implementing the entire request at once, the agent inspects your codebase, breaks the work into small steps, and explains the next proposed change. After you approve that step, it implements the agreed scope, runs focused checks, and reports the result before asking to continue. Use it for features, refactors, migrations, and architecture changes where you want to review decisions as the work develops.

    The skill instructs the agent to wait for explicit approval before applying a proposed implementation step. It can read the codebase and analyze existing behavior to prepare the proposal. Before asking for approval, it explains the objective, expected behavior, affected files or modules, validation plan, and important risks. These approval gates guide the agent's behavior; they are not a technical permission lock on its editing tools.

    Reply with something clear, such as "Approve step 1" or "Apply steps 2 and 3." Approval covers the described scope, so a step can include several related files without requiring a separate confirmation for each edit. If you approve multiple named steps, the agent implements and validates them one at a time. Asking a question or requesting an explanation does not count as approval.

    Tell it what to change before approving the proposal. For example: "Update password-reset emails only; leave billing emails unchanged." The agent revises the scope and waits for approval of the updated proposal. You can also ask to see a proposed interface or discuss an alternative before any files are written. Revising a future step does not automatically undo changes you have already approved and completed.

    The agent reports what changed, how the behavior is affected, which focused checks ran, and any concerns it discovered. It also updates a progress ledger so you can see each step's status, validation, and result. The ledger normally stays in the conversation or an available task checklist. The next proposed step comes back to you for approval before implementation continues.

    If a focused check fails, the agent investigates and fixes the issue when the fix fits the approved scope. If the fix requires new behavior, materially changes the risk, or changes an agreed decision, it marks the step as blocked and brings a new proposal to you. Routine implementation details needed to finish the approved step do not require another approval; a material change to the scope does.

    After each implemented step, it runs the smallest relevant checks, such as focused tests, type checking, or linting. Full test suites, integration validation, and production builds run after the final implementation step only when you explicitly request them. Documentation is also created only when requested. You can include either request in your original prompt.

    New in Agents & Orchestration