Jose Antonio Licon · Pittsburgh, PA

One person.
Many very different projects.
One engine.
Shipping daily.

I build apps, games, and platforms — powered by an AI development system I built myself.

Xanadu isn't an AI assistant. It's an autonomous development loop.

Not “Tony uses AI to help him code” — but a tiered, self-correcting, rule-learning execution system that compresses two weeks of work into two days of wall-clock time.

It runs on open models, on hardware I control. Day to day, that's a Mac running a 27B coding model through Apple's MLX — and in practice, that handles nearly everything. When a roadmap is big, it scales out to RunPod: one rented GPU or many, each running agents in parallel to clear hundreds of tasks in a sprint. The same move buys headroom for larger models if a job ever calls for them. Claude sits at the top of the ladder, reached only when a task has beaten every open-model tier — so frontier compute goes to the problems that genuinely need it.

Every rung of that ladder is a setting, not a rewrite. Each tier names a model, and swapping one in — a newer release, a bigger dense model, a small fast one, a coding specialist — is a config change. When a better open model ships, Xanadu gets better the same day.

Underneath, a BAD_PATTERNS immune system blocks mistakes it has already seen, a rule promotion loop turns repeated fixes into permanent rules shared across every machine, and a velocity feedback loop shapes what gets planned next.

The apps it ships aren't just products. They're the benchmarks. Galaxican at 600+ completed tasks — most of them run in parallel on a RunPod GPU — is a live proof of concept for the system itself.

Most people describing AI-assisted development mean Copilot or Cursor. This is categorically different — an unattended system with a planner, an executor, a validator, error classification, and a rule promotion loop.

That's Xanadu.

Projects

Xanadu

In daily use

An autonomous development loop: local LLMs plan, write, test and fix code straight from a roadmap, escalating to Claude only when they're stuck.

Xanadu is the engine behind everything else on this page. Give it a project's ROADMAP.md and it works through the tasks unattended, one validated change at a time, then surfaces only the blockers that genuinely need a human. Most of the work runs on local models on hardware I already own; paid cloud models are the last rung of the ladder, not the first.

  • Works straight from a project's ROADMAP.md: one task, one tested change
  • Tiered model ladder: four local LLM tiers first, Claude only after repeat failures
  • Real validation gates: static analysis plus per-task tests on every attempt
  • Learns from its mistakes: repeated error patterns become permanent rules shared across machines
  • Scales from one Mac to parallel workers to rented RunPod GPUs
  • Fully resumable: all state lives in the roadmap and git, so it survives being killed mid-run
PythonAnthropic APIGoogle Cloud Firestore

Galaxican

Live

Merge fleets. Take the galaxy. Minimalist real-time strategy with no ads and no in-app purchases.

Real-time strategy stripped to its bones. Capture stars, merge swarms of units into squads and battleships, and push back enemy fleets across 30 levels and 90 challenges in six galactic regions. It plays offline, with no ads and no in-app purchases.

  • 30 levels and 90 challenges across 6 galactic regions
  • Captured stars spawn units; fuse them into squads and battleships
  • Enemy towers and AI squads that fight back
  • Single-drag lasso selection, pinch or scroll zoom, two-finger pan
  • Plays offline: no ads, no in-app purchases, no internet permission
  • iOS, Android, and an in-browser build
FlutterFirebaseGCP Cloud Functions
galaxican.com ↗

Magic Task Hat

Live

Your personal life organizer — sprints, a roadmap, and a magic hat full of ready-made tasks, with everything automatically ordered by priority.

A personal life organizer that runs on agile. Pull ready-made tasks from the magic hat — common goals, pre-filled and already estimated — and get started in minutes. Everything you add is scored and automatically ordered by priority, so the most important thing is always next. Commit the top of the list to a sprint and watch your roadmap fill in.

  • Gamified onboarding: start Small (3 tasks, 3 days) or go BIG (two-week sprints)
  • Pipeline automatically orders every task by MICE score (Magnitude, Impact, Confidence, Effort), most important first
  • Sprint board with To Do, In Progress and Done, plus a daily check-in
  • Roadmap projects future sprints from your effort capacity
  • Analytics with unlockable insight milestones and lifetime stats
  • Magic Hat: a store of common tasks, pre-filled and estimated, added in one click
  • AI-suggested scores and objectives, in your own language
Next.jsReactReact NativeVitestTailwind CSSTypeScriptFirebase
magictaskhat.com ↗

