Five Days, 700 Tokens, and a Lesson in Planning
I didn't build NovelBridge because I thought it would become a great product.
I built it because I wanted an excuse to learn.
The project started from the Kiro University Challenge. Unfortunately, my country was not part of the official program, so I couldn't really participate the intended way. The challenge encouraged participants to build custom agents and MCP integrations, but I decided to do something different.
Instead of completing challenge deliverables, I wanted to see how far I could push Kiro while building something I would genuinely use.
That decision eventually became NovelBridge.
The problem was personal
I've been reading Chinese web novels and Japanese light novels for years.
The problem starts when the official translation gets dropped.
You can paste a chapter into an LLM and get a translation, but after enough chapters strange things begin happening:
- Character names change.
- Terminology drifts.
- Writing style becomes inconsistent.
- Details get lost between chapters.
Solutions already existed.
Some websites let you paste a chapter URL and automatically translate pages one after another. Many even have a convenient next button that continues the story.
The problem was usually cost.
Most limited free users to roughly ten chapters per month before requiring payment.
I originally set out to make a very small alternative for my own use.
I wasn't thinking about differentiation.
I wasn't thinking about competitors.
I wasn't thinking about product-market fit.
I was thinking:
"Can I build something that helps me keep reading?"
Day 1: The dangerous excitement phase
Day one was probably the most fun.
Everything felt like progress.
Every generated page felt like a milestone.
Every successful feature made me wonder:
"What else can this thing do?"
Kiro surprised me immediately.
I knew modern coding agents could generate code.
Actually watching an agent:
- research a topic,
- produce a plan,
- implement code,
- and test the result
felt very different from reading about it.
For projects like this, AI was genuinely faster than I was.
If I had started the project manually, I probably would have spent one or two weeks just deciding whether the idea was worth pursuing.
Instead, I had a working proof of concept almost immediately.
At the time I thought speed was the biggest advantage.
Later I realized it can also become the biggest trap.
Day 2: Planning debt arrives
The second day was where reality started catching up.
I had let the agent make too many decisions on its own.
Whenever a task finished, I usually skimmed the summary and moved on.
The problem was that the agent had been making assumptions.
Reasonable assumptions.
But assumptions nonetheless.
I hadn't clearly defined:
- the final product,
- the architecture,
- the important features,
- or even what success looked like.
Without a defined destination, every feature seemed equally valuable.
This was also the day I started looking at competitors.
That was uncomfortable.
I discovered products like OpenNovel and OmniTranslate that already solved large parts of the problem.
There were open-source projects capable of translating entire EPUB books with almost no effort.
My first reaction was:
"There's no way I can compete with this."
That realization forced me to think about what was actually unique.
The answer wasn't features.
The answer was locality.
Most products either used hosted models or required subscriptions.
NovelBridge could become:
- local-first,
- bring-your-own-model,
- bring-your-own-token.
That became the project's identity.
Day 3: The token budget collapses
I originally gave myself a budget.
I had received approximately one thousand Kiro tokens from an event and decided the project should stay within one hundred.
That estimate aged poorly.
By the third day I had consumed most of the budget.
The project was incomplete.
One of the most important features, browser-resident storage, wasn't even implemented yet.
At that point I did something surprisingly productive.
I stopped generating.
Instead, I started reading.
Because the project was intentionally small, I could still understand the entire codebase.
I spent time tracing the flow of the application, understanding architectural decisions, and identifying where changes should happen.
This ended up teaching me more than the generated code itself.
I realized that AI can create a foundation quickly, but if I don't understand that foundation, I become dependent on the next prompt.
Understanding the system was ultimately what allowed me to continue after the token budget became a constraint.
Day 4: Building with understanding
Day four looked very different from day one.
The novelty had worn off.
The excitement had been replaced by deliberate engineering work.
Instead of asking AI to solve entire problems, I began implementing features piece by piece.
This was when several important improvements happened:
- local-first storage,
- architecture cleanup,
- UI improvements,
- feature redesigns,
- simplification of earlier decisions.
Ironically, some of the best improvements happened after I stopped relying on autopilot.
The codebase had become useful because I understood it.
The AI was no longer the driver.
It had become a collaborator.
Day 5: AWS humbles me
The final challenge was deployment.
This was my first serious AWS deployment.
The application itself was functioning.
The infrastructure was not.
I spent a significant amount of time learning how the various AWS services fit together and troubleshooting networking issues.
Fortunately, earlier networking knowledge from CCNA studies helped.
Concepts like:
- inbound rules,
- outbound rules,
- traffic flow,
- service boundaries
were already familiar.
Deployment still took effort, but it felt manageable instead of overwhelming.
When the application finally went live, the accomplishment wasn't that it worked.
The accomplishment was that other people could actually use it.
That changed how I thought about the project.
The biggest lesson
I expected to learn AI tooling.
Instead, I relearned planning.
The most important realization wasn't technical.
It was this:
AI can generate code, but it cannot make your decisions for you.
When I had no plan, progress felt fast but expensive.
When I finally understood the architecture and had a clear direction, progress became slower but significantly more effective.
Looking back, I think the project followed a simple rule:
- The first 20% of effort was coding.
- The remaining 80% was making decisions.
The better those decisions became, the easier implementation became.
Would I do it the same way again?
Surprisingly, yes.
If I had started by researching every competitor, analyzing every market opportunity, and planning every feature, I probably never would have built NovelBridge.
The lack of planning created problems.
It also created momentum.
What I would change isn't the decision to start.
I would simply introduce structure earlier.
Because once the project grew beyond a prototype, planning stopped being optional.
Final thoughts
NovelBridge taught me something unexpected.
AI made starting easier than ever.
But finishing still required engineering.
It required:
- understanding the code,
- making architectural decisions,
- choosing product direction,
- and accepting responsibility for the tradeoffs.
Those are things no model can do for you.
At least not yet.
The biggest benefit of AI wasn't that it built the project for me.
The biggest benefit was that it lowered the cost of starting something I otherwise would never have attempted.