Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    git advanced workflows

    1

    Navigate complex Git operations like rebase, bisect, and reflog recovery with safety-first command sequences.

    $8

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    git advanced workflows

    git advanced workflows

    Example session with this skill installed

    I accidentally did a hard reset on my feature branch 'api-fix' and lost three commits. I haven't pushed yet. How do I get them back safely?

    • Read your context and instructions
    • Compiled the git advanced workflows

    I will help you recover your lost commits using the Git reflog. Since these changes were not pushed, they exist only in your local reflog history.

    Git Recovery Plan: Lost Commits on 'api-fix'

    PhaseActionCommandPurpose
    1. BackupCreate emergency taggit tag recovery-backupEnsure current state is marked before moving HEAD.
    2. LocateInspect refloggit reflog show api-fixIdentify the SHA-1 hashes prior to the reset operation.
    3. VerifyPreview commitgit show <commit-sha>Confirm the content of the lost work.
    4. RestoreReset to SHAgit reset --hard <commit-sha>Point the branch back to the desired state.
    5. ValidateCheck loggit log --oneline -n 5Confirm the three lost commits are back in history.

    Command Sequence

    
    # 1. Create a safety marker
    git tag recovery-point-$(date +%s)
    
    # 2. View the history of HEAD movements
    git reflog
    
    # 3. Look for the entry just before 'reset: moving to...'
    # It will look like: HEAD@{1}: commit: Added auth middleware
    # Replace HEAD@{1} with the specific index found
    git reset --hard HEAD@{1}
    

    Safety Controls

    Abort Path: if the reset goes to the wrong point, use git reset --hard recovery-backup to return to where you started this recovery.
    *

    Risk: High. A --hard reset overwrites the working directory. Ensure you have no uncommitted changes before running.

    Next steps

    1. Run git reflog and identify the hash from just before the accidental reset.
    2. Verify the commit content with git show <hash>.
    3. Execute the reset command to restore your work.

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

    About this skill

    The problem

    Standard Git commands often fall short when history gets messy or regressions hide deep in the commit logs. Developers risk losing work or breaking shared branches when attempting complex rebases, reflog recoveries, or bisects without a clear safety net.

    What it does

    • Generates step-by-step plans for interactive rebases and history cleaning.
    • Provides guarded workflows for recovering lost commits via the reflog.
    • Automates the setup for git bisect to isolate regressions efficiently.
    • Orchestrates multi-tasking environments using Git worktrees.
    • Calculates safe cherry-pick sequences with pre-flight validation checks.

    Why this beats prompting it yourself

    Generic LLMs often suggest dangerous commands like --force or omit critical backup steps. This skill enforces a "safety-first" protocol, requiring --force-with-lease, mandatory backup branches, and explicit abort paths for every destructive operation.

    Use cases

    • Cleaning up a messy local feature branch before a Pull Request.
    • Finding the exact commit that introduced a bug using automated bisect.
    • Recovering a branch that was accidentally deleted or reset.
    • Managing multiple active tasks simultaneously using worktrees instead of stashing.

    Known limitations

    Requires manual confirmation of repository state and branch sharing status. Does not execute commands directly in your shell.

    User must manually verify if branches are shared with others. The skill provides guidance and command sequences but does not execute them directly.

    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 2 months ago

    Permissions

    Terminal / Shell
    Listed2 months ago

    What's inside

    Frequently Asked Questions

    This skill provides guarded, step-by-step command sequences for high-risk operations like interactive rebases and reflog recoveries, ensuring you never lose work by mandating backup branches and safety flags like --force-with-lease.

    This skill is designed to work with any LLM-based agent that supports markdown text output and code block generation, acting as a specialized knowledge layer for your existing AI developer tools.

    You will receive the proprietary logic and system instructions required to configure your AI agent to handle advanced Git logic, along with documentation on how to integrate it into your development cycle.

    Yes, the skill is optimized for modern Git versions and includes specialized workflows for Git Worktrees, allowing you to manage multiple feature branches simultaneously without the overhead of stashing.

    No, for security reasons, this skill generates validated command sequences for you to review and run, ensuring you maintain full control over your repository's state and history.

    New in DevOps & Cloud