Voice Coding in VS Code: Dictate Comments and Documentation

The Problem

Developers write more text than most people realize. Beyond the code itself, there is a constant stream of non-code writing that happens inside VS Code: inline comments, function docstrings, README sections, commit message drafts, ticket descriptions, todo annotations, and architectural decision notes.

This writing is often treated as secondary — something to do quickly, or defer until later. The result is codebases with sparse documentation, functions with no explanation of why they exist, and architectural decisions that exist only in someone's memory.

The friction is real. After spending mental energy on a complex algorithm, the last thing most developers want to do is write a paragraph explaining it. Typing feels like additional work on top of the real work. But documentation written immediately after implementation — while the context is fresh — is dramatically more valuable than documentation written a week later, or never at all.

How Telvr Works with VS Code

Telvr integrates with VS Code and any other text editor through system-level cursor-position injection. No VS Code extension is required. No API key in your editor. No configuration inside VS Code itself.

The workflow for development documentation:

1. Open VS Code and position your cursor where you want the documentation to appear — above a function, in a comment block, in a README file, or in a new markdown document.
2. Press your Telvr hotkey.
3. Speak your documentation, explanation, or task description.
4. Release the hotkey. The formatted output appears at your cursor in under two seconds.
5. Continue coding.

Telvr works in all VS Code contexts: the editor itself, the integrated terminal (for spoken command ideas), and markdown preview files. It also works in VS Code's settings JSON and other configuration files where you might want to add comments.

Best Enrichment Mode for VS Code: Dev Task

The Dev Task mode is designed specifically for development workflow documentation. When you activate it and speak about a piece of code or a task, the AI structures your output into a development-ready format with four sections:

Context: Background information explaining what this code does, why it exists, or what problem it solves.

Requirements: What the implementation needs to satisfy — constraints, dependencies, edge cases, or business rules.

Implementation Notes: Technical details, approach taken, trade-offs considered, or important caveats.

Acceptance Criteria: How to verify the implementation is correct — what tests should pass, what behavior to expect, or what conditions define success.

This structure is immediately useful for:

• Function-level documentation blocks explaining complex logic
• File-level header comments for non-obvious modules
• Task descriptions when planning work directly in code files
• Architectural decision records (ADRs) drafted in markdown

For simpler inline comments — a quick explanation of a regex, a note about a known limitation — Clean and Correct mode gives you clean, readable prose without the formal structure.

Before and After Example

Raw speech input (Dev Task mode):

"so this function handles the rate limiting for the API uh it needs to track requests per user per minute and it should use a sliding window not a fixed window because fixed windows can allow burst traffic right at the boundary um it depends on Redis for the counter storage and it should return a 429 with a retry-after header when the limit is exceeded we should also make sure that the limit keys expire automatically so we don't fill up Redis over time"

After Dev Task mode:

Context Handles per-user API rate limiting using a sliding window algorithm. Uses Redis for distributed counter storage to support multi-instance deployments.

Requirements

• Track requests per user per minute using sliding window (not fixed window)
• Return HTTP 429 with Retry-After header when limit is exceeded
• Redis keys must expire automatically to prevent unbounded storage growth

Implementation Notes

• Sliding window chosen over fixed window to prevent burst traffic at window boundaries
• Redis dependency required for distributed rate limit state

Acceptance Criteria

• Rate limit is enforced correctly under sustained and burst traffic patterns
• Redis keys expire as expected (verify with TTL commands)
• 429 responses include a valid Retry-After header
• No Redis key accumulation after extended test periods

The spoken version is a rambling explanation. The Dev Task output is a structured specification you can paste directly above the function as a documentation block.

Time Savings

Documentation is chronically underprioritized because it is slow to write relative to its perceived value in the moment. Developers who switch to voice documentation report two changes: they document more, and they document better.

Writing a thorough function documentation block takes five to eight minutes of focused typing. Speaking the same content takes sixty to ninety seconds, and the Dev Task mode handles the formatting. The reduced time investment makes documentation feel viable rather than burdensome.

For longer documents — READMEs, architecture decision records, onboarding guides — the time savings scale proportionally. A one-thousand-word README that would take forty-five minutes to write can be dictated in ten to twelve minutes and then edited from there.

There is also a quality argument. When documentation is drafted immediately after writing the code, while the implementation details are fresh, the resulting documentation is more accurate and more useful. Telvr's speed makes it practical to document while coding rather than as a deferred task.

Across a typical development week with regular documentation work, Telvr can recover two to three hours — and produce a better-documented codebase as a side effect.

Getting Started

1. Download Telvr for macOS from telvr.ai.
2. Complete setup and configure your preferred microphone.
3. Set a hotkey that works in your VS Code workflow — something you can press without moving your hands far from the home row.
4. Open VS Code, position your cursor above a function or in a documentation block, and test your first dictation.
5. Set Dev Task as your default mode for development documentation work.

A good first exercise: find the three most complex functions in your current project — the ones that would benefit most from clear documentation — and dictate a Dev Task block for each. The whole exercise should take under ten minutes and produce documentation that would have taken an hour to write.

New users get a €3 Welcome Credit to try all enrichment modes with no commitment. After that, you only pay for what you use — tiered pricing starts at €0.030 per minute and drops to as low as €0.003 per minute as your usage grows. No monthly minimum.