Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Builder Kit

    1

    Plan, build, verify, and review software changes with repository-aware AI workflows, approval gates, and evidence-backed checks. Free and open source.

    Free

    2 usesSecurity scanned
    Builder Kit

    Builder Kit

    Example session with this skill installed

    Use Builder Kit to plan a profile-update API endpoint for our Python backend.

    Users should be able to update their display name and bio, but not their email, password, role, or account status.

    Give me a proposed API contract, security requirements, implementation plan, and acceptance criteria. Mark anything that depends on repository inspection as unverified. Do not change files until I approve the plan.

    • Read your context and instructions
    • Compiled the builder kit

    Summary

    Classification: planned work. This feature introduces an API endpoint and authorization requirements, so it needs an approved plan before implementation.

    Selected lenses: backend engineering, security and privacy, and quality engineering.

    No repository has been inspected. The proposal below must be checked against the application's existing routes, authentication, validation, and persistence conventions. No files have been changed.

    Proposed API contract

    Endpoint: PATCH /users/me

    This path is provisional; reuse the repository's established API prefix and naming conventions.

    Example request

    
    ```json
    {
      "display_name": "Alex Morgan",
    ```
    
      "bio": "Developer building useful tools."
    
    ```
    }
    
    
    | Field | Proposed behavior |
    |---|---|
    | `display_name` | Optional in a partial update; when supplied, must be a non-empty string |
    | `bio` | Optional in a partial update; an empty string clears it |
    | Omitted fields | Remain unchanged |
    | Unknown or protected fields | Reject the request rather than silently ignoring them |
    
    
    Maximum lengths, whitespace handling, null handling, and empty-request behavior must be confirmed against existing product rules and model constraints.
    
    **Proposed success response**
    
    ~~~json
    
    ```json
    {
      "display_name": "Alex Morgan",
    

    "bio": "Developer building useful tools."

    }
    ~~~
    

    Use the application's existing response envelope and status conventions if they differ. Return no sensitive account fields.

    Security requirements

    • Resolve the target account from the authenticated principal. Do not accept a target user ID in the request body.
    • Explicitly allow only display_name and bio; do not assign arbitrary request properties to the user model.
    • Reject attempts to change email, password, role, or account status.
    • Apply existing authentication, CSRF protection where relevant, and request-size controls.
    • Preserve existing output-escaping rules for profile text; accepting text does not make it safe to render as HTML.
    • Avoid logging credentials, session tokens, or unnecessary profile content.

    These are implementation requirements, not verified properties of the current application.

    Implementation plan

    1. Inspect repository instructions, related endpoints, user models, authentication helpers, and tests.
    2. Confirm field constraints, error formats, and update/concurrency conventions; revise this proposal where necessary.
    3. Obtain approval for the finalized contract and implementation plan.
    4. Add the request schema and endpoint using existing application patterns.
    5. Update only supplied, permitted fields through the established persistence layer.
    6. Add focused tests, run relevant checks, and report actual outcomes and limitations.

    Acceptance criteria

    ScenarioExpected result
    Authenticated user updates both permitted fieldsBoth values persist and appear in the response
    User updates only their bioDisplay name remains unchanged
    User supplies an empty bioBio is cleared
    Request is unauthenticatedExisting authentication error; no mutation
    Request includes role or another forbidden fieldValidation error; no partial mutation
    Request violates confirmed field constraintsExisting validation error format; no mutation
    Update succeedsResponse contains only the approved profile fields

    Next steps

    Provide access to the repository so its conventions and constraints can be checked. Any material differences will be reflected in the final plan before approval.

    Status: proposal prepared; repository-dependent details unverified. No implementation or verification has been performed.

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

    About this skill

    Builder Kit gives your coding agent a structured workflow for changing software: understand the repository, classify the task, plan substantial changes, get approval, implement, and verify.

    It brings together five workflows—Builder Kit Router, Develop from Spec, Start New App, Adversarial Review, and PR Review Loop—with shared engineering references, planning templates, and Git safety guidance.

    Free and open source under the MIT license.

    What it does

    • Matches process to risk. Separates localized tiny fixes from substantial work that needs specification, planning, and approval.

    • Loads relevant guidance. Uses architecture references and specialist lenses for data, APIs, security, reliability, accessibility, and frontend work.

    • Sets explicit safety boundaries. Instructs the agent to preserve unrelated changes, respect repository rules, and obtain authorization for publishing or destructive actions.

    • Challenges assumptions. Reviews specifications, plans, architecture, and code for material flaws, distinguishing evidence from uncertainty.

    • Reviews and fixes iteratively. When fixes are authorized, repeats review and verification within a bounded loop, reporting unresolved risks and blockers.

    • Guides new applications. Works through product discovery, design decisions, approval, and scaffolding without presenting a prototype as production-ready.

    How it works

    1. Ask explicitly. For example: “Use Builder Kit to plan this feature. Do not implement until I approve.”

    2. Discover and classify. The agent reads repository instructions and relevant code, identifies constraints, and selects the appropriate workflow.

    3. Plan and approve. Non-trivial implementation requires an approved plan. Large or high-risk work requires specification approval before planning.

    4. Implement and verify. Authorized changes proceed in coherent slices with proportionate checks and a clear account of results and limitations.

    Tiny fixes use a lighter path. Adversarial reviews remain read-only unless changes are separately authorized.

    Languages and tools

    The workflows are language-agnostic, with additional reference guidance for Java, Python, C++, Jenkins, and frontend development.

    Repository work uses the host agent’s available filesystem, shell, and Git tools. GitHub-specific actions require suitable tools, authentication, and explicit authorization; this package does not supply those capabilities.

    Why use it instead of a one-off prompt?

    Builder Kit makes engineering expectations reusable: what to inspect, when to stop for approval, which risks to consider, and what evidence to gather before claiming completion.

    Its value is a consistent process grounded in the repository—not a promise that an agent will never make mistakes.

    Example requests

    • “Use Builder Kit to specify and plan a new API endpoint.”

    • “Use Builder Kit to investigate this localized bug and verify the fix.”

    • “Run a read-only adversarial review of this architecture.”

    • “Run the PR review loop on my current changes. Ask before editing.”

    • “Use Start New App to discover requirements and plan a new application.”

    Requirements and limitations

    • The Agensi connector must make the bundled supporting documents accessible to the host agent. If a required resource cannot be retrieved, the affected workflow should stop and report it.

    • Implementation and verification require authorized editing and command-execution tools.

    • This listing delivers workflow instructions and reference materials, not a hosted coding service or native plugin installation.

    • Instructions cannot guarantee agent compliance, defect-free code, security, or production readiness.

    • End-to-end execution through Agensi has not yet been verified.

    Requires host agent filesystem and Git tool access. Workflow halts if required reference documents are missing. Maximum 10 iterations for the PR review loop.

    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

    2 uses

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 27 days ago

    • Free with an Agensi account

    Requires

    GitHub
    OpenAI
    Anthropic

    Permissions

    Read Files
    Write Files
    Network Access
    Terminal / Shell
    Environment Variables

    Allowed Hosts

    api.github.com
    api.openai.com
    api.anthropic.com
    Listed27 days ago

    What's inside

    Frequently Asked Questions

    Unlike standard prompting, Builder Kit enforces a rigorous multi-stage workflow including task classification, adversarial review, and mandatory approval gates to prevent the 'blind coding' and sweeping, unverified changes typical of autonomous agents.

    The kit is language-agnostic and compatible with any LLM-based agent that has authorized filesystem and shell access, featuring specific reference standards for Java, Python, C++, Jenkins, and modern Frontend stacks.

    You will receive the six core modules (Router, Adversarial Review, Develop-from-Spec, PR Review Loop, Start-New-App, and Git Handler) along with the structured templates and technical lenses required to run the development harness.

    Installation involves adding the kit's modules to your agent's toolset and pointing it to your local references directory; however, it requires the host agent to already have existing filesystem and Git permissions to function.

    The 'Adversarial Review' module acts as a specialized stress-test phase where the agent identifies hidden flaws in architecture, concurrency logic, or security boundaries before any code is actually committed.

    New in Prompt & Skill Engineering