More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Git Workflow and Versioning Playbook

    1

    Branch short, commit atomically, untangle messy trees, write messages that explain decisions, and version releases so consumers can trust an upgrade.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Git Workflow and Versioning Playbook

    Git Workflow and Versioning Playbook

    Example session with this skill installed

    My working tree is a mess: I fixed an expired-token bug, reformatted half the codebase while I was in there, and started a CSV export that isn't tested yet. Sort it out. Also, our next release removes the old format=json API parameter — what version bump is that?

    • Read your context and instructions
    • Compiled the git workflow

    Sort at staging time, not later. Three changes, three fates:

    1. Commit the formatting first, alone: chore: apply formatter to auth and export modules. Use git add -p and stage only formatting hunks, skipping every logic change. Reason: formatting mixed into a behavior change makes the real diff unreviewable and the commit unrevertible.

    2. Commit the fix second, on its own: fix: reject expired tokens at the gateway. Stage the auth logic and its test; run the tests; this commit must be green by itself. Message body explains the decision: "Expired tokens were being refreshed instead of rejected; the refresh path now checks expiry first. Closes #482." Because it stands alone, it can be cherry-picked to a release branch without dragging the formatter pass along.

    3. The CSV export does not get committed yet. It has no tests, so it isn't a save point — it's inventory at risk. Either write the tests and commit it on feature/csv-export as a parser-only slice behind no endpoint, or park it with git stash -u and finish the release first. What it never does is ride along inside the fix commit "while you were in there."

    Version call: removing format=json is MAJOR. A consumer who sends that parameter today gets working behavior; after the release they get an error or silently different output. That's an incompatible change to the contract, and the bump table is blunt about doubt: unsure whether it's breaking means treat it as breaking — a surprise major is cheaper than a broken consumer. So if you're at 1.4.2, this release is 2.0.0. Two follow-throughs: the changelog entry goes under Removed, phrased as user impact ("Requests using format=json must switch to the Accept header"), and if 1.x is still supported, the deprecation should have been announced in a 1.x release first — announce, mark deprecated, remove in the next major. Tag it v2.0.0 and derive the artifact version from the tag so the tag, the build, and the changelog can't disagree.

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

    About this skill

    Git is the only undo system that survives across sessions, agents, and machines — but only if the history is legible. This skill installs the full working discipline: short-lived branches named by intent, the save-point loop (change, verify, commit, repeat) that makes every commit a known-good restore point, atomic commits scored against a four-point rubric before they are pushed, a practical method for untangling a messy working tree into clean commits with git add -p, commit messages that explain why rather than restating the diff, small scoped pull requests reviewers can actually trust, conflict resolution that reads both sides before deciding, and the recovery commands worth knowing cold. The release half treats versioning as a consumer contract: semantic versions with a bump decision table, tags that artifacts derive their version from, deprecations with a runway, and changelogs written for readers instead of pasted from commit logs. Includes a complete worked example of sorting a three-change tangle into revertible commits.

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

    • It defines working discipline, not hosting-platform settings — protected branches, required checks, and permissions are configured in your platform, though the skill tells you what to ask for.
    • It assumes a trunk-based flow; teams locked into long-lived release trains or GitFlow by policy will need to adapt the branching section.
    • Commit conventions defer to your repo's existing style — the skill will match a house convention rather than override it.

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

    Software
    Git

    Permissions

    Terminal / Shell
    Listed24 days ago
    Updated21 days ago

    What's inside

    Frequently Asked Questions

    No — not on shared branches. Rewriting published history breaks every collaborator's clone, and the skill's one hard rule is never force-pushing shared work. Start the discipline from today forward; use the untangling method on your current tree and let the clean history accumulate.

    One idea, green on its own, revertible without collateral damage. In practice that's usually a couple of hundred lines. Past roughly a thousand, the rubric says split — and behavior changes never share a commit with formatting or refactors.

    Major. The decision table treats doubt as breaking, because the costs are asymmetric: an unnecessary major bump costs consumers a careful read of the changelog, while a breaking change shipped as a minor costs them a production incident.

    New in DevOps & Cloud