I was spending so long on the boring parts of building software that I started losing interest in building itself.
So I built Backroom: a one-person software agency that runs from a Discord chat, on Switch. In a real run, two client documents that contradicted each other became an agreed brief in 30 minutes. That used to take me three to four days.
This post is how it works, what broke the first time it went live, and how you can set up the same shape yourself.
The problem was never the code
I run WebbyWasp, a small software agency, on my own. I build apps for startups testing new ideas. Most of them start with under 1,000 users, and they have no reason to pay big cloud bills for something that might not work.
So I keep costs tiny. For an earlier hackathon I built PgFy, because paying for a separate database per project made no sense: 50 databases for $12 a month. My client apps' databases run on it today.
Money wasn't the real cost, though. Time was.
Every new project meant the same work. Set up git. Copy compose IDs. Manage environment variables in Dokploy. Click through deploys. Then sync WhatsApp chats, task boards and every other project, and carry all of it to an AI agent by hand. Agreeing one final document took three to four days, partly because I kept putting off the work around it.
None of that was building. It was just tedious.
What Backroom does
A client talks in Discord. A team of agents does the work behind the scenes, and I only make the decisions that commit the business.
- Lead (Claude) reads the client's documents, finds contradictions, and writes the brief and technical plan.
- Builder (Codex) builds on a branch.
- Reviewer (a fresh Codex) tests the running app without ever seeing the builder's conversation.
- Desk (plain code, no AI) holds the approvals.
The rule behind all of it: the agents decide the work, and plain code holds the keys.
One real run
I tested this on real accounts with a demo project called Cedar Studio.
The client pressed Start a project, and the project was ready in 26 seconds. Then they posted two documents. One required a phone number on a quote form. The other said email only.
The lead caught that conflict and asked about it in the chat. It also found a second one nobody planted: the client wanted Polar plans, but the other document said no other integrations.
The client answered in one line: "Email only, please. Don't ask for a phone number. And yes, include the Polar plans section."
The lead worked out the rest, and the client confirmed the final brief 30 minutes after posting the documents. That time includes bugs I was fixing live.
Then GitHub filled itself in. A milestone, an issue with 12 acceptance criteria, a branch, commits signed by a Backroom Builder identity, and a pull request with CI. I never opened GitHub to do any of it.
The builder produced what the client agreed: a quote form with no phone field, and a Polar plans page in the admin dashboard.
Why Switch is the backbone
Backroom doesn't just use Switch. It stops without it.
Rooms are the wall. Clients and agents live in separate Switch rooms. When an agent tries to reach a client room, Switch refuses with HTTP 403. I didn't have to build that isolation myself.
Verified identity is the release gate. Every approval is tied to a verified sender. An agent's message can never count as mine, so an agent can't approve its own work. A prompt injection has nothing to talk to.
Handoffs run through it. Claude passes work to Codex through Switch, so two different vendors work as one team.
You can test this yourself with no accounts. bash demo.sh runs 49 steps on a real Switch stack, using scripted roles. Then it turns Switch off, and five real operations fail.
What replaced the clicking
NixOS replaced Dokploy. The deployer builds one exact commit and runs it in its own sandbox on a server I control. A deploy is one tap, not a build cycle I babysit.
The harness layer makes agents swappable. Each role is one line of config:
lead: {harness: claude, model: sonnet}
builder: {harness: codex, model: gpt-6-luna}
reviewer: {harness: codex, model: gpt-6.1-sol}
Trying a better model is a one line change.
Keys are the one chore left. I couldn't remove environment variables, but I could shrink them. The builder declares a name in .env.required, and I paste the value once into a private page. Saved values are never shown again, and they never reach an agent or the chat.
What broke when it went live
Every test passed before this run. Then the real path found what tests couldn't, because tests use stand-ins and these bugs lived in the joins between real systems.
- The desk couldn't verify senders. It deliberately has no Docker access, so its identity lookup failed on every message, silently. A tiny read-only helper fixed it, without giving the desk root-level access.
- Agents were locked out of their own folders. The login error blamed an old install. The real cause was folder permissions.
- Approval cards lost their buttons. Switch drops them from cards that are too long.
- A one-second loop burned GitHub's whole hourly limit. Polling now runs once a minute.
-
The sandbox protected
.git, so the builder couldn't commit until it got that one path. - In-memory tests hid a real Postgres bug that only CI could see.
My favourite: the builder refused to start because a document still said "proposed", even though I had approved it. That refusal was wrong, and it was exactly the caution I want.
The lesson: a green test suite doesn't prove the pieces fit. Send one real message through every hop before you trust anything.
Set this up yourself
If you are new to Switch, this is the shape that worked:
- Run Switch and connect your agents through its agent protocol. I used Claude Code and Codex.
- Bridge a Discord forum to a client room, and keep agents out of that room. Give them a private work room.
- Put one plain-code agent between the two rooms. Make it the only thing allowed to cross the wall.
- Use Switch's verified sender identity for every approval.
- Turn Switch off and confirm your workflow really stops.
The README has the setup, and bash demo.sh proves the wall in about a minute.
Where it stands
The workflow above ran on real accounts, up to a built app with an open pull request. Independent review and deploy for this project are the next stretch, and the code path that lets small safe changes ship with no taps from me is tested but hasn't run live yet. The reviewer catches I rely on so far came from rehearsal, including an admin page showing "Section not found".
I'm rolling Backroom out to production for a real client next.
The biggest change isn't the 30 minutes. It's that I'm building again, instead of configuring.
One person. A whole team.







Top comments (0)