AI makes coding faster. It does not make projects predictable.
When I started building Memstory, I thought I had a reasonably good idea of what I was getting into.
The concept was simple enough: build a language-learning application around stories instead of isolated exercises. Let the learner encounter vocabulary in context, click unfamiliar words, return to them through memory drills, practise grammar and eventually move from recognition towards actual language production.
There would be a backend, a mobile application, a database, some learning logic and content.
Obviously, some of those things would be difficult.
What I completely failed to predict was which ones.
That has become one of the biggest lessons of the entire project. AI can make software development dramatically faster, but it accelerates different kinds of work at wildly different rates. As a result, the normal intuition you use to estimate a project starts to break down.
A technically complicated feature can suddenly take an afternoon.
Something that sounds like "add the vocabulary" can consume days.
And something as innocent as "the app should have enough stories to actually learn Russian" can quietly turn into a small publishing operation involving almost 200 texts, thousands of words, structured JSON, morphology, translations, database imports, validation and finally an audio production pipeline.
At some point I had to admit that this project had become slightly insane.
A language app needs a language
The first version of Memstory did not need much content.
To prove the concept, a handful of stories was enough. I could build the reader, make words clickable and demonstrate the basic learning loop.
But that only proves that the software works.
It does not prove that the learning experience works.
The whole idea of Memstory depends on repeated exposure. Words should appear naturally in different contexts. Sentence structures should become gradually more complicated. A beginner should be able to start with extremely simple Russian and eventually read longer stories without the transition feeling artificial.
That requires volume.
So I started writing.
The first texts were deliberately tiny. Then came dialogues. Everyday situations. Culture. History. Essays and reportage-style texts. Longer narratives. Eventually multi-part B1 stories where the language could become considerably more natural and the sentences much longer.
One story became ten. Ten became fifty.
Eventually the database was approaching 200 stories.
This is where a distinction that is easy to ignore when building prototypes became impossible to avoid:
A prototype needs content. A product needs a corpus.
And a corpus is not just a lot of text.
Every word became data
Memstory is not an ebook reader.
If a Russian word appears in a story, the application needs to understand what that word is.
The learner should be able to tap it and see useful information. The system needs to know the surface form appearing in the sentence, the underlying lemma and the relevant translation. Eventually the same vocabulary has to be usable elsewhere in the application.
That meant the stories could not simply be pasted into a text field.
They had to become structured language data.
I ended up building an import workflow around JSON. A story would provide the context, and the vocabulary appearing in it would be processed into structured import batches containing words, forms and translations.
For a noun, "knowing the word" does not mean storing one Russian string and one Finnish translation. Russian nouns have cases and numbers. Adjectives bring gender, number and case. Verbs bring person, tense, aspect and other forms.
And then there are all the perfectly normal irregularities that languages have spent centuries inventing specifically to ruin database schemas.
Suddenly a short story containing a few dozen useful new words could produce a surprisingly substantial JSON import.
The database started accumulating not merely vocabulary, but a morphological network behind the vocabulary.
That was exactly what I wanted.
It was also an enormous amount of work.
JSON hell
This was perhaps the clearest example of how badly I had estimated the project.
Generating structured JSON with AI sounds like almost the ideal use case for AI.
And in many ways it is.
Producing complete paradigms manually would have been absurd for a project like this. AI made it possible to generate hundreds and eventually thousands of structured entries at a scale I could realistically work with.
The problem is that "possible" and "automatic" are very different things.
A batch could look perfect and still contain a subtle error.
A Russian form could be wrong. A Finnish translation could describe the lemma correctly but be misleading for the particular inflected form. An irregular form could be regularised. ё could quietly turn into е. A noun paradigm could contain a plausible-looking form that simply did not exist. Two entries could accidentally describe the same thing differently.
And because the data was structured, syntax itself became another failure point.
One missing bracket and the import failed.
One malformed string and the import failed.
Wrong top-level structure and the import failed.
Then there were errors that were worse than failed imports: imports that succeeded.
A parser rejecting malformed JSON is annoying. Incorrect linguistic data being accepted into the database is much more dangerous because now the system confidently contains bad information.
So the workflow became:
Generate.
Inspect.
Import.
Find an error.
Fix it.
Import again.
Check the database.
Discover another problem.
Adjust the generation rules.
Generate the next batch.
Discover that the new rules solved one problem and introduced another.
Repeat.
For dozens and dozens of batches.
The strange economics of AI-generated work
This created a phenomenon I had not really appreciated before starting Memstory.
AI made the vocabulary project possible precisely because it reduced the cost of producing each individual batch.
But reducing the cost changed my ambition.
If creating vocabulary data manually had taken ten times longer, I would have designed a much smaller vocabulary system. Perhaps I would have stored only lemmas. Perhaps the prototype would have contained 500 carefully selected words. Perhaps I would have postponed morphology indefinitely.
Instead I could look at a story and think:
Why not import all of it?
Then I could look at the next story and think the same thing.
And the next one.
AI had reduced the marginal cost enough that the ridiculous option became feasible.
The problem was that a small amount of human verification multiplied by a very large amount of AI output still becomes a very large amount of work.
That equation is worth remembering.
If AI produces something in thirty seconds but checking it properly takes five minutes, generating 1,000 items has not saved you from a project. It has created an 83-hour quality-control job.
AI can remove the bottleneck from production and quietly move it somewhere else.
Then every story needed a voice
Once the stories and vocabulary were finally becoming substantial enough, the next obvious step was audio.
Memstory is supposed to teach language through exposure. Reading Russian without hearing Russian would leave a major part of that idea unfinished.
After testing the options, I chose ElevenLabs.
This was one of the more satisfying decisions in the project. The quality was good enough that the stories started to sound like listening material rather than text being mechanically converted into speech. With longer stories especially, voice, rhythm and pacing change the experience considerably.
For approximately five minutes, I could enjoy having solved the audio problem.
Then I remembered that I had almost 200 stories.
Choosing ElevenLabs was easy.
Actually producing the library was another production pipeline.
Generate the audio. Listen. Notice a pronunciation or pacing issue. Check the source text. Generate again if necessary. Name the file. Connect it to the correct story. Verify playback. Move to the next one.
Again and again.
The same pattern had returned.
"Add audio" sounded like a feature.
At this scale, it was operations.
The software was sometimes the easy part
This is probably the part of Memstory that has surprised me most.
I expected the software engineering to dominate the project.
There is plenty of it: Django and DRF on the backend, React Native and Expo on mobile, APIs, data modelling, offline behaviour, audio playback, interactive story text, vocabulary drills, phrase production and grammar exercises.
Some of those problems have been genuinely difficult.
But AI is extremely good at helping with many of them.
A component that I would once have expected to spend a weekend building can sometimes be working in an evening. Boilerplate almost disappears. Refactoring is faster. Debugging becomes conversational. I can explore an unfamiliar library without first spending hours building a complete mental model of its documentation.
That does not mean AI writes the application for me. Architecture still matters. Bad decisions still produce bad systems. Generated code still needs to be understood.
But it changes the speed dramatically.
What it does not change at the same rate is everything surrounding the code.
Content needs judgement.
Language needs judgement.
UX needs judgement.
A database containing thousands of generated linguistic facts needs verification.
Two hundred stories still need to be read.
Two hundred audio files still need to belong to the correct two hundred stories.
Suddenly the difficult part of a software project may not be software.
AI destroys your intuition about difficulty
This has become the larger lesson for me.
Before AI-assisted development, I had a reasonably intuitive way of looking at a project.
Some features looked technically difficult. Some looked straightforward. You could roughly estimate where the painful parts would be.
That intuition is much less reliable now.
Imagine two tasks.
The first requires building a reasonably complicated interface with state management, gestures and an API connection.
The second requires preparing 50 vocabulary entries.
The first sounds like software engineering.
The second sounds like data entry.
With AI assistance, the first might be surprisingly fast.
The second might explode into morphology, translation, validation, JSON schemas, import scripts, edge cases and hundreds of tiny linguistic decisions.
So the important question is no longer simply:
How difficult is this?
It is:
Which parts of this problem can AI actually accelerate, and where will the bottleneck move afterwards?
That second question is extremely difficult to answer before doing the work.
Faster tools create bigger projects
There is another uncomfortable consequence.
AI does not merely allow you to finish the same project faster.
It changes what you decide to build.
Without AI, I probably would not have attempted to create almost 200 pieces of Russian learning content, generate structured vocabulary around them, build morphological data, create multiple types of grammar and production exercises and then turn the whole library into listening material.
At least not as a solo side project.
It would have been obviously unreasonable.
With AI, each individual step looked reasonable.
That is the trap.
You do not decide one morning to undertake a ridiculous project.
You decide to do one more reasonable thing.
The reader works, so let's make the words interactive.
The words are interactive, so let's make the vocabulary reusable.
We have the vocabulary, so let's build memory drills.
The stories work, so let's add more levels.
We have levels, so let's add enough stories for actual progression.
We have the stories, so they should have audio.
We have all this structured language, so naturally we should build grammar exercises around it.
Every individual decision makes sense.
Then one day you look at the system and realise that your hobby project contains a mobile application, a backend, a CMS, a language corpus, a morphological database, multiple learning engines and nearly 200 narrated stories.
This was not the plan.
However: Now. A couple of months in, a couple of mental breakdowns later - I'm finished with the content stage and am ready to begin testing. My plan is to use it to learn Russian - and then eventually publish it in Apple Store and maybe Google Play.