@ioloroX ↗

ioloro

Solo developer shipping iOS/macOS apps and a geospatial computer-vision pipeline, run through Claude Code plus a fleet of local and cloud agents.

How this setup has evolved

Version 1 · Latest

Add hardware specs to Machines; skip DewyMarshal box

How I work with AI

What I build

I'm a solo developer shipping a portfolio of iOS and macOS apps, plus a computer-vision / geospatial ML pipeline behind one of them. AI does the first implementation, gives my changes a second look before I ship, and increasingly runs as an unattended fleet of agents that handle capture, labeling and training across several machines. I stay in the loop for judgment calls and final review.

Agents & harnesses

  • Claude Code (current): My primary harness for coding, refactors and multi-agent orchestration. Most day-to-day work runs through it against Swift/Xcode projects.
  • DewyMarshal (current): A macOS agent I built to orchestrate a fleet of Macs — it claims capture/label/train tasks off a queue and runs them mostly unattended. I drive and inspect it through its own MCP server.
  • Fleet Orchard (current): The fleet-management backbone behind DewyMarshal and Clay — it turns a Mac app into a task-fleet node reporting to a shared coordinator, so work can fan out across machines.
  • Local-LLM agents via Ollama (current): On-device models (Qwen family) for per-item investigation and vision QA where I want the work to stay local rather than go to the cloud.

Apps

  • Xcode (current): The build/sign/run home base for every app I ship; my coding agent works against the same projects.
  • iTerm + zsh (current): Dev servers, fleet SSH sessions and one-off scripts alongside the agent.
  • BugBridge (current): A menu-bar app I built to capture and annotate bug screenshots and recordings, then file tickets straight to Linear.
  • Linear (current): Where epics, tickets and project state live; my agent reads and writes it directly.
  • Blender (current): Headless, Python-scripted 3D asset generation for a game project — a build → render → self-critique → export loop.
  • QGIS / PopGIS (current): Inspecting geospatial imagery and detections for the mapping pipeline.
  • Tailscale (current): Private network tying the Mac fleet together for distributed runs.
  • Docker (installed): Local containers for backend services.

Models

  • Claude Opus (current): The model behind my coding and orchestration sessions.
  • Qwen, local via Ollama (current): On-device investigation and image QA.
  • Custom segmentation models (current): Mask2Former-family models I train on cloud GPUs for the CV pipeline.

Machines

  • This Mac (current, local): MacBook Pro, Apple M4 Pro, 48 GB — primary dev machine running my editor, coding agents and browser.
  • Mac fleet (current, remote): Additional Macs on Tailscale that claim and run capture/label/train tasks from DewyMarshal; the workhorse is a Mac Studio (Apple M4 Max, 48 GB).
  • Cloud GPU (current, on-demand): Ephemeral GPU pods on RunPod, spun up per training run.

Skills

Release & marketing (personal)

  • App Store Connect suite (current): A large set of skills covering build lifecycle, signing, notarization, TestFlight, metadata and localization, screenshots, pricing and submission health — the mechanical parts of shipping to the App Store.
  • release-manager (current): The master runbook I invoke when cutting a release.
  • marketing-copy (current): Website copy review, press-kit generation, and App Store preview-video and screenshot planning.

Engineering (personal)

  • ios-testing (current): Writing and reviewing Swift Testing / XCTest / XCUITest suites, plus flaky-test, actor-isolation and CI-stability debugging.
  • swift-concurrency, apple-design (installed): Reference guidance for Swift concurrency and Apple-platform design.
  • tile-detection-merger-researcher (installed): A research subagent for the CV pipeline's tile-stitching stage.

MCP connections

  • My own tooling (current): I wrap in-house apps as MCP servers so the agent can drive them directly — DewyMarshal (the fleet orchestrator), Clay (CV annotation/training), and DewyCaddy (round data).
  • Linear (current): Project and issue management.
  • Sentry (current): Crash and error triage for shipped apps.
  • RevenueCat (current): Subscription and paywall configuration.
  • RunPod (current): Provisioning cloud GPUs for training.
  • Hugging Face, Google Workspace (current): Model/dataset access and email/calendar/drive context.

Private endpoints, tokens and account details stay local and off this page.

How I work

  • I brief Claude Code with a focused task against a specific project, let it implement, then review the diff, run the build/tests, and try the change myself before shipping.
  • For large ML jobs I don't babysit, I set a directive and let the Mac fleet claim work off a queue — capture, labeling and training run unattended, and I define where each run should stop.
  • When I hit a bug, I capture and annotate it in BugBridge and file it to Linear, where my agent can pick it up.
  • I use local models for cheap, private per-item judgment, and reserve cloud GPUs for the heavy training step.
  • Before trusting a model's output at scale, I run an adversarial second-look pass — a separate agent, or a color/geometry sanity check — rather than accepting the first result.
  • Shipping to the App Store is almost entirely skill-driven: I invoke my release runbook and the ASC skills handle signing, notarization, metadata and submission.