I Built a System to Write the Stories I Could Never Finish

For most of my career, I’ve been a systems builder.

I design processes. I think in constraints. I take problems apart and rebuild them into something that works.

Over time, that evolved.

As I moved into building business strategy, leading teams, and shaping go-to-market efforts, I became a storyteller in a different sense. Not fiction, but using narrative as a tool. Aligning teams. Framing markets. Explaining why something matters and where it’s going.

Marketing is storytelling.
Strategy is storytelling.
Building a company is storytelling.

I became good at that.

What I never developed was storytelling for its own sake.

The kind that stands on its own. The kind that doesn’t exist to sell, align, or execute something else.

And it wasn’t from a lack of ideas.

I’ve had more story ideas than I knew what to do with. They’ve lived in notebooks, half-finished Word documents, and in my head for years. The problem was never imagination.

The problem was execution.

The Real Constraint: Context and Continuity

When I sat down to write, it was just me and whatever I could hold in my head at that moment. My own context window.

I would make progress, then life would take over. Work. Family. Coaching. Training.

When I came back, the context was gone.

Not the idea, but the state of the idea. The rules I had set. The tone I was in. The direction I was heading. All the invisible structure that makes a story coherent.

That’s where it broke.

Not because I couldn’t write.

Because I couldn’t maintain continuity over time without a system.

The First Unlock: AI as a Thinking Partner

The shift didn’t happen all at once.

It started when I began using AI in my day-to-day work. Not for writing, but for thinking. Testing ideas. Stressing assumptions. Iterating on problems.

At some point, I realized I could do the same thing with story ideas.

A thought didn’t have to sit static anymore. It could be explored conversationally. Pushed. Refined. Broken apart and rebuilt in real time.

Some ideas died quickly. They didn’t go anywhere interesting.

Others expanded.

One of them became The Handshake Protocol.

That was the first unlock:
AI as a sparring partner for ideas.

The Second Unlock: Translation

I’ve spent decades working in technical systems.

When I explain something like a “handshake” in a system, I naturally think in layers, interfaces, and abstractions. That works in engineering. It doesn’t work for most readers.

Historically, this is where my progress slowed.

Not because the ideas weren’t clear to me, but because translating them into language that others could easily understand took time and effort I didn’t always have.

AI is unusually good at this.

Not at generating the idea, but at translating it and refining the language.

That was the second unlock:
AI as a finishing tool for clarity and language.

The Real Constraint: Access

At first glance, this looks like a story about AI.

It isn’t.

It’s a story about access.

If you want to produce a high-quality book through traditional means, you need:

• Time to iterate and rewrite
• Access to editors
• Feedback loops
• Continuity management across a long work

Most of those functions exist. They’re just not accessible to most people.

I didn’t lack ideas.
I lacked access to the system required to execute them.

So I built one.

From Documents to a System

My early attempts were fragmented.

I used ChatGPT to refine drafts. I stored chapters in Word. I tried to keep continuity in my head and through scattered notes.

The process broke down quickly.

The context window couldn’t hold the entire work. The timeline drifted. Rules I had established early were unintentionally violated later.

That’s when I approached the problem the way I approach any system.

I moved the work into a structured environment using a repository and an editor designed for managing complex projects.

Instead of expecting AI to remember everything, I created system files:

• rules
• canon
• characters
• timelines
• constraints

Now AI didn’t need to “know” the story.

It operated within the system of the story.

That eliminated the context window problem entirely.

At that point, it stopped being a writing experiment.

It became a system.

How the System Works

The process starts the same way I approach any problem:

What is the idea I want to explore?

From there:

1. Define the problem or lesson
2. Identify the mechanisms that would express it
3. Establish rules and constraints
4. Build the world, characters, and timeline
5. Stress test everything through conversation

This produces structured input, not prose.

The draft comes later.

When I write a chapter, I’m not starting from scratch. I’m operating inside a defined system. AI helps refine language, check continuity, and challenge inconsistencies, but I remain the source of direction and decisions.

Then we iterate.

And iterate again.

Until it’s good enough.

Not perfect. Good enough.

Because unlike traditional publishing, this doesn’t have to be final.

The Moment It Became Real

The proof wasn’t theoretical.

It happened sitting at a table with my four-year-old.

We talked about what a story could be. Who the characters were. Where it took place. What should happen.

Within hours, we had created The Green Tractor.

A complete children’s story, published and available for people to read.

AI didn’t create it.

A conversation did.

The system made it possible to take that conversation and turn it into something real, quickly enough that the energy of the idea wasn’t lost.

That’s what changed.

The Tension: Is This Still “Writing”?

A traditional author might look at this and say:

You didn’t agonize over every word.
You didn’t spend years refining the craft.
You’re shortcutting the process.

They’re not wrong about the difference.

They’re wrong about the conclusion.

We’ve seen this pattern before:

• printing presses
• typewriters
• word processors

Each one made creation more efficient.

Each one was initially seen as diminishing the craft.

This is the same shift.

The ideas are still mine. The direction is still mine. The decisions are still mine.

I’m just using better tools.

Living Stories

Traditional books are static.

Once published, they’re fixed in time.

Nexissary Books is built on a different assumption:

A story can be durable, but not static.

Readers can engage early. They can respond, challenge, and contribute signal. That input can shape future chapters or refine existing ones.

Not all feedback is equal. Not all feedback is used. The author still holds the line.

But the work is no longer created in isolation.

It becomes a system with interaction.

Over time, this can evolve further:

• stories that continue beyond the original author
• branching versions
• preserved canon with evolving interpretations

This is closer to software than traditional literature.

Versioned. Iterated. Maintained.

Risks and Failure Modes

This approach is not without risk.

If the system is poorly defined, everything becomes generic.

If the author doesn’t protect their voice, it gets diluted by AI or the crowd.

If feedback isn’t filtered properly, signal gets buried under noise.

And there is a real tension between:

• evolving a work
• and preserving something meaningful and complete

These are not solved problems.

They are managed constraints.

Why This Exists

I am not trying to replace traditional writing.

I am solving a different problem:

There are people with ideas worth exploring who will never produce them because the system required to do so is inaccessible.

Time. Cost. Structure. Process.

This removes those barriers.

It doesn’t make everyone a great writer.

It does make it possible for more people to actually tell their stories.

The Bet

Right now, I care more about readers than revenue.

I’m publishing openly. Iterating in public. Building Nexissary Books as both a platform and a process.

The bet is simple:

If the ideas are strong and the stories resonate, an audience will form.

And if the system works, it won’t just unlock my stories.

It will unlock others.