Zeg wat ik zei: dictatie zonder de AI-herschrijving

Er is een klacht over AI-verbeterde dictatie die paradoxaal klinkt tot je hem hebt meegemaakt: de transcriptie was prima — het is wat er na de transcriptie gebeurde dat het verpestte. Jij zei het ene, en de tool leverde een gepolijst, zelfverzekerd, licht ander ding. Een nuancering stilletjes weggelaten. Een slag om de arm verwijderd. Een zin geherstructureerd tot iets wat je nooit zou zeggen. En in de ergste versie van het patroon — degene waarop mensen ter plekke met een tool stoppen — draait de betekenis om. "Deploy niet voordat de tests slagen" komt er aan de andere kant uit als een instructie over deployen, minus dat niet.

Voor incidenteel dicteren is dit een ergernis. Voor de manier waarop ik dictatie echt gebruik — prompts voeren aan Claude Code, de workflow uit Claude Code aansturen met je stem — is het gif. Een codeeragent neemt je woorden als specificatie. Hij weet niet dat je dictatietool je heeft geparafraseerd. Is de nuancering die de instructie veilig maakte weggegladstreken tussen je mond en de terminal, dan voert de agent vrolijk de gladgestreken versie uit. Precisie is het hele punt van een prompt, en een AI-herschrijflaag is een machine die precisie weghaalt terwijl ze het resultaat er bewuster uit laat zien.

Waarom herschrijven AI-dictatietools wat je zei?

Het antwoord op categorieniveau is niet dat iemand van plan was spraak te vervormen. Het is dat "schoon deze transcriptie op" een oprecht aantrekkelijke functie is, en dat de voor de hand liggende manier om die te bouwen is: het ruwe transcript door een taalmodel halen.

Ruwe spraak is rommelig — stopwoordjes, valse starts, herhaalde woorden, ontbrekende interpunctie. Vraag je een LLM dat op te ruimen, dan levert die prachtige output. Het probleem is dat een taalmodel niet redigeert, zoals een menselijke corrector die "eh" schrapt dat doet. Het genereert opnieuw. De output is een nieuwe tekst die het model een goede versie van jouw invoer vindt, en "goed" is waar je intentie weglekt. Modellen die getraind zijn op behulpzaamheid en vloeiendheid hebben meningen: slagen om de arm lijken op ruis, nuanceringen lijken op rommel, een onhandige-maar-precieze formulering lijkt op iets om te verbeteren. Meestal is de herschrijving onschuldig. Maar ze is probabilistisch, en aan de output kun je niet zien welke zinnen zijn getranscribeerd en welke zijn gecomponeerd. Het politoer is uniform; de getrouwheid niet.

Dat is het diepe probleem met LLM-politoerpijplijnen: ze falen stil en zelfverzekerd. Een spraakherkenner die je verkeerd verstaat produceert meestal iets zichtbaar fouts. Een herschrijflaag die je verraadt produceert iets zichtbaar goeds — grammaticaal, plausibel, in jouw stem — en precies daarom wordt het omgedraaide "deploy niet" verstuurd in plaats van onderschept.

Letterlijk als standaard

Keebyes standpunt is simpel: wat het speech-to-text-model hoorde is wat er bij je cursor landt. Standaard zit er geen taalmodel tussen de transcriptie en je terminal een betere versie van jou te componeren — de standaard politoerfase is een korte lijst deterministische regels, en verder niets.

Dat is een bewuste weddenschap, en ze komt uit het vibecoding-gebruik. Wanneer je dictatie het stuurkanaal is voor codeeragents, is de taak van de tool transport, geen auteurschap. Jij bent de schrijver; de agent is het publiek; de dictatielaag hoort geen mening te hebben. Die workflow — hele prompts uitspreken in plaats van ze te typen — staat uitgewerkt in spraakdictatie voor AI-prompts.

Er is een LLM-politoer in Keebye — ik kom erop terug — maar je kiest er zelf voor, hij draait volledig op jouw machine, en hij werkt onder een beveiliging die is ontworpen om veelvoorkomende vormen van afdrijving, ongebreidelde uitdijing en herhaling af te wijzen. Zakt de output voor die controle, dan valt Keebye terug op regels. De standaard blijft regels.

Wat doet die opschoning dan precies?

Letterlijk hoeft niet ruw te betekenen. Keebye levert een optionele opschoningsstap mee — enhancement, standaard aan en per app te overrulen — maar hij is regelgebaseerd, geen model, en de volledige lijst van wat hij doet past in één alinea:

Hij verwijdert losstaande stopwoordjes (um, uh, erm, you know). Hij vouwt directe woordherhalingen samen — "the the" wordt "the". Hij vouwt witruimte samen. Hij zet de eerste letter in hoofdletter, en hij voegt een punt aan het eind toe als je er zelf niet mee eindigde. Dat is de hele lijst. De regels zijn deterministisch en eng afgebakend; ze herordenen niet doelbewust zinsdelen, verwijderen geen ontkenningen en vervangen geen synoniemen.

