A Claude Code plugin for building and tending contract-first software.

One install gives you a project template, agents that build and review your work in a loop, a design loop and a status line. From inside Claude Code, run:

/plugin marketplace add MaybloomTech/maybloom-stack
/plugin install maybloom-stack@maybloom-stack

Read the quick start

Four uses, and the first prompt for each

Each prompt is a plain sentence you type in a Claude Code session; the skill that answers it takes over from there. Every use needs Claude Code and the plugin, and each says what else to have ready: everything each use needs.

  1. Start a project from the template

    A protobuf contract, a Go backend (TypeScript on request), an Expo client and a docs site, with one example resource wired through every layer from the first commit.

    You need Python 3 and git, Node 24 and pnpm 10, and Docker for the Go backend’s database and toolchain.

    In a session started in an empty folder:

    Bootstrap a new maybloom stack project called Orchard.
  2. Have agents build and review a slice

    For work bigger than one conversation: an architect session writes the brief, a builder builds it, and a fresh reviewer reviews it round by round until it is ready to merge.

    You need A forge and its client (gh for GitHub, fjo for Forgejo), a tracker and its skill, a Delegation section in AGENTS.md, and the status line.

    In a session in your project:

    Help me write a brief for this slice: <what you want built>.
  3. Decide how a screen looks before it is built

    A designer sketches directions and builds one pass on the design board, a critic judges it from screenshots, and you look last.

    You need A laptop with Chrome, and an interface scaffolded from the template, with its design board.

    In a session in that project:

    Run the design loop for the notes list screen.
  4. Watch your usage and session budget

    Two lines under the prompt: the 5-hour and weekly windows with their resets, context against your session budget, and the prompt cache countdown.

    You need jq, curl and git, a claude.ai sign-in for the usage numbers, and Claude Code 2.1.251 or later for the cache countdown.

    In any session:

    Install the status line.

    It draws this under the prompt:

    ~/workspace/app | [main] | Fable 5.1
    5h:31% (2h00m) | weekly:55% (2d07h33m) | fable:53% (4d08h39m) | ctx:12% | cache:4m50s

One contract, many paths

The maybloom stack is a schema-first monorepo framework. Protocol Buffers define every boundary, code generation owns the edges, and people write the three layers in the middle. The backend is Go by default and TypeScript on request; the interface is one Expo app; the public surfaces are static Astro sites.

The maybloom skill tree: the contract at the root with two limbs, servers and clients; validated paths lit green — Go (the default) and TypeScript, Expo shipping to iOS, Android and web, Astro for static surfaces; kotlin, python, rust, swiftui and flutter waiting as dashed open paths

The contractprotobuf · Connect-RPC · generated edges

Servers

  • GodefaultvalidatedThe connect-go + sqlc + goose blueprint, as two services walked it
  • TypeScriptvalidatedThe Fastify + Connect-RPC + Drizzle blueprint
  • Open:
    • kotlin
    • python
    • rust

Clients

  • ExpovalidatedThe Expo Router client blueprint, React Query hooks in each feature over a Backend context
  • AstrovalidatedAstro for the public, static surfaces
  • Open:
    • swiftui
    • flutter
validated
Built and run for real, and carried by a reference the skills load.
validating
Blueprinted in the docs, first real service still proving it.
open
Permitted by the core, not blueprinted.

See the drawing

The documents, in reading order

  1. 1OverviewWhat the maybloom stack is and the principles behind it
  2. 2Quick startInstall the plugin, then the first thing to type for each of its four uses
  3. 3ContractsThe protobuf layer, Buf toolchain, and proto conventions
  4. 4Backend: TypeScriptThe Fastify + Connect-RPC + Drizzle blueprint
  5. 5Backend: GoThe connect-go + sqlc + goose blueprint, as two services walked it
  6. 6InterfaceThe Expo Router client blueprint, React Query hooks in each feature over a Backend context
  7. 7SitesAstro for the public, static surfaces
  8. 8Choosing a runtimeWhen Fastify, when Go, when Astro
  9. 9SkillsHow the stack ships as agent skills
  10. 10DelegationHow work on the stack is split between roles and model tiers, and why
  11. 11Running a loopWho starts which role and with what, one prompt per role, a filled brief, one run from card to merge, and the session budget
  12. 12Design loopHow a screen's look is decided before it is built, by a designer, a critic and the owner
  13. 13Status lineThe two-line Claude Code status line, what it shows, how to install it and why the budget hook needs it
  14. 14Adopting the stackBringing an existing service onto the contract without a rewrite
  15. 15Prior artHow the maybloom stack compares to what exists