Disclaimer: Yes, this post was created with the help of AI — why not?
One afternoon, I typed a single sentence into an AI assistant, pointed it at a GPS file from a gravel bike ride — and a few hours later had three working apps, a live interactive map, and a tool that can compare any two routes. No prior design, no detailed instructions. Just a file and an idea.
This is the story of how that happened, step by step — prompts and all.
Tools used Link to heading
- Claude Code — Anthropic’s AI assistant that runs in your terminal. You talk to it in plain English and it reads files, writes code, and runs commands. Think of it as a very capable coding partner that lives in your command line.
- OpenSpec — A workflow that runs on top of Claude Code. Before writing any code, it asks the AI to write a plan: what it is going to build, why, and how. Like an architect’s blueprints before construction begins.
Step 1: One sentence, one dashboard Link to heading
Prompt:
@done.gpx is a GPS track that I created on a gravel bike. Analyse this track
and create a single-page website displaying the most important statistics
and information that can be extracted from it.
One sentence. No design document, no technology decisions. Just a goal in plain English.
What came back: a complete web page with a map, elevation profile, speed, distance, and moving time — opening directly in any browser. No installation, no account, no internet needed.
The prompt did not say how to build it. It described what the result should feel like. That shift — from instructions to intentions — is one of the most useful habits with AI. Describe the outcome you want, not the steps to get there.
Worth knowing: The first version had a bug — elevation showed as zero. After pointing it out, the AI fixed it on its own. Always give AI output a quick review, just like work from any collaborator.
Step 2: Asking for more — and letting the AI surprise you Link to heading
Prompt:
* Add to @index.html a speed profile of the ride.
* When passing with the mouse or finger over the elevation and speed profile graphs,
display the X and Y values. Link this to the location in the map.
* Any other improvement to the UI you can bring?
* Ask any questions.
Two things in this prompt are worth noting. First: “link this to the location in the map” — no explanation of how, just the behaviour described. The AI figured out the rest.
Second: “Any other improvement to the UI you can bring?” This open invitation produced something unexpected — the AI coloured the route on the map by speed (green = slow, red = fast), without being asked.
Ending a prompt with an open question is a reliable way to get ideas you would not have thought to request. You know what you want; the AI knows what is possible. That combination consistently outperforms either working alone.
Step 3: From a one-off result to a tool anyone can use Link to heading
Prompt:
Create a Python app in folder named 'app-analysis' which outputs a single page 'output.html':
* 'output.html' must be like @index.html
* Use new venv and requirements.txt for dependencies.
* Desired usage: ./app.py <input.gpx> [--output/-o output.html]
* Python app should use external template files for HTML and CSS.
* Create basic documentation in 'app-analysis/README.md'.
* Ask any questions.
Step 1 produced a dashboard for one specific ride. This prompt turned it into a reusable tool that works with any GPS file.
Two lessons here. First: you can describe the command you want to run — ./app.py ride.gpx -o output.html — without explaining how to build it. The AI handles the implementation.
Second: always ask for documentation in the same prompt. It takes no extra effort and pays off the moment you return to the tool months later, or share it with someone else. Ask once; it is already written.
The output: 8 stat cards, a map where the route changes colour by speed (green = slow, red = fast), and interactive charts. Hover over the charts to see a dot move along the route on the map.
Step 4: Comparing two rides — and watching the AI ask questions back Link to heading
Prompt:
Create a Python app in folder named 'app-compare' which outputs a single page 'comparison.html':
* Usage: ./app.py --completed done.gpx --todo todo.gpx [-o comparison.html]
* The app must compare a completed ride with a planned route, bringing information
on effort, time differences, tips, etc.
* Create basic documentation in 'app-compare/README.md'.
* Ask any questions.
Before building anything, the AI came back with two questions: What should the page show? How should estimated time be calculated?
This is one of the most underrated things AI assistants can do: ask for clarification rather than guess. When an AI asks you questions, it has identified genuine ambiguity in your request. Answering directly produces a much better result than letting it assume.
The answers: yes to all display options, time scales with distance. The result — a completed 39.6 km Basel ride versus a planned 102 km route — came out as "~24% easier per km", but roughly 3 hours longer due to the extra distance.
The output: an effort estimate, a stat table where green means easier and red means harder, both routes drawn on one map, and elevation profiles on the same scale.
What’s next Link to heading
A few things that would make this more solid:
- Automated tests — a simple check with a tiny GPS file to verify that distance and elevation calculations are correct.
- Visual regression tests — take a screenshot of the output after every change and compare it to the previous one. Catches a broken map or missing chart that no code test would.
- CI/CD pipeline — run both tools automatically on every code change and catch any breakage before it reaches the main branch.
- Better error handling — right now, a malformed GPS file could crash the tools. Friendly error messages instead of crashes.
- A single entry point — one command to run the whole project, instead of consulting each app’s own documentation.
Four prompts. Three applications. One afternoon. The AI did not just write code — it planned, asked clarifying questions, and left behind documentation explaining what it built.
The full project is open: gitlab.com/carlessanagustin/gps-deep