Trail exists because TrekCrumbs almost broke me.
TrekCrumbs is a privacy-first travel app. Everything is stored on-device, with no cloud services involved. Time zones influence every interaction. I developed it over five months with ChatGPT as my development partner. I’m an IT leader with extensive operations experience, but I had never shipped a mobile app before. The technical skills were learnable, but the process almost wasn’t.
Early on, everything felt fantastic. Features were delivered quickly. Bugs got fixed promptly. Progress was visible and tangible. I was creating a cross-platform app from the ground up, and the velocity was truly exciting.
Then the problems started compounding.
It started with a decision about the data model: using separate schemas for each crumb type. It was flexible, clean, and easy to extend. I made that call during a chat conversation and moved on. You’ve already heard that part. What matters is what came after. Every decision after that quietly depended on one that no longer existed anywhere except a conversation I wasn’t going to reopen. Fields drifted apart. Validation logic was duplicated. Small changes broke things that seemed unrelated. The system wasn’t failing randomly; it was following rules that had never been written down.
ChatGPT kept suggesting fixes like mapping layers, UI patches, and converters. All of these are technically correct and address symptoms, but they never fix the real problem. Meanwhile, the underlying structure continued to diverge.
The real problem wasn’t code quality. It was a key decision that had been made during a conversation that was never documented and quietly influenced everything that followed. When the cost finally became apparent, it arrived all at once.
We stopped for a full week. Not to add features. Not to fix bugs. To tear the schema apart and rebuild it from scratch. A week of stepping back, normalizing the data model, and defining how everything should actually work end-to-end. That week was the most expensive part of the entire project, and none of it was about code.
But the schema wasn’t the only issue. It was just the first place it became visible.
Every new chat session starts fresh. The model doesn't remember what we decided, so I have to rebuild the system in real time. Not from artifacts, but from memory. I’m no longer using a system; I am the system. And I’m a poor place to store critical decisions at that speed.
Decisions that should have been explicit were implicit. I would tell ChatGPT to handle something a certain way, and a few sessions later, it would suggest the opposite. Not because it was wrong, but because there was no record making the earlier choice definite. Without a written record, there was nothing to anchor against. Everything became negotiable again.
Then came the part I didn’t notice until much later.
Delegation was happening without awareness. The model would make small decisions that seemed reasonable in isolation: a field name here, an ordering decision there, a default value that “made sense.” I would accept the output because it worked, without realizing that judgment had quietly shifted from me to the model. Not because I chose to delegate, but because nothing in the process forced me to stay in control. Those decisions accumulated, and when something broke, I couldn’t answer a simple question: why is it this way? The answer was somewhere across multiple chats, hundreds of messages deep, effectively unrecoverable.
I shipped TrekCrumbs. It works. I use it. I’m proud of it.
But the cost of that project wasn’t in the code. It was in rework caused by undocumented decisions. Lost reasoning that no one could reconstruct. Duplicated thinking because nothing was documented. The velocity was real, but so was the waste.
After TrekCrumbs, I didn’t focus on improving prompting. Instead, I aimed to eliminate the need for it. I started building what eventually became ADF, the early version of what is now Trail. The idea was simple but strict: decisions had to be made outside of conversation. Every step had to be documented before execution. Inputs needed to be explicit. Outputs had to be verifiable. If something wasn’t in a file, it didn’t exist.
That evolved into Trail.
What if every decision lived in a file instead of a conversation? What if intent was immutable once execution started? What if the person building couldn’t depend on anything outside the declared inputs; no chat memory, no “earlier context,” just files?
Trail enforces that system.
TrekCrumbs was not created with Trail. The chaos of building TrekCrumbs is the reason Trail exists.
TrekCrumbs: trekcrumbs.com
Web: trail.venturanomadica.com
Top comments (0)