Before I started using agentic AI, building an app used to feel heavy.
Not just the coding part — the whole thing.
You sketch ideas, start building, get an MVP together, then build a website, then think about launch, then deployment, and only after all that do you really start finding out whether the idea was worth it. Depending on the idea, that could take 1 month, 3 months, sometimes 6.
Because of that, a lot of ideas just stayed ideas.
I came across the Tiingo API for stock and dividend data. The free tier was enough for my personal use, and I was already paying $9.99/month for a dividend tracker app. That was enough for me to think… okay, this one is worth building.
This time I used agentic AI — mainly Claude CLI, and sometimes CODEX.
Idea to MVP in a day. By day 2, 47 beta testers from Reddit. By day 4, a working website. Instead of spending weeks just trying to get version 1 off the ground, I was already thinking about the PROD-ready version.
The app is called Finance Forest: Portfolio.
So how do I do it?
The way I think about it: I play two roles depending on the phase. During planning, I am the architect. I have the vision, I make the decisions, I draw the boundaries. Claude is the advisor helping me think clearly. During implementation, I shift into supervisor mode. Claude does the building. I review, test, and decide when something is good enough to commit and move on. That shift in mindset is actually what makes this work.
The 8 Steps
1. Create a dummy project and open Claude CLI or CODEX in terminal
I start with a clean project and a very simple statement of the idea. I start with a clean project and one simple message.
For Finance Forest: Portfolio, that was: *“I want to build a SwiftUI iOS app that lets me track my dividend stock portfolio using the Tiingo API. End-of-day prices are fine. I want to see what I own, how much dividend income I am making, and what payments are coming up.”*
No architecture decisions. No feature list. Just the core idea in plain words.
2. Create a Documentation folder right away
Before any serious coding starts, I create a Documentation folder. This is where I keep product notes, MVP scope, feature ideas, API decisions, and implementation phases.
For Finance Forest: Portfolio, by the end of day 1 that folder had files like `MVP_SCOPE.md`, `API_DECISIONS.md`, and `IMPLEMENTATION_PHASES.md`. Small files, but having them there meant I never had to re-explain the context. Claude could reference them at any point.
3. Start in plan mode and discuss the idea properly — never start by coding
This is the biggest lesson for me. Never begin with “build the app.” Start with “help me think through the app.” This is where the real back-and-forth happens.
The prompt I used was roughly: *“Here is my idea. Before we write any code, help me figure out what actually needs to be in version 1 versus what can wait. I want the smallest version that would still be genuinely useful to me.”*
That single conversation saved me from building things I did not need yet. iCloud sync got pushed to after the MVP was working. Charts were phase 5, not phase 1. Without that planning conversation, I would have tried to build everything at once and probably abandoned it halfway through.
For Finance Forest: Portfolio, the discussion was around questions like:
- What should the onboarding look like if the user needs a Tiingo API key?
- Should the app focus on real-time prices? No, end-of-day was enough.
- What are the core views? Portfolio summary, dividend calendar, forecast, and charts.
- What makes this useful enough for someone to switch? Seeing dividend income clearly and simply.
There were also some technical decisions made during this discussion. SwiftData over Core Data because the app would be SwiftUI-native and I wanted the simpler syntax. CloudKit for sync because the data is personal and device-to-device sync is something users expect now. Tiingo’s end-of-day endpoint instead of real-time because real-time would have added complexity and cost for something that just did not matter for a dividend tracker.
4. Turn that plan into an implementation checklist with phases
After that, I asked Claude to convert the idea into build phases. That immediately makes the project feel real and manageable.
For Finance Forest: Portfolio, it looked like:
- Phase 1 — app structure and models (`Portfolio`, `Stock`, `DividendPayment`, `PricePoint`)
- Phase 2 — Tiingo API integration (end-of-day prices and dividend history)
- Phase 3 — portfolio and holdings screens
- Phase 4 — dividend calendar and forecast
- Phase 5 — charts, import/export, and polish
Phases 3 and 4 were where the actual app started to look real.
5. Start coding phase by phase
This part matters. I do not ask for everything at once. Breaking it up gives much better output and makes reviews much easier.
For Finance Forest: Portfolio, that meant starting with `TiingoService` and verifying it with a real ticker like AAPL. Then `PortfolioListView` showing holdings and total value. Then `DividendCalendarView` for upcoming payments per month. Then `IncomeForecastView` for the 12-month projection. Each was its own focused conversation with Claude. Short, specific, reviewable.
6. Test and commit after every phase
After each phase, I test and commit. It keeps progress clean and gives me safe checkpoints — if something breaks in the next phase, I can always go back instead of trying to untangle everything at once.
For Finance Forest: Portfolio, the commits mapped to: SwiftData models → Tiingo integration → portfolio list → dividend calendar → income forecast → iCloud sync → monetization. Each one a real checkpoint.
7. Once the app is working, use Claude to build the website
After the MVP was usable, I used the same process to build the website. What makes this easy is that Claude already has all the context from the documentation created in step 2 — the plan, feature list, positioning, and onboarding flow. So instead of starting from scratch, I just ask it to turn what already exists into a website.
For Finance Forest: Portfolio, that meant a site explaining what the app does, why it is useful for dividend investors, how to set up the Tiingo API key, and how to join testing. First version came together fast.
8. Use Claude for all the “words” work
This part is underrated.
For Finance Forest: Portfolio, Claude helped write the App Store listing, the onboarding screen explaining why you need a Tiingo API key and how to get one, the Reddit post that got me 47 beta testers in a day, and the website copy. All of it came together quickly because Claude already understood what the app does and who it is for.
That is the part that still blows my mind a little.
For Finance Forest: Portfolio, Claude was not just helping me write code. It helped me think through the product, break it into phases, build the MVP, turn existing context into a website, and help with the words needed to launch it.
Before, getting to that stage used to take months.
Now I can take an idea, turn it into something real in days, get it in front of actual users, learn from what they do, and then decide what deserves the deeper PROD effort.
That changes how I think about building entirely.
Crazy times 🙂