commit push

    1

    Automate structured Git commits and pushes with mandatory type-prefixed subjects and descriptive bodies.

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    commit push

    Example session with this skill installed

    Commit my staged changes using the refactor type and push it to the remote.

    • Read your context and instructions
    • Compiled the commit push

    I have analyzed your staged changes, which involve separating the validation logic from the request orchestration in the billing service. I have committed these changes using git-cz and pushed the branch to the remote.

    Git Workflow Execution

    ActionDetailResult
    Branchfeature/billing-updateVerified
    Commit TyperefactorApplied
    Tool Usedgit-cz --non-interactiveSuccess
    Commit Subjectrefactor: split billing service validation logicValidated
    Push Statusorigin feature/billing-updatePushed

    Commit Message Detail:

    refactor: split billing service validation logic
    
    Separates billing validation from request orchestration so the rules are easier to reuse and maintain. This change moves the logic into a dedicated validator class to improve testability.
    

    Next steps

    • Verify the new commit appears in your remote repository history.
    • Continue with the next task now that the billing service is refactored.
    • Open a Pull Request if the feature is ready for review.

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

    About this skill

    Stop wrestling with inconsistent Git histories and missing context in commit logs. This skill enforces a strict, structured commit and push workflow that ensures every change is documented with both a mandatory type-prefixed subject and a detailed body. It automates the verification of staged changes, checks for advanced tooling like git-cz, and handles upstream tracking during the push process.

    What it does

    • Enforces commit structure by requiring a lowercase type, a specific colon format, and a mandatory descriptive body paragraph.
    • Validates staged changes by inspecting the active diff before committing to ensure the intent matches the generated message.
    • Selects optimal tools by checking for git-cz presence and defaulting to non-interactive mode for automation-friendly commits.
    • Handles remote synchronization by pushing the active branch and automatically setting upstream tracking if it is missing.
    • Prevents empty bodies by verifying the final commit message contains a description before allowing the push to execute.

    How it works

    1. Inspection: The agent verifies the Git environment, identifies the current branch, and confirms changes are staged.
    2. Analysis: It reviews the staged diff to categorize the work into allowed types like feat, fix, or refactor.
    3. Execution: It generates the structured message and commits using git-cz (preferred) or git commit with multiple -m flags.
    4. Verification: It performs a final check on the commit log to ensure the body was not dropped before pushing to the remote.

    Frameworks & tools

    This skill works with standard Git environments and is optimized for repositories using git-cz (Commitizen).

    Why this beats prompting it yourself

    Generic prompts often produce one-line commits or inconsistent prefixes. This skill strictly enforces a two-part message structure and performs a pre-push safety check to ensure your repository history remains clean, searchable, and compliant with professional standards.

    Use cases

    • Enforcing structured commit messages across a distributed development team.
    • Automating the commit-and-push flow during rapid development cycles.
    • Ensuring every production hotfix has a mandatory explanation in the Git log.
    • Standardizing branch upstream configuration for new local branches.

    Known limitations

    Does not support automatic file staging; changes must be staged before invocation. Only supports five specific commit types and forbids scope usage.

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

    Requires changes to be staged manually first. Limited to five specific commit types: feat, fix, hotfix, test, refactor. No support for commit scopes.

    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

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 16 days ago

    • Free with an Agensi account

    Software
    Git

    Permissions

    Terminal / Shell
    Listed16 days ago

    What's inside

    Frequently Asked Questions

    This skill enforces a mandatory structure consisting of a lowercase type prefix (like feat or fix) and a required descriptive body paragraph, preventing the vague one-line commits that often plague shared repositories.

    Yes, the skill requires files to be added to the staging area first; it then analyzes the staged diff to ensure the generated commit message accurately reflects your actual code changes.

    The skill is optimized for environments with git-cz (Commitizen) installed, but it will automatically fall back to standard Git commands using multiple message flags if advanced tooling isn't present.

    The skill automatically identifies your current branch and handles the push process, including setting the upstream tracking reference if you are working on a new local branch for the first time.

    To maintain a strict and clean history, this skill is limited to five specific commit types and intentionally excludes scope usage to ensure maximum readability and consistency across the log.

    New in APIs & Backend

    Free