Planning Yellowstone With Claude — and Shipping a Homepage at 30,000 Feet

I just spent nine nights road-tripping Grand Teton and Yellowstone with my family — three lodges, two national parks, one rental car, and a stack of confirmation emails that did not agree with each other. The trip itself was the easy part. Getting there without something falling through the cracks was a project, and I ran it the way I run projects at work: in a Claude Project, with a master document, and with the AI doing the reconciliation work I would have gotten wrong at 11 PM.

This is a practical account of what that looked like — and how it ended with me updating my homepage from seat 23D somewhere over Idaho.

The Setup: A Project, Not a Chat

Trip planning conversations sprawl. Flights in one thread, lodging in another, and three weeks later you’re asking “wait, which reservation number was the horseback ride under?” The fix was the same one I use for engineering documentation: give everything a home.

I created a Claude Project and loaded it with the source documents — the Delta itinerary PDF, the Expedia rental confirmation, the Signal Mountain Lodge order confirmation, the Yellowstone National Park Lodges reservations, even a scanned 1989 National Geographic map of the region because it’s beautiful and occasionally useful.

Then Claude and I built a master agenda as a markdown file: every confirmation number, every check-in time, every balance due, every open action item. Each planning session started from that document and ended with an updated version I saved back to the Project. Same discipline as a runbook. The document was the source of truth; the conversations were just how it got edited.

What Claude Caught That I Didn’t

This is the part worth writing about, because “AI helped me plan a trip” is meaningless without specifics. Cross-referencing the booking PDFs against my running summary, Claude flagged several errors that would have bitten us:

A lodge balance I thought was paid. My early summary said Signal Mountain Lodge was “paid in full” at $406.84. It wasn’t — that was the deposit. The order confirmation PDF labeled the deposit as “Payment Amount,” which is how the error crept in. Actual total: $813.68, with the balance due at the property. Not a catastrophe, but a surprise bill at check-in is exactly the kind of thing that sours a vacation morning.

A drive time understated by half. The original plan said Old Faithful to Jackson Hole Airport was 60 miles, 1.5 hours. It’s actually 95–100 miles through two national parks in peak summer — 2.5 to 3 hours before construction delays. With a 5:30 PM flight and an off-airport rental return, that correction changed our entire departure-day plan. We left at checkout instead of after lunch.

A reservation “conflict” that wasn’t. Two different Yellowstone reservation numbers looked like a duplicate booking. Claude dug into the confirmations and resolved it: one covered the Mammoth hotel plus a horseback ride, the other covered Old Faithful Inn plus a cookout. Two valid bookings, bundled differently than the emails implied.

A confirmation buried inside another confirmation. The Old West Cookout never showed up in an inbox search because it never got its own email — it was “Item 2 of 2” inside the lodging reservation. Claude found it by searching my Gmail through the connector with a domain-scoped query instead of keywords. Human me had given up after two searches.

None of these required intelligence I don’t have. They required patience I don’t have — the willingness to re-read four PDFs line by line every time a number changed.

The Artifacts: Making the Plan Visible

A markdown agenda is great for accuracy and terrible for handing to your family. So we generated visual artifacts from the same source data:

A color-coded trip calendar — every day as a column, morning/afternoon/evening rows, meals, booked items starred, drive days flagged. This became the thing we actually referenced from the road.

A schematic itinerary map — an original diagram of the two-park road network with every day’s route plotted and color-coded by time of day. Not a real map, not to scale, but it made the routing logic legible in a way turn-by-turn directions never do. Nine small day-by-day panels underneath showed each day’s movement at a glance.

Color-coded family trip calendar: nine days as columns with morning, afternoon, and evening rows, lodge color bands, and booked items starred — The trip calendar (top shown — click for the full nine days)

Schematic itinerary map of the Grand Teton and Yellowstone road network with lodges marked and daily routes color-coded by time of day — The itinerary map (top shown — click for all nine day panels)

A Mermaid flowchart of the lodge-to-lodge flow, because apparently I can’t plan anything without a diagram.

The interesting part is that these weren’t separate efforts. The calendar, the map, and the agenda all derived from the same reconciled data, so when a detail changed — a dinner reservation, a road closure — the correction propagated instead of forking.

