Voice Typing in the Terminal: Commands Without Keyboards

TL;DR: Terminal commands are short, formulaic, and repetitive. Voice typing handles them surprisingly well. From git to docker to npm, speaking commands is faster and less error-prone than typing them from memory.

Why the Terminal Is Great for Voice

Terminals might seem like the last place you would use voice. They are precise, unforgiving, and full of special characters. But there are several reasons voice typing works well here:

1. Commands are natural language-adjacent. "git commit dash m fixed the login bug" is almost English.
2. Commands are short. Most terminal commands are under 20 words, which is the sweet spot for accurate voice transcription.
3. Typos are costly. One wrong character in a terminal command can do something completely different (or fail silently). Speaking reduces typos.
4. Commands are repetitive. You type the same git, npm, and docker commands hundreds of times. Voice eliminates the muscle-memory tax.

How Murmur Works in the Terminal

Murmur works in any application where you can type, including:

• Windows Terminal
• PowerShell
• Command Prompt (CMD)
• VS Code integrated terminal
• Git Bash
• Any terminal emulator (Hyper, Alacritty, etc.)

The workflow is simple:

1. Focus your terminal
2. Press your Murmur shortcut (default: Ctrl+Space)
3. Speak your command
4. Murmur transcribes and inserts the text
5. Press Enter to execute

Murmur's AI-powered transcription accurately handles technical terms and command syntax. When you say "git log dash dash oneline dash 10," it transcribes git log --oneline -10, not "git log - - one line - 10."

Git Commands by Voice

Git is the most common terminal tool for developers, and voice handles it perfectly.

Everyday Commands

Commit Messages

This is where voice really shines. Instead of typing a lazy one-line commit:

git commit -m "fix bug"

You speak a proper commit message:

git commit -m "Fix race condition in WebSocket reconnection logic where
multiple reconnect attempts could fire simultaneously when the heartbeat
timeout and connection error events triggered at the same time"

That took 12 seconds to dictate. It would have taken 30+ seconds to type, and in practice, most developers would have typed "fix ws reconnect" instead.

Branch Operations

"git checkout dash b feature slash user preferences"
→ git checkout -b feature/user-preferences

"git merge develop"
→ git merge develop

"git branch dash d feature slash old branch"
→ git branch -d feature/old-branch

Log and History

"git log dash dash oneline dash 20"
→ git log --oneline -20

"git log dash dash author equals yegor dash dash since equals last week"
→ git log --author=yegor --since="last week"

npm and Package Manager Commands

Running Scripts

"npm run dev"
→ npm run dev

"npm run build"
→ npm run build

"npm run test dash dash coverage"
→ npm run test --coverage

Installing Packages

"npm install express cors helmet"
→ npm install express cors helmet

"npm install dash D typescript at types slash node"
→ npm install -D typescript @types/node

Speaking long package names is often faster than typing them, especially with scoped packages.

Docker Commands

Docker commands tend to be long and flag-heavy, which makes them perfect for voice:

"docker compose up dash d"
→ docker-compose up -d

"docker build dash t my app colon latest dot"
→ docker build -t my-app:latest .

"docker logs dash f api container"
→ docker logs -f api-container

"docker exec dash it postgres container psql dash U admin"
→ docker exec -it postgres-container psql -U admin

Working with AI Agents in the Terminal

The biggest productivity gain from voice in the terminal comes from AI coding agents like Claude Code. These tools run in the terminal and expect natural language prompts.

Instead of typing short, incomplete prompts, you speak detailed instructions:

"Look at the failing tests in the user module and fix them.
The issue is probably related to the email service mock that
we updated yesterday. Make sure all the assertions match the
new response format."

See Voice Coding with Claude Code for a deep dive on this workflow.

Tips for Speaking Terminal Commands

Speak Punctuation and Flags Clearly

Use Natural Phrasing

You do not always need to dictate character by character. AI-powered voice tools understand natural phrasing:

• "list all running docker containers" can transcribe as docker ps
• "show the last 20 commits one per line" can transcribe as git log --oneline -20

The transcription depends on your tool's intelligence. Murmur handles this well thanks to its advanced AI transcription.

Speak at a Natural Pace

Do not slow down for technical terms. Modern transcription handles technical vocabulary better when it has the context of surrounding words. A normal speaking pace gives the AI more context to work with.

Correct on the Fly

If you see a transcription error before pressing Enter, just backspace and retype the incorrect part. Voice handles 95% of the command; your keyboard handles the last 5%.

Power User Workflows

Chained Commands

Speak complex command chains naturally:

"npm run build and and npm run test and and npm run deploy"
→ npm run build && npm run test && npm run deploy

SSH and Remote Commands

When working with remote servers:

"ssh deploy at production server"
→ ssh deploy@production-server

"rsync dash avz dot slash dist slash user at server colon slash var slash www"
→ rsync -avz ./dist/ user@server:/var/www

Environment Variables

"export DATABASE URL equals postgres colon slash slash localhost colon 5432 slash mydb"
→ export DATABASE_URL=postgres://localhost:5432/mydb

Quick Script Authoring

For one-liner scripts or quick automation:

"for file in star dot log do echo processing file done"
→ for file in *.log; do echo "processing $file"; done

Complex scripts are still better written in a file. But for quick terminal one-liners, voice is fast enough.

When to Use Voice vs Keyboard in the Terminal

Use voice for:

• Git commit messages (longer, more descriptive)
• AI agent prompts (detailed instructions)
• Long commands with many flags
• Commands you do not type often enough to have memorized
• Any command longer than 30 characters

Use keyboard for:

• Very short commands (ls, cd .., pwd)
• Arrow-key navigation through command history
• Tab completion for file paths
• Correcting small transcription errors

The hybrid approach is the most productive. Voice handles the high-effort parts, keyboard handles the quick parts.

Conclusion

Terminal voice typing sounds counterintuitive until you try it. Git commit messages become detailed instead of lazy. Docker commands flow out without consulting the docs. AI agent prompts become rich and context-filled.

Murmur makes this seamless because it works in any terminal application with accurate AI-powered transcription. Download it, try a few git commands by voice, and see how it feels. Most developers are surprised by how natural it becomes after just a day or two.

For more on voice coding workflows, see our complete voice coding guide.