Personal Product AI-Powered

Gooey Runner

A native macOS app that analyzes any local project, stands it up in Docker, and runs a detect → auto-fix → escalate-to-Claude healing loop to get it running.

Highlights

  • AI-assisted analysis and self-healing loop powered by the Claude API, degrading gracefully to local-only when no key is present
  • Phase-driven workspace state machine orchestrating analysis, env confirmation, container startup, and log streaming
  • Swift 6 strict-concurrency architecture with a design-faithful SwiftUI front end

Skills

Native macOS / SwiftUI developmentLLM integration & agentic loopsSwift 6 strict concurrencyDeveloper tooling

Overview#

Gooey Runner is a macOS app (Swift 6, SwiftUI) that takes the friction out of running an unfamiliar codebase. Point it at a local project and it analyzes the stack, infers the environment and setup steps, brings the project up under Docker Compose, streams logs, and — when something breaks — runs an automated healing loop that attempts a local fix before escalating to the Claude API for a smarter one.

The Problem#

Getting an unfamiliar project running locally is a notorious time sink: missing env vars, undocumented setup steps, version mismatches. Gooey Runner turns that into a guided, mostly-automated flow, and uses an LLM only where it adds real leverage — diagnosing failures the local heuristics can't.

My Role#

Founder and sole engineer — engine, AI integration, SwiftUI front end, and the design system.

Architecture & Approach#

The app is split into a fully-built engine and a design-faithful UI, joined by two coordinators. A root app model owns the long-lived state, and a per-project workspace view model runs a phase state machine (unanalyzed → analyzing → ready → configuringEnv → starting → running / failed / blocked) that orchestrates the whole pipeline: local plus AI analysis, environment confirmation, docker compose up, log streaming, and the healing loop. A single routing surface maps the current phase to the screen and the available actions.

Technical Highlights#

  • Two-tier analysis. A synchronous local analyzer handles stack detection; a separate Claude-powered analyzer infers environment variables, setup steps, and external dependencies. The two result types are deliberately non-interchangeable, and AI features degrade gracefully to local-only when no API key is configured.
  • Detect → auto-fix → escalate loop. Failures are first matched against local auto-fixes; unresolved cases escalate to Claude for a proposed fix, which is then applied and retried.
  • Swift 6 strict concurrency. The codebase uses the Observation framework throughout (no Combine), and resolves main-actor data-race constraints by constructing services as function-local instances at the call site rather than storing non-Sendable services — a real, non-obvious concurrency pattern.

Skills Demonstrated#

Native macOS and SwiftUI development, practical LLM integration and agentic self-healing loops, Swift 6 strict-concurrency design, and developer-tooling product sense.