Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    developer handoff agent

    1

    Automate repository handoffs and safe integrations for multi-developer teams using Git LFS and Unreal Engine.

    $5.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    developer handoff agent

    developer handoff agent

    Example session with this skill installed

    The shift is over. Check what Shane and the agents did, look at my local C++ changes in the Source folder, and give me an integration plan to get this to main.

    • Read your context and instructions
    • Compiled the developer handoff agent

    I have analyzed the current repository state, cross-referencing the git log with Docs/Beta/Coordination.md and the recent Claude result logs.

    Integration plan: 2024-10-24

    State

    • HEAD: 8f2a3c4
    • Local main: 2 commits ahead of origin.
    • Counts: 12 modified, 4 untracked, 0 staged, 1 stash.
    • Incoming: 3 commits from Shane (mostly UI assets).

    Changes by author and window

    • Connor (Local): Source/IronBreach/PlayerController.cpp (Ready).
    • Shane (Remote): Content/UI/Widgets/WBP_MainHUD.uasset (Ready).
    • Claude (Local): Source/IronBreach/AI/Task_FindCover.cpp (Ready - Pass Audio/Sfx1102).
    • In Progress: Content/Art/Characters/Enemy_Grunt.uasset (Shane - ACTIVE window).

    Collisions and decisions

    • Collision: Config/DefaultEngine.ini modified by both Local and Remote.

    Decision: Perform three-way merge into a review folder. Keep both Shane's plugin updates and local net-code tweaks.

    Left out on purpose

    • Saved/Logs/Editor.log: Classified as keep-local artifact.
    • Content/Art/Characters/Enemy_Grunt.uasset: Owner (Shane) has an ACTIVE window; skipping to avoid partial commit.

    Sequence

    1. TAKEN: Post window line for integration scope.
    2. Fetch: Pull Shane's changes; set colliding DefaultEngine.ini aside.
    3. Merge: Apply reviewed .ini changes.
    4. Build: Run Build.sh (Editor); verify PlayerController in sandbox.
    5. Commit: Stage exactly 8 files. Verify against commit-1024-files-reviewed.txt.
    6. Push: git push origin refs/heads/main.

    LFS size and risks

    • LFS Total: 14.2 MB (2x .wav files from Claude pass).
    • Risk: Low. Well under quota.

    Needs a decision

    • Confirm if the upstream deletion of Source/Legacy/OldPhysics.cpp should be honored (currently exists locally as untracked).

    Next steps

    • Review the proposed .ini merge in the /review folder.
    • Run the sandbox build check for the PlayerController.
    • Provide the "Go" signal to begin the automated commit sequence.

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

    About this skill

    Managing a multi-developer repository with mixed binary assets and C++ source is a recipe for broken builds and lost work. This skill acts as an automated release manager, reconciling local state against remote changes and agent-specific handoff documents to ensure conflict-free integrations.

    What it does

    • State reconciliation synchronizes local, stashed, and remote git states while tracking Git LFS assets.
    • Author attribution maps file changes to specific developers or AI agents based on folder conventions and coordination docs.
    • Path classification separates ready-to-commit code from in-progress windows, temporary build artifacts, and protected binary assets.
    • Collision resolution detects overlapping changes in text and binary files, proposing manual merges or specific overrides.
    • Integration planning generates a sequenced list of operations including fetches, builds, sandboxed verification, and chunked commits.

    How it works

    1. Analyze logs by parsing git porcelain output, LFS lists, and coordination markdown files to identify who owns which changes.
    2. Audit changes against project maps to flag protected assets like maps or icons that require special handling.
    3. Draft a plan that summarizes collisions, LFS sizes, and the exact sequence of commands required to sync safely.
    4. Execute integration through staged sequences including builds in isolated sandboxes and verified pushes that never force-rewrite history.

    Frameworks & tools

    Built for projects using Git, Git LFS, C++, and Unreal Engine workflows. It interacts with standard CLI tools and reads internal coordination docs like Coordination.md and project-map.md.

    Why this beats prompting it yourself

    Generic agents often overlook binary asset collisions or accidentally commit build artifacts like Intermediate/ folders. This skill enforces a strict "boring" sequence that halts on every surprise, preventing the catastrophic "push over an upstream deletion" error common in multi-agent environments.

    Use cases

    • Preparing a clean handoff for another developer after a long coding session.
    • Reconciling agent-generated assets with manual C++ changes without breaking the build.
    • Safely merging incoming remote changes into a local tree with active stashes.
    • Auditing a workspace to identify files that should never be committed.

    Known limitations

    Does not support automatic merging of binary .umap or .uasset files. Large LFS uploads may stop the plan due to quota risks. Requires specific coordination file structures to track agent windows.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.

    Cannot merge binary assets (uasset/umap). Stops on LFS quota risks or non-LFS files >95MB. Requires coordination.md and project-map.md for full attribution logic.

    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 buying a skill.

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

    Software
    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed9 days ago

    What's inside

    Frequently Asked Questions

    This agent acts as an automated release manager that reconciles Git LFS binary assets and C++ code, preventing common Unreal Engine pitfalls like committing build artifacts or overwriting a teammate's binary files.

    The skill is designed for any AI agent or developer workflow that uses Git CLI; it specifically looks for `Coordination.md` and `project-map.md` files to understand work boundaries.

    No, the agent cannot merge binary files like `.uasset` or `.umap`; instead, it detects these collisions early and halts the integration to prevent data loss.

    You will receive the agent's logic configuration, documentation on the required coordination file structures, and a guide for integrating it into your existing Git/Unreal workflow.

    Setup requires an existing Git LFS repository and the creation of two simple markdown mapping files that define your team's file ownership and protected directories.

    The agent identifies and filters out temporary folders like `/Intermediate`, `/Saved`, and `/DerivedDataCache` automatically, ensuring only source and necessary assets are staged.

    New in Agents & Orchestration