Agentic Coding by Voice: The Future of Dev Productivity

TL;DR: AI coding tools are evolving from autocomplete to autonomous agents. As agents handle more of the implementation, the developer's job shifts to giving clear instructions. Voice is the fastest, most natural way to do that.

The Three Eras of AI-Assisted Coding

Software development has gone through three distinct phases with AI assistance:

Era 1: Autocomplete (2021-2023) GitHub Copilot suggested the next line of code. You typed, it guessed. The input was code, the output was code. Useful, but limited.

Era 2: Chat-Based Coding (2023-2025) Tools like Cursor, ChatGPT, and Copilot Chat let you describe what you want in natural language. The input shifted to English (or any language), the output was code blocks you could apply. A big step forward.

Era 3: Agentic Coding (2025-present) Claude Code, Cursor Agent mode, and similar tools do not just generate code snippets. They read your entire codebase, plan multi-step changes, edit multiple files, run tests, and iterate on their own work. You describe a goal, and the agent executes it.

Each era shifted more of the work from the developer to the AI. And with each shift, the input method matters more.

What Is Agentic Coding?

Agentic coding means using AI tools that act autonomously to accomplish development tasks. Instead of asking for a code snippet and manually applying it, you give an agent a task, and it:

1. Reads relevant code files to understand context
2. Plans an approach
3. Makes changes across multiple files
4. Runs tests or builds to verify
5. Iterates on failures
6. Presents the completed work for your review

This is fundamentally different from autocomplete or even chat-based coding. The agent is doing the implementation. Your job is to:

• Describe what you want clearly and completely
• Review the output to ensure quality
• Course-correct when the agent goes in the wrong direction

Two of these three tasks are communication tasks. And voice is how humans naturally communicate complex ideas.

The Bottleneck: Typing Detailed Prompts

Here is the core problem with the current agentic coding workflow:

The quality of the agent's work is directly proportional to the quality of your instructions. A vague prompt produces vague code. A detailed prompt produces precisely what you need.

But developers are trained to write code, not prose. And typing long, detailed instructions in a terminal or chat panel is slow and unnatural. So what happens in practice?

Developers write the shortest prompt that might work:

add user authentication

Then they iterate when the output is not right:

no, use JWT not sessions

put the middleware in a separate file

also add refresh tokens

Four prompts, four iterations, four review cycles. Each one takes time. And the total prompt word count across all iterations is often higher than if they had written one detailed prompt upfront.

The bottleneck is not the AI. It is the cost of expressing detailed requirements through typing.

Why Voice Is the Natural Input for AI Agents

Speed: 3x More Words Per Minute

The average developer types 60-80 words per minute. The average person speaks 150+ words per minute. For natural language input (which is what agents expect), voice is simply faster.

A 100-word prompt takes 75 seconds to type but only 40 seconds to speak. And because voice has lower friction, you naturally include more detail, which means fewer iterations.

Natural Detail: You Explain More When Speaking

When you explain a technical problem to a colleague, you do not give them a five-word summary. You describe the context, the expected behavior, what you have tried, and what the constraints are.

Voice prompts naturally mirror this pattern. When the cost of words drops (speaking vs typing), you include information you would have cut.

Typed prompt: "Fix the performance issue in the dashboard"

Spoken prompt: "The dashboard page is loading slowly, taking about 4 seconds on initial load. I think the issue is that we are fetching all user data on the main query instead of lazy loading the activity feed. Can you separate the activity feed into its own API call that loads after the initial page render, and add a loading skeleton component while it loads?"

Same developer, same problem, dramatically different prompts. The spoken version gives the agent enough context to nail it on the first try.

Stream of Consciousness: Think Out Loud

One of voice's unique advantages is that you can think out loud. With typing, you need to formulate your thought before writing it. With speaking, you can reason through a problem in real-time:

