I built a software team around Claude Code — Dev House

[SinghAbhinav04]

I got tired of making one Claude Code session do everything — plan, code, review, test, and fix its own mistakes.

So I built Hackeroom: a platform where you literally build your own software team around Claude Code.

Give each member a name, role, model, permissions, and skills — then put them into seats like:

Planner → Coder → Reviewer → Tester → Auditor

Each member runs in its own real Claude Code session.

And you can watch the whole thing happen in a pixel-art office.

The weird part is that the team isn't hardcoded.

Want 3 developers and no reviewer? Do it.

Want 3 coders working in parallel? Do it.

Want an auditor that can only inspect? Do it.

Leave a seat empty? That phase simply doesn't run.

A few things I went surprisingly deep on:

• Permissions actually enforce themselves. A PreToolUse hook checks every tool call against a capability manifest. The agent can't simply modify its own permissions.

• Skills are isolated per agent. A huge skill document doesn't get dumped into everyone's context. It's loaded only when that member needs it.

• Memory is shared without sharing conversations. Agents write down what they learn, and other agents get a small indexed summary before reading the full memory on demand.

• You can see exactly who's burning tokens. Cost and token usage are tracked per member and model.

So instead of:

You → Claude → everything

it's more like:

You → Team → Planner → Developers → Reviewer → Tester

Each member is still running Claude Code underneath — Hackeroom is the layer that turns those sessions into an actual team.

Here's a short demo:
https://github.com/user-attachments/assets/19d73b9d-1e8d-477e-bde9-27c8614c3f07

And here's what the team looks like:

Repo: Dev House

The part I'd actually love people to tear apart is the permission/hook architecture and the idea of treating individual Claude Code sessions as persistent team members.