Skip to main content

Loading…

Skip to main content
HomeProjectsPostsContact
Justin Tsugranes LogoJustin Tsugranes Logo

Justin Tsugranes

HomeProjectsPostsContact

Stay in the loop

Occasional notes on what I'm building, lessons earned, and the studio behind it.

By subscribing, you agree to receive No spam. Unsubscribe in one click anytime. from Justin Tsugranes. No spam. Unsubscribe anytime. Privacy Policy

© 2026 Total Ventures LLC. All rights reserved.

Privacy PolicyTerms of ServiceCookie Policy
Building an AI Story App: Architecture and Lessons from Inky | Justin Tsugranes | Justin Tsugranes
Xinf
Building an AI Story App: Architecture and Lessons from Inky
←Posts

Building & Operating

Building an AI Story App: Architecture and Lessons from Inky

A technical deep dive into building an AI story app. Learn the architecture, agentic engineering patterns, and hard lessons from shipping Inky in a multi-product studio.

Justin Tsugranes·May 22, 2026·4 min read
On this page
  1. The Architecture: Beyond the Single Prompt
  2. Agentic Engineering in the Studio
  3. The Stack: Choosing Durability Over Hype
  4. What I Learned the Hard Way
  5. 1. The "As an AI" Problem
  6. 2. Cost Control
  7. 3. The Feedback Loop
  8. Working in Public

I am shipping today. Inky, the latest product from my studio, is live.

Most people think building an ai story app is a matter of writing a clever prompt and wrapping it in a UI. They are wrong. If you want to generate a coherent 2,000-word narrative that maintains character consistency, plot tension, and stylistic integrity, you aren't looking for a prompt—you are looking for a system.

Inky is that system. It is an AI-native storytelling engine built to handle the complexity of long-form creative work. I built it using AI as the team, architecting the logic while agentic engineering handled the heavy lifting of the implementation.

Here is how the system works and what I learned the hard way while building it.

The Architecture: Beyond the Single Prompt

When you are building an ai story app, the first wall you hit is the context window. Even with 128k or 200k tokens, the model's attention drifts. If you ask a single LLM to "write a 10-chapter mystery novel," the middle will sag, the ending will be rushed, and the protagonist’s eye color will likely change by chapter four.

I architected Inky as a multi-stage pipeline. Instead of one prompt, it uses a series of specialized agents coordinated by a central controller.

  1. The Architect: This agent takes the initial user seed and builds a world bible. It defines characters, settings, and the overarching plot arc.
  1. The Outliner: It breaks the arc into granular beats. Not just chapters, but the specific emotional and narrative shifts required in every scene.
  1. The Draftsman: This agent writes the prose, one beat at a time, while constantly referencing the world bible to ensure consistency.
  1. The Editor: A final pass to check for hallucinations, repetitive phrasing, and pacing issues.

By decoupling the planning from the execution, the system produces work that feels intentional rather than stochastic.

Agentic Engineering in the Studio

I don't run a team of developers. I run a studio where AI is the operating layer. For Inky, this meant using agentic engineering to build the very tools that build the stories.

I used VERA, my custom agent orchestration layer, to manage the state between these different stages. The challenge in building an ai story app isn't the generation; it's the state management. You have to pass the right amount of context from the world bible to the Draftsman without overwhelming it with irrelevant data.

I learned the hard way that more context isn't always better. If you give the model the entire history of the world for a scene where two people are just buying coffee, the prose becomes bloated. I had to build a retrieval system that only injects the specific character traits and plot points relevant to the current scene.

Keep reading

Related posts

All posts→
Building an AI Story App: Lessons from Shipping Inky
Jun 7, 2026

Building an AI Story App: Lessons from Shipping Inky

I am building Inky, an AI storytelling app. Here is the architecture, the failures, and the systems required to ship a generative product that actually works.

aiarchitectureinkyshipping

The Stack: Choosing Durability Over Hype

