An Office for My Claude Code Sessions
I think of my agents as specialists. Besides the ones that write code, I have dedicated PM and QE agents, and in my own sessions I use agent skills, like Matt Pocock's skills, to give them their jobs. In Terminal tabs they all look the same. Then I built a 3D kitchen for my short story Doctor Bones, and it made me wonder if I could build an office where I could see them as a team.
So I built one. It is a 3D loft in New York with brick walls, steel windows and a coffee bar, and each developer in it is one of my Claude Code sessions. While a session works, its developer types at their desk with its tool calls on the monitor. When it needs my OK, they raise a hand. When its turn ends, they get coffee. I click a person instead of a tab.
By the afternoon the office was working on itself. Its sessions filed tickets, I approved them, and workers built them and reviewed each other's pull requests. That evening I wrote a constitution for the office, a set of rules that every session in its repo reads. This post covers what I built, how it works, what I still decide myself, and how the office could become a software factory.
Why an office
A 3D world is more than I need to see which session is waiting on me. A list of sessions can do that. I wanted a way to picture my agents the way I think about them, as a team of specialists with their own desks and their own work. Seeing who is waiting came with it.
From skills to sessions
The office is the second world in a repo I already had. The first is the 1950s kitchen from my short story Doctor Bones, a 3D scene that code can drive through a small relay server. Curl, an Appian process model or an agent can send it commands. A Claude Code hook can send events the same way, so a world can show what a session is doing. I wrote about how I built the kitchen in Building a 3D World for a Short Story.
In my first version, each developer was one of Matt Pocock's skills. When the agent used /tdd, Marcus went to his desk, and each of the others had a few skills of their own. It looked good in the demo, but it did not hold up in real sessions. Most of a session is reads, edits and shell commands, not skills, so the Lead did all the work while everyone else drank coffee.
So I changed the model. Each developer is now a session. Add worker starts a new Claude Code session for a repo I pick, in its own checkout, and a developer goes to a desk for it. Clicking anyone opens their session in the terminal beside the office.
The sessions still have jobs. The PM reads the repo and splits an idea of mine into tickets, which wait in Triage until I approve them, and it is told not to change code. Devs build tickets, each in their own copy of the repo and on their own branch. Reviewers are my QEs. They read each pull request and post what they find as a comment. The Lead is whoever gets the first desk. The job titles from the skills version, such as Priya's Debugging and Marcus's Tests, are still there, but who gets a ticket is just the next free desk, not a match to the work. The PM, Devs and reviewers get their jobs from a brief that the relay types into the session. The Lead has no brief yet, and no brief names a skill.
What the office shows
| In the office | In the session |
|---|---|
| Typing at their desk, with the tool calls on their monitor | Working |
| A raised hand, then passing the time in their chair | Waiting for permission, or for an answer in a question dialog |
| At the coffee machine, on the couch, at the window or at the ping pong table | Nothing is happening. The Floor list beside the office says whether the session is ready for a prompt or the person is free. |
| Free for another session. Anyone past the first three people leaves the office. | The session ended |
The raised hand is the part I use most. The browser tab's title counts the raised hands, so I can see that someone is waiting even when the office is in a background tab. While a worker waits, they stay in their chair and pass the time. They check their phone, swivel, lean back and look around, and the hand goes back up every so often.
Some of it is only for fun. Every few minutes a manager in a suit walks through, and anyone without real work sits down at a desk and looks busy until the manager leaves. A radio plays six old records that are a little out of tune. The org chart puts me at the top as the manager, and its Reorg button arranges everyone another way and says that nothing else changes. The company is called Building 58, which the rename pull request, written by a worker, describes as "a location inside the automated Ilium Works in Kurt Vonnegut's Player Piano".
How a session becomes a person
Claude Code runs hooks on events such as a prompt, a tool call, a permission request and the end of a turn. My hook sends a short summary of each event to the relay, and the relay passes it to the office page. The hook trims what it sends: skill names, file paths inside the project, the first two words of a shell command such as npm test, and the session's title. It does not send prompts unless I turn that on. It gives up on the relay after one second, and most events run it in the background, so it never slows Claude Code down.
Sessions started from the office run in a terminal panel beside the scene. The relay starts claude in a pseudo-terminal on my Mac, and the page shows it with xterm.js. A web page that can run commands on my computer is a risk, so the relay only answers the office page on the same computer. A request from another website, a tunnel or another computer is refused, even with the key.
Each session takes the first free desk. There are nine desks, so nine sessions can run at once. The browser remembers who had which session, so after a reload everyone is back at the same desk.
The office worked on itself
My first commit for the session version was at 9:25 in the morning. The first pull request opened at 10:02, and the last one merged at 5:18 in the afternoon. In between, 17 pull requests merged, with 35 commits that added about 6,500 lines.
The first pull requests came from sessions I opened and directed myself. Then the office got a Board, and from 2:12 in the afternoon on, most of the work came through it. A ticket waits in Triage until I approve it. When I press Start on a Ready ticket, the relay makes a copy of the repo, a new branch and a Claude Code session, and types the ticket in as the worker's brief. The worker builds it and opens a pull request. When the pull request opens, another worker starts as a reviewer and posts a review as a comment on it.
The first ticket was a bug in the office itself. After the waiting animation merged, every worker's head had disappeared. The angle a head turns to and the worker's appearance were both stored in a field called look, and the appearance overwrote the angle.
Sessions also filed tickets while they worked. Of the 27 tickets on the Board at the end of the day, I wrote 4 on the Board myself. One long-running session filed 15, and other sessions filed 8. For example, the reviewer of one pull request found that its clean-up step silently deleted gitignored files. The worker fixed that, and filed a ticket for the same bug in another part of the office. Every ticket a session files waits in Triage for me.
The automatic review of the rename to Building 58 is a good example of what the reviewers posted. It checked every place the company name appears, and measured the wider neon sign in headless Chrome to make sure it did not clip. It ended with a list of things for a person to check by hand, and it said plainly that it had not looked at the rendered office. To check that the new CI pipeline could fail, one worker opened a pull request that was meant to go red and was never merged.
I decide what moves, for now
The help page, which one of the workers wrote, says it plainly: no ticket starts by itself. A ticket gets a worker only when someone presses Start. Nothing moves a card past Building, not even a merged pull request. Workers are told not to merge, so I merge on GitHub. At most three tasks are built at once.
In Who Owns the Process? I wrote about Lauren Tan's trust ladder. You give agents more as they prove themselves, and the proof comes from verification. The office started on the bottom rungs on purpose, and the first step up merged at the end of the day. With T-6, I can let one session, the Lead, move tasks and tickets too. It can do that only after I press Let the Lead move the board with its session on screen, and the same button takes it back.
The Ready column reads like the next rungs: review comments that reach the worker without anyone carrying them (T-17), a clean pipeline before review (T-11), and a Lead whose brief is to keep tickets moving (T-18). Each one hands another move from me to the agents. I want to start each one only when I have evidence that the checks before it catch what they should.
These rules are a check on the process, not a security boundary. "Told not to merge" means the words in a worker's brief. Sessions run with my normal permissions, and one could read the relay key from my hook settings. The token the relay gives each session only lets it list and file tickets, unless it is a Lead I have let move the board. A session that read the relay key would not need the token.
A constitution for the office
GitHub's Spec Kit has you write a constitution once per project, a set of principles for the work that follows. That evening I wrote one for the office. It is two files. CLAUDE.md holds twelve short rules, and Claude Code loads it into every session in the repo, so every PM, Dev, reviewer and Lead reads it. A longer docs/constitution.md gives the reason and the check for each rule, and lists what I have not decided yet.
There is a tension in that. Pocock's README says that frameworks like Spec Kit "try to help by owning the process," and his skills leave the process to you. So my constitution covers only who moves work and what counts as done. How to write the code is left to the skills I pick.
The most useful part came from Lauren Tan's pstack. Its /correct skill keeps a table that pairs each rule with what enforces it, so I gave CLAUDE.md that column too. Filling it in showed me which rules are real. The relay's code refuses requests from other websites, and GitHub will not merge to main until the pipeline passes. But the rule that workers never merge is enforced by nothing except the words in the brief. A session runs with my GitHub login, and it could merge if it decided to. Pocock's /retro and Tan's /correct point to the same fix: when a check can catch a mistake, build the check, and write docs last. /retro would also keep CLAUDE.md much shorter, mostly pointers to other files. Mine is a table of twelve rules, and I expect it to shrink as checks replace them.
The constitution also proposes one of Pocock's skills for each role. The PM starts with /to-tickets, a Dev with /implement and its ticket, a reviewer with /code-review, and the Lead with /triage. Reading the skill files settled the details. /implement can take one ticket. It uses tdd where it can, at seams agreed beforehand, reviews its own work with /code-review and commits, which fits one ticket per session. tdd asks a person to agree the seams before it writes a test, so a ticket has to name them, or the Dev waits for me. /implement, /to-tickets and /triage run only when someone types their name, and the relay types the brief into the session as my first prompt, so a brief that starts with the skill's name runs it. /code-review checks a diff against the ticket and against the repo's standards, and reports the two apart. My reviewers today look for bugs and check the diff against the pull request's description, but not against the ticket or the repo's standards.
pstack covers a different part of the work. It has no planning skills on purpose, and its README says "the best spec is code." Its strength is proof. /interrogate has other models try to break a diff, and keeps only the findings that a run proves. Some skills in both libraries take on many tickets or pull requests at once, such as Pocock's /implement-spec and the playbooks in pstack's /poteto-mode that drive pull requests all the way to merged. Those do the office's own job, so office sessions do not use them. None of this is built yet. Today no brief names a skill.
Toward a software factory
A lot of people now call this kind of system a software factory. Addy Osmani writes in The Factory Model that engineers now build the factory that builds the software, and that "Generation is not the bottleneck anymore. Verification is." Pocock has a software-factory skill, still in progress, that names the parts: a ticket tracker, a git host, an orchestrator that starts runs, runners that do the work, and an observability platform where a person can see what happened in each run. In those terms, the office is close to his own-tracker design, where one app holds the tickets, starts the work and shows what happened. Its floor is the observability platform. The main difference is that his runs never wait for a person, and the office's sessions do, with a raised hand.
The most automated version is what people call a dark factory, where no person writes or reviews the code. Simon Willison described how StrongDM runs one, with two rules: "Code must not be written by humans" and "Code must not be reviewed by humans." It checks the work with test scenarios kept outside the code, where the agents cannot see them.
The office is far from that, and it is not really a factory yet. A factory starts work from events, such as a label on an issue. In the office only I press Start, and the only thing that starts on its own is the review when a pull request opens. Sessions run on my Mac with my logins, not on throwaway machines with only the access a ticket needs. And a Dev writes its own tests.
I am fine with giving up more control. As I wrote in Who Owns the Process?, near the top of Tan's trust ladder the agents merge their own pull requests overnight. So the constitution lists the rungs from here, roughly in order:
- Review findings go back to the Dev without me carrying them, with a limit on the rounds.
- The Lead keeps tickets moving, and stops sessions that are finished or idle.
- A label starts a ticket, with no one pressing Start.
- A pull request merges when CI, the review and the hidden checks pass. The relay merges it, not a session.
- A monitor watches what shipped and files tickets.
Each rung is its own ticket. It is off until I turn it on, and it starts with one kind of ticket, such as docs-only changes. Pocock's software-factory skill lists questions to answer before any of them goes in, such as where a person comes back in and what stops two runs from doing the same work. Rungs 3 and 4 take me out of a step, so they wait for two things: checks that the Dev cannot see or change, like StrongDM's scenarios, and sessions that run with only the access their ticket needs.
Some things stay with me at every level: what to build, the quality bar, and the rungs themselves. Osmani's second factory post makes the same point. Human judgment does not leave the factory. It moves upstream to intent and design, and downstream to evidence and owning what ships.
What I don't know yet
I have not measured whether the office makes me faster. It does answer the question it was built for, which session needs me. That leaves the hard question from Steering Claude Code Without a Keyboard. Sessions filed 23 tickets in an afternoon, and approving one costs a single click. That is the same pattern as the A button on the game controller: approving got cheap, and reading what I approve did not.
Four numbers would tell me whether the office helps, and which kind of ticket is ready for the next rung:
- How long a raised hand waits before I answer.
- How often I reject a ticket from Triage.
- How many review findings turn into changes.
- How each finished task turned out, with the labels Osmani cites from Vercel: success, flawed, blocked or manual.
The relay already sees the events it needs for the first two.
The agents had a big part in building their own office, and I am curious where that goes. For now their goals stay narrow on purpose. Every piece of work starts from something in the office: a ticket I approved, a task I started or a prompt I typed. When they think of new work, they file a ticket, and it waits in Triage for me. They do not set goals of their own outside that, and as I wrote above, that is a rule about the process, not a security boundary. Rungs 3 and 5 would let a label or a monitor start work, one small kind of ticket at a time.
Code
The code and the constitution are public in Building58 on GitHub. The office runs locally and needs Node 18, python3 for the terminal, and Claude Code. Running it needs no packages to install.