// brew_chai · open source · MIT

Brew your next feature.

One brief in. brew_chai plans the work, asks the few hard questions, splits it into sprints, executes in parallel, audits the result and hands back a PR.

MIT licence · repo opening shortly · 48 agents · 35 commands · What we would take →

$ curl -fsSL https://creativehuman.ai/brew-chai/install.sh | bash

~60 MB signed binary · macOS, Linux, Windows · npm and the public repo follow when it opens

Creative-Human-AI/brew_chaiMIT · opening soon
plugins/brew_chai/v3.0.8
agents/48 agents
commands/35 commands
hooks/12 hooks
scripts/30 scripts
skills/references/4 rubrics
LICENSE.mdMIT
rolecontributors
maintainerheiko-alt
contributorsopening soon
+ nextyou ←
labelgood first issue
openGo, Rust, Java
openOpenCode
openCursor adapter
opennon-TS docs
openformatters
reviewsame gates
plan-critic≥ 95/100
deep-cleantier 3
run 1 of 4~/repo · brew_chai · live
$ /brew ""
detectrouteplancritiquedecomposeexecuteaudithand off
plan-critic
▸ earlier · 0 hidden events
PR · ready
// what your team gets

Three promises that land on the same PR.

// 01

Ships PRs, not suggestions.

A brief goes in. A branch comes back with code, tests, commit history and a description that reads the diff. Work that goes into review, not chat output someone has to assemble.

PR
ready · branch, tests, commit history
// 02

Nothing merges on a vibe.

Plans must score 95/100 with the plan critic before decomposition. Every sprint ends in a tiered audit; the final sprint always gets the full swarm. A task cannot be marked complete with typecheck errors or a failing review.

plan-critic
≥ 95/100 · final sprint tier 3
// 03

Your code stays on your machine.

brew_chai is orchestration. Inference runs through the Claude Code you already have, on your subscription or your API key. Every prompt that touches your repo is a plain file on your machine; read it before you run it.

code content sent
never · source readable · MIT
// what runs

Eight phases. One question round, then silence.

Phase names map to real commands and agents in the plugin. The rail on the left follows you through them.

~/repo · brew_chai · live

// 01Detect

/detect-stack writes .stack-profile.md: language, framework, test runner, lint and build commands every agent reads.

// 02Route

/brew classifies the intent, estimates scope in a few greps, and picks the workflow.

// 03Plan

plan-author reads the codebase, asks the clarifying questions that matter, and writes the plan document.

// 04Critique

plan-critic scores it 0–100. Under 95 goes back with itemised feedback, up to five rounds.

// 05Decompose

sprint-planner, task-creator, task-assigner: sprints, task IDs, dependency graph, parallel batches.

// 06Execute

task-implementer agents run in parallel batches, in isolated git worktrees, with a checkpoint commit per sprint.

// 07Audit

The tiered gate: Tier 1 sanity, Tier 2 parallel auditor swarm, Tier 3 comprehensive. Fix loop until zero issues at threshold.

// 08Hand off

worktree-merger merges in dependency order; knowledge-extractor proposes rules for next time; docs-syncer updates the docs; you get the branch.

phases
8/8 · one question round · PR ready
// brief in, PR out

One command. One branch. Every gate on record.

// what you type
$ /brew "add OAuth login (Google + GitHub) to the settings page"
plain English · one command · one question round
/brew/plan-this
plan-author → plan-critic → sprint-planner
task-creator → task-assigner → task-implementer ×3
deep-clean --tier 3 → worktree-merger → knowledge-extractor
// what you get
PR · ready#1284 · main ← feature/oauth-auth
Add OAuth (Google + GitHub) to /settings
3 sprints · 26 tasks · 14 files · +427 / −23
plan-critic
97/100 · accepted on iteration 2
sprint-verifier
PASS · intent matches spec, all 3 sprints
deep-clean · tier 3
hygiene 96 · completeness 98 · craftsmanship 94 · security 99
0 issues at HIGH or above
TaskCompleted gate
typecheck clean · review ≥ 95 · 26/26 tasks
tests
14 added · 12/12 existing pass
knowledge
2 rules proposed for .claude/rules/
// why it holds up

Built like an engineering org, not a chat loop.

// 01

Critic gates with a number on them.

plan-critic passes at 95/100 and not below. The TaskCompleted hook refuses to close a task with typecheck errors or a review under threshold. The threshold is yours to set in .brew_chai.yaml.

threshold
95/100 · yours to set
// 02

An auditor swarm, in parallel.

/deep-clean audit --tier 2 runs hygiene, completeness, craftsmanship and security at once, and adds performance and design-system auditors when the code in scope calls for them. Each scores 0–100. Tier 3 adds dependencies, environment and knowledge extraction. The final sprint of every feature gets Tier 3.

tier 2
4 always-on + 3 conditional · final sprint tier 3
// 03

An audit-fix loop that knows when to stop.

Fixes run until zero issues at your severity threshold. Circuit breakers: plateau detection, two failed attempts on the same issue triggers investigation, a checkpoint with you every five rounds.

issues at threshold
0 · plateau · 2 attempts · 5 rounds
// 04

Parallel worktrees, one merger.

Implementers work in isolated git worktrees on batches the task assigner built from the dependency graph. worktree-merger brings the branches back in order. The orchestrator itself never runs git merge.