"So the issue is... we have this WebSocket connection that drops when the user switches tabs. I think Chrome is throttling the connection after a certain timeout. What we probably need is a heartbeat mechanism, right? Like a ping every 15 seconds. And then on the client side, if we detect a disconnect, we should reconnect automatically but also replay any events we missed. Actually, the replay might be complex. Let us start with just the heartbeat and auto-reconnect and handle the replay in a follow-up task."

This kind of reasoning is incredibly valuable for an AI agent. It shows your thought process, your constraints, and your prioritization. A typed prompt would lose most of this context.

How Murmur's AI-Powered Transcription Helps

Not all voice typing tools are equal when it comes to agentic coding. Murmur is specifically designed for developers and technical workflows.

When you dictate a prompt for Claude Code in the terminal, Murmur's AI accurately transcribes:

• Technical terms (TypeScript, PostgreSQL, WebSocket, REST API)
• File paths and naming conventions (camelCase, kebab-case)
• Programming concepts (dependency injection, middleware, type guard)
• Command names (npm, git, docker-compose)

This accuracy means less correction and higher confidence that your spoken prompt will be transcribed correctly, so your AI agent gets the right instructions on the first try.

The Vision: Conversational Development

Where is this going? Here is what development looks like when voice + agents mature:

Morning Planning

You open your terminal and speak to Claude Code:

"Good morning. Let us pick up where we left off yesterday. The user preferences feature is about 70% done. We still need to add the preferences API endpoint, connect it to the frontend settings page, and write integration tests. Let us start with the API endpoint."

The agent reads your codebase, sees the existing work, and starts implementing.

Continuous Refinement

As the agent works, you review and redirect conversationally:

"That looks good but use Redis for caching the preferences instead of the in-memory store. Our Redis client is in lib/redis and the other services already use it."

"Actually, add a cache invalidation hook on the PUT endpoint too, so when a user updates their preferences the cache is cleared immediately."

Code Review by Voice

When a colleague opens a PR, you review it by speaking your comments:

"The implementation looks solid but I am concerned about the N+1 query on line 45 of the user repository. For a list of 100 users, this fires 100 separate preference queries. Can you batch this into a single query using a WHERE IN clause?"

Documentation as Conversation

Instead of dreading documentation, you just explain what the module does:

"This module handles user preference management. It exposes a REST API with GET and PUT endpoints, stores preferences in PostgreSQL with a Redis cache layer, and publishes change events to our message queue for other services to react to. The cache TTL is 5 minutes and invalidates on write."

Your voice typing tool transcribes this into clean documentation. Done.

The Practical Path from Here to There

You do not need to wait for the future. You can start using voice with AI agents today:

Start Small

1. Download Murmur and set up the shortcut
2. Use voice only for AI prompts at first (Cursor chat, Claude Code)
3. Notice how your prompts become longer and more detailed
4. Notice how the AI's output improves

Build the Habit

After a week of voice prompts, expand to:

• Git commit messages
• PR descriptions and review comments
• Documentation and README files
• Slack messages about technical topics

Go Hybrid

The optimal workflow is not 100% voice. It is voice for natural language, keyboard for code and navigation. Find your balance.

What This Means for Developers

The shift to agentic coding changes what it means to be a productive developer. Technical knowledge still matters. You still need to understand architecture, review code, and make design decisions. But the implementation bottleneck moves from "can I write the code?" to "can I describe what I want clearly enough?"

Developers who can articulate clear, detailed requirements to AI agents will be dramatically more productive than those who type terse prompts and iterate.

Voice is the tool that makes articulation effortless. It is not about replacing your keyboard. It is about unlocking the part of development that is already about communication.

Conclusion

Agentic coding is here. The tools will only get more capable. The question is not whether AI agents will do more of the implementation work but when. And as that happens, your ability to communicate clearly and quickly with those agents becomes your primary leverage.

Voice typing with tools like Murmur is not a nice-to-have in this future. It is a core productivity tool, the interface between your expertise and the agents that implement your vision.

The developers who thrive in the agentic era will be the ones who can think clearly and speak effectively. Start building that muscle now.