App-aware tone and code
The same sentence should read one way in a chat box and another way in an editor. When AI refinement is on, InkSpoke looks at the app your cursor is in and shapes the output to fit — relaxed in chat, precise in an IDE, command-safe in a terminal — without you changing a setting.
One transcription, shaped by where it lands
After InkSpoke transcribes your speech, refinement reads the foreground app and window and pulls two independent signals from it:
- Tone — a Professional / Casual / Technical / Neutral / Custom instruction, chosen by matching the app's name against your tone presets.
- Output mode — whether to refine as Standard prose, code-aware text (for editors), or terminal-aware text (for terminals).
Both are decided automatically, per dictation, at the moment InkSpoke refines.
Tone matching and code/terminal awareness only run when the master AI Refinement switch is on. With it off, your raw transcription is injected verbatim and none of this applies. See How refinement works for the full pipeline and the master switch.
Tone presets — matching your voice to the app
A tone preset is a small rule: one or more app-name patterns plus a tone style. When refinement runs, InkSpoke walks your presets in order and the first preset whose app pattern matches the foreground app wins. Its tone is applied to that dictation.
| Tone style | What it asks refinement to do |
|---|---|
| Professional | Formal, polished phrasing — good for email and customer-facing writing. |
| Casual | Relaxed, conversational phrasing — good for chat and social apps. |
| Technical | Precise, jargon-friendly phrasing that preserves technical terms. |
| Neutral | A plain, even tone with no strong slant. |
| Custom | Uses your own free-text instruction (a custom prompt) instead of a preset style. |
InkSpoke ships with a starter set of tone presets already seeded, so app-aware tone works out of the box. To see exactly which apps each preset matches — and to add, reorder, or edit them — open your Tone Presets and review the patterns there. Because the first match wins, ordering matters: put more specific app patterns above broader ones.
The Custom style lets you write the exact instruction you want ("keep it warm but brief", "British spelling", "no exclamation marks"). Pair a custom prompt with the app patterns for the tool where you need that voice.
Code- and terminal-aware output
Independently of tone, refinement detects when the foreground app is a code editor or a terminal and switches its output mode:
| Output mode | When it applies | What it does |
|---|---|---|
| Standard | Any ordinary app (chat, email, docs) | Normal prose refinement. Tone presets still apply. |
| CodeAware | The app matches a known IDE/editor | Code-aware refinement that respects code and uses the file's detected language. |
| Terminal | The app matches a known terminal | Terminal-appropriate output, so dictated commands stay usable. |
Detection is automatic — it runs from the app/window context InkSpoke already harvests during refinement. It only runs when at least one of the two toggles below is on (both are on by default).
Which apps count as an editor or terminal
InkSpoke recognizes editors and terminals by process name. The current lists:
| Category | Recognized processes |
|---|---|
| IDEs / editors (→ CodeAware) | code, cursor, rider, idea, xcode, vim, nvim, emacs, sublime, atom, fleet |
| Terminals (→ Terminal) | terminal, iterm, warp, wezterm, alacritty, konsole, gnome-terminal, kitty, hyper, cmd, powershell, wt |
File-language detection
In an editor, InkSpoke also reads the active file's extension from the window title to tell refinement which language you're in:
| Extension | Language | Extension | Language |
|---|---|---|---|
.cs | C# | .rs | Rust |
.py | Python | .java | Java |
.js | JavaScript | .rb | Ruby |
.ts | TypeScript | .cpp / .c / .h | C/C++ |
.go | Go |
If the file's language can't be determined from the title, refinement still uses code-aware output — it just won't be language-specific.
Examples: Slack vs an IDE vs a terminal
The same spoken thought lands differently depending on where your cursor is.
Dictating into a chat app (e.g. Slack). The app isn't an editor or a terminal, so refinement uses Standard output. Tone comes from whichever preset matches your chat app — set up a Casual preset for it and the result stays relaxed and conversational.
Dictating into VS Code. The process is code, which matches an IDE pattern, so refinement switches to CodeAware. If the window title shows app.ts, InkSpoke also knows you're in TypeScript and refines with that in mind — keeping identifiers and code intact instead of "prose-ifying" them.
Dictating into Windows Terminal or PowerShell. The process (wt, powershell, or cmd) matches a terminal pattern, so refinement uses Terminal mode and produces output that's safe to run, rather than a polished paragraph.
Tone presets and output modes react to the app. When you want a workspace to always refine a certain way — its own vocabulary, tone, and even a pinned model — use a workspace instead. Workspaces layer domain knowledge on top of app-aware tone. See Workspaces.
Settings
| Setting | Default | What it does |
|---|---|---|
AI Refinement (AiRefinementEnabled) | On | Master switch. Tone and code/terminal awareness only run when this is on. |
Tone Presets (TonePresets) | Starter set seeded | App-name patterns → tone style (or custom prompt); first match wins. |
IDE integration (IdeIntegrationEnabled) | On | Enables CodeAware detection for editors and file-language detection. |
Terminal mode (TerminalModeEnabled) | On | Enables Terminal output mode for terminal apps. |
Turning both IDE integration and Terminal mode off disables code/terminal detection entirely — every app then gets Standard output (tone presets still apply).
You can flip refinement itself on and off without opening Settings using the Toggle AI Refinement hotkey:
| Platform | Toggle AI Refinement |
|---|---|
| Windows / Linux | Alt + Shift + R |
| macOS | ⌥ + ⇧ + R |
When refinement is off, the listening overlay shows "AI refinement off" so you always know which mode you're in.
Platform notes
Reading the foreground app name and window title relies on InkSpoke's per-OS context harvester:
- Windows — UI Automation.
- macOS — Accessibility (grant InkSpoke Accessibility permission so it can read the active window).
- Linux —
xdotool/xclip.
The detection patterns and language map are identical on every platform — only the mechanism for reading the active window differs. If app-aware tone or code detection never seems to trigger, confirm the relevant OS permission or helper is in place.
Next steps
- How refinement works — the full pipeline, the master switch, and streaming output.
- What are workspaces — pin tone, vocabulary, and models to a domain instead of an app.
- Command Mode — speak an instruction to transform text you've selected in any app.
- Dictate into code and terminals — a hands-on walkthrough for developers.