Why I stopped looking for a moat and built a GenAI tool for my daughter

I’ve been building with LLMs since ChatGPT dropped. Every wave since—RAG, AutoGPT, fine-tuning, agents, MCP, context engineering, Skills, harness engineering—I’ve ridden it, shipped with it, and argued about it at meetups in Silicon Valley.

And like everyone else, I've spent a lot of that time chasing the same ghost: the defensible moat. What can you build that a frontier model won't eat in six months? It's the question every founder, PM, and engineer is asking in some form. I have strong opinions, and I bet my time on them. But GenAI shifts every month, and like a gambler at the craps table, I keep moving my chips.

What pulled me out of that loop wasn’t a better framework. It was my daughter.

She decided she wanted to write a movie. Not “someday”—now, with a notebook and a plot and characters whose names no human has ever been given. Watching her work, I realized I’d been so deep in the moat discourse that I’d forgotten my first passion—the reason I joined multiple startups in Silicon Valley in the first place: to build for entertainment. Technology was always the medium, not the point.

So how could I help my daughter's writing given what GenAI has to offer? I’m not looking for what’s defensible, but what’s useful.

Agentic coding, applied to writing

To be clear—I’m not the first to point an LLM at a manuscript. Sudowrite has been building AI-native fiction tools for years. NovelCrafter gives novelists a solid workspace with codex-style world bibles and chapter-level AI assistance. The Narrative Context Protocol, built on Dramatica theory and powering Subtxt, is doing some interesting experimentation around authorial intent.

What I didn’t see anyone doing was taking the patterns getting battle-tested right now in agentic coding and porting them over to writing. Agentic coding is where every new idea in LLMs gets pressure-tested first. It’s where context engineering was born, where harness engineering is being worked out, where the agentic optimization loop is getting its reps. The tools that have come out of it—IDEs with agents that navigate a codebase, linters that catch bugs before runtime, git diff and branches and blame—are the most cutting-edge human-AI collaboration tools that exist.

Laires

So Laires is my exercise to bring what’s working in the agentic coding domain and port it to writing. What does git diff look like for a plot? What’s a linter for character consistency? What does an agent with tools look like when the codebase is a manuscript?

Laires treats your novel or screenplay like a codebase. It parses your manuscript into a narrative graph—characters, objectives, conflicts, relationships, arcs—then hands you an LLM agent with 28 built-in tools to query, lint, and co-edit your story.

A few of the pieces:

  • laires diff—see how your narrative graph changed between git commits. Not what words changed—what story changed. Which character’s objective shifted. Which conflict resolved. Which relationship is new.
  • laires lint—consistency checks across the whole manuscript. Contradictions, dropped threads, timeline issues.
  • laires perspective <character>—re-read any scene through a specific character’s eyes. Useful when you suspect a POV has gone flat.
  • Consultant vs. Workshop modes—one is read-only analysis that hands you a revision brief. The other is live co-editing with the agent.
  • Your choice of model—Anthropic, OpenAI, Gemini, or local via Ollama. No lock-in.

It’s a native desktop app (single Rust binary), a CLI, and an agent you can actually talk to about your story. It represents a fundamental shift in how we think about writing tools—moving from a blank canvas to an active collaborative runtime environment.

Expanding the Creative Stack: Storyboarding & VDD

As I played with Laires, I realized the narrative graph was just the baseline. To fully unlock the creative process, we need to bridge text with visual rhythm. This led me to start building a set of sister open-source projects that round out this creative stack:

  • storyboard-loop: An open-source iteration engine that closes the gap between script updates and visual storyboards. It listens to narrative graph shifts and automatically triggers image generation loops to keep visual animatics in sync with the latest draft.

  • storyboard-ide: A dedicated visual workspace for creators. It pairs screenwriting with real-time visual frame generation, displaying side-by-side text, narrative graph relationships, and the visual storyboard. It treats storyboarding not as a post-writing chore, but as an interactive design loop.

  • vdd-loop (Vibe-Driven Development Loop): The development harness I am playing with to build both of those tools. Building AI-driven creative tools is notoriously non-deterministic; tests fail because the "vibes" changed. vdd-loop is a testing and execution harness that runs continuous prompt/output evaluation loops, letting me "vibe-code" these visual editors with predictable, reproducible outcomes.

The real bet: finding the right abstraction for writers

The part of this I find most interesting is the abstraction underneath.

Git is the canonical example. Linus shipped it in 2005 and the mental model—commits, branches, diffs, merges—has barely changed in twenty years. Nearly every tool built since, from GitHub to Copilot to whatever agentic IDE ships next week, sits on top of it.

Laires, storyboard-loop, and storyboard-ide are the journey to find the right abstraction for writers and agents to work in unison. Maybe the narrative graph is it. Maybe the primitives are different. But some structured representation of story is the layer every future writing tool will sit on top of—and that’s the thing worth chasing.

"Technology was always the medium, not the point. The real work is finding the alpha in places where human context, pacing, and character still hold the line."

If you're interested in the code, or want to contribute to the creative tooling stack, check out the repositories: Laires, storyboard-loop, storyboard-ide, and vdd-loop.