User Dashboard in 30 Minutes
28 files created and edited, 1,831 lines of production code — blueprint planned and implemented in 30 minutes on Opus 4.6 with 98.5% cache hit rate.
Dashboard Implementation Blueprint — Cost Analysis
A full user dashboard system — route group, sidebar shell, settings with OAuth account linking, installation wizard, and 12 CTA replacements — blueprint planned and implemented in 30 minutes on Opus 4.6.
What Happened
A developer needed to evolve composure-pro.com from a marketing site into a product platform. Users need accounts before installing, so "Install Free" buttons needed to become "Get Started", and authenticated users needed a real dashboard experience after signup.
The Composure blueprint skill planned the entire scope, then executed it — 28 files created and edited, 1,831 lines of production code, in 30.7 minutes across two phases.
| Blueprint | Implementation | Combined | |
|---|---|---|---|
| Duration | 21.1 min | 9.6 min | 30.7 min |
| Cost | $7.08 | $9.58 | $16.66 |
| Cache hit rate | 96.5% | 99.4% | 98.5% |
Phase 1: Blueprint (21 minutes)
The blueprint skill scanned the code graph (891 nodes, 2,178 edges across 154 files), read 35 source files, ran 18 graph queries for impact analysis, asked 3 interactive scope questions, and produced a 200+ line blueprint with per-file implementation specs.
| Metric | Value |
|---|---|
| Duration | 21.1 minutes |
| API turns | 129 |
| Files read into context | 35 |
| Graph queries (MCP) | 18 (semantic search, query, impact radius, stats, large functions) |
| User questions | 3 (user routing, CTA strategy, build scope) |
| Blueprint output | 200+ line document with per-file specs |
| Agent spawns for code | 0 |
| Phase cost | $7.08 |
Sub-Agent: Background Research
During the blueprint phase, one sub-agent was spawned to run in the background on Haiku 4.5 while the main Opus session continued planning.
| Task | Research competitor dashboards to inform the blueprint's dashboard design decisions |
| Model | Haiku 4.5 (not Opus — research doesn't need deep reasoning) |
| Duration | 24.6 seconds |
| Tokens | 27,404 |
| Tool calls | 9 |
| Estimated cost | ~$0.16 |
When are sub-agents used? Sub-agents are reserved for parallel work that won't be referenced line-by-line in the main context — research, document generation, or summaries. They run on cheaper models (Haiku 4.5 at $1/MTok vs Opus 4.6 at $5/MTok) and execute in the background so the main session doesn't wait.
Sub-agents are never used for code implementation. Code work stays in the main context so every file read gets cached and every subsequent turn reuses that cache at a 90% discount. An agent spawn starts a fresh context that cannot share the parent's cache — breaking the compound savings that make long sessions efficient.
Phase 2: Implementation (9.6 minutes)
The blueprint's checklist drove implementation. Nine tasks were created with dependency ordering, then executed sequentially. Zero agents — all file reads and writes ran in the main Opus 4.6 context, riding the cache built during the blueprint phase.
| Metric | Value |
|---|---|
| Duration | 9.6 minutes |
| API turns | 124 |
| Files created | 16 |
| Files edited | 12 |
| Lines written | 1,332 (1,186 via Write + 146 via Edit) |
| TypeScript errors | 0 (clean on first tsc --noEmit) |
| Agent spawns for code | 0 |
| Phase cost | $9.58 |
What Was Built
| Component | Files | Details |
|---|---|---|
| CTA replacements | 8 edits | "Install Free" → "Get Started" across hero, getting-started, features, plugins, creators, plugin-page-layout, skill-page-layout + 5 data objects in feature-data.ts |
| Mobile nav rewire | 2 edits | Imported HeaderAuthButtons with new layout prop (vertical for mobile, horizontal for desktop) |
(external) route group | 6 new | Auth guard layout, user/[id_prefix] layout with dashboard shell sidebar, dashboard/settings/install page shells, /user account resolver redirect |
| Dashboard components | 4 new | dashboard-container (greeting + card grid), quick-actions-card, subscription-card, installation-card |
| Settings components | 4 new | settings-container (tabs), profile-section, connections-section (Supabase linkIdentity/unlinkIdentity), subscription-section |
| Install wizard | 2 new | install-container (5-step wizard with progress bar), install-step (copyable commands with clipboard API) |
| Dashboard shell | 1 new | Shared sidebar navigation component with active route highlighting |
| Auth routing | 2 edits | Updated getLoginRedirectPath() and handleDashboardClick() for external privacy group |
Post-Implementation: Developer-Requested Adjustments
After the core implementation, the developer requested additional refinements. These were scope additions — not fixes for broken code. TypeScript compiled clean after every phase.
| Adjustment | What changed |
|---|---|
| Middleware rename | lib/supabase/proxy.ts → middleware.ts (clarity: Next.js 16 uses proxy.ts at root, Supabase helper is middleware) |
| Welcome page replacement | /welcome redirect → /user with account resolution and onboarding fallback |
AUTH_ROUTES constant | Created centralized auth path constants, migrated 15+ files from hardcoded /login, /sign-up, /error, /welcome strings |
| Auth form links | login-form.tsx and sign-up-form.tsx now use getAuthLinks() instead of hardcoded hrefs |
Cost Breakdown
Blueprint + Implementation (Opus 4.6 Pricing)
| Category | Tokens | Rate | Cost |
|---|---|---|---|
| Input (uncached) | 1,743 | $5.00/MTok | $0.01 |
| Output | 54,414 | $25.00/MTok | $1.36 |
| Cache read | 25,354,609 | $0.50/MTok | $12.68 |
| Cache write (5m) | 418,633 | $6.25/MTok | $2.62 |
| Total | 25,829,399 | $16.66 |
Without Caching (Hypothetical)
If prompt caching did not exist:
| Phase | With Caching | Without Caching | Savings |
|---|---|---|---|
| Blueprint | $7.08 | $46.15 | $39.07 (85%) |
| Implementation | $9.58 | $84.08 | $74.50 (89%) |
| Total | $16.66 | $130.23 | $113.57 (87%) |
Model Pricing Reference (2026)
| Model | Input | Output | Cache Write (5m) | Cache Read | Used for |
|---|---|---|---|---|---|
| Opus 4.6 | $5/MTok | $25/MTok | $6.25/MTok | $0.50/MTok | Main session (blueprint + implementation) |
| Haiku 4.5 | $1/MTok | $5/MTok | $1.25/MTok | $0.10/MTok | Sub-agents (background research) |
Why This Is Efficient
Zero agents for code work
All 28 file operations (16 creates + 12 edits) ran in the main Opus 4.6 context. The only agent spawn was a Haiku 4.5 research task running in the background.
Every file read into the main context gets cached at $0.50/MTok on subsequent turns. Agent spawns start fresh contexts that cannot reuse the parent's cache.
| Approach | Cost for 35 file reads | Cache reuse |
|---|---|---|
| Direct Read (this session) | ~$0.18 total | Cached for all 253 turns |
| Agent spawns (hypothetical) | ~$5.25+ total (35 x $0.15) | Zero — each starts cold |
Implementation rode the blueprint's cache
The blueprint phase front-loaded the expensive context building: 35 file reads, 18 graph queries, 129 turns of accumulated context. By the time implementation started, 99.4% of every API call's input was served from cache:
- Blueprint: 96.5% cache hit rate (still building context)
- Implementation: 99.4% cache hit rate (riding the warm context)
Implementation produced 1,332 lines in 9.6 minutes because it didn't need to re-read or re-discover anything — the blueprint had already loaded every relevant file into cached context.
Single context enables cross-cutting changes
The CTA replacement touched 8 component files + 5 data objects that all needed the same change pattern. Because all files were in one context:
- Every replacement was consistent (same icon, same href, same label)
- No reconciliation pass needed
- Completed in a single sweep with zero drift between files