Retro Car Radio

Live

Internet radio with a classic car preset interface. Old-school vibes, a world of streaming.

Tune in like it's 1975. Retro Car Radio puts a vintage dashboard radio on your phone, streaming live stations from the Radio Browser community directory. Program favorites to the push-button presets, or load a curated preset set and just drive.

  • Live streaming with station logos and now-playing metadata
  • Curated preset sets: Public Radio, Golden Oldies, decades and genres
  • Station search by genre, sorted by stream quality
  • Program any station to a preset button, or add it to a set
  • Cloud sync, preset pack import, and a listening leaderboard
  • iOS and Android
FlutterFirebase Cloud FunctionsNode/TypeScript
retrocarradio.com ↗

HootPGH

Beta

Community-driven platform for activism and resource sharing in Pittsburgh.

A hub for Pittsburgh organizers and neighbors: urgent calls to action, a directory of emergency and crisis resources, and a searchable calendar of community events, all in one place.

  • Latest updates feed on the home page
  • Action alerts: urgent, time-sensitive calls to action
  • Resource directory for emergency and crisis support
  • Community events with search, filters, and list or calendar views
FlutterFirebaseNode.js
hootpgh.netlify.app ↗

Witch's Bricks

In development

A turn-based tactical hex board game where gem "bricks" capture tiles and merge upward in grade.

Two witches, one hex board, one action per turn. Move and grow your gems, capture sockets, and merge bricks into higher grades before the board fills. Each campaign level teaches one new mechanic, against a deterministic AI opponent.

  • Campaign where every level teaches one mechanic, starting with The Spark: move and grow
  • Ruby vs Sapphire duels on a hex board
  • Select a gem to light up every socket it can reach
  • One action per turn, answered by the AI opponent
  • Built spec-first by Xanadu: a normative spec with a conformance test suite
Flutter

ProjectsDash

Internal tool

A local dashboard for everything I'm building: status, activity, roadmap progress, and who (or what) did the work.

The control room for this whole portfolio. ProjectsDash scans every project on my machine and shows where each one stands: commit activity, roadmap progress, curated screenshots, and how much of the work ran on local LLMs, RunPod GPUs, or Claude. It's also where the screenshots on this page are curated.

  • Project cards with status, stage, weekly commit sparkline and roadmap progress
  • Per-project Weekly Activity chart with hover counts
  • Where the Work Ran: local LLM on the Mac vs RunPod vs Claude vs untagged commits
  • Xanadu activity: tasks per day, average duration, finished tasks by model
  • Editable stack, repo, hosting and ops commands, written back to each project
  • Marketing vault with a drag-to-reorder screenshot gallery
Next.jsReactTypeScriptTailwind CSSDrizzleVitest

The engine

Xanadu

An autonomous development loop: local LLMs in a tiered cascade, mechanical error correction, and a planning layer that turns a backlog into running code — unattended.

Claude sits at the top, handling escalations and architecture. Everything below runs on open models — usually on my Mac, which handles nearly everything. For big sprints it scales out to rented RunPod GPUs, one or many, running agents in parallel to handle them rapidly — or up to larger models if a job calls for it. Gemini is the outside voice: I consult it for creative work and as a sanity check on what the loop produces. A 2-week plan compresses to 2–3 days of wall-clock time.

Tasks completed autonomously

1,200+

First-pass success rate

~70%

LLM tiers in the cascade

4 + Claude

Why I built it

I started where everyone starts — Claude, Gemini, the usual suspects. I was amazed at what was possible. Then I ran out of tokens.

Most people slow down at that point. I bought a maxed-out MacBook Air and started learning local LLMs instead.

What began as a workaround turned into something more interesting: a complete development loop. Product ideation. SWOT analysis. Backlog generation. Code execution across parallel workers. Models that fail over to more capable tiers when a task is too hard. Error patterns that get learned and encoded so they don't burn retries twice.

Now I set it running overnight. By morning, the project is mostly done. When I need more firepower, I spin up RunPod. A week of backlog in an hour, at a cost that doesn't require a VC.

It didn't replace the craft — my background as a full-stack developer and technical product manager is what makes the system work, not what it replaced. I still drive. I still take the wheel when the models hit a wall, or the project needs a pivot. Agile methodology is the backbone of the whole system — not just a buzzword, but the actual structure that keeps five projects moving at once.

This isn't a silver bullet. It's a superpower.