Since launch: I shipped 12 updates, ending in 2.0 on September 30, 2026: a full redesign on my own design system, a new genre, and a way to start a story from one sentence. Along the way I stopped asking whether a feature worked and started checking whether it ever reached the reader. Sometimes it didn't.
- Found a broken link in the story's memory and fixed it. Open debts reached the writer in 0 of 74 passages before, 57 of 74 after.
- Cut the wait to start a story from 15.9 to 10.7 seconds, and designed what the reader sees during it.
- Designed Silid, Qento's design system, and refined it over 30 to 40 rounds in Claude Design.
1 - The Design Problem
Most AI story apps fail at the second paragraph. The first one is novel. The second is where you realize the AI is writing at you, not with you.
The question was never "how do I generate good AI prose." It was: how do I design an experience where the reader never feels the AI?
I looked at the field and found a gap. Nobody had claimed personalized literary fiction for general readers. There were games, and there were writing tools, but no living book that grows with you.
The reframe. I started with "AI co-writing for people with story ideas." That was wrong. Qento isn't a tool for people who want to write. It's for people who want to read something made for them. That one change rewrote the onboarding, the interaction model, the UI language and the App Store copy.
Four principles came out of it:
Reader first.
Every friction point is judged from the reader's seat, not the engineer's or my own ego.
Restraint over richness.
The interface disappears into the story.
Psychology over archetype.
Picking a character elsewhere is picking a costume. In Qento you pick a wound.
Earned complexity.
The system can be as deep as it needs to be, as long as the reader never sees it.
An early prototype in Figma Make, wired to the Claude API, had testers asking where they could download it. That was enough to commit.
2 - Learning to Measure It
In August I faced the question every AI builder eventually hears: did I overengineer this? If a chat assistant can write a story, what's all this machinery for?
I didn't want to answer that with an opinion, so I tested it. Behind the prose, Qento keeps track of things a novel has to remember: who's alive, where everyone is, and who owes what to whom. I wrote down what a pass would look like before I ran anything, then ran the same stories with and without each part of that memory.
What I found. The system wasn't too big. One part of it was disconnected. Qento was noticing every promise and debt in the story and saving it correctly. Then it never handed that record to the part that writes the next passage.
You could see it in the stories. In one test, the protagonist asks, "Tell me what I still owe, and to whom." The saved record said: two shillings, lent by Alys, due back by Candlemas. The story didn't know that. It answered with something else entirely, or got the debt backwards.
After I connected it, a protagonist in another test story, asked the same kind of question, answers:
"Miller's owed a pin by Sunday. You're owed the iron work. I'm owed nothing."
The last line matters because it's right about an absence. Nobody owed the protagonist anything, and the story said so instead of making something up.
- Passages where the open debts reached the writer: 0 of 74 before, 57 of 74 after.
- Times the protagonist recited their debts correctly: 0 of 6 before, 5 of 6 after. A small sample: six planted questions.
The fix made each passage about 0.2% cheaper, not more expensive, and nothing was cut.
What changed in how I work. I used to ask whether a feature worked. Now I ask whether its output ever reaches the reader, and I check by following one fact from where it's created to the sentence on the page. It wasn't the first time I'd hit this. Right after launch, the soul system tracked how each protagonist changed, and I'd built a card to show it, but the card appeared nowhere in the app. Now a Soul Journey card rises over the last page when a reader finishes. Both were the same bug: good work stopping one step short of the reader. 2.0 was built with that check, and the pass bar written down before the work started.
3 - How I Build
Claude Code writes the code. My job is everything around it: the plan, the bar, and the call. Every major system starts as a written plan in the repo that says what it's trying to prove, what's out of scope, and how I'll know it worked. Then I run the work like a small team. One Claude session builds. A separate session reviews each piece on its own branch and says whether it's ready. A third pressure-tests the plan. I make every build, cut and spend decision, and only I can ship.
The lesson that surprised me: written rules weren't enough. I banned feature flags in the project's instructions, and sessions added them back twice in two days. So the rule became a check that runs before any code is written, and shipping or spending money became things the tools refuse without my sign-off.
It's the same lesson as a design system: guidelines drift, enforced rules hold.
I wrote this up as field notes for designers, and taught it to Workday's design team.
4 - The Soul System
Every protagonist in Qento starts from one of eight psychologies, and each one is built on a wound: the thing that broke them, the armor they built around it, and the drive that keeps them moving.
Most interactive fiction treats character choice as a costume. A class, a name, a look. Every compelling protagonist in literary fiction is defined by what broke them, not by their strength.
The soul shapes the inner voice, the texture of the prose and the emotional register. It also moves. As the reader makes choices, the armor softens or hardens, and the wound surfaces or heals.
5 - Designing the Reading Loop
The whole product is one loop: read, choose, the story continues, read again. Every other screen exists to support one turn of it, so I designed from the loop outward.
Choices should feel like instincts. Most turns, the reader taps one of a few short options without stopping to deliberate. When they want something the options don't cover, they can write their own action. The default keeps the reading pace; the escape hatch keeps the reader in charge.
The story arrives as it's written. Text streams in live, so it feels like a story being written for you right now, not pulled from a database. Readers start reading before the passage finishes. The paragraph travels first and the story's record follows it, so if the record breaks, the reader still gets the paragraph. Before that change, a long test story lost 5 of its 293 paragraphs.
Two ways in. The original setup wizard asks four questions: genre, protagonist, soul and world. It's thoughtful, and it's slow for someone who already has an idea. In 2.0 a reader can type one sentence instead. Qento reads it, works out the genre, the protagonist and their soul, and shows that read back as an identity card the reader can correct before the story starts.
The hard part of that design was the wait. Behind one sentence are several model calls in a row. On my phone, the time from tapping start to the story being ready went from 15.9 seconds to 10.7 seconds. I didn't change a prompt or a model to get there. I moved work the reader didn't need yet off the path they were waiting on, and used the remaining wait to show them something true: their identity card, held on screen while they're still reading or editing it.
6 - What I Cut, and Where I Moved the Line
My filter for every feature: does this serve the reading, or does it serve my urge to show off what I can build? Most of what I cut before launch is still cut. A few lines moved as the product took shape, and I'd rather show those than pretend the first list was perfect.
Branching story tree: still cut.
A map of paths breaks the feeling of reading a novel.
Stats and character sheets: stats still cut, character cards added.
A card shows what's passed between you and a character, and what you've learned about them. No numbers.
Social feed and co-writing: still cut, saving a passage added.
Readers can save a story's closing line as an image, the way you'd save a passage from a book you love. No feed.
AI confidence scores and model toggles: still cut.
They break immersion.
Voice narration: still cut.
Listening isn't reading. Genre music plays underneath; nobody reads to you.
Talking to your protagonist: built, after launch.
It was on the roadmap at launch and shipped days later as Diwa.
Diwa is where I had to defend the line. It's a conversation with your protagonist's inner voice. A mockup drew it the obvious way, as a chat: bubbles, an avatar. I rejected it. The app is a book, so Diwa reads like a screenplay: the protagonist's actions in small caps, their words in the book's serif, and the reader's own words in gold, right-aligned. No bubbles, no avatar.
7 - Version 2.0
2.0 is the biggest release since launch, and most of it is visible the moment you open the app.
A design system for a room you read in. For 2.0 I gave Qento a design system: Silid (Tagalog for "room"). It started as my own designs. I then took them into Claude Design, Anthropic's design tool, and pushed them further over 30 to 40 rounds of iteration, one part of the app at a time. The idea: the story is the light source, and everything else floats and steps back. Twelve rules hold it together. Three of them do most of the work:
- One gold action per screen. Gold is spent on one thing only: the act of writing. Send, Begin, Keep reading. If a screen seems to need two, one of them isn't primary.
- Gradient means touchable. Anything tappable that isn't the main action has a gradient. Anything informational doesn't.
- Silence while reading. Menus, cards and settings open as drawers over the blurred page, so the story is always behind you, never replaced.
The type follows the same split: Literata (a book serif) for anything the story says, Inter for labels.
The real phone was the final word, not the board. Wherever a board and the running app disagreed, I made the call and wrote down why. The app keeps its own icons, because a glyph in a mock is an approximation. The soul picker's page dots moved above the carousel, because on a real phone the board's placement needed a scroll to find. A blinking cursor drawn in the mocks never shipped, because streaming text stays exactly as built.
Accessibility is in the rules, not a final pass. Reduce Motion turns movement into short fades instead of removing it, so nothing disappears for anyone. The three kinds of underline in the prose (a person, an invented word, a recurring motif) differ in line style as well as color, so none of them depends on seeing color. With VoiceOver, each paragraph announces its marked words without breaking up continuous reading. In 2.0, the reading screens follow the reader's text size, and every lineage card is tested so its text stays readable over the art.
A mark with roots. The new icon is built from Baybayin, the pre-colonial Filipino script: ᜃᜓ, "ku," the first syllable of kuwento, the Tagalog word for story. The system names inside Qento are Tagalog too. It's a Filipino-made app and I wanted it to look like one.
A new genre: Horror. Horror needed its own rules. In an adventure, tension builds through events. In horror, it builds through what's taken away. It ships with five kinds of horror, each with its own way of building dread, six ready-made story openings and its own score.
67 illustrated lineage cards. In 2.0, a character's heritage (a Half-Elf, a Halfling, or one of Qento's own lineages like the Oathmarked) has an illustrated card. The art sits behind the text as a faint texture, never as a picture.
Fin. - Where It Stands, and What's Next
Readers. 508 people had tried Qento as of September 30, 2026, with almost no marketing: an App Store listing and a few search ads. It's rated 4.9 from 8 ratings. Early on I moved Qento from the Games category to Books, because far more people who finished setup went on to read their first chapter there. That settled the positioning question: Qento is a book, not a game.
What I'm watching in 2.0. It shipped on September 30, so it's too early to say whether it worked. I'm holding it to the same check as everything else: does it reach the reader? For Quick Start, that means comparing how many readers who start from one sentence go on to make their first choice, against readers who use the full setup.
The problem I haven't solved: the opening, and the craft that has to follow it. Most of what makes a Qento story feel alive pays off over time. Characters with their own agendas need time to act, debts need time to come due, and the protagonist needs time to change. None of that has happened yet in a story's opening, and the opening is where readers decide to stay. My funnel data puts the biggest drop between finishing setup and making the first choice. But a beautiful first chapter alone wouldn't fix it. If chapter two falls off, I've only moved the cliff.
1. The opening, and the craft behind every chapter.
The first scene has to hook on its own, built from what the reader gave me, before any of the slow-building systems have paid off. Then every chapter after it has to hold that same bar, so a strong start isn't a cliff.
2. A story that remembers.
In long test stories, Qento still makes mistakes a reader would catch: a character who died earlier shows up acting again in chapters seven and eight. I now have a check that reads every chapter against what the story has already established. Next is driving those errors toward zero across a full 25-chapter arc.
3. Community, still last.
Publishing and sharing stories is designed but not built. It stays last on purpose: the stories need to be extraordinary first. Community amplifies a good product. It can't stand in for one.
The short version. At launch, I thought the hard part was building it. Five months in, the hard part is knowing whether what I built actually reaches the reader, and that's the part I've gotten better at.
