Showdev: An AI-assisted skill to batch messy changes into Conventional Commits

Source: Dev.to

Hi DEV community 👋

I’d like to share a small project I’ve been tinkering with: conventional-commit-batcher.
This is my first “skill” built with the help of AI tools. After a few programmer friends tried it on real work‑in‑progress branches and found it useful for turning messy, mixed changes into a cleaner commit history, I decided to open‑source it.

TL;DR

• Plan first – generate a Commit Plan by intent
• Commit in batches – often with git add -p
• Validate commit messages – enforce Conventional Commits

What problem does it try to solve?

When a working tree mixes refactors, fixes, docs, and chores, it’s easy (especially for junior devs) to end up with:

• one giant “misc” commit
• vague commit messages

Resulting in a history that’s hard to review, revert, or git bisect.
I wanted something that nudges me toward a more reviewable, traceable history—without turning it into a big ceremony.

What it does (in one line)

Plan‑first commit batching + commit message validation – it helps you organize mixed diffs into logical, reviewable Conventional Commits, and validates messages before they land.

How it works (high level)

Plan first

Produce a Commit Plan that groups changes by intent (e.g., refactor vs fix vs docs).

Batch staging

Stage changes batch‑by‑batch (often with git add -p) instead of “add everything”.

Message validation

Enforce Conventional Commits formatting with an executable validator.

Safety gates

Stop early if something looks risky (conflict markers, sensitive strings, etc.).

Example: a Commit Plan (by intent)

1) refactor(auth): simplify token parsing
   changes: src/auth/*

2) fix(api): handle empty response safely
   changes: src/api/*

3) docs: update setup notes
   changes: docs/*

Repo / quick try

Repository:

If you use the Vercel skills ecosystem, you can try:

npx skills add cnkang/conventional-commit-batcher

Prefer no agent tooling? You can still use the validator and commit‑msg hook examples in the repo.

A tiny before/after example

Before (typical messy branch)

• update stuff
• fixes
• wip

After (same work, clearer history)

• refactor(auth): simplify token parsing
• fix(api): handle empty response safely
• docs: update setup notes

You can imagine how much easier it becomes to review, revert, or bisect.

A small favor: try it and share feedback

I’d really appreciate any thoughts (especially if you can try it on a “messy branch”):

• Batching by intent: does it actually help split mixed changes into logical commits? If not, what kinds of changes are hardest to separate (tests + refactor, formatting + logic, lockfiles…)?
• Team conventions: what rules do you follow (types/scopes, subject length, issue references, breaking changes)?
• Junior‑friendly guardrails: which checks feel helpful, and which feel too strict?
• Multi‑language commit messages: do you write commits in languages other than English? If yes, would you prefer type(scope) in English + localized subject/body, or fully localized messages (and how should validation adapt)?

Thank you for taking a look 🙇

If you try it and it helps (or fails), I’d love to hear what happened—either way.