In 2021, I started building a mobile coding IDE because every coding app I tried on my phone felt like a toy.
Most were either syntax-highlighted text editors or learning apps. Useful for education, but not something you could comfortably build projects with.
I thought it would take a few months.
It ended up taking four years, nearly 100,000 Android downloads, and a complete rebuild in Flutter before I finally launched on iPhone.
Today, the Android version of Code IDE is approaching 100,000 downloads, and I recently rebuilt the entire application in Flutter and launched on iPhone from the same codebase.
Looking back, a few things surprised me.
The Editor Was Harder Than the Compiler
Before I started, I assumed code execution would be the difficult part.
It wasn't.
The real challenge was making the editor feel right.
Things like:
- Auto-indent
- Bracket matching
- Cursor positioning
- Multi-line editing
- Scrolling performance
- Large file handling
Users will forgive a missing feature.
They won't forgive an editor that feels frustrating to use every day.
A lot of the development time went into small details that most users never consciously notice.
People Don't Use Software the Way You Expect
I had strong opinions about which features would become popular.
Many of those predictions were wrong.
Some features I expected to be niche became heavily used.
Some features I spent weeks building barely moved engagement metrics.
One lesson I've learned is that user requests are valuable, but usage data is even more valuable.
People often describe what they want differently from how they actually behave.
The AI Feature Users Love Most Isn't What I Expected
Recently I added an AI coding agent capable of:
- Planning projects
- Generating file structures
- Writing code
- Debugging issues
- Modifying existing projects
Initially, I assumed users would be most interested in generating code from prompts.
Instead, many users found AI-assisted debugging far more valuable.
Having an assistant inspect files, explain errors, identify bugs, and suggest fixes turned out to be more useful than simply generating code from scratch.
That reinforced another lesson:
The most impressive feature isn't always the most valuable one.
Mobile Coding Is More Controversial Than I Expected
Whenever I talk about coding on phones, reactions usually fall into two groups.
The first group says:
"Why would anyone do that when laptops exist?"
The second group says:
"I learned programming on a phone because that's what I had."
Both perspectives are valid.
I don't see a phone as a replacement for a desktop development environment.
But for learning, experimentation, coding during commutes, quick bug fixes, and small projects, I've found it surprisingly useful.
Some of the most interesting conversations I've had are with students and self-taught developers who started learning on mobile before eventually moving to a laptop.
Rebuilding Everything in Flutter Was Scary
The Android version started as a native application.
As the project grew, maintaining multiple platforms became increasingly difficult.
Eventually I decided to rebuild the application in Flutter.
The migration was larger than I expected.
The UI wasn't the difficult part.
The biggest challenges were platform-specific integrations:
- File management
- Document pickers
- Storage permissions
- Platform APIs
- Mobile-specific workflows
The payoff was being able to launch on iPhone while sharing most of the codebase.
Seeing the same project running on both Android and iOS made the effort worthwhile.
Distribution Is Harder Than Development
The biggest lesson from the last four years has nothing to do with code.
Building the product is only part of the challenge.
Getting people to discover it is a completely different skill.
Most growth didn't come from launch days.
It came from:
- Improving onboarding
- Listening to users
- Fixing bugs
- App Store Optimization
- Consistently shipping updates
There was no magic growth hack.
Just a lot of iteration.
Final Thoughts
If I were starting again today, I would spend less time guessing what users want and more time talking to them.
I'd also spend more time thinking about distribution much earlier.
Building software is hard.
Getting people to discover it can be even harder.
But four years later, seeing people learn programming and build projects with something that started as a side project has made the journey worth it.
I'd love to hear from other developers who have worked on long-term side projects.
What surprised you most after years of building the same product?
Try It Yourself
🎥 Demo Video
https://www.youtube.com/watch?v=BErHLTy4pvs
📱 iPhone
https://apps.apple.com/app/id6775024014
📱 Android
https://play.google.com/store/apps/details?id=codetoinvent.compiler_editor