I am an architect of systems, not an author of one stack. For Inky, the choices were driven by the need for a solo operator to maintain the product without burning out.

  • Monorepo: Everything lives in one place. It allows me to share types between the agent logic and the frontend, reducing the friction of shipping updates.
  • Claude API: For the creative heavy lifting, I found Sonnet 3.5 to be the most reliable for narrative voice and following complex structural instructions.
  • Firebase: It handles the real-time streaming of story beats. Users see the story being built in real-time, which turns the latency of LLMs into a feature rather than a bug.
  • Tailwind & Shadcn: Standard, boring, and fast. I don't spend time on custom CSS when I can use proven components.

What I Learned the Hard Way

Shipping is the only way to find the real bugs. Here are three things I had to fix after the first internal build:

1. The "As an AI" Problem

Models love to moralize or use flowery, repetitive language (e.g., "shimmering," "tapestry," "testament to"). I had to build a specific "Prose Filter" agent whose only job is to strip out LLM-isms and force the output into a more human, direct register.

2. Cost Control

Running four or five agents for a single story gets expensive quickly. I had to optimize the prompts to use smaller models (like Haiku or GPT-4o-mini) for the outlining and editing phases, saving the high-reasoning models for the actual prose generation.

3. The Feedback Loop

Users don't just want to click a button and wait. They want to intervene. I had to re-architect the system to allow for "Human-in-the-loop" checkpoints. Now, the Architect presents the world bible to the user for approval before the Draftsman ever writes a word. This increased user retention by 40% because they felt ownership over the output.

Working in Public

Building an ai story app is a lesson in managing complexity. It’s about creating a container where the AI can be creative without breaking the structural rules of storytelling.

Inky isn't a finished project; it's a living system. I'm constantly tweaking the weights of the Editor agent and refining how the world bible is indexed. This is the reality of being a builder in the age of agentic engineering. You don't finish a product; you tune a system.

If you are interested in the specific prompt chains or the VERA orchestration logic I used for this, I'm happy to talk.

Full implementation details are available in The Builder's Playbook — totalventures.io/resources/builders-playbook

Recommended$79

The Builder’s Playbook

How I run a multi-brand studio with AI agents — the systems, not the hype.

  • •The agent-augmented operating model
  • •Real workflows you can copy
  • •From idea to shipped, repeatably
Get the playbook →
If this resonated

The studio is where the rest of it lives.

Total Ventures is the umbrella — the products, the resources, the strategy session.

totalventures.io
  • Resources

    Launch Checklist + the Builder’s Playbook bundle.

  • Strategy session

    A focused hour on your repo, stack, and monetization.

  • The brands

    The portfolio of products I’m building, end to end.

Studio Notes

How I’m building the studio.

The operator’s log — systems, decisions, and what’s working.

JT

Written by

Justin Tsugranes

Founder, Total Ventures

Solo-founder building a multi-brand product studio with AI agents. Writing about building, operating, and shipping.

ShareXLinkedInFacebook
#ai#engineering#shipping#architecture

On this page

  1. The Architecture: Beyond the Single Prompt
  2. Agentic Engineering in the Studio
  3. The Stack: Choosing Durability Over Hype
  4. What I Learned the Hard Way
  5. 1. The "As an AI" Problem
  6. 2. Cost Control
  7. 3. The Feedback Loop
  8. Working in Public
Building an AI Story App: Lessons from the Studio Floor
Jun 6, 2026

Building an AI Story App: Lessons from the Studio Floor

Inside the architecture of Inky. A look at agentic engineering, narrative coherence, and the lessons learned the hard way while building an ai story app.

aiarchitectureagentic-engineeringinky
EditorialB
Jun 5, 2026

Building an AI Story App: Systems Over Hype

A look inside the architecture of Inky, an AI storytelling app. No buzzwords, just the systems and agentic engineering required to ship a durable product.

aiengineeringsystems-architectureinky