Building Morningbrew: How I Turned a Solo Side Project into an AI-Powered Product Team

Morningbrew: specialty coffee journal and roaster map

The project

Morningbrew is a specialty coffee journal and roaster map. Users log bean purchases, record brew parameters, rate extraction results, and curate a personal map of roasters and cafes. The application is live at morningbrew.cc.

I designed and built the entire application using Next.js, Supabase, Mapbox GL JS, and Cloudflare Workers. The initial release included 100+ tracked coffees, 40+ roasters, 50+ routes, 49 database migrations, a custom design system with dark and light modes, and automated CI/CD checks for linting and test coverage.

Morningbrew runs as a production application with authenticated workflows, transactional emails, and security headers.

The project served as an experiment in multi-agent product delivery.

The challenge of solo development

Solo development often overlooks subtle details: an interface label that drifts from voice guidelines, a row-level security policy that works for standard paths but fails on empty states, or ambiguous form validation.

Cross-functional product teams catch these discrepancies through diverse perspectives: designers evaluate interaction models, writers refine copy, QA engineers probe edge cases, and security engineers assess threat vectors.

I designed an agentic pipeline to replicate that cross-functional rigor for independent development.

The agentic pipeline

The three layers: Linear triggers, Obsidian provides context, 10 Claude Code agents execute

The workflow connects Linear issues to Claude Code agents, each assigned a specific discipline:

Linear for issue management. Work items begin as Linear issues. Adding a “Claude Task” label triggers a webhook to initialize Claude Code, eliminating manual prompt formatting.

Obsidian for context architecture. Product decisions, data schemas, design tokens, copy guidelines, and architectural constraints live in an Obsidian vault. Agents reference this knowledge base as a single source of truth. When the UX Writer agent edits interface copy, it evaluates changes against documented voice guidelines.

Specialized agent definitions. Individual agent personas reside as markdown files in .claude/agents/, each configured with explicit principles and structured output schemas.

The initial group covered engineering: Architecture, Product Management, QA, and Security.

I expanded the roster to include the complete product discipline: Product Designer (design system tokens and layout), UX Writer (microcopy and voice), UX Strategist (business outcomes and conversion), Information Architect (navigation and taxonomy), User Researcher (feedback synthesis), and Test Engineer (failing test generation prior to implementation).

The role of constraints

Generic prompts produce generic output. Constrained agents produce trustworthy work.

Giving agents explicit constraints significantly improves output quality.

Unconstrained prompts yield generic recommendations. Conversely, agents configured with explicit personas, principles (such as favoring proven patterns over complex abstractions), and structured review templates produce dependable pull request evaluations.

The Product Designer verifies existing CSS variables before introducing new styles; the UX Writer audits terms against the copy guide; the Security Engineer evaluates threat models for new endpoints.

The persistent memory log

The learning loop: break, log, test, prevent. The memory file turns mistakes into permanent fixes.

A key component of the pipeline is the persistent memory file at .claude/memory/learnings.md.

When an edge-case bug occurs, the root cause and corresponding test requirements are recorded in the log. Agents review this document prior to touching related subsystems.

Examples of captured patterns:

Logging coupled state changes in authentication spinners to prevent navigation deadlocks.
Establishing standard Supabase RLS policy structures to prevent permission leaks.
Documenting microcopy tone guidelines to ensure conversational consistency.

While repository configuration files define rules, the memory log preserves accumulated operational experience.

Repository configuration structure

The primary repository configuration file focuses on five core sections: project context, conventions, commands, workflow, and architecture. Concise configuration guidelines prevent context dilution during agent runs.

Configuration operates hierarchically: personal global defaults provide the base, project files set team conventions, and directory-specific files provide local overrides.

Context layers: personal defaults, project conventions, directory overrides. Inner wins.

Audit findings

A parallel audit conducted by 9 specialist agents surfaced critical pre-launch improvements:

Request body schema validation across API routes.
Event-level interaction tracking for key conversion flows.
Automated tests for edge-case row-level security scenarios.
Standardized empty-state messaging across sub-pages.
Rate limiting configurations for public endpoints.

Automated code generation provides velocity; specialized review agents ensure systemic quality.

Scope and technical foundation

Shipped by 1 person and 10 agents: 50+ routes, 76 components, 88 test files, 49 migrations, 9k lines SQL

The application launched with 50+ routes across four route groups, 76 domain components, and 25 custom data-fetching hooks. The Postgres schema comprises 49 migrations totaling 9,013 lines of SQL with row-level security across every table. Initial database seeding included 100+ coffees, 40+ roasters, and 12+ cafes.

The test suite includes 88 unit test files, RLS integration suites, and 6 end-to-end user journeys. The design system uses custom HSL tokens across light and dark themes. The email notification system incorporates RFC 8058 compliant HMAC-signed unsubscribe tokens.

Learnings

Building with AI amplifies the value of product judgment. When code generation is rapid, the primary bottleneck becomes decision-making: schema design, UX hierarchy, and trade-off evaluation.

AI agents operate most effectively as specialized reviewers. While code generation is rapid, the critical value lies in catching edge cases: inconsistent labels, untested state transitions, and security headers.

Maintaining a persistent memory log allows AI agents to retain past architectural corrections and avoid recurring errors.

Technical stack

The frontend is built with Next.js App Router, TypeScript, and Tailwind CSS. The database layer runs on Supabase (Postgres, Auth, Storage, RLS). Maps use Mapbox GL JS with Supercluster point aggregation. Deployments run on Cloudflare Workers.

Project tracking uses Linear, context documentation resides in Obsidian, and agent orchestration runs via Claude Code.

Morningbrew is live at morningbrew.cc.