Voice to Text for GoLand
You're building a Go service in GoLand. The code is clean, the tests pass, but your exported functions have no documentation. Godoc will generate empty pages. Package consumers will be confused. Writing proper documentation comments means switching from implementation mode to explanation mode. That context switch is exhausting after hours of coding. Blurt lets you speak your godoc comments directly into GoLand. Hold a button, explain what the function does, release. Properly formatted documentation appears at your cursor. Works for package docs, function comments, commit messages, and code reviews. Anywhere you can type in GoLand, you can dictate.
The Typing Problem
Exported functions with missing godoc
Your package has 20 exported functions. Each should have a comment starting with the function name. But writing 'ProcessOrder takes an order ID and validates the order against the inventory system, returning an error if the order cannot be fulfilled due to insufficient stock or invalid product codes' for every function? After implementing the logic, typing documentation feels like punishment. So you ship with 'TODO: add docs' or nothing at all. The pkg.go.dev page looks empty.
Package-level docs that never get written
Every Go package should have a doc.go file explaining what the package does, how to use it, and any important caveats. You know exactly what to say. You could explain it in 60 seconds to a colleague. But creating the file, typing out paragraphs of formatted documentation? That's 20 minutes you don't have. The package ships without context. New team members reverse-engineer the purpose from code.
Commit messages that say 'update handler'
You just refactored the HTTP handlers to use the new middleware chain. Git asks for a commit message. You should explain the architectural decision, the breaking changes, why the old approach failed under load. Instead, you type 'refactor handlers' because your brain is exhausted from the actual work. The commit history becomes useless for debugging production issues six months later.
Code review comments you keep brief
You're reviewing a PR that introduces a subtle race condition in a goroutine. You could explain the issue, show why it's dangerous, suggest the proper channel or mutex pattern. But typing all that context takes five minutes. You write 'potential race here' and move on. The author doesn't learn. The same pattern shows up in the next PR.
Error wrapping explanations you skip
Go's error handling is verbose for a reason. Each error should be wrapped with context about what operation failed. But writing meaningful error messages like 'failed to connect to payment gateway: exceeded retry limit after 3 attempts with 500ms backoff' takes longer than the actual error handling code. You wrap with 'failed to process' and lose the debugging context.
How It Works
Blurt works everywhere in GoLand. Code comments, godoc headers, commit messages, terminal, code review annotations. Any text field, any context.
Hold your hotkey
Press your chosen shortcut anywhere in GoLand. A small indicator confirms Blurt is listening.
Speak your documentation
Dictate your godoc comment, package explanation, or commit message. Blurt handles punctuation and formatting automatically.
Release and continue
Text appears at your cursor. No clicking, no confirmations. Your hands stay on the keyboard. Keep coding Go.
Real Scenarios
Speaking godoc comments for exported functions
You just wrote a function that handles OAuth token refresh. Position your cursor above the function, hold your hotkey: 'RefreshToken exchanges an expired access token for a new one using the provided refresh token. It validates the refresh token against the token store and returns an error if the token has been revoked or expired. The new access token is valid for one hour.' A proper godoc comment in 10 seconds. The function will show up correctly on pkg.go.dev with real documentation.
Dictating package documentation
Your payments package needs a doc.go file. Open the file, hold button: 'Package payments provides a unified interface for processing credit card transactions across multiple payment providers. It supports Stripe, Square, and Braintree out of the box with an extensible provider interface for adding others. All operations are idempotent using the provided request ID. See the examples directory for common integration patterns.' Complete package documentation before you forget the design decisions.
Detailed commit messages for Go refactors
You've restructured the repository pattern across three packages. The commit dialog opens. Hold button: 'Refactor repository layer to use generics for type-safe CRUD operations. Eliminates duplicate code across UserRepository, OrderRepository, and ProductRepository. Breaking change: Repository interface now requires Go 1.18 or later. Maintains backward compatibility for existing database drivers.' A comprehensive commit message in 15 seconds. Future maintainers will understand why this change exists.
Explaining concurrency patterns in comments
You just implemented a worker pool with rate limiting. The code uses channels in ways that might confuse future readers. Hold button above the struct: 'workerPool manages a fixed number of goroutines that process jobs from the jobs channel. The semaphore channel limits concurrent external API calls to prevent rate limiting. Workers exit gracefully when the done channel is closed.' Context that prevents future debugging sessions.
Code review feedback on error handling
A PR wraps errors without adding context. Hold button on the problematic line: 'This error wrapping loses the original context. Consider using fmt.Errorf with the %w verb to wrap the underlying error while adding what operation failed. Something like: failed to fetch user profile: %w. This preserves the error chain for errors.Is and errors.As checks.' Constructive feedback that teaches, not just rejects.
Interface documentation for consumers
Your package exports an interface that other teams will implement. Hold button above the interface: 'Storage defines the contract for persistence backends. Implementations must be safe for concurrent use from multiple goroutines. The Close method should release all resources and is safe to call multiple times. See the postgres and redis packages for reference implementations.' Clear contracts prevent implementation bugs.
Struct field documentation
Your configuration struct has fields that need explanation. Cursor after a field, hold button: 'MaxRetries specifies how many times to retry failed HTTP requests before returning an error. Retries use exponential backoff starting at 100 milliseconds. Set to zero to disable retries. Negative values are treated as zero.' Field-level docs that make the struct self-documenting.
Why GoLand developers choose Blurt over built-in dictation
| Blurt | macOS Dictation | |
|---|---|---|
| Activation | Single customizable hotkey | Double-tap Fn key |
| Speed | Text appears in under 500ms | 2-3 second delay typical |
| Go terminology | Handles goroutine, channel, interface correctly | Struggles with Go-specific terms |
| IDE integration | Works in all GoLand contexts | Inconsistent in dialogs and popups |
| Price | $10/month or $99/year | Free (included with macOS) |
| Free tier | First 1,000 words free | Unlimited but unreliable |
Frequently Asked Questions
Start Typing Faster Today
Free to try — no credit card required
Download Blurt