Skip to main content

InkSpoke for developers

For developers who would rather talk than type — dictating comments, commit messages, docs, and chat straight into their editor and terminal, with refinement that knows the difference between prose and code.

Profile​

You live in an IDE and a terminal, with a browser and a chat app never far away. You type fast, but your hands take a beating and a lot of what you write isn't code — it's the prose around code: docstrings, commit messages, PR descriptions, design notes, Slack threads, and long prompts to an AI assistant. You want to:

  • Dictate the words, keep the syntax. Say a comment or a commit message and have it typed where your cursor already is — without a "helpful" model mangling identifiers, flags, or code.
  • Stay in flow. No window-switching, no copy-paste, no leaving the terminal.
  • Own your stack. Run speech and refinement on-device, or point InkSpoke at your own model provider (BYOK). Keep your audio and your keys under your control.

InkSpoke is built for this. Speech recognition runs on your device by default, and refinement automatically switches into a code- or terminal-aware mode based on the app you're dictating into.

What you'll get from InkSpoke​

  • Code- and terminal-aware refinement. InkSpoke detects when you're in an IDE or a terminal and adjusts its output mode so comments read like comments and terminal text stays terminal-safe — instead of being "prettified" into broken prose.
  • Injection that survives terminals and remote sessions. For terminals and code editors, InkSpoke types character-by-character (SendKeys) so nothing is dropped and your clipboard is never clobbered.
  • Transform selected code in place. Highlight a block, speak an instruction ("add a docstring", "translate these comments to English"), and Command Mode rewrites the selection.
  • Bring your own model. Use the built-in InkSpoke Platform model, an on-device model, or your own provider key for refinement — pinned per workspace if you like.
  • A workspace that speaks your stack. Teach InkSpoke your project's jargon, APIs, and style once, and it applies automatically when you're in the right app.
  • Hands-free command running (Pro). Map voice commands to launch apps, focus windows, or fire key combos — "run dev", "git status", "clear screen" — without leaving the keyboard.

You can start with the defaults and change nothing. Here's the developer-friendly configuration — most of it is already on:

SettingRecommendedWhy
Speech modelWhisper Small (on-device)The free default — fully offline and private. Upgrade to a larger on-device or cloud model any time.
AI RefinementOn (the default)Cleans up filler and grammar; toggle off for verbatim.
IDE integrationOn (the default)Enables code-aware refinement when you dictate into an editor.
Terminal modeOn (the default)Enables terminal-aware refinement and SendKeys typing into terminals.
Text injectionAuto (the default)Uses SendKeys for terminals and editors, clipboard-paste elsewhere.
Text modelBuilt-in Platform, on-device, or BYOKPick the provider that refines your text. Bring your own key for full control.
WorkspaceA "Software Engineering" workspaceAuto-applies your project vocabulary and a code-friendly style.
Personal dictionaryOn (the default)Deterministically fixes recurring terms (e.g. spoken "gpt" → "GPT").

For the text model, the built-in InkSpoke Platform model works out of the box. To use your own provider, add a key on the web account and pick your active models — see Choosing your models and Models and providers. You can also keep everything local with an on-device text model; see On-device vs. cloud.

Default hotkeys you'll use constantly:

ActionWindows / LinuxmacOS
Start / stop dictationAlt + Space⌥ + Space
Command Mode (transform selected text)Alt + Shift + C⌥ + ⇧ + C
Toggle AI RefinementAlt + Shift + R⌥ + ⇧ + R
Toggle Hands-Free (wake word)Alt + Shift + H⌥ + ⇧ + H
Build a "Software Engineering" workspace with the wizard

Settings → Workspaces → create a workspace opens a guided wizard. Pick a Purpose (e.g. Code Comments or Documentation) and a Domain (Software Engineering or DevOps). InkSpoke seeds a matching tone, output style, and starter vocabulary, and names the workspace for you. If you want raw, unrefined text for a workspace, the Voice-to-Text purpose turns refinement off. See Create and tune a workspace.

Essential features​

  1. App-aware tone & code refinement — InkSpoke matches your foreground app: casual in chat, precise in a doc, and code- or terminal-aware in your IDE and terminal. It even reads the file extension from your editor's window title to know the language you're in.
  2. Command Mode — select any text or code and speak an instruction to rewrite it in place. If the model can't produce a result, your selection is returned unchanged, so you never lose it.
  3. Text injection — how the finished text reaches your app. Auto types via SendKeys into terminals and editors (preserving your clipboard) and pastes elsewhere; it also handles remote-desktop sessions.
  4. Models and providers (BYOK) — run refinement on the built-in Platform model, an on-device model, or your own provider key. A workspace can pin its own text model.
  5. Workspaces — teach InkSpoke your project's vocabulary and style, applied automatically based on the app you're in. Feed in a coding-standards doc or API reference as domain context.
  6. Voice commands (Pro) — a spoken wake word plus mapped commands to launch apps, focus windows, run key combos, and more — hands-free.

