Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Bounded Implementation

    1

    Implement an approved objective inside an explicit change boundary, preserve project invariants, and return focused validation evidence with deviations and residual risks.

    $14

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Bounded Implementation

    Bounded Implementation

    Example session with this skill installed

    Implement the approved POST /login rate limit: allow 10 requests per minute per IP and return 429 on the 11th. Limit changes to the approved middleware and auth route surfaces, do not refactor other routes, and report focused checks plus any residual risk.

    • Read your context and instructions
    • Compiled the bounded implementation

    Illustrative worked example. Synthetic data from the package; this is not an observed external execution.

    OBJECTIVE: rate-limit POST /login to 10 req/min/IP, 429 on exceed.
    BOUNDARY: middleware/rateLimit.js (new), routes/auth.js (wire on /login only). Excluded: other routes, global config.
    CHANGED SURFACES: + middleware/rateLimit.js; routes/auth.js (1 line).
    CHECKS: lint PASS; type PASS; new test login.ratelimit.test.js PASS (10 ok, 11th -> 429); full auth suite PASS.
    ACCEPTANCE EVIDENCE: test asserts 11th request within window returns 429; resets after window.
    DEVIATIONS: none.
    UNVERIFIED / RESIDUAL RISK: distributed deployment would need shared store (in-memory limiter is per-instance) - flagged, out of approved scope.

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

    About this skill

    When a decision is settled and an approved objective must be coded without scope creep, Bounded Implementation turns the request into an explicit change boundary. It reads the smallest sufficient repository evidence, preserves project invariants, makes the smallest coherent mutation on the approved surface, and returns focused validation evidence with deviations and residual risks.

    What it does

    It starts from an approved objective, acceptance criteria, current authority, permitted surface, and enough repository evidence to locate the authoritative implementation seam. Project governance, accepted specifications, committed contracts, tests, and current repository evidence keep their authority order.

    How it works

    1. Establish the change boundary: objective, invariants, allowed files or components, excluded work, required acceptance checks, and migration or configuration implications.
    2. Make the smallest coherent mutation at the authoritative seam, reuse project patterns, and avoid unrelated cleanup or speculative abstraction.
    3. Validate with the narrowest relevant format, lint, type, test, or build checks, then run the original reproduction or acceptance loop.
    4. Hand off for independent review with changed surfaces, checks, deviations, residual risk, and unverified items.

    Output

    The result follows a fixed decision shape:

    • OBJECTIVE
    • BOUNDARY
    • CHANGED SURFACES
    • CHECKS
    • ACCEPTANCE EVIDENCE
    • DEVIATIONS
    • UNVERIFIED / RESIDUAL RISK

    Boundaries

    This is an implementation workflow after the behavior or decision is approved. It does not discover root cause, choose architecture, provide final release sign-off, silently widen scope, install dependencies, commit, push, merge, deploy, run destructive migrations, or mutate production. If new evidence expands scope, it stops and requests a revised decision or specification. If a needed capability is absent, it uses a repository-native fallback when possible and records the item UNVERIFIED or BLOCKED.

    Why it is different

    An architecture or root-cause workflow resolves what should be built or why a failure occurred. Bounded Implementation starts after that decision and confines the mutation, acceptance checks, and handoff to the approved surface. It is not a release gate.

    This is an implementation workflow, not root-cause discovery, architecture selection or final release sign-off. It requires an approved objective, acceptance criteria, current authority, permitted surface and sufficient repository evidence. It does not imply dependency installation, commits, pushes, merges, deploys, destructive migrations or production mutation. Shell, Git, browser, network, MCP and package-manager capabilities are not assumed; unavailable checks are marked UNVERIFIED or BLOCKED.

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

    Permissions

    Read Files
    Write Files

    Requires read access to the smallest sufficient project evidence and write access to the approved implementation surface. Terminal/Shell is optional for focused project checks; if unavailable, use repository-native or manual checks and mark affected items UNVERIFIED or BLOCKED. Browser, network access, MCP services, external accounts and environment variables are not required by the package.

    Listed19 days ago

    What's inside

    Frequently Asked Questions

    It keeps an approved implementation task inside its declared change boundary, so the agent can change the intended surface without silently expanding into unrelated refactoring.

    Use it after the behavior or design, acceptance criteria, current authority and permitted surface are settled. Do not use it to discover root cause, choose architecture or provide final release sign-off.

    It returns OBJECTIVE, BOUNDARY, CHANGED SURFACES, CHECKS, ACCEPTANCE EVIDENCE, DEVIATIONS and UNVERIFIED / RESIDUAL RISK, followed by a handoff for independent review.

    Those workflows decide what should be built or explain why a failure occurred. This skill starts after the decision and confines implementation, focused checks and handoff to the approved surface.

    You need an approved objective, acceptance criteria, current authority, permitted surface and enough repository evidence to locate the implementation seam. Read and write access are required; shell checks are optional with fallback.

    New in Code Quality & Review