← all writing

How I Built i-Rise: A Solo iOS App, Spec-First with AI

By Deepak Sisodiya

I shipped i-Rise — a daily affirmations app, now live on the App Store.

I built all of it myself. The research, the design, the architecture, the code, the release. No team, no co-founder, no handoffs.

But the part I actually want to write about isn't the app. It's how I built it — because the way I work now looks almost nothing like the way I worked for the last decade.

Why I built it

For most of my career I've been a frontend engineer. React, React Native, TypeScript — building interfaces inside teams, owning a slice of a larger system.

i-Rise was different. I wanted to own the whole thing, end to end, and find out what one engineer can really do now that AI sits in the loop.

I picked affirmations because it's a simple, honest product. Something calm and useful — a quiet space to reset your thinking, with no feed and no noise. The kind of thing I'd actually want on my own phone.

Simple to describe doesn't mean simple to build, though. A real app still needs local storage, subscriptions, notifications, analytics, crash reporting, and a release pipeline. That was the point. I wanted to ship something production-grade, not a weekend demo.

The real shift: I stopped leading with code

Here's the honest truth — the hard part of building i-Rise wasn't writing code. It was deciding what to build, and keeping the whole thing coherent as it grew.

So I stopped leading with code. I led with specs.

Every feature started as a written description — what it was, why it mattered, how it should behave — before a single line got written. The AI didn't get to guess. It got clear intent to execute against.

Garbage spec in, garbage code out. So I put the thinking up front.

To make that work across a months-long project, I used Cursor's Memory Bank — a structured set of living documents the AI reads before it touches anything: the product context, the system patterns, the technical decisions, the active task, and the running progress.

Instead of starting every session from a blank chat and re-explaining the architecture, the AI always had the project's memory in front of it. It stayed coherent across the entire codebase — not just the file that happened to be open.

A workflow with actual modes

What surprised me most was how structured the process became. Each feature moved through defined stages, not a vibe:

I did this 35+ times. Every feature: analyzed, planned, designed, validated, built, and then documented back into the memory bank.

The result is the opposite of how solo side-projects usually go. The codebase got more coherent as it grew, because every decision left a written trail the next decision could build on.

What I actually built

i-Rise ended up being a genuinely full product:

Under the hood

The stack was chosen to be boring in the best way — proven tools that let one person move fast without cutting corners:

A few decisions mattered more than the rest. Going offline-first with Realm meant the app feels instant and works on a plane. The seen/unseen algorithm was the difference between "a list of quotes" and something that feels alive. And wiring up CI/CD early meant shipping an update was a single command, not an afternoon — which, when you're solo, is the thing that keeps you shipping.

What it taught me

The biggest lesson is one I keep coming back to:

AI doesn't replace engineering judgment. It amplifies whatever discipline you already bring.

If you point it at a vague idea, you get a vague mess, faster. If you point it at a clear spec, inside a system that remembers your decisions, you get something you can actually stand behind.

The bottleneck moved. It used to be how fast I could type. Now it's how clearly I can think — about what's worth building, how it should behave, and how the pieces fit. Eleven years of frontend work didn't become less valuable. It became the thing that made the AI useful.

i-Rise is a small proof of where I'm heading: pairing real engineering rigor with AI-assisted, agentic development to take an idea from a spec all the way to the App Store — solo.

If you want to see it, i-Rise is live on the App Store, and there's a fuller breakdown on the project page.

This is the way I build now. And it's just the beginning.