For the last 4 months, the first thing I do after I wake up is yell at my AI.
I have 5 monitors plus my phone. On each screen there are from 3 to 6 parallel coding sessions — a mix of Claude Code and Codex instances — that have been running 24/7 through the day and night, building new products and extending the ones I’ve already shipped. They don’t sleep. I do.
I operate my AI coding agents with my voice. I hold a key, I narrate what I want next, I release the key, and the text magically appears in whichever terminal or editor pane I’m staring at. “Add a retry on the webhook”, “What’s blocking the deploy?”, “Roll the last migration back”, “Show me the diff.” I almost never type. I look at maybe five or 10% of the code that gets written for me — enough to spot-check direction, not enough to read it line by line. That’s intentional: the productive surface area scales with how much I’m willing to not read. The guardrails — evals, traceability, staged rollouts, one-command rollback — are what let me get away with it.
This workflow has exactly one piece of infrastructure that I cannot live without. It’s the voice dictation. The LLM is fungible — Claude this week, Codex next week, whatever’s best next month. The dictation is the steering wheel. If the steering wheel is laggy, or rate-limited, or stops working on a plane, or sends a transcript of me thinking out loud at 6:30 AM to a third party’s servers, the whole orchestration collapses back into typing. And typing is slow now. Typing feels like rowing a boat after you’ve been flying.
Which is why I noticed, a few weeks ago, that I was about to pay Wispr Flow $144 a year for the privilege of holding a key and speaking into it. And then I noticed something else: I knew exactly how to build it myself.
On Monday, April 20th, 2026, I sat down at 10:48a to write a small script. By 12:36p — one hour and forty-eight minutes later — I pushed a public LocalFlow repository to GitHub that does the core of what Wispr Flow charges that $144 a year to do. Hold a key. Speak. Release. Your words appear, transcribed, in whatever app is focused.
That’s it. That’s the entire product. That’s the feature people are paying ~$12/month for, the feature Superwhisper charges $249 lifetime for, the feature Monologue and WillowVoice both price at $144/year, the feature MacWhisper packages at $69 one-time.
I didn’t pull an all-nighter. I didn’t have a team. I didn’t get help from a co-founder. I had one editor window, one terminal, and an LLM to argue with about edge cases in the keyboard listener.
That’s it. That’s the moat.
My version is called LocalFlow. It’s 152 lines of Python. It runs entirely on your laptop. It costs nothing. It is, today, sitting on GitHub waiting for anyone who wants to curl | bash their way to never paying for voice dictation again. 100% local. Offline. Total privacy. $0 in cost.
I’m not telling you this to brag. I’m telling you this because the implication scares me, and it should scare a lot of founders.
Let’s get specific, because vagueness is how SaaS pricing survives. Here is what LocalFlow does, in full:
Loads OpenAI’s Whisper model once at startup. Warms it up with a buffer of silence so the first real transcription isn’t slow.
Listens globally for the right Option key. (Configurable — change one line if you want F19 or Ctrl+Option.)
While you hold the key, streams microphone audio into an in-memory buffer at 16 kHz mono.
On release, transcribes the buffer directly (no temp files), copies the result to your clipboard, sends ⌘V to paste into the focused app, and restores your previous clipboard contents so you don’t lose what you had copied.
Prints a timing line so you can see how long inference took.
That’s the product. It works in Slack, Gmail, Cursor, the terminal, Notes, Linear, anywhere. It works offline. It works on a plane. It does not send a single byte to anyone’s server. There is no account. There is no telemetry. There is no usage limit.
The “extending” part — which the user prompt for this article specifically called out — is the kicker: the entire transcription pipeline is one function. _transcribe_and_paste(audio). If you want to do anything fancy — strip filler words, translate, send to an LLM for cleanup, route different hotkeys to different prompts — you change four lines and you have a feature that Wispr Flow’s PMs would write a quarterly roadmap memo about.
I’m not exaggerating. Open ptt.py. Count. 152 lines.
Here is the part where I am going to upset some people.
A lot of consumer AI startups right now are not products. They are distribution layers wrapped around a model someone else trained. The moat is not the technology. The moat is the onboarding flow, the design polish, the App Store rank, the founder’s Twitter followers, and — most importantly — the gap between what a normal person can build and what they think they can build.
That gap is closing. Fast.
Five years ago, building LocalFlow would have required:
Training or licensing a speech recognition model
Writing custom audio I/O for macOS at the framework level
Hand-rolling a global keyboard hook
Months of polish to make the latency tolerable
A go-to-market motion to convince anyone you existed
In 2026, it required:
pip install openai-whisper sounddevice pynput numpyHalf a Monday afternoon
A
curl | bashinstaller because that was the fastest way to share it
The four libraries I imported did 99% of the work. Whisper does the transcription.
The “killer feature” of Wispr Flow is not transcription. Transcription is a commodity now. The killer feature is that you don’t have to assemble it yourself. That is a real feature. It is worth something. It is just not worth what the market is currently pricing it at, because the floor under the price is rapidly dropping toward zero as the toolchain gets better.
To be fair to the companies in the table above, some of them are doing real work beyond the wrapper:
Wispr Flow’s auto-formatting pipeline — taking rambling speech and reshaping it into clean prose — is genuinely useful and would take me a non-trivial afternoon to clone with an LLM call. (Note: an afternoon, not a year.)
WillowVoice is investing in voice-style personalization that sounds like you across apps. That’s a data moat with a UX feedback loop, which is much more defensible than the transcription itself.
Superwhisper is integrating deeply with agentic coding tools (Cursor, Claude Code). That integration surface is real product work.
Monologue’s context-aware formatting that adapts to which app you’re in is the kind of polish that takes design taste, not just code.
These are real products. I am not saying they are worthless. I am saying their base layer — the thing 90% of users actually pay for, the thing customers describe when they recommend the product to a friend (”you hold a key and it types what you say!”) — is now a weekend hack.
If your pricing assumes the base layer is the value, you have a problem. Your customers will eventually notice that the open-source clone exists, and the only question is whether they notice it through a Hacker News post, a YouTube tutorial, or a co-worker who installed it for them.
Voice dictation is not special. The same dynamic is unfolding across:
Note-takers and meeting summarizers. Whisper + a Claude/GPT call + a polished Notion-style UI. The “AI” is one API call.
Background removers, image upscalers, audio cleaners. Open-weight models from Stability, BlackForestLabs, and a half dozen research labs are already as good as the leading paid apps for most use cases.
Code assistants that wrap a frontier model with a custom prompt. When the wrapper is the product, the wrapper is the moat, and the moat is one good system prompt and a Cursor extension away from being replicated in a weekend.
“AI-native” CRMs and writing tools whose differentiator is “we prompted an LLM well.” That’s not a company. That’s a feature waiting to be commoditized by the model vendor itself in the next release.
The historical analogy isn’t perfect, but it’s close: in the late 90s, you could sell “an FTP client” or “a calendar program” because building one was hard. Then the building got easier, and the moat became distribution, brand, and integration depth. The same shift is happening to “AI-powered X” right now, except compressed into 18 months instead of 10 years.
If your company’s pitch deck says “we use AI to do X” and X is something a Whisper-grade open model can do, X is your weakness, not your strength. Your defensibility has to live somewhere else: in workflow lock-in, in proprietary data, in a deep integration that takes a year to replicate, in a brand that people trust enough to pay a premium for the same underlying capability.
If you want to try LocalFlow, the install is one line on a Mac with Homebrew:
curl -fsSL https://raw.githubusercontent.com/vmysla/LocalFlow/main/install.sh | bashThe repo is here: github.com/vmysla/LocalFlow.
It is licensed for personal and non-commercial use; if you want to bundle it into a product and sell it, email me. (Yes, that license restriction is intentional — I’m aware of the irony of writing an article about the death of moats and then putting a small one on my own code. The point is that anyone could write this in an afternoon, not that I am claiming exclusive rights to the idea. Fork it under whichever license suits you; reuse the techniques.)
If you want to extend it — add LLM-based cleanup, custom hotkeys per app, multi-language support — the entire transcription path is one function. Make it yours.
I did not write this article to convince you to use my dictation tool instead of someone else’s. I genuinely don’t care which one you use. Wispr Flow is a more polished product than LocalFlow, and if $144 a year buys you back enough time, that is a perfectly defensible purchase.
I wrote it because the time between “this is a defensible startup” and “this is a Monday afternoon Python script” has collapsed to something close to zero for a startling number of AI-powered products. Founders are still pricing as if the moat is the model. Customers are still paying as if the moat is the model. Neither is true anymore, and the gap between “true” and “what the market is doing” is where opportunity — and risk — lives for the next several years.
If you are building one of these companies: figure out what your real moat is. Now. Today. Before someone with a Monday afternoon and an LLM finds out what you charge and decides they don’t feel like paying it.
If you are paying for one of these products: open the repository link above and decide whether you still want to.
If you are an investor in one of these companies: ask the founder, on the next call, what they’d do if a 152-line clone of their flagship feature got 10,000 stars on GitHub next week. Watch their face.
LocalFlow is open source at github.com/vmysla/LocalFlow. Built in 108 minutes on April 20, 2026. It is, right now, the thing my voice talks to every morning while a fleet of agents builds things on my behalf across five monitors. If you build something better on top of it, please tell me — I’d genuinely love to see it.