Monokit is on sale: the app screens most kits leave out · See Monokit → · Read the post →

← Studio

Engineering · 2026

Bloom: The Meta-System for Compounding Product Development

A first look at the framework I've been building — and what happened when I used it to start a new product this week.

How I stopped accumulating accidental scaffolding across projects and built a meta-system that makes every product inherit the best decisions from every product before it.

Update, November 2026: mithril has since replaced shulkerbox's session layer, and council was retired in October 2026. The post stays as a record of how Bloom started.

Most product scaffolding is accidental. You copy from the last project, carry forward what worked, drop what didn't, and end up with a slightly different setup every time. By the sixth product you're starting from a pile of conventions that belong to five different versions of how you used to think about building software.

I wanted each new product to inherit the best thinking from every one before it, on purpose rather than by copy-paste. I wanted the decisions to compound.

So I built Bloom.

Five repos you mount

Bloom is a meta-system for product development. You don't extend it like a framework, you mount it: five independent git repos that attach to any product as submodules under .bloom/.

RepoWhat it does
soulPhilosophy, values, design ethos, operating principles
ideaPer-product definition layer — intent, mission, north star, IA, architecture
stackTech defaults and working starters (lite and full profiles)
shulkerboxSkills, session continuity patterns, self-improvement loops
councilBusiness advisor plugins and governance patterns

The idea is composition over inheritance. Each repo is versioned on its own, and a product mounts what it needs. When the system improves (better stack defaults, sharper session habits, cleaner templates), every future product starts from the improved version.

The decisions live in the system, not in my head or in the last project's README.

A working starter, not a config file

Bloom has two stack profiles. The default, lite, is:

  • Next.js 15 (App Router, Turbopack)
  • React 19 + TypeScript 5.8
  • Supabase (auth + Postgres)
  • Tailwind 4 + shadcn/ui + Radix
  • pnpm
  • Vitest + Playwright
  • Vercel

Lite is a working starter: auth pages, a dashboard route group, Supabase SSR helpers, proxy middleware, shadcn components and an e2e test spec, wired together and tested. The rule is time-to-deploy over portability. Start on lite, and move to the full Nx/NestJS profile only when there's a real reason to own more infrastructure.

Trying it on Kingmaker

This week I started a new product, Kingmaker: an AI coaching tool that helps people follow through on their goals. You bring a coaching plan, and the AI checks in, surfaces your commitments, holds you accountable and makes drift harder than progress.

Kingmaker already existed as a repo (I'd started it the night before with a mission statement), so instead of running bloom-init I mounted the submodules by hand:

BLOOM_SOURCE="file:///Users/me/Projects/Active/Bloom"
git -c protocol.file.allow=always submodule add "$BLOOM_SOURCE/soul" .bloom/soul
git -c protocol.file.allow=always submodule add "$BLOOM_SOURCE/idea" .bloom/idea
git -c protocol.file.allow=always submodule add "$BLOOM_SOURCE/stack" .bloom/stack
git -c protocol.file.allow=always submodule add "$BLOOM_SOURCE/shulkerbox" .bloom/shulkerbox

Then I scaffolded the docs spine and notes from templates:

for template in intent mission north-star product-surfaces architecture IA-graph; do
  [[ -f ".bloom/idea/templates/${template}.md" ]] && cp ".bloom/idea/templates/${template}.md" "docs/${template}.md"
done
cp -R .bloom/shulkerbox/templates/notes/. notes/

I copied in the lite template, installed dependencies and ran the type checker. Clean.

For local development, supabase init && supabase start runs the full Supabase stack in Docker (Postgres, Auth, Storage, and Studio at localhost:54323), with no cloud account or credentials to manage. Shipping is one command to push to a hosted project.

From nothing to a Next.js 15 app with Supabase auth, shadcn UI and passing e2e tests took about 20 minutes.

The habits come with it

The app is the visible part. The habits matter more.

  • Session continuity. Shulkerbox's templates scaffold a notes/ folder (inbox.md, activity-log.md, friction.md, insights.md). Every session ends with a handover and the next one starts by reading it, so context never has to be rebuilt from scratch.
  • Spec first. The idea templates scaffold the docs spine: intent, mission, north star, product surfaces, architecture, IA. I fill them in before building, and every task has to trace back up that chain to the vision. If it can't, I probably shouldn't be building it.
  • No commits to main. The stack installs a pre-commit hook at bootstrap, so work always happens on branches. It isn't something to remember. It's just how the repo works.

Where Bloom stops

Bloom is a meta-system, not a product. For Kingmaker, the real work is still ahead: a coaching data schema (sessions, goals, plan items, commitments, weekly pillars), plan ingestion that parses a coaching document into phases and actions, an AI session loop with Claude as a coach that remembers what you committed to last time, and the session UI itself.

Bloom gets me to zero quickly and cleanly. The product is mine to build. That's the right division of labour.

The trade-off

Bloom has opinions. If you don't want Next.js, Supabase and Vercel as defaults, you'll spend more time deviating than benefiting. Deviating has a rule: write an ADR explaining why. If three products deviate on the same thing, the stack itself should change.

For one product built once, it's probably overhead. It pays when building products is a practice: the decisions from product one become the foundation of product two, and the habits come along with them. Intelligent compounding, not accidental accumulation.

What's next

Bloom isn't a public package yet. It started as a personal system, and I use it more and more on consulting work. Kingmaker is the first product I'm building fully in public with it.

The pieces I plan to open up are the bloom-init bootstrap script, the stack.yaml contract with the lite template, and shulkerbox's session continuity patterns.

The best way to follow along is to watch Kingmaker get built.