Also worth setting up early: a personal dictionary and personal context for the identifiers, product names, and acronyms that come up in your codebase.

Example workflows​

1. Dictate a comment or docstring into your editor​

  1. Put your cursor where the comment should go in your editor (VS Code, Cursor, Rider, IntelliJ, Vim, and more are detected as IDEs).
  2. Press Alt + Space (⌥ + Space on macOS). The listening overlay appears.
  3. Explain the function in plain language. InkSpoke transcribes on-device and refines in code-aware mode, reading the file extension in the window title to know whether you're in C#, Python, TypeScript, Go, Rust, and so on.
  4. Press the hotkey again (or click Send). The polished comment lands at your cursor.

2. Refactor selected code with Command Mode​

  1. Highlight the block you want to change.
  2. Press Alt + Shift + C (⌥ + ⇧ + C on macOS).
  3. Speak the instruction — "add a docstring", "add error handling", "translate these comments to English", "convert this to an arrow function".
  4. InkSpoke captures the selection, runs your instruction through the active text model, and replaces the selection with the result. In a terminal it uses a terminal-safe copy strategy to grab the selection. See Command Mode.
Command Mode uses your active text model

The transform runs on whatever text-processing model is active — your BYOK cloud or local model when resolved, or the on-device model in Local mode. Pin a model on your code workspace to keep it consistent.

3. Write a commit message in the terminal​

  1. At a commit prompt (or anywhere your cursor sits in a terminal), press Alt + Space and describe the change.
  2. InkSpoke detects the terminal (cmd, PowerShell, Windows Terminal, iTerm2, Alacritty, kitty, wezterm, and more) and refines in terminal-aware mode.
  3. On Send, the text is typed via SendKeys character-by-character — so word-boundary spaces aren't dropped and your clipboard is left untouched.
Dictating into a remote session?

When the focused app is a Microsoft Remote Desktop client, InkSpoke automatically switches to injection primitives that survive the RDP keyboard pipeline, with terminal-friendly newline handling. No manual setup — see Text injection.

4. Run dev tasks hands-free (Pro)​

  1. Enable the wake word (Settings → Hands-Free → Wake Word; first enable downloads a small offline model). Then enable Voice Commands (requires Pro).
  2. Browse starter templates in the Terminal, Editor, and Productivity categories — ready-made recipes like "run dev", "git status", "clear screen", "save file", and "open {app}".
  3. Say, for example, "annika action run dev". With Continuous Commands on, you can chain the next command without repeating the wake name.
  4. Need a raw key press? "annika action press enter" (or "press control s") works without any mapping. See Voice commands.
Voice control is English-only and Pro-gated

The wake-word engine runs fully offline but is English-only. Voice Commands require Pro to fire — free users can view and edit mappings, but they won't execute. Set up your wake name and sensitivity first in Wake word setup.

Pro tips​

  • Toggle refinement off for exact strings. Press Alt + Shift + R to inject verbatim when you're dictating an identifier, a flag, or a command you don't want "cleaned up."
  • Load your project's vocabulary into a workspace. Workspace knowledge entries can be pulled from a file — .md, .json, .yaml, .csv, .pdf, and more — so add your API reference, glossary, or coding standards as Domain Context and refinement stays on-terminology.
  • Add jargon to your personal dictionary. Whole-word substitutions apply before refinement, so spoken "gpt" reliably becomes "GPT," "cli" becomes "CLI," and so on. Longest triggers win, so multi-word terms are safe.
  • Pin a text model per workspace. Your code workspace can use one provider while your chat workspace uses another — the refinement backend follows whichever model a workspace pins.
  • Re-refine from History without re-recording. Open a past dictation in Settings → History and reprocess it with a different text model (or re-transcribe with a different speech model). Handy for A/B-ing providers on the same audio.
  • Keep the mic private on cloud ASR. If you use continuous recording after the wake word, note that on a cloud speech model the pre-wake audio would be uploaded — leave that option off to keep it local. See Voice commands.

Next steps​