claude-company

Highly opinionated AI software company you drop into any repo.

About  •  Get Started  •  How It Works  •  The Team  •  The Rules  •  FAQ

:bulb: About

You describe what you want built. A CEO agent plans the work, staffs a team of AI product managers, architects, tech leads, developers, and QA engineers, builds it, tests it in a real browser with screenshots, and reports back with proof.

You>  /orchestrator build me a waitlist page with an admin view

CEO   sized the request: feature
CEO   product-manager wrote the spec (3 options considered, picked #2)
CEO   tech-lead "waitlist" spawned 2 developers + 1 QA engineer
QA    captured: loaded / empty / error / after-signup screenshots
CEO   gates: lint PASS  typecheck PASS  tests PASS (stamped)
CEO   merged. Here is what shipped, the evidence, and one decision I need from you.

Most multi-agent frameworks write their process as prompts and hope the model follows them. Under pressure, models skip steps: they commit failing code, edit tests until they pass, and mark their own work as done. claude-company replaces hope with enforcement:

Gates are enforced, not narrated. Hooks (small scripts that run before every action) block the bad action itself: no commit while tests fail, no code without a plan, no editing protected files, no gaming the test suite. Every block is logged.

And it is frictionless where it matters: you are the client, not the process operator. Specs, briefs, task state, and gate config are all generated by the agents themselves. You hear back for two reasons only: decisions that belong to you, and delivery with evidence.

:rocket: Get started

1. Install the CLI once, then install the company into any project:

npm install -g claude-company
claude-company install .

Or without a global install: npx claude-company install .

Prefer no npm at all? Clone and run the installer directly - same TUI, same result:

git clone https://github.com/devmesh-in/claude-company
./claude-company/install /path/to/your/project

1. Open your project in Claude Code and start the company:

/orchestrator build me <what you want>

There is no setup step. On first contact the company onboards itself: it studies your codebase (or treats your request as the founding brief of a new one), finds your real test and lint commands, and wires them in as gates. The installer merges with your existing settings and never overwrites them; running it twice changes nothing.

The getting started guide walks the full path from install to first delivery.

:gear: How it works

The CEO sizes every request, so a typo fix never gets a committee and a product build never skips design:

flowchart LR
    A([Your request]) --> B{CEO sizes it}
    B -->|ideation| C[Strategists diverge<br>Options memo]
    B -->|quick| D[One developer]
    B -->|feature| E[Spec with options<br>Sealed brief<br>Tech-lead team]
    B -->|program| F[Architect: scored designs<br>Waves of parallel teams]
    C -.the winner re-enters.-> B
    D --> G[Gates + evidence]
    E --> G
    F --> G
    G --> H{CEO verifies:<br>reruns gates, checks diffs,<br>judges screenshots}
    H -->|red| E
    H -->|green| I([Merged + delivery report])

Five things happen on every build, regardless of size:

1. Plans come first. For features and products, the product manager explores 8 to 15 directions before writing the spec, and the architect picks the design from 2 to 3 scored alternatives. Both record the options they rejected and why.
2. Work orders are sealed. Builders receive a brief: mission, exact owned directories, definition of done, and a decided fallback for every ambiguity. Ten parallel agents make the same assumption instead of ten different ones.
3. Teams build in parallel. Each tech lead runs its own developers on separate directories in an isolated git worktree, fills the gaps between their pieces, and sends a QA engineer through the running app.
4. Producers never grade their own work. Developers report, leads verify, QA captures screenshots but does not judge them, the CEO judges, and an independent auditor rechecks the big merges.
5. The gates decide. Your test suite, linter, and build run as a stamped ladder. The stamp goes stale the moment a file changes, and the commit hook blocks anything red, stale, or unstamped.

Read how it works for the full method, including diagrams of the pipeline, the gate lifecycle, and the change-request flow.

:busts_in_silhouette: The team

flowchart TD
    YOU(["You: the owner<br>business policy, deploys"]) --> CEO["CEO: your main session<br>plans, staffs, verifies, reports"]
    CEO --> IS["ideation-strategist<br>explores the option space"]
    CEO --> PM["product-manager<br>specs with testable requirements"]
    CEO --> AR["architect<br>scored designs, boundaries"]
    CEO --> TL["tech-lead<br>one per workstream"]
    CEO --> AU["auditor<br>independent review"]
    CEO --> ST["security-reviewer<br>devops-engineer<br>docs-librarian"]
    TL --> D1["developer"]
    TL --> D2["developer"]
    TL --> QA["qa-engineer<br>browser + screenshots"]

:shield: The rules it enforces

Each rule is a hook that blocks the action itself. When a hook blocks an agent, the message contains the recipe to become compliant, so the process self-heals instead of stalling.

Every block and every hotfix bypass is one line in company/state/adherence.log, so enforcement is visible, not claimed. All hooks fail open: an internal error lets the action through rather than jamming your session.

:keyboard: Commands

:wrench: Customizing

Everything is a plain file you can read and edit: gates in company/gates.config, protected files in company/frozen-surfaces.json, roles in .claude/agents/, process in company/METHOD.md. The customizing guide covers the common changes.

:question: FAQ

More than a single Claude session: parallel agents multiply token use. The company counters this by scaling ceremony to the task, so small fixes get one developer and no meetings.

Yes. It reads your code, adopts your conventions, and wires your existing test commands in as gates. It adapts to your project, not the other way around.

Gates are your own commands in company/gates.config; edit them anytime. For real emergencies there is a hotfix mode that logs instead of blocks, and the process catches up afterward.

Yes. Specs record the options considered, memos record the roads not taken, decisions wait for you in company/state/DECISIONS.md, and the adherence log records every block.

No agent, including the CEO, ever decides: production deploys, database migrations in production, anything involving money, weakening a protection rule, or business policy. The company merges to your main branch; shipping to users is a button only you press.

Everything lives in plain files: delete company/, ORCHESTRATOR.md, the claude-company agents/skills/hooks under .claude/, and the marked block in CLAUDE.md (between the claude-company:begin/end comments). Remove the claude-company hook entries from .claude/settings.json if you had your own settings merged. Your code, git history, and own configuration are untouched - the installer never modifies them.

:books: Documentation

:page_facing_up: License

This project is licensed under the MIT License. See the LICENSE file for details.