Claude Code Plugin: Blueprint + Implement

An AI-powered multi-agent system that turns a product idea into a fully scaffolded, service-provisioned mobile app ready for store submission.

Blueprint + Implement is a Claude Code plugin system I built that orchestrates the entire lifecycle of creating a mobile or web application from initial product interview through keyword research, design system creation, codebase scaffolding, and parallel multi-agent implementation.

It replaces weeks of manual setup work (Firebase provisioning, App Store Connect configuration, RevenueCat subscriptions, Sentry/PostHog integration, 41-locale i18n, legal compliance) with a structured, repeatable pipeline driven by AI agents that automate through browser automation and CLI tools.

Launching a new app involves dozens of disconnected tasks across different platforms: creating Firebase projects, registering apps in App Store Connect, setting up analytics, writing privacy policies, generating store metadata in 40 languages, configuring subscriptions, running security audits. Each requires context from previous decisions: pricing affects the paywall, keywords affect naming, design tokens affect every screen.

Most of this is mechanical, repeatable, and error-prone. The real value is in the product decisions, everything else is execution.

Phase 1: Blueprint. A 7-step pipeline that turns a raw idea into a complete implementation plan: /ideate -> /keyword-research -> /interview -> /design -> /plan -> /generate -> /generate-website. Each step builds on the previous: the product interview locks pricing decisions, keyword research (4 data sources: Google/Apple Autocomplete, Apple Search Ads, Google Trends) shapes app naming and website copy, technical interviews capture architecture decisions, and the plan synthesizes everything into phase-gated agent sub-plans.

Output: a scaffolded, compilable codebase (iOS Swift, Android Kotlin, or Next.js 16 with 41 locales) with all research embedded in .blueprint/ for full traceability.

Phase 2: Implement. 4 AI agents run in parallel terminals, each following its own plan: services (provisions Firebase, Sentry, PostHog via browser automation with BrowserOS), store (creates App Store Connect / Google Play record, locales, compliance), dev (builds features phase-by-phase with verification gates), and monetization (sets up RevenueCat subscriptions + paywall UI, blocked until store finishes).

I was launching multiple apps under the same brand and noticed 80% of the work was identical mechanical setup: same Firebase flow, same App Store Connect compliance surveys, same Sentry config, same 41 locales. The decisions were different each time, but the execution was the same.

• Product decisions are captured once and propagated everywhere, keywords inform naming, which informs store listings, which informs blog content
• Mechanical setup is automated through browser automation, not manual clicking through dashboards
• Multiple workstreams run in parallel with explicit dependency management
• Every generated codebase embeds its own research context so future AI agents have full provenance
• Phase gates prevent AI from running ahead without human validation

The result is a pipeline where the human focuses on product thinking (ideation, keyword strategy, design preferences) and the system handles execution (scaffolding, provisioning, configuration, compliance).

Browser automation as infrastructure: Firebase, Sentry, PostHog, and App Store Connect are all provisioned through browser automation the AI drives the actual web UIs, handling auth flows, form filling, and multi-step wizards. This was not always feasible through CLI or MCP commands, so I needed to use browser automation instead, and especially automation with BrowserOS to have full control on an authenticated browser.

Keyword-driven decisions. Research from 4 data sources feeds into app naming, website headlines, store metadata, FAQ generation, and blog content strategy. Nothing is arbitrary, every copy decision traces back to data. And this was a gamechanger decision. AI is sometimes misleading or inventing data sources, here, the model is constrained to provide backed data, the impact was noticeable on our keyword ranking.

Agent coordination without shared state. Agents coordinate through a flat markdown file. No databases, no message queues, just file reads and writes on a shared repository. Simple, debuggable, and version-controlled. This simplicity was key, at a stage where having agents that understand in live which agent is doing what, a simple markdown file helped agents collaborate!

Embedded provenance. Every generated codebase contains all research artifacts: the product interview, keyword strategy, technical decisions, and design tokens. Any agent (or human) can trace why a decision was made months later.

Convention embedding. Each scaffolded codebase includes a comprehensive developer reference (naming conventions, architecture patterns, service configurations, available tools) so that any AI agent working in the repo later has full context without needing the original conversation.