Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Atomic Commit Splitter

    0

    Organize messy git diffs into a structured plan of atomic Conventional Commits ordered by dependency layer.

    $7

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Atomic Commit Splitter

    Atomic Commit Splitter

    Example session with this skill installed

    Split my current changes into atomic commits. I added a CSV export feature. Don't run any git commands that change anything.

    • Read your context and instructions
    • Compiled the atomic commit splitter

    I inspected the working tree with read-only git (git status --porcelain, git diff --stat). There are 8 changed files across 4 layers. I grouped them into 4 self-contained commits, lowest layer first. Nothing was staged or committed.

    Commit plan

    #Commit messageFiles
    1feat(shared/csv): add csv serializer with quote escapingsrc/shared/csv/serialize.ts, src/shared/csv/index.ts
    2feat(entities/user): expose active users querysrc/entities/user/api.ts, src/entities/user/index.ts
    3feat(features/exportUsers): add admin csv export with 50k limitsrc/features/exportUsers/exportUsers.ts, src/features/exportUsers/index.ts
    4test(features/exportUsers): cover limit, escaping and authorizationtest/exportUsers.test.ts

    All 8 files are assigned to exactly one commit.

    Commands for you to run

    git add src/shared/csv/serialize.ts src/shared/csv/index.ts
    git commit -m "feat(shared/csv): add csv serializer with quote escaping"
    
    git add src/entities/user/api.ts src/entities/user/index.ts
    git commit -m "feat(entities/user): expose active users query"
    
    git add src/features/exportUsers/exportUsers.ts src/features/exportUsers/index.ts
    git commit -m "feat(features/exportUsers): add admin csv export with 50k limit"
    
    git add test/exportUsers.test.ts
    git commit -m "test(features/exportUsers): cover limit, escaping and authorization"
    

    git add and git commit are on separate lines so you can review between them.

    Next steps

    1. Run each pair in order and check git status after each commit.
    2. If you prefer one commit per feature instead of per layer, tell me and I will regroup.

    PASS

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

    About this skill

    Messy diffs and massive, multi-file "work in progress" commits make code reviews difficult and break git history. This skill analyzes your current working tree to partition changes into self-contained, atomic units following the Conventional Commits standard. It provides a structured plan for human execution without ever touching your git state directly.

    What it does

    • Diff mapping scans your staged, unstaged, and untracked files to understand the scope of changes.
    • Dependency ordering organizes commits from the lowest layer, such as utilities and entities, to the highest layer, like UI components and features.
    • Atomic grouping ensures each proposed commit is logically self-contained so that builds and tests remain green.
    • Command generation produces explicit, non-destructive git commands for you to review and run.

    How it works

    1. Analyze: The skill runs read-only commands like git status and git diff to map the change set.
    2. Review Check: It looks for a review.md file to ensure architectural approval before proceeding.
    3. Partition: Changes are grouped by layer, starting with shared utilities and ending with documentation or tests.
    4. Plan: It generates a commits.md file containing the rationale and specific commands for each commit.

    Frameworks & tools

    This skill works with any project using Git and follows the Conventional Commits specification. It is compatible with all languages and frameworks.

    Why this beats prompting it yourself

    Generic prompts often suggest git add . or mix UI changes with backend logic. This skill enforces strict layering rules and provides separate add and commit lines to ensure you maintain a professional, bisectable history.

    Use cases

    • Cleaning up a long coding session that touched multiple modules.
    • Splitting features from accidental refactors or style fixes.
    • Layering changes so that shared logic is committed before the features that rely on it.

    Known limitations

    This tool is read-only and will not execute git commands for you. It requires manual review for review.md approvals if that file is present in your workflow.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Workflow Automation.

    Read-only tool that proposes commands but never executes them. Stops if an unapproved review.md is present. Requires manual execution of commands.

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

    Software
    Git

    Permissions

    Read Files
    Write Files
    Listed19 days ago

    What's inside

    Frequently Asked Questions

    This skill analyzes your working tree to group related changes into logical, 'atomic' commits that follow the Conventional Commits spec, ensuring your git history is clean, bisectable, and easy to review.

    No, the skill is non-destructive and read-only; it generates a structured 'commits.md' plan with specific git commands for you to review and execute manually.

    The skill is language-agnostic and works with any Git-based project, provided your AI agent has read access to your local file system and Git CLI.

    By identifying 'dependency layers,' the skill ensures that foundational changes like database schemas or utility functions are committed before the UI components that depend on them.

    You receive the logic and structured workflow for your AI agent to perform diff mapping, dependency analysis, and the command generation template.

    The skill checks for a 'review.md' file in your project to ensure that your proposed architectural changes align with your project's standards before it suggests a commit plan.

    New in Workflow Automation