merges by
worktree-merger only · dependency order
// 05

Sprint state that survives a closed terminal.

run-state.json per feature, state.json per sprint. Re-run the command and it resumes from the last completed phase. A PreCompact hook saves state before context compaction.

resume from
last completed phase
// 06

Rules enforced in code.

Twelve hook scripts on nine Claude Code events. No push, merge or reset --hard during a sprint. Reviewers can only write markdown. Every review must carry a numeric score and a verdict. Files are auto-formatted after every write.

hooks
12 scripts · 9 events
.brew_chai.yamllines light as you read
# gates are fixed in the agent definitions: # plan-critic 95/100, up to 5 iterations # sprint-verifier 90+ PASS, under 70 stops the run # audit deep_clean: issue_threshold: "MEDIUM" circuit_breakers: plateau: true resistant_attempts: 2 confirm_after_rounds: 5 parallel_instances: 3 # per auditor type # sprints run_sprints: audit_interval: 3 # tier 2 every N sprints audit_on_final: true # final sprint gets tier 3 knowledge_on_final: true # execution # implementers run in isolated git worktrees; # worktree-merger merges them in dependency order # state # run-state.json resumes a feature, state.json a sprint; # a PreCompact hook saves both before compaction # hooks · 12 scripts · 9 events PreToolUse: block-destructive-git.sh PreToolUse: restrict-reviewer-writes.sh PostToolUse: auto-format.sh TaskCompleted: validate-review-score.sh
// open source

Read the prompts. Then improve them.

brew_chai is MIT licensed, and the repository opens shortly at github.com/Creative-Human-AI/brew_chai. Every agent, command, hook and rubric is a plain file you can read before you let it near your repo. We built it to ship Glasshouse and this site, and we still use it every day.

We want contributors. The agents are markdown; the hooks are shell; the scripts are Bash and Python that return JSON. If you have shipped production code with coding agents, you already know enough to make one of these better.

The areas below are where help will count most on day one. Tell us which one you would take and we will point you at it when the repo opens. Maintainers review every PR through the same gates the tool runs on itself.

Creative-Human-AI/brew_chaiMIT · v3.0.8 · opening soon
areawhat is there today · + what we would take
agents/48 agent definitions in plugins/brew_chai/agents/New auditors, tighter rubrics, better failure messages ← you
commands/35 workflow commands in plugins/brew_chai/commands/New workflows, stack-specific variants, argument handling ← you
skills/references/12 scoring auditors, 4 rubric skillsLanguage-specific checks, calibration against real codebases ← you
adapters/Claude Code and the Agent SDK work today; OpenCode, Cursor, Continue, Windsurf and aider are stubsWorking adapters for the stubs ← you
hooks/ · scripts/12 hook scripts, 30 helper scriptsGo, Rust, Java stack detection; formatter coverage ← you
docs/USAGE-GUIDE.md, docs/Walkthroughs for non-TypeScript stacks, translations ← you
your PR
plan-critic ≥ 95 · deep-clean tier 3 · merged

MIT licence · last release v3.0.8 · public repo opening shortly
Copyright 2026 Heiko Altrichter / Creative Human AI.

Free to use, fork and self-host. No paid tier, no seat count, no key to buy. Talk to us →

// for the security review

brew_chai never sees your code.

  • [ok]
    Code never leaves the developer's machine.brew_chai is the orchestration layer. Inference runs through the Claude Code, Agent SDK, Bedrock, Vertex or Foundry credentials your team already uses, governed by that tool's policy.
  • [ok]
    The prompts are readable.Every agent and command is a file in the repository. Your security team can read, diff and pin them. The CLI verifies signed prompt packages with an Ed25519 public key pinned into the binary.
  • [ok]
    Telemetry is off by default.When opted in, events carry command names, timings, adapter and exit code. Never code content.
  • [ok]
    Destructive git is blocked during a sprint.A PreToolUse hook rejects git push, merge, reset --hard and checkouts of main while a sprint is active. Reviewers and critics can write only .md files.
  • [ok]
    Self-host the backend.The prompt backend ships as a Docker container and runs behind your firewall with no dependency on our infrastructure. If Creative Human ever shuts down, signed prompt content is released publicly so deployed installs keep working.
code content sent
never · telemetry off by default
// is this for your team

Honest fit. Read the right column too.

// right for you if
  • +You ship production code and review is not optional
  • +You already run Claude Code and want a workflow on top of it, not a replacement
  • +You would rather read the prompts than trust a hosted black box
  • +Your features touch six or more files and need a plan before a diff
  • +You want the same planning, audit and review discipline from every engineer on the team
// probably not if
  • You want a chat window to think out loud in; your IDE already has one
  • You want autocomplete and suggestions, not delivered branches
  • You are on Cursor, OpenCode, Windsurf, Continue or aider and need it working today (those adapters are stubs; help us finish them)
  • Your environment cannot accept any outbound traffic and you will not self-host the backend
adapters working today
2 of 7 · Claude Code · Agent SDK · five stubs to finish

Free to run. Yours to improve.

Install it in a minute, run /brew on something real, and tell us where it gets in your way.

brew_chai is built by Creative Human AI, an AI lab in Berlin. We use it ourselves, every day, on Glasshouse and on this site.