git workflow and versioning

    1

    Enforce atomic commits, trunk-based branching, and semantic versioning for clean, reversible git history.

    Free

    1 useSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    git workflow and versioning

    Example session with this skill installed

    I've finished adding the Zod validation to the task endpoint and fixed a small typo in the sidebar. I need to commit these and prepare for a patch release.

    • Read your context and instructions
    • Compiled the git workflow

    I have separated your changes into two atomic commits to maintain a clean history and prepared the release metadata. I intentionally kept the validation refactor separate from the UI typo fix.

    Git Workflow Execution

    ActionDetails
    Commit 1feat: add Zod validation to task creation endpoint
    Commit 2fix: correct sidebar navigation typo
    Branchfeature/task-validation
    Version BumpPATCH (v1.0.4 -> v1.0.5)
    ChecksTests: Pass | Lint: Pass | Secrets: None

    Proposed Changelog Entry

    
    ## [1.0.5] - 2025-05-22
    ### Added
    - Input validation for task creation using Zod to prevent malformed database entries.
    
    ### Fixed
    - Typo in the sidebar navigation labels.
    

    Change Summary

    • Modified: src/routes/tasks.ts, src/components/Sidebar.tsx

    Scope Discipline: I ignored the outdated API docs in docs/api.md as they require a separate documentation chore.

    • Risk: The new Zod schema is strict; ensure frontend clients are sending all required fields.

    Next steps

    1. Run git push origin feature/task-validation.
    2. Create a PR into main.
    3. Tag the release with git tag -a v1.0.5 -m "Release 1.0.5" after merge.

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

    About this skill

    AI agents generate code faster than humans can review it, leading to bloated PRs, messy histories, and broken main branches. This skill enforces disciplined version control to keep changes manageable, reviewable, and reversible. It transitions your workflow from giant, "hope-it-works" commits to a structured, incremental approach that treats git history as documentation.

    What it does

    • Atomic Commits ensures every commit represents one logical change for easier debugging and reverts.
    • Structured Messages implements standardized commit types like feat, fix, and refactor to explain the "why" behind changes.
    • Trunk-Based Workflow prioritizes short-lived feature branches and feature flags to minimize merge debt.
    • Parallel Worktrees manages multiple streams of work simultaneously using git worktree without branch-switching overhead.
    • Release Discipline automates semantic versioning and human-readable changelogs based on consumer impact.

    How it works

    1. The Save Point Pattern involves committing every successful increment and reverting immediately if a test fails.
    2. Pre-Commit Hygiene runs a checklist of diff reviews, secret scanning, linting, and type checking before finalizing changes.
    3. Change Summaries generate a map of modified files, untouched areas, and potential risks for every PR.
    4. Versioning Audit determines if a change requires a MAJOR, MINOR, or PATCH bump based on breaking changes.

    Frameworks & tools

    Works with any project using Git. Includes specific automation patterns for JavaScript/TypeScript environments using Husky, lint-staged, and Zod, but the logic applies to any language.

    Why this beats prompting it yourself

    Generic prompts often produce messy "update" commits or skip the pre-commit checks that prevent secrets from leaking. This skill enforces a rigorous "save point" philosophy that ensures an agent never loses more than one small increment of work and maintains a production-ready main branch.

    Use cases

    • Multi-feature development using worktrees to let an agent work on three parallel features without interference.
    • Versioned package releases that require strict semantic versioning and formatted changelogs for external consumers.
    • Large-scale refactoring that must be split into small, atomic PRs to pass code review.

    Known limitations

    Does not support long-lived Gitflow-style branches or SVN. Requires a local Git installation and assumes a basic understanding of branch merging.

    Requires Git. Best suited for trunk-based development. Some automation examples are JS/TS specific but principles are universal.

    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

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Requires

    tsc
    Node.js
    Git

    Permissions

    Terminal / Shell
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill solves the 'bloated PR' problem by enforcing atomic commits and trunk-based development, ensuring that AI-generated code is broken down into small, reviewable, and reversible increments rather than massive, messy updates.

    It is compatible with any AI agent or framework that has access to a local Git environment, including popular coding assistants and autonomous agents that support custom tool integration.

    No, this skill is designed for trunk-based development with short-lived branches; it does not support legacy Gitflow architectures or older version control systems like SVN.

    The package includes the core logic for the 'Save Point' pattern, pre-commit hygiene checklists, automated semantic versioning rules, and specific automation patterns for environments like Husky and lint-staged.

    The skill includes a 'Versioning Audit' step that analyzes the scope of changes—such as breaking changes or new features—and automatically suggests the appropriate MAJOR, MINOR, or PATCH bump.

    New in LLM Ops