Live Data Where It Mattered

Static planning only gets you so far in a park where the ground literally explodes sometimes. Claude’s connectors and search covered the dynamic layer:

AllTrails for trail research — which surfaced that a segment of the Taggart Lake trail was closed for the season, before we drove to the trailhead to find out
Web search for current road status, which caught a bridge construction delay near Tower and the closure of Biscuit Basin after a hydrothermal explosion
Gmail for the confirmation archaeology described above

The pattern that emerged: use the Project documents for what’s booked, use live tools for what’s changing, and keep the master agenda as the merge point between them.

Mount Moran under dramatic clouds, rising over Jackson Lake with boats moored at the Signal Mountain Lodge marina — Mount Moran over Jackson Lake, from the marina at Signal Mountain Lodge

Trail selfie with family walking ahead through sagebrush flats toward distant mountains — Trail miles with the family — sagebrush as far as you can see

Selfie in front of the stone Roosevelt Arch inscribed 'For the Benefit and Enjoyment of the People' — The Roosevelt Arch at the North Entrance — "For the benefit and enjoyment of the people"

Old Faithful erupting, water column rising into a towering steam cloud — Old Faithful, on schedule — the one reservation nobody can move

A grizzly bear crossing a grassy meadow, photographed at long distance — A grizzly, photographed at a respectful — and legally mandated — distance

A large bison grazing in green grass near a thermal flat — Local traffic

The log-framed lobby of the Old Faithful Inn, looking up through four stories of balconies hung with America 250 banners — Looking up inside the Old Faithful Inn — 1904 log architecture, dressed for America's 250th

The hand-wrought iron clock on the Old Faithful Inn's massive stone fireplace chimney — The Inn's great clock, hand-forged on the stone chimney in 1904

Morning sun through drifting steam over a runoff channel in the Upper Geyser Basin — Morning steam in the Upper Geyser Basin, before the crowds

Old Faithful's full eruption column against a clear blue sky — One more eruption for the road

Swipe or scroll sideways to browse all ten →

Shipping From Seat 23D

Here’s the part that would have sounded absurd to me two years ago.

On the flight home — a 737 out of Salt Lake City, tray table down, phone on airplane Wi-Fi — I decided my homepage was stale. So I updated it. From the plane, on my phone — I left my laptop at home.

My site is an Astro static build deployed to Cloudflare Pages, and the whole pipeline is Git-based: change a file, push to main, live in about ninety seconds. And this was no typo fix — it was a proper design pass: a darker, more editorial homepage with a glass-effect header, an animated hero, and scroll-reveal sections. Working through Claude on my phone, I described the look I wanted, reviewed the diff, and pushed. By the time we started our descent into Seattle, the new homepage was deployed.

I’ve written before about chasing the “edit from anywhere” workflow. This was the proof point: not editing from a coffee shop, but from a metal tube at 30,000 feet, with the same confidence I’d have at my desk. The static-site-plus-Git architecture earns its keep in exactly these moments — there’s no server to babysit, no CMS session to time out. Just files, a commit, and a CDN.

What I’d Do Differently

Start the Project earlier. The reconciliation wins all came from having source documents in one place. The errors Claude caught had been sitting in my summaries for months before I set that up.

Trust the document, not the memory. Every time I answered a trip question from recall instead of the agenda, I was wrong about something — a time, a balance, a confirmation number. The discipline of “check the doc” applies to vacations exactly as much as production systems.

Budget estimates need the same rigor as bookings. My food estimate was the softest number in the whole plan and I never re-baselined it against actual park pricing. It showed.

The meta-lesson is the same one from my daily work: Claude didn’t plan my vacation. I planned my vacation. Claude kept the plan honest — caught the drift between what I believed and what the documents said, and turned one reconciled dataset into every format the trip needed, from a budget table to a map my family would actually look at.

That, and it let me ship a website from an airplane. Not a revolution. But a very good Friday.

How I Use Claude (by Anthropic) Every Day — The daily workflow this trip planning grew out of
Setting Up Keystatic CMS: A Messy Proof of Concept — The earlier chapter of the “edit from anywhere” chase
Context Engineering: Managing the Smart Zone — Why the master-document discipline works