Cómo creé mi primera app para macOS con solo 2 prompts en Codex

🚀 Descargar la aplicación: El binario compilado listo para usar está disponible en GitHub Releases.

Hace tiempo que dejé de usar el teclado el 100% del tiempo. Con mucha más frecuencia, simplemente dicto texto por voz, esperando una transcripción rápida y precisa.

Principalmente, esto es para interactuar con modelos de IA. Mi esposa incluso bromea diciendo que ahora hablo más con mi ordenador que con ella. Y honestamente, no le falta razón: creo firmemente que para que una IA entregue resultados sobresalientes, cuanto más contexto, matices y detalles en vivo le aportes, mejor será el resultado. Escribir todo eso a mano en el teclado es simplemente tedioso y lento.

Por eso necesitaba una herramienta de dictado por voz. No una app genérica, sino algo que funcionara exactamente como yo quería: mantener presionada una tecla (Fn / Globe en modo push-to-talk), soltar mis pensamientos, soltar la tecla y ver cómo el texto transcrito aparece de inmediato justo donde parpadea el cursor.

Lo que no funcionó con las soluciones existentes

En macOS existen opciones excelentes. Probé varias alternativas y dos me parecieron realmente buenas.

Wispr Flow funciona genial: interfaz agradable y respuesta instantánea. Pero su plan gratuito se agota muy rápido y luego exige una suscripción mensual recurrente.

Luego probé MacWhisper:

MacWhisper es un gran producto. Ejecuta modelos en local de forma gratuita, lo cual es fantástico para la privacidad. Sin embargo, yo quería conectar mi propio modelo remoto en la nube, al que ya tenía acceso dedicado mediante API. Y en MacWhisper, la opción de configurar un servidor personalizado y un token API está reservada para la versión de pago Pro.

Todas estas aplicaciones tienen grandes ventajas, pero comparten un inconveniente fundamental: quieren tu dinero.

Y en la era de la inteligencia artificial, cuando una app te pide suscripciones por un simple wrapper básico, simplemente nos sentamos y escribimos nuestro propio fork de vibecoding.

Cómo funciona Simple Flow

Yo mismo no escribí ni una sola línea de código en Swift para esta aplicación. Toda la arquitectura, el código y la compilación final fueron generados desde cero por OpenAI Codex en tan solo dos prompts.

A nivel general, el flujo de trabajo consta de cuatro pasos lógicos:

1. Captura del atajo de teclado: La app reside silenciosamente en la barra de menús y detecta globalmente la pulsación de la tecla Fn (Globe) en modo push-to-talk.
2. Grabación de audio: Mientras la tecla está presionada, el audio del micrófono del sistema se graba en un búfer temporal.
3. Envío a la nube: En el momento en que se suelta la tecla, el archivo de audio se envía de forma asíncrona a mi endpoint remoto con autorización mediante token.
4. Inserción del resultado: El texto transcrito se pega de inmediato en la ventana activa emulando pulsaciones sintéticas de ⌘V.

Desarrollo en 2 prompts con Codex

Prompt 1: Lógica central y arquitectura

En el primer prompt, describí el flujo con palabras sencillas: demonio en la barra de menú, captura de la tecla Fn, grabación de audio, petición HTTP a la API e inserción en el foco activo.

Codex seleccionó los frameworks nativos de macOS (AVFoundation, ApplicationServices, CoreGraphics) y construyó una máquina de estados pura y determinista, un monitor de eventos para el atajo de teclado y un inyector de texto:

public enum DictationPhase: Equatable, Sendable {
    case idle
    case recording
    case transcribing
    case feedback(FeedbackKind)
}

public struct DictationStateMachine: Sendable {
    public private(set) var phase: DictationPhase = .idle

    public mutating func handle(_ event: DictationEvent) -> [DictationEffect] {
        switch (phase, event) {
        case (.idle, .hotkeyPressed):
            phase = .recording
            return [.captureFocus, .startAudio]

        case (.recording, .hotkeyReleased):
            phase = .transcribing
            return [.stopAndTranscribe]

        case (.recording, .escapePressed):
            phase = .idle
            return [.cancelAudio, .returnToIdle]

        case (.transcribing, .transcriptionInserted):
            phase = .feedback(.inserted)
            return []

        case (.transcribing, .failed(let message)):
            phase = .feedback(.error(message))
            return []

        default:
            return []
        }
    }
}

import ApplicationServices
import CoreGraphics
import Foundation

