Pixel Path is an open-source (MIT) Claude Code skill by Jon Wheatley that turns any two real-world places into a first-person, pixel-art fly-through of the actual road between them. You ask Claude for 'a pixel path from Bath to Bristol' and it routes the trip, bakes the real buildings, land cover, landmarks, hills, and horizon from OpenStreetMap and elevation data, generates retro scenery art with RetroDiffusion, self-checks with screenshots, and outputs an interactive HTML page you scroll along.

How much does Pixel Path cost to run?

The code is free; only the art costs money, at $0.18 per picture via RetroDiffusion (Oct 2026). Cost depends on the number of distinct-looking regions along the route, not distance. There's a free 'placeholders' tier ($0, code-drawn stand-ins), then sparse (~$0.72–1.44), moderate (~$3.24–5.76), and detailed (~$6.48–11.16) for one to two regions. Budget ~25% extra for re-rolls of bad images.

What makes Pixel Path technically interesting?

It's a strong example of an agent that verifies its own output. The skill doesn't consider a route 'done' when the code runs — it runs a self-check pipeline: cleanup (flood-filling backgrounds, dropping cut-off images), a layout check for gaps in street walls, and a 'sweep' that renders every 75m with the sky painted magenta to detect sky bleeding through buildings, then tells Claude to look at the worst frames and keep re-rolling until clean.

What does Pixel Path need to run?

Node 18+ (no npm packages needed just to build a route), a RetroDiffusion account with credit for real art (placeholders are free), and Node 20+ with Playwright/Chromium for the screenshot self-checks. It pulls live data from Nominatim, OSRM, Overpass, AWS Terrain Tiles, and Wikidata. Install it in Claude Code via '/plugin marketplace add jonwheatley/pixel-path'.

Pixel Path: A Claude Code Skill That Turns Any Two Real Places Into a Pixel-Art Fly-Through

By Prahlad Menon Published 2026-10-21 4 min read

Every so often a project comes along that isn’t trying to change the world — it’s just delightful. Pixel Path, a Claude Code skill by Jon Wheatley, is one of those. You tell Claude “make me a pixel path from Paris to Versailles,” and it hands back a playable, retro-arcade fly-through of the actual road — real buildings, real hills, real landmarks, drawn in pixel art.

But look a little closer and it’s also a quietly impressive piece of agent engineering.

What It Does

Ask for a pixel path between any two places and the skill:

Routes the trip (OSRM car profile).
Bakes the real world along it — every building on its real footprint, land cover (fields, forest, water, parking), landmarks at their true positions, and the actual hills and horizon, marched over a 61×61 km elevation grid with the Earth’s curvature.
Generates scenery art for each region with RetroDiffusion.
Checks its own work with screenshots.
Hands you an HTML page you scroll through — scroll to speed up to a blur, scroll back to slow down and reverse, M for a minimap, I for your location.

The result is the classic pseudo-3D arcade-racer look (think OutRun), except the road is a real one pulled from OpenStreetMap. Signs are drawn by code, so town names, distances, and street names are exact.

The Clever Part: It Verifies Itself

This is what makes Pixel Path worth writing about beyond the novelty. The skill doesn’t call a route done when the code runs — it calls it done when the pictures pass. The self-check pipeline:

Cleanup. Each generated image has its backdrop flood-filled away; images that still carry a painted sky, a cut-off edge, or a sliver are dropped. A contact sheet is written for Claude to actually look at.
Layout check. The whole route is laid out exactly as the page will render it, hunting for gaps in street walls and adjacent buildings that accidentally share the same picture.
The sweep. Every 75 m of built-up road, the camera looks straight ahead and 30° to each side, paints the sky magenta, masks every building, and counts sky bleeding through or between buildings. The 20 worst frames are written out with the problem marked.
Review. Claude is told to look at the worst frames and keep fixing and re-rolling until the sweep is clean.

That’s a generate → render → screenshot → critique → regenerate loop — the same self-correcting pattern we admired in Kiln’s text-to-3D work and exactly the kind of agent-native skill design that separates a toy from a tool. The author even reports the honest numbers: 10% (Bath) to 34% (Manhattan) of pictures came back flawed, and the self-check re-rolled them within budget.

Honest About Its Limits

The README is refreshingly candid, which is a good sign. OpenStreetMap coverage decides the street (missing buildings get plausibly filled by land use); open plazas read as wide paving because that’s what’s there; landmarks are flat facing-pictures, not models; and Overpass — the public data step — is the slow, flaky bottleneck that can stretch a long route to an hour on a bad day. Driving routes only, one afternoon’s light, no traffic or weather.

Why It Matters

Two reasons. First, it’s a beautiful demonstration of agent self-verification — vision-in-the-loop quality control, not just “run the code and hope.” Second, it’s a reminder that Claude Code skills aren’t only for serious engineering; this is a creative pipeline (maps + routing + a diffusion model + a pseudo-3D renderer + a screenshot critic) wired together into a single conversational command.

Real use cases exist too — real roads as game levels, journey recaps, stream backgrounds, travel content, or just a commented pseudo-3D renderer to learn from. But honestly? The best reason is that scrolling down a pixel-art version of a road you’ve actually driven is a small, genuine joy.

It’s MIT-licensed, free to try with placeholder art, and installs in one command.

Repo: github.com/jonwheatley/pixel-path