Developers got autocomplete everywhere — except everywhere else

In 2021, Copilot put ghost text in your editor and changed how developers write code. Five years later, the same developer types commit messages, PR descriptions, and Slack answers into text fields that predict absolutely nothing.

The pattern you already know — suggestion appears as you type, Tab accepts — doesn't have to stop at the editor. System-wide autocomplete brings it to commit messages, PR descriptions, docs, and chat, with a model tuned for prose instead of code. I build one of these, and I built it because the fields developers type into all day are the ones no code-completion tool was ever going to cover.

Why the editor got it first

Code was the easy win, for structural reasons:

Code is highly predictable. Syntax constrains what comes next; an IDE knows the types, the imports, the function signatures. Prediction has guardrails everywhere.
The editor is a controlled environment. The IDE owns the text field, the rendering, the keystrokes. Injecting ghost text is trivial when you built the text box.
The training data was sitting there. Public code corpora made code models possible years before anyone had good data for personal prose.

The prose fields developers type into fail all three conditions. A commit message is free text. Slack is a third-party app that renders its own input box. And nobody has a public corpus of your commit messages — which turns out to be the interesting problem, and the reason the system-wide version took until Apple Silicon and MLX made on-device fine-tuning practical.

The technical hurdle on macOS specifically: a system-wide tool can't own the text field, so it uses Accessibility to watch the focused field and draw suggestions next to the caret in any app. That's why TypeTab asks for Accessibility permission once during setup — it's the same mechanism, pointed at prose instead of code.

The fields where it pays

Where does a developer actually type prose all day? Everywhere outside the editor:

Commit messages. Same structure every time — imperative mood, scope, short why. A model that's watched your last 500 commits knows your format better than a template does.
PR descriptions. The setup, the change, the risk, the test plan. Your personal shape, repeated across every repo.
Issue and ticket replies. "Can't repro on main — which build are you on?" The sentences are yours, and they rhyme with yesterday's.
Prompts to AI tools. You write prompts to LLMs every day now. Those have personal structure too — your context-setting style, your constraints, your "answer concisely" tics.
Docs and READMEs. The prose between the code blocks.

None of that is code completion. All of it is typing you do every day, with patterns a small model learns fast.

What a prose model learns from you (from our training logs)

I'll share something from our own fine-tuning work, because it surprised us. When we trained a small model on everyday writing, the first thing it learned wasn't vocabulary — it was register. The shape of your "no, but here's the thing" sentence. The way you open a status update. The phrases you reach for when you're explaining tradeoffs.

For developers specifically, we made one design call worth knowing about: TypeTab filters code, shell commands, and URLs out of its training corpus by default. Your secrets stay out of the model. The model learns your prose — commit messages, replies, docs — not your source. (You can export and inspect your entire training corpus anytime; it's a plain JSONL file. The full learning mechanism is in how TypeTab learns your writing style.)

The muscle memory is already installed, too. If you've used Copilot, accepting ghost text with Tab is a reflex. That's the entire onboarding cost of prose autocomplete: zero. The first time a commit message field suggests the rest of your line, you'll know what to do.

What it won't do

Honest limits, since I'm the vendor:

It won't write your code. TypeTab is a prose model. It's not Copilot, it doesn't complete functions, and it won't suggest implementations. Use your code tools for code.
It won't write paragraphs from a prompt. It finishes sentences you've started. If you want generated long-form text, that's a different tool category — and one that comes with the averaged-voice problem I wrote about in how to write faster with AI without sounding like AI.
It's Mac-only. If you live on Linux or Windows, this category is thinner on those platforms — for now.

The way I'd frame it: your editor already has an AI that writes code with you. TypeTab is the AI that writes around the code — the commit message explaining it, the PR description selling it, the Slack reply unblocking it. The words between the keystrokes — the ones that matter.

FAQ

Is there a Copilot for everything, not just code? Yes — system-wide autocomplete apps bring ghost-text completion to every text field on macOS: commit messages, PR descriptions, Slack, docs, browser. They use Accessibility to watch the focused field rather than waiting for apps to adopt an API, which is why they work where editor tools don't.

Will AI autocomplete leak my code? TypeTab won't — it filters code, shell commands, and URLs out of its training corpus by default, and the model runs entirely on your Mac. Nothing you type leaves your machine. You can export and inspect the full training corpus as a JSONL file anytime.

Does ghost-text autocomplete work in commit message fields and Slack? Yes. Because system-wide tools watch the focused text field via macOS Accessibility, they work in any app's input box — including terminal-based git commit editors, JetBrains and VS Code commit fields, Slack, Linear, and browser text areas.

How is this different from Copilot? Copilot predicts code inside your editor using a code model. Prose autocomplete predicts your writing in every app using a small model fine-tuned on your own text. They're complementary — developers typically run both, one for the code, one for everything around it.