public final class HotkeyMonitor: @unchecked Sendable {
    private var eventTap: CFMachPort?
    private var decoder: HotkeyEventDecoder

    public init(hotkey: Hotkey = .fnKey) {
        self.decoder = HotkeyEventDecoder(hotkey: hotkey)
    }

    public func start() {
        let mask = (1 << CGEventType.flagsChanged.rawValue)
        self.eventTap = CGEvent.tapCreate(
            tap: .cghidEventTap,
            place: .headInsertEventTap,
            options: .listenOnly,
            eventsOfInterest: CGEventMask(mask),
            callback: { (proxy, type, event, refcon) -> Unmanaged<CGEvent>? in
                guard let refcon = refcon else { return Unmanaged.passUnretained(event) }
                let monitor = Unmanaged<HotkeyMonitor>.fromOpaque(refcon).takeUnretainedValue()
                monitor.handleFlagsChanged(event.flags)
                return Unmanaged.passUnretained(event)
            },
            userInfo: Unmanaged.passUnretained(self).toOpaque()
        )
        
        let runLoopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, eventTap, 0)
        CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, .commonModes)
        CGEvent.tapEnable(tap: eventTap!, enable: true)
    }
}

import CoreGraphics
import Foundation

public final class SystemEventPoster: EventPosting, @unchecked Sendable {
    public func postPasteCommand() -> Bool {
        let cmdKeyCode: CGKeyCode = 55 // Command key
        let vKeyCode: CGKeyCode = 9    // 'V' key

        let source = CGEventSource(stateID: .combinedSessionState)
        guard let cmdDown = CGEvent(keyboardEventSource: source, virtualKey: cmdKeyCode, keyDown: true),
              let vDown   = CGEvent(keyboardEventSource: source, virtualKey: vKeyCode, keyDown: true),
              let vUp     = CGEvent(keyboardEventSource: source, virtualKey: vKeyCode, keyDown: false),
              let cmdUp   = CGEvent(keyboardEventSource: source, virtualKey: cmdKeyCode, keyDown: false) else {
            return false
        }

        cmdDown.flags = .maskCommand
        vDown.flags   = .maskCommand
        vUp.flags     = .maskCommand
        cmdUp.flags   = []

        // Post Command+V synthetic event tap directly to active focused application
        cmdDown.post(tap: .cghidEventTap)
        vDown.post(tap: .cghidEventTap)
        vUp.post(tap: .cghidEventTap)
        cmdUp.post(tap: .cghidEventTap)

        return true
    }
}

Prompt 2: Interfaz de ajustes y compilación final

En el segundo prompt, pedí una interfaz de usuario completa:

• Indicador de estado en la barra de menús (Ready / Recording).
• Ventana nativa de ajustes: selección de micrófono, grabador de atajos de teclado personalizados, comprobación de permisos de macOS (Accesibilidad y Micrófono) e inicio automático al encender el Mac.
• Almacenamiento seguro del endpoint y token API en el Keychain del sistema.
• Script automatizado para compilar el paquete .app de producción.

Codex escribió toda la interfaz en SwiftUI/AppKit, compiló el proyecto Swift en la terminal y me entregó el ejecutable SimpleFlow.app.

El resultado

Arrastré SimpleFlow.app a mi carpeta /Applications, introduje mi token y servidor en la configuración, y funcionó a la primera exactamente como quería.

Incluso medí el consumo real del proceso mediante top mientras escribía este artículo:

• CPU: 0.0% en reposo (el proceso duerme en el RunLoop y solo despierta con las interrupciones de CGEventTap).
• RAM: ~50 MB (la memoria base estándar de los frameworks del sistema AppKit y SwiftUI).

Apenas consume recursos, permanece silencioso en la barra de estado y transcribe mis prompts a las IAs sin suscripciones ni límites artificiales.

Código fuente y descargas en GitHub

He publicado todo el código fuente del proyecto de forma abierta:

Puedes descargar el archivo compilado (SimpleFlow-v1.0.0.zip) directamente desde la página de Releases en GitHub. Para instalarlo, simplemente descomprime el archivo y arrastra SimpleFlow.app a tu carpeta /Applications.

Bottom Text

En 2026, el software personal ya no es un mito, sino una realidad para todos, incluso para quienes no tienen experiencia en programación. Crear una herramienta propia adaptada a tus necesidades es hoy más fácil que buscar la alternativa perfecta en internet.

No sé qué otra conclusión sacar de esto: aprovechadlo y cread vuestras propias herramientas, amigos.