Prompts dicteren naar parallelle agents, lane voor lane

De eerste keer dat je twee codeeragents naast elkaar draait, voelt er iets niet goed, en het kost even tijd om er een naam aan te geven. Elke agent is snel. Elk van hen zou alleen een duidelijke winst zijn. Samen zouden ze dubbele winst moeten opleveren. In plaats daarvan voelt de dag meer versnipperd dan met één agent, en eindig je de middag met minder af dan je verwachtte.

De reden zijn niet de agents. Het is de vorm van de invoer die ze nodig hebben. Een codeeragent draait op proza: "splits de handler, houd de publieke signature intact, voeg een test toe voor het timeout-pad." Proza is goedkoop om te bedenken en duur om af te leveren, want afleveren betekent je handen en je aandacht op het juiste moment in het juiste venster zetten. Met één agent valt dat moment samen met je natuurlijke ritme. Met drie komen de momenten wanneer ze komen, en elk ervan onderbreekt waar je middenin zat.

Deze post gaat over het afleverprobleem, niet over het denkprobleem. Het is een praktische workflow voor het dicteren van prompts in parallelle agent-lanes op een Mac, met de eerlijke grenzen erbij. Heb je Claude Code aansturen met je stem nog niet gelezen: die post behandelt de basis voor één lane; deze gaat ervan uit dat je er al meer dan één draait.

Waarom parallelle lanes juist typen afstraffen

Een prompt heeft drie kosten: hem vormen, hem afleveren, en daarna weer terugkomen. Vormen is onvermijdelijk en gebeurt vooral in je hoofd. Afleveren betekent, als je typt: focus wisselen naar de terminal van de agent, de invoerregel vinden, veertig tot tachtig woorden typen en op enter drukken. Terugkomen betekent weer oppakken wat je deed voordat de agent iets vroeg.

Met één lane zijn de afleverkosten klein, omdat je waarschijnlijk toch al naar die terminal keek. Met parallelle lanes doe je dat bijna nooit. Lane één stelt een vraag terwijl je de diff van lane twee leest. De vraag is makkelijk; het antwoord is één zin. Maar antwoorden betekent de diff verlaten, en als je terugkomt lees je de laatste dertig regels opnieuw om te vinden waar je was.

Vermenigvuldig dat met elke bijsturing, elke "ja, ga door", elke "nee, het andere bestand", en de overhead stapelt zich op. Parallelle lanes falen niet omdat agents traag zijn. Ze falen omdat jij de berichtenbus wordt, en een berichtenbus die zich fysiek tussen vensters moet verplaatsen heeft een verschrikkelijke latency.

Stem haalt het grootste deel van de afleverkosten weg. Je houdt je ogen op de diff, houdt een toets ingedrukt, zegt de zin, laat los. De woorden landen in het invoerveld van de agent. Je bent nooit weggeweest.

De opzet die werkt

Dit is de opzet, opzettelijk saai gehouden.

Een hotkey, geen venster. Keebye woont in de menubalk en luistert naar een hotkey die je indrukt of aantikt (rechter ⌘ is de standaard; Fn en rechter ⌥ zijn de andere opties, en Esc breekt een lopende dictatie af). Er is geen appvenster om te openen en geen modus om binnen te gaan. Vasthouden, praten, loslaten. Dat doet meer dan het klinkt: een dictatietool die een eigen venster nodig heeft is gewoon nóg een lane.

Invoegen in het veld met focus. Het transcript wordt ingevoegd waar je cursor staat. Standaard gebeurt dat door plakken, met terminal-bewuste dosering zodat een lange prompt een shell niet overspoelt. Draai je agents binnen tmux of over SSH, waar plakken zich slecht gedraagt, dan is er een optionele typmodus die de tekst als Unicode-toetsaanslagen injecteert; Dictatie die de terminal overleeft legt uit wanneer je die omzet.

Batch, geen stream. Keebye transcribeert bij het loslaten van de toets, als één uiting. Je ziet geen woorden verschijnen terwijl je praat. Voor prompten is dat de juiste afweging: je wil dat de hele zin in één keer landt, opgeschoond, in plaats van hem woord voor woord te zien opdoemen terwijl de invoer van de agent al een halve gedachte bevat.

Alles on-device. Transcriptie draait lokaal (een standaardmodel dat op Engels is afgestemd, of een model met 25 talen als je daarvoor kiest). Na de modeldownload werkt het met wifi uit. Voor het prompten van agents gaat dat minder over privacytheater en meer over latency: er is geen rondje langs een server, dus een korte prompt is bijna klaar zodra je de toets loslaat.

Een ritme voor het wisselen van lanes

De workflow die uiteindelijk bleef hangen bestaat uit drie gewoontes.

