How to Use Lanson Flow with VS Code
Short version: VS Code is still where a huge share of developers write prompts, comments, and commit prose — Copilot Chat, inline chat, the terminal, Source Control. Lanson Flow is an AI voice keyboard built around LiveFinal: text is formed, corrected, and finalized while you speak, so long dictation does not create a long wait at the end. Use Flow to speak into VS Code’s text fields. Context-aware writing comes second. Optimized for coding scenarios: programming terminology and domain proper nouns with no setup, environment-aware correction, and Content Shield learning proper nouns from recent input. Multilingual output is a strong use case on top — not the product definition.
Why VS Code + voice is a real workflow (not a demo)
VS Code’s AI surfaces reward clear intent: Copilot Chat, inline edits, agent-style tasks, comments, and commit messages. That intent is writing.
Typing those well competes with reading code. Speaking them is closer to how you already explain a change to a teammate.
Competitors publish adjacent guides — Wispr Flow’s VS Code use-case pages, Superwhisper’s voice-coding hub, Typeless’s any-field dictation. The category is real. The useful question for Lanson Flow is narrower:
When I finish a long Copilot Chat prompt out loud, is the writing already finished with me — or do I wait for another full cleanup pass?
That is what LiveFinal is for.
Speak continuously. Your text finishes with you.
Why Lanson Flow fits coding workflows
Lanson Flow is optimized for coding scenarios — not as an IDE plugin, but as voice writing that understands how developers speak:
1. Programming terminology and domain proper nouns — no setup required. Speak idempotency, upsert, webhook, service names, ticket IDs. You do not need a vocabulary import ritual or a marketplace extension for Flow to handle technical nouns.
1. Environment-aware correction. Flow automatically detects the current environment and applies targeted correction so what you speak lands as usable writing in the field you focused.
1. LiveFinal — long spoken instructions finish with you. Progressive finalization while you speak: no matter how long the instruction, input completes as you finish. Long dictation does not create a long wait at the end.
1. Content Shield learns proper nouns from recent input. From what you just said, Flow automatically understands and saves commonly used proper nouns — product names, symbols you keep repeating, team jargon — so later dictation stays consistent.
Still the same contract: focus the text field, then speak. No Screen Reader Mode setup, no voice @file tagging, no invented IDE integrations.
What you need before you start
1. VS Code installed (stable or Insiders) with the Chat / Copilot surfaces you actually use.
1. Lanson Flow from flow.lansonai.com — free to try, with a weekly free quota.
1. A device where Flow can insert text at the cursor — iPhone/iPad are the prominent surfaces on the product site; Mac has limited-availability / beta messaging (macOS 13.0+). Confirm current desktop availability before you promise a Mac-first workflow to a team.
Flow is designed as voice input into the apps you already use — text lands where the keyboard / cursor is, not in a separate transcription window you copy from. Treat that as the contract: focus the field in VS Code, then speak.
This guide does not claim a VS Code extension marketplace listing, Screen Reader Mode setup, automatic variable recognition from open tabs, or voice @file / #file tagging. Those are specific IDE integrations some competitors document. Lanson Flow’s public story is LiveFinal + context-aware writing in the places you already type.
The basic loop (same in every VS Code surface)
1. Click into the text field where you want words: Copilot Chat input, inline chat, editor comment, terminal prompt, Source Control message box, Notebook markdown cell, etc.
1. Start Lanson Flow the way your device expects (keyboard / Flow control on that platform — verify in-app; shortcuts can change).
1. Speak the whole thought — constraints, file names as you say them, edge cases, “don’t change X.”
1. Stop when you are done. Under LiveFinal, the system should be finishing the remaining tail, not starting a fresh end-of-utterance rewrite of everything you said.
1. Skim once, submit (Enter / Copilot send), or keep editing by voice or keyboard.
If paste / insertion fails in a quirky field (some terminals and embedded webviews are picky across all voice tools), use your platform’s normal paste fallback and continue. Do not treat a single sticky field as “Flow doesn’t work with VS Code.”
Where to use Flow inside VS Code
1) Copilot Chat — explain, debug, ask with full context
Chat is where terse typing hurts most. Voice lets you include:
Example shape (speak it; do not memorize it):
“In the payment webhook handler, duplicate events create double charges when the client retries. I already added an idempotency key store but race windows remain. Walk the concurrency path, propose the smallest lock or upsert fix, and don’t refactor the billing domain model.”
LiveFinal matters here because good debug prompts are long. You should not pay a second wait tax proportional to how carefully you explained the bug.
2) Inline chat / edit — short, precise instructions
For selections, keep spoken instructions short and mechanical:
“Extract this into a pure helper; keep the public signature stable.”
“Add null checks for optional config fields and keep the error messages user-facing.”
Voice shines when the instruction is clear; it does not replace reading the diff.
3) Comments, docstrings, and TODOs
Prose around code is often postponed because typing breaks flow. Dictate while the reason is still in working memory:
“Document that we cache for sixty seconds because the upstream rate-limits burst traffic; link to the ops runbook on quota errors.”
Context-aware writing helps here: fillers and false starts should become readable comment prose, not a raw transcript of “um actually wait.”
4) Integrated terminal
You can dictate carefully into the integrated terminal — shell commands, gh issue text, interactive git commit messages, or CLI agent prompts if you use them inside VS Code’s terminal.
Be deliberate:
5) Source Control — commit messages
Open Source Control, focus the message box, and speak the why:
“Fix duplicate webhook charges under retry. Idempotency check now happens inside the same transaction as the charge write. Adds a regression test for concurrent deliveries.”
Same idea for PR bodies drafted in the browser or CLI — Flow follows the focused field.
6) Notebooks and Markdown editors
For .md / Jupyter markdown cells, dictate explanations, experiment notes, and README sections the same way: focus the cell, speak continuously, skim, continue.
Prompting tips that work better when you speak
Prefer complete briefs over telegraphic keywords. Copilot and similar agents handle verbose, structured speech well. Include edge cases you would skip if you were typing at 40 WPM.
Say structure out loud. “First… Second… Acceptance criteria… Out of scope…” — then let Flow’s formatting / cleanup turn that into readable prompt text.
Name symbols the way you say them. “user ID” vs userId — you may still tweak casing once. Do not expect magically perfect symbol binding unless / until Flow publicly documents IDE symbol reading. Manual # / @ file or symbol mentions in Copilot still work the normal way: type or pick them, then speak the rest of the prompt.
One job per dictation when iterating. Dictate a full first brief. After Copilot responds, dictate the follow-up (“only change the test; leave production code”). Continuous speaking is for depth, not for mushing five unrelated tasks into one paste.
Keep keyboard for precise caret work. Voice for intent; keys for surgical edits. That hybrid is normal, not a failure of either tool.
LiveFinal: why long VS Code prompts are the point
Traditional voice input often feels like:
record → stop → process → clean up → paste
The longer the prompt, the longer the end wait — exactly when you want to stay in the Copilot loop.
LiveFinal inverts that:
While you speak, text is continuously formed, corrected, and finalized. When you stop, input should complete with you — finishing the remaining tail, not starting another full processing pass. No matter how long the spoken instruction, long dictation does not create a long wait at the end.
So:
Long dictation does not create a long wait at the end.
That maps cleanly to VS Code:
| VS Code job | Why LiveFinal helps |
|---|---|
| Long Copilot Chat briefs | Speaking length should not become end-wait length |
| Debug narratives | You can include full context without rationing words |
| README / design notes in editor | Multi-minute thoughts stay interactive |
| Iterative follow-ups | Each turn finishes with you, so the loop stays tight |
Context-aware voice writing (the second layer)
LiveFinal answers when writing finishes. The second layer is what kind of writing lands in VS Code.
Lanson Flow is not “raw Whisper into the chat box.” Public product framing emphasizes context-aware voice writing: cleanup of fillers, grammar, entities, and continuity across what you already said — supported architecturally by ideas such as StableStream (committed text should stay stable), Content Shield (recognition alone is not enough — and from recent input it automatically understands and saves commonly used proper nouns), and rolling context.
In practice inside VS Code, that means you can speak like a human:
…and aim for sendable prompt prose, not a transcript you must rewrite before Copilot sees it.
Do not oversell: always skim before you accept an edit that touches production paths.
Multilingual use case
If you think in one language and want VS Code prompts or comments in another, Flow’s multilingual path is a strong use case:
Speak in your language. Write in any language.
Useful for bilingual teams drafting English prompts, comments, or PR text while reasoning aloud in another language.
Do not position Lanson Flow as “a translation keyboard for VS Code.” Translation/cross-lingual output supports LiveFinal writing; it is not the product identity.
Fair boundaries: what this Cookbook does not claim
| Claim type | This guide |
|---|---|
| Speak into VS Code text fields | Yes — focus field, use Flow |
| LiveFinal continuous finalization | Core product contract |
| Context-aware cleanup for prompts / comments | Second-layer product story |
| Official VS Code marketplace extension | Not claimed |
| Auto variable recognition via Screen Reader Mode | Not claimed |
Voice @filename / #file tagging in Chat | Not claimed |
| “Works identically in every embedded terminal” | No — paste fallbacks exist across the category |
| Exact free-quota numbers | Soft only — verify /pricing |
Competitors such as Wispr Flow, Superwhisper, and Typeless are legitimate options with different optimizations (suite breadth, on-device control, polish/quota). Choose on job-to-be-done. Coexistence is fine.
A 10-minute practice path
1. Open a throwaway folder in VS Code.
1. Focus Copilot Chat. Dictate a 150–250 word feature brief with constraints. Submit. Note whether end wait felt tied to speaking length.
1. Select a function. Dictate an inline instruction and review the proposal.
1. Dictate a docstring and a commit message for a tiny change.
1. Try one terminal dictation of a harmless command (echo / git status). Confirm paste behavior on your OS.
If Mac desktop access is still limited on your account, run the same loop on the device Flow currently supports for you, or request Mac beta access via the path shown on flow.lansonai.com.
FAQ
Does VS Code have built-in dictation?
Not as a full replacement for a system voice keyboard. Most “voice coding” setups use an OS-level or keyboard-level tool that inserts text into VS Code’s inputs. Lanson Flow is that kind of input surface.
Will Flow write code for me?
No. Flow turns speech into writing in the focused field. Copilot / your models write and edit code. Your job is clearer prompts + careful review.
Is this only for Copilot?
No. The same loop helps with comments, commits, notebook notes, and any other VS Code text field — including third-party chat panels that accept ordinary keyboard input.
What about privacy / code on screen?
Follow your company’s policy for any cloud voice tool. Do not dictate secrets, tokens, or customer data into prompts. Re-read Lanson’s current privacy / data statements on the product site before enterprise rollout.
Start here
1. Get Lanson Flow: flow.lansonai.com
1. Focus a Copilot Chat or inline chat field in VS Code.
1. Speak a complete brief — and notice whether the text finishes with you.
Speak continuously. Your text finishes with you.
That is the Cookbook thesis for VS Code. Everything else is practice.