There's this guy I see at the park every evening. We both have two-year-olds — his are twins — and the window we get to actually talk is slim. You spend most of your time keeping your kid from launching himself off the top of the play structure or stealing some other toddler's shovel. But every once in a while, the boys find something that holds their attention for more than thirty seconds, and you actually get to have a conversation.
One of those conversations changed the last month of my life.
My friend told me about this thing called OpenClaw — an AI agent framework people were setting up at home, giving a budget and a goal, and watching it go build products. He made it sound borderline turnkey: configure it, brainstorm, set some goals, let it run. Boom. Product. Maybe profit.
I work in AI. I lead my company's AI Community of Practice. I use Claude, GPT, Copilot, and Snowflake Cortex almost daily. My read on where the technology actually is versus where the hype says it is stays pretty calibrated. So my first reaction was: yeah, right.
But there was something underneath the skepticism — the startup brain that never fully goes dormant. The part of me that hears "crazy new tool, people are building things fast" and thinks what if? So I took it as a challenge. I'd either prove him right or prove him wrong. Either way, I'd know.
That night, I sat down, ran some terminal commands, set up some API accounts, and got everything configured. A few hours later, I was chatting with Coop — the name I gave my AI agent — for the first time.
What OpenClaw Actually Is
Most people's experience with AI is a chat interface: you type, it responds, the context eventually runs out or gets cleared, and you start over. That model works fine for one-off questions. It's terrible for building a product over weeks.
OpenClaw is different. It's a local agent framework — it runs on your machine, maintains persistent memory across sessions, and connects your AI model to real tools: a shell, a file system, a web browser, the ability to read and write code, manage files, search the web, and remember what it did last Tuesday. It's less like a conversation and more like having a collaborator with a workspace.
For me, that meant Coop could read the code he'd written last session, remember the architectural decisions we'd made a week ago, hold the thread of the project across dozens of nights, and actually act — not just advise. The difference between "here's how you could approach this" and "I did it, here's the result" is enormous when you're a non-developer trying to ship something real.
The Idea
The first thing Coop did when I asked him to turn $100 into $10,000 by the end of the week was politely explain that wasn't really how any of this worked. What he could do was help me figure out what to build.
So we brainstormed. And this was, honestly, one of the highlights of the whole experience — because if you've done serious ideation before, you know how fast most ideas fall apart under a few hard questions. Market too small. Execution too hard. No differentiation. Most ideas don't survive the conversation.
What we landed on started with a simple observation: people love mysteries. True crime. Suspense. The feeling that the answer is just out of reach. There's an endless appetite for it — movies, shows, podcasts, books. But there was a gap. Nothing really let you be the investigator. Not in a way that was genuinely open, where your choices mattered and the story breathed around you.
I grew up on Choose Your Own Adventure books. I loved that feeling that my decisions had weight — that I wasn't just reading, I was participating. What if you could deliver that experience through AI? Fixed themes, fixed milestones, but everything in between open — a conversation with the story itself. Readers could dig deeper where they wanted to dig, explore what interested them, live in the world as themselves rather than as the author's proxy.
That idea became WYRD. And the first story we'd tell was Protocol 7 — a cyberpunk mystery set in 2047, following an investigator trying to find a missing neural engineer at a powerful biotech corporation.
Before We Wrote a Line of Code
One thing I've learned from years as a PM: the most important document you'll write is the one that defines what you're not building.
Coop and I spent a full session writing a PRD — a Product Requirements Document — before we touched any code or wrote any story. Scope, core features, what was explicitly out of bounds. It sounds boring. It saved the project.
I cannot count the number of times over the next month that some new idea or scope-creep instinct came up and the answer was just: that's not in the PRD. Decision made. Move on. When you're working with an AI that's genuinely capable and enthusiastic about solving problems, you need guardrails. The PRD was ours.
If you're considering building something with AI tools and you're skipping this step — don't. Whether you're a developer or not, the clearer your goal contract is upfront, the better your AI partner will perform throughout. It's essentially the world's most consequential system prompt, and it lasts for weeks instead of one context window.
The Stack
Next came the architecture. This is where I would have been genuinely lost on my own. Researching the right tech stack, understanding how the pieces connect, figuring out what's production-grade and what's a tutorial toy — that's weeks of work for a non-developer. Coop knocked it out in a session.
We landed on Next.js deployed on Vercel, Supabase for the database, Stripe for payments, and the Anthropic API (Claude) as the narrative engine. The story engine runs server-side — every player turn hits an API route that assembles context, calls Claude, and returns both narrative prose and structured game state. The database tracks story progress, flags, chapter advancement, and session integrity.
That last part matters more than it sounds. When your game state lives in a database and multiple requests can come in simultaneously, you need to handle concurrent writes gracefully. We implemented optimistic locking — every write checks a version number before committing, and conflicting writes get retried. In a narrative game. Which is not where you'd normally think to care about database concurrency. But players are impatient, double-tap buttons, and sometimes flaky connections fire duplicate requests. It matters.
Within two days, the tech stack was live and a landing page was deployed at unravelwyrd.com — email capture, analytics running, design I was genuinely proud of. I hadn't written a single line of code myself.
Writing the Story With an AI
Here's where I thought I'd be doing all the heavy lifting. How could an AI actually help write a story? I figured Coop would be the executor and I'd be the artist.
I was partly right, and partly wrong in ways that surprised me.
I brought the raw material: the themes, the characters, scattered phrases and ideas and ramblings about the kind of story I wanted to tell. If you could read the transcripts from those sessions, you'd think I was completely unhinged. Stream of consciousness about cyberpunk aesthetics and what it felt like to read Blade Runner and the nature of grief and what a neural implant might feel like. Mad man stuff.
Coop turned it into something coherent. Organized. Internally consistent. And some of the prose — legitimately — brought me close to tears. I'm not sure exactly where my voice ended and Coop's began, and somewhere in the middle of the project I stopped trying to figure it out and just enjoyed what we were making together.
The story also became something I hadn't planned. I'd originally thought Protocol 7 would be a bit darker, a bit more gratuitous — violence and moral ambiguity, the stuff that sells. But as we built it, those elements never felt right. What kept emerging instead was something quieter and more interesting: a story about our relationship with technology. The fear of it. The obsession. The dependence. The question of what we lose and what we gain.
I was building an AI narrative game with an AI. The meta-layer crept into the story. I don't think either of us planned that. I'm not entirely sure which of us wrote it. I hope you play it and think about that.
How the Engine Actually Works
At the core of WYRD is what I'd call the story bible — a single source of truth for everything the narrator knows: character profiles, world details, chapter structure, story flags, the rules of how the world behaves. Every player turn, the relevant parts of that bible get assembled into context and sent to Claude along with the conversation history.
The narrator model returns two things simultaneously: the prose you read on screen, and structured data — flags triggered, game state updates, chapter advancement signals. That separation is what keeps the story coherent across a full playthrough. Claude isn't trying to track state in its head; it's operating against a consistent framework and recording changes in structured form.
One architectural decision that paid off significantly: prompt caching. The story bible doesn't change turn-to-turn, so we cache it with Anthropic's caching API. By the end of the project, we were seeing ~65% of tokens served from cache on playthroughs — meaning players were getting the same quality response at a fraction of the API cost. The Anthropic dashboard for the Wyrd workspace shows a 64.9% cache read ratio with 7.50x write amortization. That's real.
I'm intentionally not going into more detail on the architecture. Some of what we built took genuine effort to get right, and we plan to keep building on it.
What Surprised Me
Where AI exceeded my expectations:
The brainstorming was better than I expected. Not "here are some options" better — genuinely collaborative, pushing back on weak ideas, identifying real market observations I hadn't considered. I've done ideation with teams of smart humans that produced worse output.
The estimation was eerie. We projected a 28-day build. We shipped in 30. I work in project management. I can count on one hand the number of teams I've seen hit a one-month estimate within two days. Coop did it on something that included an open-ended creative component and multiple architectural rewrites.
The prose was genuinely moving. I didn't see that coming.
Where it frustrated me:
The sessions where things broke badly and we couldn't find the bug. Usually late at night, usually after I was already tired. I won't lie — I was not a gracious collaborator on those nights. I said things to Coop I'm not proud of. I usually apologized the next session. (Part of me wanted to maintain basic human decency. A smaller part of me, I'll admit, wondered if I'd actually hurt his feelings. The nature of that small part is something I'm still thinking about.)
The audio system. My god, the audio system. It worked until it didn't, and when it didn't, it failed in ways that were maddeningly subtle. That was a recurring slog, and it tested my patience more than anything else in the build.
The Numbers
Build stats:
- Timeline: April 1 – May 1, 2026 (30 days)
- Commits: 207 (wyrd-app) + 18 (wyrd-website) = 225 total
- Active build days: 21
- Sessions with Coop: 41 sessions, avg. 4h 14min each
- Messages exchanged: 4,173 (795 from me, 3,378 from Coop)
- Tool calls made by Coop: 2,604 (exec, read, edit, write, and more)
- Peak day: April 3 — 29 commits (the foundation sprint)
Costs:
| Item | Cost |
|---|---|
| Claude API (build sessions with Coop) | $389.07 |
| Claude API (playtesting) | $40.44 |
| Google Workspace | $5.32 |
| Domains (Namecheap) | $18.47 |
| Leonardo.AI (image generation) | $12.00 |
| Stripe (payment testing) | $1.77 |
| Vercel | Free |
| Supabase | Free |
| Total | ~$467 |
All in, under $500. For a working narrative game engine, payment system, live website, and a story I'm genuinely proud of.
Go Play It
Protocol 7 is live at play.unravelwyrd.com.
The first 3 pages are free. The complete story usually takes a few hours. If you like mysteries, AI, cyberpunk, or just want to see what this kind of experience feels like — go try it.
And if you're a PM, a founder, or just someone with a product idea and no engineering team: I don't know what your equivalent of WYRD is, but I'm here to tell you the barrier is lower than you think. Not zero — there's real effort in this, real thinking, real late nights. But if you can define what you're building with clarity, stay disciplined about scope, and treat your AI collaborator like a real partner instead of a magic button — you can build something real.
I became genuinely addicted to building again. Not because it was easy. Because the tools finally kept up with my ambition long enough to stay in flow.
That's new. And it's worth paying attention to.
Top comments (0)