Je ogen blijven op de lane die oordeel vraagt. Op elk moment is er één lane waar je aandacht hoort, meestal een diff of de uitvoer van een test. Dat is de lane die je leest. De andere krijgen alleen korte gesproken instructies. Wanneer lane twee een beslissing nodig heeft, kijk je even, klik je in het invoerveld, houd je de toets vast, zeg je de beslissing, laat je los en klik je terug. De klik is de enige mechanische kostenpost; de zin zelf is gratis.

Prompts worden als volledige zinnen uitgesproken. Agents gaan beter om met volledige zinnen dan met telegramstijl, en dictatie levert volledige zinnen op omdat mensen zo praten. "Draai de schemawijziging terug maar houd de API-hernoeming, draai daarna de migratie opnieuw en laat me de uitvoer zien" is een prima gesproken prompt. Getypt is hij vervelend.

Stopwoordjes gaan eruit, betekenis niet. De opschoning van Keebye is standaard regelgebaseerd: hij haalt de "eh", de "uh" en het herhaalde woord weg en laat je formulering intact. Er is een optionele lokale-LLM-politoer voor nettere zinnen, met daarachter een fidelity-beveiliging die terugvalt op het letterlijke transcript wanneer de gepolijste versie ernstig tokenverlies, uitdijing of herhaling laat zien. Die beveiliging is een heuristiek, geen semantische controle: hij verifieert niet of de gepolijste tekst je betekenis of een ontkenning heeft behouden. Voor het prompten van een agent laten de meeste mensen de politoer uit; een letterlijk transcript is precies wat je zei, en dat is wat je de agent wil laten uitvoeren.

Waar stem goed voor is, lane voor lane

Niet elke prompt wil gesproken worden. Na een paar maanden ziet de verdeling er ongeveer zo uit.

Bijsturingen en vervolgen: altijd stem. "Ga door." "Nee, de andere config." "Voeg een test toe voor het lege geval en draai opnieuw." Dit zijn de prompts met het hoogste volume in een parallelle sessie, en ze zijn allemaal één adem lang.

Reviewfeedback: meestal stem. Een diff lezen en vertellen wat er mis mee is, is natuurlijk. "De retry-lus slikt de fout in, log hem vóór de sleep, en begrens het aantal pogingen op vijf." Dictatie vangt dat op spreektempo terwijl je ogen op de code blijven.

Eerste taakbriefings: gemengd. Een lange, gestructureerde briefing met bestandspaden en randvoorwaarden heeft nog steeds baat bij typen, of bij een grof gedicteerde versie die je daarna bewerkt. Stem is prima voor het proza; exacte identifiers gaan makkelijker getypt. Het eigen woordenboek helpt hier: voeg de modulenamen van je project en je terugkerende jargon één keer toe, en ze worden niet langer als het naastbijgelegen Engelse woord getranscribeerd.

Alles met code erin: typen. Een regex dicteren is geen pretje. Dicteer de instructie ("schrijf een regex die de version header matcht"), niet het artefact.

Eerlijke grenzen

Sommige zijn van Keebye; sommige zijn van de categorie.

Latency bij de eerste dictatie. De microfoon draait warm na de eerste dictatie van een sessie en houdt daarna een pre-roll van 500 ms aan. De allereerste keer indrukken op een dag kan de kosten van het starten van de stream betalen, en een woord dat je zegt voordat de buffer aanstond kan afgekapt worden. Waarom dictatie-apps je eerste woord opeten behandelt de mechaniek.

Nauwkeurigheid op identifiers. Variabelenamen in snake case en interne afkortingen zijn precies waar elk spraakmodel op worstelt. Het woordenboek verkleint dat, maar heft het niet op. Lees de prompt voordat je enter indrukt op iets destructiefs.

Beveiligde velden. Keebye weigert tekst in te voegen in wachtwoordvelden en beveiligde invoervelden. Dat is opzettelijk en soms onhandig, wanneer een terminal om een passphrase vraagt.

Geen spraakcommando's. Er is geen vocabulaire voor "nieuwe regel" of "selecteer alles". Keebye is een dictatietool, geen laag voor spraakbesturing. Navigeren tussen lanes blijft een klik of een sneltoets.

Alleen macOS. De Windows-build is niet uitgebracht.

Waar je verder kunt kijken

Draaien je agents vooral in één editor, dan hebben de gidsen voor Cursor en Claude Code de specifieke details per tool. Kies je tussen dictatie-apps voor deze workflow, dan is Keebye vs Superwhisper een eerlijke vergelijking die ook zegt waar Superwhisper beter past.

De korte versie van alles hierboven: parallelle agents hebben niet nodig dat jij sneller typt. Ze hebben nodig dat jij niet langer de traagste schakel ertussen bent. Houd je ogen op de lane die oordeel vraagt en spreek tegen de rest.