Voordat de opschoning draait, worden je woordenboekvervangingen toegepast — zelf gedefinieerde vervangingen voor het jargon en de eigennamen die spraakmodellen verminken, zodat "pnpm" en je modulenamen aankomen zoals je codebase ze schrijft.

En is zelfs de regelgebaseerde stap meer ingrijpen dan je wilt, zet enhancement dan uit; Keebye voegt dan het ruwe transcript van het spraakmodel in: stopwoordjes, herhalingen en al. Voor sommige contexten — iemand citeren, dicteren in een veld waar die punt aan het eind dingen kapotmaakt — is het ruwe transcript de betere keuze, en met de override per app kies je daarvoor.

Het optionele politoer, en de getrouwheidsbeveiliging eromheen

Nu de LLM waar ik op zou terugkomen. Voor wie wél slimmere opschoning wil, biedt Keebye een optionele politoermodus (polish_mode op local_llm): een klein Qwen3-model dat on-device draait via llama.cpp, Metal-versneld, waarbij er niets ergens naartoe gaat. Zijn instructies zijn de enge versie van politoeren — repareer interpunctie en hoofdlettergebruik, verwijder stopwoordjes, behoud de exacte woorden, taal en betekenis van de gebruiker, houd code en bestandsnamen verbatim. Generatie is deterministisch (greedy sampling, dezelfde invoer → dezelfde uitvoer) en begrensd; blijft het model na een deadline van twee seconden hangen, dan wordt zijn output verworpen.

Maar instructies zijn hoop, en dit artikel bestaat omdat hoop geen garantie is. Dus elk met een LLM gepolijst resultaat gaat door een getrouwheidsbeveiliging voordat het je cursor mag raken. De output moet minstens 50% van de tokens van de oorspronkelijke transcriptie behouden. Hij mag niet opzwellen — alles voorbij ruwweg twee keer de oorspronkelijke lengte (plus vier tokens) zakt. Ongebreidelde herhaling wordt gedetecteerd. Zakt het gepolijste resultaat voor een van die controles, dan gooit Keebye het weg en valt in plaats daarvan terug op de regelgebaseerde opschoning.

Die beveiliging vangt ernstig tokenverlies, ongebreidelde uitdijing en herhaling op voordat de output van het model het regelmatig opgeschoonde transcript kan vervangen. Het is een heuristiek, geen semantisch bewijs: een korte herschrijving of een veranderde ontkenning zou nog steeds door de drempels kunnen komen. Kan een nuancering zich geen afdrijving veroorloven, laat het AI-politoer dan uit en lees de ingevoegde tekst na voordat je hem verstuurt.

De eerlijke grenzen

Letterlijk betekent letterlijk. Ratel je, dan landt je geratel — zelfs het optionele politoer is geïnstrueerd en beveiligd richting opschonen, niet componeren, dus Keebye maakt van een meanderende gedachte geen kernachtige instructie. De discipline om te zeggen wat je bedoelt blijft bij jou.

De regelgebaseerde opschoning is met opzet dom. Hij haalt "eh" weg; hij repareert je grammatica niet, herstructureert geen aaneengeregen zin en merkt niet op dat je jezelf tegenspreekt. Iets slimmers zou juist de oordelen terugbrengen die dit ontwerp wil vermijden.

En getrouwheid beschermt tegen herschrijven, niet tegen verkeerd verstaan. Hoort het spraakmodel "cache" als "cash", dan wordt die fout trouw bewaard — de beveiliging heeft geen idee wat je bedoelde te zeggen, alleen wat er is getranscribeerd. Letterlijke dictatie verschuift de vertrouwensgrens naar het STT-model; het schaft die grens niet af. (Verwant: is jouw probleem dat het model in een compleet verkeerde taal transcribeert, dan is dat een andere storing met een andere oplossing — Pin je dicteertaal vast.)

Tot slot de kadering op categorieniveau: AI-politoer is geen zwendel, en veel gebruikers geven oprecht de voorkeur aan output die vloeiender leest dan ze spreken. Ben jij dat, dan leunen andere tools daar goed in, en onze vergelijkingen zeggen dat eerlijk — Keebye vs Wispr Flow en Keebye vs Superwhisper hebben allebei een echte sectie "wanneer de andere tool beter past".

Transport, geen auteurschap

De afspraak die Keebye aanbiedt is met opzet smal: jij spreekt, en een licht opgeschoond transcript landt waar je cursor staat. Wanneer die woorden prompts zijn voor een agent die er letterlijk naar handelt, is smal een functie. Het duurste wat een dictatietool een developer kan aandoen is geen typefout. Het is een vloeiende zin die je nooit hebt gezegd.

Keebye is in early access voor macOS. Start hieronder je gratis proefperiode, dicteer "Deploy niet voordat de tests slagen", en controleer of die precieze beperking de opschoning overleeft. Die test is het hele product.