I Built a Full-Featured Mac Dictation App with Codex in 20 Hours

I built a modern, fully featured Mac dictation app in about 20 hours by talking to Codex.

Not a weekend-demo version of a Mac app. Foil is a native, open-source voice dictation app with local and cloud transcription, app-specific cleanup, searchable history, paste recovery, a signed and notarized DMG, Homebrew distribution, automatic updates, and an actual public beta.

I put somewhere around 20 hours of my dedicated attention into it.

That is an estimate of my attention, not wall-clock compute / inference time. And I think that's the measure of most things in the future: how much of my attention does building X require?

I defined a detailed initial plan - with all the bells and whistles / features I wanted - and Agents built, tested (including full e2e tests on a remote Mac mini to test onboarding and user setup, local and cloud transcription / cleanup, etc.,) while I did other things. GitHub Actions built artifacts. Codex loops kept going without needing me to watch every command. The project unfolded across weeks, but the scarce input—my focused human time—stayed very small.

After our kickoff - I intervened to QA and steer.

The receipt is public. As of this post, the Mac repository has:

• 658 commits
• 332 merged pull requests
• 32 releases
• roughly 780 test methods across unit, integration, and UI suites
• 10 GitHub Actions workflows

Of course the "wrapping a transcription model" part wasn't hard: the majority of our time was spent QA-ing and polishing the more detailed features (e.g., app-aware cleanup / dictionary replacement) and the onboarding / setup flow (a little finicky as it requires managing mac accessibility settings).

What Foil does

Foil is a Mac dictation app like Wispr Flow - but it's self-hostable, more configurable, and open source. Hold a key, talk, release, and it pastes the transcript into the app you were already using.

You can transcribe locally with whisper.cpp, use Groq or OpenAI Whisper, or point Foil at your own OpenAI-compatible endpoint. You can keep the raw transcript or apply different cleanup prompts, preferred terms, and corrections depending on the app you are working in.

The basic interaction sounds tiny. The long tail is not.

A useful dictation app has to deal with microphone capture, hotkeys, macOS Accessibility permissions, clipboard restoration, target-app behavior, API keys, local server lifecycle, transcription failures, cleanup failures, history, updates, signing, notarization, installation, and the fact that synthetic paste works differently across Mac apps.

That long tail is where most side projects die. It is also where agents are most valuable.

The Codex App has gotten insanely OP

I built Foil entirely inside the Codex app, but I used it for far more than code generation. The breakthrough is that its tools now compound into something closely approximating a complete product and development team:

• Product management: goal loops turn broad outcomes into tasks, assign work across sessions, track evidence, and continue until the outcome is actually proven.
• Engineering: agents edit Swift, run Xcode builds, manage Git and GitHub, open pull requests, review changes, and fix CI failures.
• QA: browser use tests the website, while computer use and accessibility snapshots interact with the real Mac app—including native UI and finicky macOS permission flows.
• Remote QA: Codex can push testing to another Mac on my network, install the latest build, exercise onboarding, microphone permissions, local and cloud transcription, and collect screenshots and test evidence without tying up my primary machine.
• Infrastructure and release: GitHub Actions build signed artifacts, run the automated suites, and move verified changes toward release.
• Specialists on demand: plugins and skills provide repeatable workflows for design, debugging, review, release engineering, and other jobs that benefit from focused process.

One of the most useful powerups here was remote control. A spare Mac mini effectively became a dedicated QA machine. Codex could send it a build, run the hardware-dependent flows that ordinary CI cannot prove, inspect the resulting app state, and bring the evidence back into the main development loop.

That matters for Foil because microphone input, Accessibility permissions, onboarding, local transcription servers, and native paste behavior all depend on the actual machine. The agent was not merely asserting that the Swift compiled; it was testing the installed product on another Mac while I continued using mine.

A design skill produces an asset. Computer use checks it inside the real app. Xcode tooling builds and tests it. Remote control sends the build to a dedicated Mac mini for hardware-level QA. GitHub automation reviews and ships the change. Then the next agent inherits the code, screenshots, test results, and receipts instead of starting from scratch.

The looping layer acts as management. Each goal defines the outcome, the strongest realistic failure modes, and the evidence required to call it complete. Agents can scout the problem, implement a bounded slice, judge the result, and keep going while useful work remains.

That is very different from repeatedly asking a chatbot to “try again.” It is closer to giving a dedicated software team a product brief and checking in when the work requires taste, authority, or a physical-world decision.

Where my 20 hours went

My time went into the places where human taste and authority still matter:

• Deciding what Foil should be and what it should not become
• Trying the app and noticing when something felt confusing
• Choosing between competing UX directions
• Providing credentials or permission when an external system required it
• Rejecting work that was technically correct but not good enough
• Deciding which risks were worth hardening next

I was not manually typing 21,000 lines of Swift. I was not hand-authoring hundreds of test cases. I was not sitting there refreshing GitHub Actions. I was steering, sampling, judging, and occasionally taking over when physical-world context mattered.

This is why “AI saved me 30%” feels like the wrong frame. The more interesting change is that projects which never deserved hundreds of hours of my life can now exist at all.

The landing page is part of the proof

The same workflow produced Foil's separate landing-page repository, current product screenshots, SEO pages, analytics, and demo media. The screenshots come from deterministic app states or the signed production app—not an invented Figma version of a product that does not exist.

That separation is useful. The native app can stay focused on release engineering while the web surface can iterate on positioning and media. Both remain inspectable in the public usefoil GitHub organization.

What I think this means

Foil is not evidence that human attention is obsolete. It is evidence that human attention has become extremely leveraged.

I supplied the itch, the taste, the risk tolerance, and the final judgment. Codex supplied an enormous amount of patient execution: implementation, tests, review, screenshots, remote QA, release automation, documentation, and all the boring connective tissue that turns code into a product.

The result is a free Mac app that I use, a public codebase anyone can inspect, and a frankly obnoxious ratio between my focused time and the amount of finished work.

You can try Foil or check out the repo here.