My wife started writing again after a long pause.
That was the real beginning of the project. Not a market map. Not a feature brainstorm. Just her sitting with old notes, half-scenes, names she still cared about, and that slightly painful feeling of wanting to write but not wanting to fight the setup first.
She did not ask for a platform. She did not ask for an AI co-author. She asked for something more modest and harder to build well: help.
What she wanted was an assistance-type tool beside the manuscript. Something that could help sort scenes, keep track of names, remember what had already happened, and maybe point out when a detail drifted. But it could not take over. She still wanted to write the sentences herself.
My first thought was embarrassing in the way many first engineering thoughts are embarrassing: with GPT, this should be easy.
I could already see the pieces. Local-first app. Manuscript in the middle. Story memory somewhere nearby. Notes, characters, scene plans, continuity checks. AI suggestions that did not touch the draft until approved. It sounded almost tidy when I said it in my head.
Then I started actually shaping it, and the tidy version fell apart.
The first versions kept making the same mistake. They made the assistant too present.
There was always a temptation to add a rail, a prompt box, a side panel, a new button, another mode. It all looked reasonable in isolation. It also made the app feel like the writer had acquired a second job: managing the helper.
That is not what she needed. She needed the manuscript to stay in front. The help had to live at the edge: a small proposal, a scene note, a continuity warning, a prepared plan she could ignore without guilt.
The second bad assumption was that the model would cover the boring parts.
For a quick demo, it sort of does. Paste a chapter into a model and ask for feedback. You will get something fluent. Sometimes it is useful. Sometimes it is the kind of useful that gets worse the moment you build a real product around it.
A writing app has to remember which text is draft, which note is canon, which suggestion was rejected, and which idea was just a throwaway. It has to avoid poisoning tomorrow’s context with today’s bad guess. It has to be private by default. And it has to be careful with voice, because when someone is returning to writing, voice is not decoration. It is the whole fragile thing.
Language made this less abstract.
English lets you cheat for a while. Spaces do more work than you notice. Names are easier to spot. Sentence boundaries are less mysterious.
Chinese text took away those cheats. Segmentation mattered. Common phrases could look like names. Context trimming behaved differently. IME input had its own little traps. The manuscript stopped being “text” as a generic blob and became what it always was: a working object with rules.
GPT was useful through all of this. Very useful. It could inspect the repo, wire the obvious pieces, write tests, find missing paths, and move faster than I would have moved alone.
But it did not make the product judgment go away. In some ways it made the judgment arrive sooner.
The hard questions were not “can we add a panel” or “can we call a model.” Of course we could. The hard questions were smaller and more annoying.
Should rejected text ever become memory? No.
Should the assistant rewrite the manuscript directly? No.
Should everything go to a provider because that is simpler? Also no.
Should the interface make the writer think about the assistant every five minutes? Definitely no.
Those answers sound obvious now. They were less obvious while building, because every wrong version still looked like software progress.
That is the part I keep coming back to. GPT made it easier to build. It did not make it easier to know what deserved to be built.
My wife’s request was still the best product spec: help me write again.
Not “write for me.” Not “give me a dashboard.” Not “turn my book into an AI workflow.”
Help me write again.
That is a much higher bar than a demo.