Dictating Commit Messages the AI Can Expand
Good commit messages get skipped because writing them well is slow and boring. What if you could just say what you changed out loud, and let the AI turn that one spoken line into a clean, conventional commit? On a Mac, that workflow is now realistic, and it happens entirely on your own machine.
Key takeaways
- Speak the gist of a change, and AI cleanup expands it into a subject line plus a short body.
- Everything runs on-device, so your code, voice and commit text never leave the Mac.
- A custom AI prompt can lock the output to conventional commit format automatically.
- A custom dictionary keeps library, function and variable names spelled correctly.
Why dictate commit messages at all?
Writing a tidy commit message is a small tax you pay dozens of times a day. You know what you changed, but turning that into a crisp subject line and a useful body takes typing, editing and second-guessing. So most commits end up as "fix stuff" or "wip", which future you will resent.
Dictation flips the effort. Most people speak around three to four times faster than they type, so saying "I fixed the login timeout by increasing the retry window and added a test" takes a couple of seconds. The slow part was never the thinking, it was the tidy formatting. That is exactly the part an AI cleanup step is good at. If you already dictate other developer work, this fits the same habit you build when you code by voice on a Mac.
How the dictate-then-expand workflow works
The pipeline is short. Your microphone captures the sentence, a local speech-to-text model turns it into raw text, an on-device AI pass rewrites that raw text into a formatted commit, and the result lands wherever your cursor is. Because BlaBlaType works system-wide, that cursor can be in your terminal, in the commit box of your Git app, or in the message field of an editor like Cursor.
The key detail is that every stage runs on your Mac. The Whisper and Parakeet models that do the transcription are local, and the AI cleanup is powered by Apple Intelligence on-device. That is different from routing a prompt to a cloud model, in the spirit of running things locally with tools like Ollama. Your diff, your file names and your voice stay put. If privacy is a real concern for you, it is worth reading whether Mac dictation is actually private before you wire this into your daily flow.
Set it up in four steps
Pick a dictation shortcut
Choose a global key you can hit without leaving the keyboard. It works in any app, so the same shortcut fires in your terminal, editor and Git client.
Add a commit-style AI prompt
Create a custom prompt that says: rewrite my dictation as a conventional commit, with a subject under 50 characters and an optional short body. This is what turns a spoken line into structure.
Load your names into the dictionary
Add library names, function names and internal jargon to the custom dictionary so terms like useEffect or Postgres come out spelled correctly instead of phonetically.
Speak the change, then commit
Put your cursor in the commit field, hold the shortcut, say what changed in one sentence, and let the AI expand it. Review, tweak if needed, and commit.
What a spoken line becomes
The point is not to remove your judgment, it is to remove the typing. You still say what matters. The AI just formats it. Here is the kind of transformation the cleanup step handles, once you have given it a conventional commit prompt.
| You say | AI expands to |
|---|---|
| fixed the login timeout by bumping the retry window and added a test | fix(auth): widen login retry window Increase retry timeout and add a regression test for the timeout path. |
| added dark mode toggle to the settings screen | feat(settings): add dark mode toggle |
| cleaned up the readme and fixed some typos | docs: tidy README and fix typos |
Notice you never dictated the word "fix" or the parentheses. You described the change in plain language and the prompt supplied the convention. This is the same "talk to the assistant, get structured output" pattern you use when you talk to ChatGPT with your voice on a Mac, only pointed at your commit box.
Dictate your next commit
Speak the change, let on-device AI expand it into a clean message, all without your code leaving the Mac. No card needed for the trial.
Download for macOSWhere this fits, and where it does not
Dictate-then-expand shines for the everyday commits that make up most of your history: bug fixes, small features, docs, refactors. For a giant, subtle change that needs a carefully argued body, you will still want to type and edit, and that is fine. The goal is to make the good habit of writing clear messages cheap enough that you actually do it every time.
It also stacks with the rest of your voice workflow. Once the shortcut is muscle memory for commits, the same setup covers pull request descriptions, code comments and even quick voice notes for yourself. The plans and full feature list live on the pricing page if you want to see what the Pro tier adds, like screen-context awareness and audio file transcription.
Frequently asked questions
How do I dictate a commit message on a Mac?
Put your cursor in the commit message field or your terminal, press your dictation shortcut, and speak the intent of the change. With on-device voice to text and AI cleanup, BlaBlaType transcribes your words locally and expands the spoken summary into a clean, conventional commit.
Can AI expand a short spoken note into a full commit message?
Yes. You dictate the gist, such as fixed the login timeout bug, and an AI cleanup step rewrites it into a subject line plus a short body. With a custom prompt you can enforce conventional commit prefixes like fix or feat automatically.
Does dictating commit messages send my code to the cloud?
Not with BlaBlaType. Speech recognition and AI cleanup run 100% on-device on your Mac, so your voice, your commit text and anything on screen stay local and are never uploaded to a server.
Can I keep the conventional commits format when I dictate?
Yes. A custom AI prompt can force the output into conventional commit style, so a spoken sentence becomes a properly prefixed subject under 50 characters with an optional body. A custom dictionary keeps library and function names spelled correctly.
Which is faster, typing or dictating commit messages?
Dictating is usually faster for the first draft because most people speak around three to four times faster than they type. The AI cleanup step then handles punctuation and formatting, so you skip the slowest part of writing a tidy commit by hand.