contributor protocol

    1

    Enforces a strict discovery and verification protocol for safe, documented, and approved codebase modifications.

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    contributor protocol

    Example session with this skill installed

    I need to rename the user internal ID field to uuid in the database schema and the API handler. What is the impact?

    • Read your context and instructions
    • Compiled the contributor protocol

    I have analyzed the impact of renaming user_id to uuid. This change affects the core schema and the primary API handler.

    Impact Analysis and Proposal

    OptionRiskEffortImpactRecommendation
    Rename field in schema and handlerPotential break for downstream consumersMConsistent naming convention✓
    Alias field in handler onlyTechnical debt in database schemaSLower risk of DB migration failure

    Proposed Changes:

    • src/schema/user.sql: Rename column user_id to uuid.
    • src/api/handlers/user.ts: Update property reference from user_id to uuid.
    • docs/api.md: Update field name in request/response examples.

    Verification Plan:

    1. Run npm run db:migrate:test to verify schema integrity.
    2. Execute npm test to ensure API handlers resolve the new property.
    3. Check CLAUDE.md architecture section for stale references.

    Proceed with these changes?

    Next steps

    • Approve the proposal to begin the multi-file edit.
    • Provide the preferred migration script format if specific SQL dialects are required.
    • Confirm if any external analytics services depend on the user_id key name.

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

    About this skill

    Standardizes the workflow for modifying codebases by enforcing a rigorous discover-propose-confirm loop. This skill eliminates silent failures and scope creep by requiring explicit approval for every file change and verifying results against the project's own build manifests and lockfiles. It treats project stability as the primary objective, ensuring that every modification rests on verified facts rather than model assumptions.

    What it does

    • Project Contract Extraction reads build manifests, lockfiles, and architecture docs to establish pinned versions and enforced invariants.
    • Strict Confirmation requires a one-line proposal and explicit user approval before any file is edited.
    • Impact Tracing analyzes dependency directions both ways to prevent cycles or regressions before proposing changes.
    • Root Cause Enforcement prohibits bypassing safety checks, weakening tests, or suppressing linter warnings.
    • Automated Definition of Done verifies changes against a checklist including test coverage, invariant validation, and documentation updates.

    How it works

    1. Discovery phase where the agent reads CLAUDE.md, package.json, or similar manifests to understand the environment.
    2. Proposal phase where the agent presents a specific change set and asks for approval.
    3. Application phase where only the approved diffs are applied to the codebase.
    4. Verification phase where the agent runs project-specific test suites and reports actual results.

    Frameworks & tools

    Works with any language or framework including React, Node.js, Python, Go, and Rust. It uses project files like CLAUDE.md, README.md, and standard build tool outputs to drive decisions.

    Why this beats prompting it yourself

    Generic prompts often lead to "hallucinated" API usage or silent regressions in complex dependencies. This skill forces the agent to verify every external API against pinned versions and prevents the rewriting of Git history or the introduction of architectural debt.

    Use cases

    • Safely refactoring legacy code while maintaining enforced invariants.
    • Implementing features in a team environment where CLAUDE.md rules must be strictly followed.
    • Fixing bugs without introducing new linter warnings or breaking public API contracts.

    Known limitations

    Does not support rewriting Git history (rebase/amend). Verification is limited to commands available in the local environment and cannot verify UI behavior or hardware-specific integrations.

    Prohibits rewriting Git history. Cannot verify behavior requiring external credentials, network access, or specialized hardware not present in the local runtime.

    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

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 18 days ago

    • Free with an Agensi account

    Requires

    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed18 days ago

    What's inside

    Frequently Asked Questions

    This skill acts as a safety layer that prevents "hallucinated" code changes by forcing the agent to verify every modification against your project's build manifests and lockfiles before execution.

    The skill is framework-agnostic and functions with any environment—including React, Python, and Rust—provided the project contains standard manifest files like package.json, requirements.txt, or CLAUDE.md.

    No, the protocol is designed for stability and strictly prohibits the agent from rewriting Git history, performing rebases, or suppressing linter warnings to ensure a clean, traceable audit trail.

    Setup is minimal; once integrated into your agent's environment, the protocol automatically initiates its discovery phase by reading your existing architecture docs and dependency files to establish safety invariants.

    You receive the full protocol implementation, including the Discover-Propose-Confirm logic, automated 'Definition of Done' checklists, and the Impact Tracing engine for dependency analysis.

    While it excels at logic and dependency verification, it cannot verify visual UI behavior or hardware-specific interactions that occur outside of command-line test suites and build logs.

    New in Agents & Orchestration