Agentic Repository Execution: Delegated Changes

    1

    Get coordinated repository changes with independent checks, recorded handoffs, and a clear completion report.

    Free

    1 useSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Agentic Repository Execution: Delegated Changes

    Example session with this skill installed

    In this Python repo, delegate a change to normalize_email so it trims outer spaces and lowercases addresses. Add tests, validate independently, and leave changes uncommitted.

    • Read your context and instructions
    • Compiled the agentic repository execution

    COMPLETED: normalize_email now trims outer whitespace and lowercases addresses. Implementation was delegated, and independent validation passed.

    Changes delivered

    src/accounts/email.py:

    def normalize_email(address: str) -> str:
        return address.strip().lower()
    

    Updated tests/test_email.py with cases for mixed case, surrounding whitespace, and an already-normalized address. No address-format validation or other behavior was added.

    Ownership and validation

    WorkOwnerResult
    Function and regression testsImplementation agentDelivered
    Independent test runValidation agentPASS
    Integrated diff and scope checkCoordinating agentPASS

    Commands verified

    python -m pytest tests/test_email.py -q
    
    # 3 passed
    python -m pytest -q
    
    # 28 passed
     git diff --check
    
    # Passed with no output
    

    No failed, blocked, or skipped required checks remain.

    Handoff

    The existing task record at agent-notes/email-normalization.md now links the changed files and validation results. Unrelated working-tree changes were left untouched. Nothing was staged, committed, pushed, or deployed.

    Next steps

    • Review the function and regression-test diff.
    • Authorize staging and a commit if you want these changes recorded in Git.

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

    About this skill

    Delegating code changes can leave you with conflicting edits, missing tests, and unclear completion claims. This skill coordinates implementation agents and returns working-tree changes with a clear report of what changed and what was verified.

    What it does

    • Scoped implementation: Assigns bounded changes while respecting repository rules and existing work.
    • Conflict control: Separates ownership and runs work in parallel only where dependencies and file boundaries allow.
    • Independent checks: Coordinates review and validation separately from implementation, according to the change’s risk.
    • Recoverable handoffs: Keeps plans, progress, and evidence available for later agents.
    • Clear reporting: Lists changed files, check results, unresolved issues, and actions not performed.

    How it works

    1. Provide the repository, requested change, and any limits.
    2. The assistant inspects local instructions, available agents, and validation tools.
    3. Implementation agents make scoped changes, followed by appropriate checks.
    4. Receive a completion or blocker report with supporting evidence.

    Works with

    Code repositories, Git working trees, repository instructions such as AGENTS.md, and existing test, lint, type-check, and build commands. Your agent environment must support launching sub-agents.

    Why use this skill

    It reduces the manual work of coordinating assignments and checking handoffs. Completion is based on inspected changes and validation results, rather than an agent’s claim that the work is done.

    Use cases

    • Implement a feature across several components.
    • Refactor code without disturbing unrelated edits.
    • Resume staged work from recorded handoffs.

    Known limitations

    Delegated implementation stops if sub-agents are unavailable. Commits, pushes, deployments, and destructive actions need separate authorization.

    Requires an agent environment that can launch sub-agents. Does not authorize commits, pushes, publication, deployment, or destructive actions.

    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 1 month ago

    • Free with an Agensi account

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    Reads the repository and local instructions; implementation agents edit scoped production files; validation uses repository test, lint, build, and Git commands. No network or secrets are inherently required.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill replaces simple 'claims' of completion with a structured handoff process that includes independent verification checks, conflict control, and a final report detailing exactly what was modified or left unresolved.

    It is designed for any agent environment that supports sub-agent spawning and has access to a Git working tree, including tools that respect repository-level instructions like AGENTS.md.

    The skill identifies file boundaries and dependencies before assigning tasks, ensuring implementation agents work in parallel only when it is safe to do so without creating merge conflicts.

    By default, the skill coordinates code changes and validation; however, for safety, it does not perform destructive actions like commits, pushes, or deployments without separate user authorization.

    You receive the core logic for the delegation and reporting workflow, documentation for integration, and any updates released within your support window.

    Yes, because it records handoffs and progress evidence, a new session can pick up the state of the repository and the 'blocker report' to continue where the previous agent left off.

    New in Agents & Orchestration