SECTION_06

Breaking Complex Apps into Steps

When and how to split a big idea into phases. Build progressively without losing context or overloading the agents.

[When to Split]

If your app has more than 5 distinct features, or involves complex state across multiple user types — split it into phases. Phase 1 should be the smallest thing you can demo.

[HOW THE COMPOSER WORKS]

Caffeine V3's Composer AI runs multiple build agents in parallel — design, backend, and frontend specialists working simultaneously on different phases of your app. When you break your build into steps, you're aligning with how the Composer thinks: each step becomes a clean, isolated task that the system can execute with precision.

> Why Phasing Matters

Trying to build everything at once has two problems: agents lose track of scope, and you can't validate the core before adding complexity. Phasing gives you a working foundation to build on — and early wins that motivate the next phase.

The other benefit: if Phase 1 reveals that you want a different architecture, you haven't sunk credits into features built on the wrong foundation.

> The Phase 1 Prompt

Scope Phase 1 explicitly

We're building this in phases. Phase 1 only:

- [Core feature 1]
- [Core feature 2]
- [Core feature 3]

Do NOT add [feature X], [feature Y], or [feature Z] — those are Phase 2.
Build the architecture to support future phases, but don't implement them now.

Confirm you understand the Phase 1 scope before starting.

[Ask for Confirmation]

Ending with "Confirm you understand the scope before starting" is a simple trick that prevents silent scope creep. The agent will summarize what it's building — and if it misunderstood, you catch it before any code is written.

> Transitioning to Phase 2

Start Phase 2

Phase 1 is complete. Now add Phase 2 features:

- [New feature 1]
- [New feature 2]

Build on top of the existing Phase 1 architecture. Do not restructure what already works unless a specific change is required for Phase 2 to function.

> Example: A Real Phase Split

🏁 Phase 1: Core product

User authentication with Internet Identity
Create and view records
Basic CRUD operations

🚀 Phase 2: Social features

Share records with other users
Comments and reactions
Public profile pages

💎 Phase 3: Monetization

Premium tiers with token payments
Creator earnings dashboard
ICRC-1 ledger integration

> THE NATIONOS MODEL — COMPLEXITY TAMED

Real-World Case Study · Built on ICP with Caffeine

NationOS is one of the most ambitious apps ever deployed on ICP with Caffeine — a fully on-chain nation-state complete with governance, dual token economics, voting chambers, an AI-powered court, and a managed treasury. It was built by @ICPvibecoder one layer at a time. No single prompt tried to do it all.

Build Sequence

Constitution Layer

Define the fundamental rules of governance first — the bedrock everything else inherits.

Dual Token System

Governance token + utility token, each with distinct supply rules and transfer logic.

Two Voting Chambers

Upper and lower house with different quorum thresholds — built and tested independently.

AI Court

Dispute resolution via on-chain AI inference, layered on top of the governance foundation.

Treasury Management

Multi-sig spending proposals and fund allocation — the final financial layer.

Key Lesson

Each of these layers was a separate prompt session. The previous layer was audited and stable before the next one began. This is why NationOS works — not because the prompt was clever, but because the build was disciplined.

"Build the skeleton first. Each session adds one organ — never the whole body at once."
— NationOS build philosophy · @ICPvibecoder

// Phase Planning Checklist

Phase 1 = smallest working demo of core value
Explicitly exclude Phase 2+ features from Phase 1 prompt
Ask for scope confirmation before building starts
Audit Phase 1 before starting Phase 2
Each phase builds on the previous — don't restructure what works