ROOM

Repetitively Obsessively Optimize Me

Voltage-controlled repo sequencer

REPETITIVELY OBSESSIVELY OPTIMIZE ME

ROOM runs a self-perpetuating (not self-hating) cold-start loop against your git repo. Stop micromanaging coding agents, let go and trust the process. Your idea sails on carefully curated universal background radiation to settle into a groove. It's kinda like raising a kid, you give some guidance but then they grow up.

Example build

room-signal-garden.vercel.app

Built from one prompt. Then gpt-5.3-codex-spark ran 100 iterations without my input.

cold starts onlyforced pivotsartifact tape intact

providers

Codex + Claude Code

Same loop. Different operators.

memory model

Cold starts only

No fragile chat residue between passes.

artifact tape

Record

Prompt, stderr, result JSON, diff patch.

stall control

Forced pivots

When the oscillator is spent, route elsewhere.

Signal source

codexclaude codecold-start promptsforced pivotswe are all on the same universal spaceshipone improvement per passsignal clipped? inspect the tapeone universeone worldone love?.room state stays localoperator-grade loop control

Module 01

One concrete improvement per cycle

ROOM keeps the loop narrow on purpose: one worthwhile improvement, one validated JSON result, one commit decision.

Module 02

Cold-start prompts stay honest

Each pass rebuilds context from local repo state, recent summaries, commits, and the current instruction instead of trusting chat drift.

Module 03

Failure tape stays inspectable

Malformed JSON, provider issues, tiny diffs, and clipped signals all leave artifacts behind so the run can be debugged after the fact.

Module 04

Stagnation triggers a reroute

Duplicate instructions, churn loops, and spent subsystems get pressure-tested until ROOM rewrites the next instruction into a pivot.

Module 05

Built like an operator tool

The product is a local power tool, not a polite platform. It assumes git, authenticated CLIs, and someone who wants the tape.

Module 06

Live TUI energy, not dashboard mush

ROOM’s visual language leans modular synth and signal trace: oscillators, resonance, overload, queue depth, pivots, and tape.

Signal choreography

Four disciplined moves. No vague orchestration theater.

01

Seed the room

Initialize local state, schema, instruction tape, summaries, and run directories inside `.room/`.

02

Fire the loop

Build fresh prompt context and drive the selected CLI headlessly with a tight JSON contract.

03

Read the meters

Store stdout, stderr, result, metadata, and diff artifacts so every iteration can be replayed like a diagnostic trace.

04

Commit or pivot

Keep strong changes, detect stale momentum, and force the next instruction to move when the signal path starts circling.

Live meters

Progress should look and sound like a machine under load.

Quick route

Install it, seed it, pressure the repo, and keep the tape.

curl -fsSL https://raw.githubusercontent.com/jcpsimmons/room/main/scripts/install.sh | shroom init --prompt "Make this repository materially better."room doctorroom run --iterations 5

Artifact tape

Every run leaves a readable trail.

prompt.txtcaptured
execution.jsoncaptured
stdout.logcaptured
stderr.logcaptured
result.jsoncaptured
diff.patchcaptured

ROOM keeps `.room/` out of its own dirty checks and commits so the operator state stays local and the repository stays sane.

External channels

Keep the signal moving outside the terminal.

The voice here is the same as the product: sharp, inspectable, and allergic to generic SaaS beige.