The result is Switch SkillOps.

• Demo (1:25): https://youtu.be/NwBfaLTQvgw
• Code (MIT): https://github.com/gaikwadashutosh35/switch-skillops

What it does

Everything happens in one Mattermost channel, skillops-triage:

1. I post a bug: "The settings page crashes when I save a profile with an empty optional display name…"
2. skillops-manager triages it: SKO-0001 · bug · risk low · TRIAGED, with acceptance criteria, the workflow it picked (bug-tdd) and why.
3. I say start SKO-0001. The manager hands it to skillops-coder, which writes a failing regression test (the bug reproduces), fixes it with a one-line change, and posts the passing test output.
4. skillops-reviewer, a separate agent that didn't write the change, re-runs the tests, checks the acceptance criteria with file references, and asks me to decide.
5. I reply "looks good, merge it". Refused. Only APPROVE SKO-0001 merge from a person counts.
6. I send the exact approval. The merge then stops at a permission card in the room, and only runs after I click Allow once.

In the recorded run, the whole thing from bug report to merge took about six minutes, most of it me reading.

Switch in one paragraph

Switch connects AI agents you already use (Claude Code, Codex, OpenCode and others) to team chat. A room is a chat channel where people and agents work together with shared context: room instructions, history, and who may talk to whom. Switch Console is the desktop app that runs a server, connects chat apps, and starts agent sessions for you. On a local setup it even brings its own Mattermost, so you don't need a Slack workspace.

Why Switch was essential

I didn't write any chat plumbing. Switch provided:

• The room. Each agent is a real Mattermost bot in the channel, and everyone sees the same history.
• Handoffs. Agents wake each other with Switch targeted messages ("@skillops-coder SKO-0001 is planned… please implement it"). Switch also has a task-delegation protocol, but its docs mark it "present but not ready for use", so I used targeted messages.
• Who may instruct whom. The default addressing policy, me and my agents, lets my agents delegate to each other while refusing strangers.
• Approval in chat. When the manager runs the merge command, Claude Code's permission prompt arrives in Mattermost as a card with Allow once / Allow for this session / Decline. That's the moment the whole demo builds to, and it came for free.

The one design rule: agents propose, code decides

Prompts are not guardrails. So the agents only read free text and draft; two small Python modules decide everything that matters:

• triage.py validates the agent's JSON draft and refuses any risk, workflow or status field in it. It sets risk from the person's own words: deploy, production, token, rm -rf and similar mean high risk, which routes to a "stop, a person decides" workflow. It also deduplicates by Switch message id.
• work.py runs every later step with a state check first. check runs the tests with fixed arguments and saves trimmed, redacted output as evidence. decide accepts only APPROVE SKO-xxxx merge from a non-agent while the request awaits approval. merge refuses anything not APPROVED.

That gives two independent gates on the one consequential action: SkillOps state, and the Switch permission card. All of it is covered by 50 standard-library unit tests.

The best bug was found by my own agents

On the first full run, the coder reproduced the bug, committed a correct fix… and check refused to move it to review. The coder stopped and reported the block in the room instead of forcing it through.

