More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    GitGuard

    1

    Protect Git workflows from messy changes, risky operations, and release mistakes.

    $9

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    GitGuard

    GitGuard

    Example session with this skill installed

    Run GitGuard on my current repository before I open a pull request.

    Inspect the current branch, working-tree state, staged and unstaged changes, untracked files, recent commits, diff scope, sensitive files, and branch relationship to the base branch.

    Do not modify, delete, commit, reset, stash, clean, or rewrite anything.

    Give me a complete GitGuard report showing what is clean, what needs attention, the risk level of each finding, and exactly what I should verify before opening the PR.

    • Read your context and instructions
    • Compiled the gitguard

    GitGuard Repository Report

    Overall Status: NEEDS ATTENTION

    GitGuard inspected the repository without modifying, deleting, staging, committing, stashing, resetting, or cleaning any files.


    1. Repository State

    CheckResult
    RepositoryDetected
    Current branchfeature/payment-retry
    Working treeChanges detected
    Staged changesDetected
    Unstaged changesDetected
    Untracked files3 detected
    Merge/rebase stateNo active conflict state detected

    The repository is not currently clean, so the final PR scope should be reviewed before any commit or merge operation.


    2. Branch Guard

    Branch: feature/payment-retry

    The branch has diverged from its upstream/base relationship.

    Risk: MEDIUM

    This does not automatically indicate a problem, but the branch relationship should be understood before opening or merging the PR.

    Recommendation:

    Review the commits that exist on the feature branch and compare them with the current base branch before deciding whether a merge or rebase is appropriate.

    GitGuard does not automatically choose merge or rebase based on personal preference.


    3. Working-Tree Guard

    GitGuard detected

    • Modified tracked files
    • Staged changes
    • Unstaged changes
    • 3 untracked files

    The untracked files should not be assumed to be disposable.

    Risk: MEDIUM

    Before committing, determine whether each untracked file is:

    1. Part of the feature
    2. A generated artifact
    3. A local-only file
    4. A temporary/debug file
    5. Potentially sensitive
    6. Unknown

    No untracked files were deleted.


    4. Diff Guard

    The primary application changes appear related to the payment-retry feature.

    However, one configuration file is outside the obvious feature scope.

    Risk: HIGH

    Configuration changes can affect environments beyond the immediate feature and may require separate review.

    Recommendation:

    Confirm whether the configuration change intentionally belongs in this PR.

    Do not remove it automatically.


    5. Sensitive File Guard

    An environment-style file was detected.

    Risk: HIGH

    Environment files can contain API keys, database credentials, service tokens, or other sensitive configuration.

    GitGuard did not display or reproduce any credential values.

    Verify:

    • The file is intentionally ignored.
    • It is not staged.
    • It is not part of the commit.
    • No credentials have previously been committed to repository history.

    If an actual credential has been exposed, removing the file alone may not be sufficient. The affected credential should also be rotated through the appropriate provider.


    6. Commit Guard

    Recent commits are generally understandable.

    One commit contains a relatively broad group of changes.

    Risk: MEDIUM

    A broad commit can make code review and future troubleshooting more difficult.

    Recommendation:

    Determine whether the commit represents one coherent change. If the repository's workflow permits history editing and the commits are not shared, splitting them may be considered.

    Do not rewrite history solely for stylistic reasons.


    7. Verification

    VerificationStatus
    Repository inspection✓ Completed
    Working-tree inspection✓ Completed
    Diff inspection✓ Completed
    Branch inspection✓ Completed
    Sensitive-file review✓ Completed
    Automated tests⚠ Not run
    Lint⚠ Not run
    Type checking⚠ Not run

    Tests, linting, and type checking are therefore not verified.


    GitGuard Priority Findings

    🔴 HIGH — Configuration change requires confirmation

    A configuration file appears outside the primary feature scope.

    🔴 HIGH — Environment-style file requires review

    Confirm that it is ignored, unstaged, and not present in repository history with credentials.

    🟠 MEDIUM — Branch divergence

    Review the feature branch against its base before proceeding.

    🟠 MEDIUM — Broad commit

    Consider whether the commit accurately represents one coherent change.

    🟡 MEDIUM — Verification incomplete

    Relevant automated checks have not been run.


    Recommended Next Actions

    1. Confirm whether the configuration-file change belongs to the PR.
    2. Confirm that the environment file is ignored and not staged.
    3. Review the three untracked files individually.
    4. Compare the feature branch with the current base branch.
    5. Inspect the final staged diff.
    6. Run the project's relevant tests, lint, and type checks.
    7. Only then prepare the final PR.

    GitGuard Final Gate

    PR Readiness: NEEDS ATTENTION

    The repository has not been modified by GitGuard.

    No files were deleted, reset, staged, committed, stashed, cleaned, or rewritten.

    Next decision: resolve the identified findings and run the required verification before opening the PR.

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

    About this skill

    GitGuard is a safety-first Git workflow skill for AI coding agents.

    It helps developers keep repositories clean, reviewable, and safer to modify by systematically inspecting Git state before important operations.

    GitGuard checks:

    • Repository and working-tree health
    • Staged, unstaged, and untracked changes
    • Branch state and divergence
    • Diff scope and unrelated changes
    • Sensitive files and credential exposure
    • Commit and staging hygiene
    • Pull-request readiness
    • Merge and rebase safety
    • Conflict handling
    • Release readiness

    Its core workflow is:

    Inspect → Classify → Warn → Recommend → Authorize → Act → Verify

    GitGuard is designed specifically for AI-assisted development, where an agent may otherwise make assumptions about repository state or perform unnecessary Git mutations.

    It protects unexplained user work, avoids unnecessary destructive operations, and clearly separates what was observed, recommended, and actually executed.

    Use it before committing, opening a PR, merging, rebasing, cleaning a repository, or preparing a release.

    Built for developers and AI coding agents working with real Git repositories—not generic Git theory.

    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.

    Known Limitations

    • Requires Git repository and terminal access through the host AI agent.
    • Available checks depend on the Git tools, shell permissions, and integrations supported by the host environment.
    • Secret detection can identify common credential patterns and sensitive files, but cannot guarantee detection of every secret.
    • Git state alone cannot always determine the developer's intent behind a change.
    • GitHub/GitLab PR, CI, and remote checks may require platform-specific integrations.
    • Release-readiness checks depend on the project's tests, build system, versioning, and release conventions.
    • GitGuard does not automatically perform destructive actions such as reset, clean, deletion, force-push, or history rewriting without authorization.
    • When a check cannot be verified, GitGuard reports Not Verified rather than assuming success.

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

    Software
    Git

    Permissions

    Terminal / Shell
    Listed2 months ago

    What's inside

    Frequently Asked Questions

    gitguard acts as a specialized safety layer that intercepts Git commands to verify repo hygiene, scan for leaked credentials, and prevent destructive actions like accidental force-pushes or overwriting uncommitted work.

    This skill is designed to be model-agnostic and works with any AI agent capable of using tools or executing CLI commands, provided the agent has access to a standard Git installation.

    Setup is straightforward: once you integrate the skill into your agent's environment, it requires standard Git CLI access and basic repository permissions to begin auditing workflows.

    While gitguard uses advanced pattern recognition to identify common secrets and .env files, it is designed as a workflow auditor rather than a standalone enterprise security platform.

    Your purchase includes the full skill package, integration documentation, and access to future updates including new audit patterns and safety checks as they are released.

    No. GitGuard protects unexplained user work and does not automatically delete files or perform destructive cleanup.

    No. Untracked files are treated as potentially valuable until their purpose is understood and appropriate authorization is provided.

    GitGuard checks for obvious sensitive files and credential exposure and can use available scanning tools when supported. Secret detection is not guaranteed to identify every credential.

    No. GitGuard focuses on Git workflow hygiene and PR readiness. Platform-specific PR capabilities depend on the host environment.

    It can inspect and assist with conflicts. Ambiguous semantic conflicts should not be resolved by guessing.

    Not by default. Force-push and other history-rewriting operations require appropriate authorization.

    Yes. GitGuard is designed around Git repositories and does not require a particular hosting provider.

    No. It provides practical Git workflow and safety checks, not a complete security audit or security guarantee.

    It reports the item as Not verified rather than claiming success.

    New in Agents & Orchestration