The cause was mine: the demo repo had no .gitignore, so running the tests wrote __pycache__/*.pyc, which got committed and was rewritten on every run. The tree was never clean, so check always said "not committed". My unit tests missed it because my own shell had PYTHONDONTWRITEBYTECODE=1, and the agents' shells didn't. The fix was a seed .gitignore, bytecode-free test runs, and a regression test that clears that variable on purpose.

It was a good reminder to test in the environment your agents actually run in.

Giving the agents a debugging method

The coder's brief said "test first, smallest fix", but nothing about what to do when the cause isn't obvious. So I gave two agents a Claude Code skill each: a SKILL.md in the agent's own folder that it loads when the task matches. Neither skill adds a single command to the agent's allowlist.

• skillops-coder → debug: reproduce with a failing test, one hypothesis at a time, find every caller of the broken function, fix where they all pass through, then check the neighbouring inputs.
• skillops-reviewer → bug-hunt: the reviewer can't run code, so it traces edge-case inputs through the change by reading it (empty, whitespace, None, Zoë, 李, emoji, repeated spaces) and checks the other callers.

I tested them live in the room and checked the agents' Claude Code transcripts rather than trusting what they said. The reviewer really did load bug-hunt: its review notes list every input it traced, plus two real problems outside the acceptance criteria (a stale docstring, and display_name=None raising). The coder never loaded debug, because the bug was obvious and its brief only calls for it on hard bugs. It still fixed the root cause. So one skill is proven and one isn't yet, and the repo says exactly that.

There's a third skill for me rather than the agents: skillops-troubleshoot, a symptom → evidence → fix runbook for the setup problems further down.

Then I tried to break it

With the demo working, I brute-forced my own code: 5,000 random and malformed drafts, 39 dangerous wordings, 25 fake approvals, 60 random workflow runs on a throwaway repo, and 18 secret formats. It found four serious bugs, all of which the happy-path demo had walked straight past:

1. Review could pass code it never tested. work.py review ran the tests on whatever branch was checked out. Start a second request while the first waits for review, and the first gets reviewed against the wrong code.
2. The merge took the branch, not the reviewed commit. Anything committed after review would have been merged too. Now review records the commit it tested, and merge takes only that commit.
3. Non-English text crashed triage on Windows. Python read the agent's UTF-8 as cp1252: Zoë was stored as Zoë, and 李 crashed it. Fittingly, the demo bug is about display names.
4. Secret redaction caught 7 of 18 formats. "token": "…" and Authorization: Bearer … went straight through. Now it catches all 18.

Each fix got a failing test first. Two more followed: @skillops-manager was getting past the "agents can't approve" check, and high-risk requests could still be started. The fuzzer also found smaller problems I haven't fixed yet. The repo lists them as open, among them rm -fr not counting as high risk.

The lesson: "agents propose, code decides" is only as strong as the code that decides, so attack that code before anyone else does.

What I wish I had known on day one (Windows, Switch Console 0.40.1)

These cost me hours. Each one is written up with logs and source references in the repo's test results.

1. You don't need WSL on Windows. On a local server, agents run as managed agents on your PC. If the provider list is empty, open Your Agents → + and click Run managed agents on this computer. I lost an afternoon setting up an Ubuntu SSH host I never needed.
2. Create agents in the New agent form, not a template. In 0.40.1 on Windows, the template form showed every provider as "Not supported here", while the New agent form worked. My template now creates only the room (instructions, members, kickoff) and adds existing agents.
3. Set the Directory when you create the agent. An agent's existing room session keeps the directory it started with, even after you edit the agent. !reset resumes the same session. If you got it wrong, delete the agent, recreate it, and !invite-agent it back.
4. If agents go silent after a restart, check the Mattermost bridge. If Mattermost comes up after the Switch server (say, Docker restarted), the bridge crashes and doesn't retry. The server log says Bridge … crashed. The fix: Admin → Status, turn Mattermost off and on.
5. Your project's allow rules need a trusted folder. Claude Code ignores a project's permissions.allow until the folder is trusted, but deny rules always apply. I verified that in each agent's folder: git status was denied while an unlisted python --version ran.
6. Read the source when the UI surprises you. The Switch repository is very readable. Every one of the issues above I confirmed in the code rather than guessing.

I filed numbers 2, 3 and 4 upstream with logs and source references (#1511, #1512, #1510). Within two hours another hackathon participant had opened a fix for the bridge crash (#1515), and I checked it against my crash logs on the issue. Detailed bug reports are a contribution too.

Tips for your first Switch room

• Start with the quickstart and get one agent answering in a room before building anything.
• Put the agent's brief in CLAUDE.md in its working directory. Console also adds the agent's instructions to the session, after Switch's own skill.
• Address agents with @name at the start of a message; a message that addresses nobody is silently ignored.
• !reset @agent gives an agent a fresh context; !help lists every room command.
• Mattermost replies often land in threads. If an agent seems stuck, check the thread under your message: a permission card may be waiting there.

What's next

SkillOps merges locally into a demo repo. Next I'd fix the open fuzzing findings, have the manager open a real GitHub draft pull request after approval, and let teams point it at their own repository.

If you're starting with Switch, I hope the list above saves you the hours it cost me. Code and docs: https://github.com/gaikwadashutosh35/switch-skillops

Built for the Flip the Switch hackathon by WeMakeDevs and DevTools Academy, with Claude Code as my pair programmer. #HowISwitch