Breakup with AI

Stop babysitting Claude Code.

Breakup with AI is a Claude Code plugin that turns vibe coding from a needy live chat into a real delegation loop:

goal -> lock -> compact execution -> verify -> receipt

You tell Claude Code what to build. Then you leave. No token casino. No blinking dopamine stream. No "quick question" every three minutes. You come back to proof.

The Problem

AI coding tools are supposed to save attention.

Instead, they often eat it.

They stream every thought. They expose token anxiety. They ask tiny questions in batches. They make you watch logs scroll by like a slot machine. You feel productive because the screen is moving, but your day becomes one long babysitting session.

Breakup with AI changes the relationship:

Give intent once. Leave the room. Return to evidence.

What It Does

• Creates a compact mission brief from your goal.
• Locks the session so casual user interruptions are blocked.
• Forces noisy shell commands through compact output.
• Blocks obvious destructive commands with Claude Code hooks.
• Uses reviewer/verifier subagents for non-trivial work.
• Requires a final receipt before Claude can stop.
• Stores run state locally in .breakup-with-ai/.

The main slash command:

/breakup-with-ai Build a mini habit tracker with streaks and local storage. Verify build before final receipt.

Emergency unlock:

/breakup-with-ai-unlock

Quick Start

Clone the repo:

git clone https://github.com/Tensorboyalive/breakup-with-ai.git
cd breakup-with-ai
chmod +x bin/bwai

Use it locally in one Claude Code session:

claude --plugin-dir "$(pwd)"

Or install it as a local marketplace plugin:

claude plugin marketplace add "$(pwd)" --scope local
claude plugin install breakup-with-ai@breakup-with-ai-labs --scope local

After the repo is public on GitHub:

claude plugin marketplace add Tensorboyalive/breakup-with-ai
claude plugin install breakup-with-ai@breakup-with-ai-labs

Validate the plugin:

claude plugin validate .claude-plugin/plugin.json
claude plugin validate .claude-plugin/marketplace.json
python3 -m unittest discover -s tests

How It Feels

Before:

thinking...
I'll inspect the files.
running...
I found something.
Can you confirm which button style you want?
tokens remaining...
thinking...

After:

LOCKED 45m full

Then the final surface is a receipt:

STATUS: completed
OFFLINE_MIN: 38
GOAL: Build a mini habit tracker...
INTERRUPTIONS: 0
PROOF:
- npm run build passed
- files_changed: 14
RISKS:
- none recorded
NEXT:
- open local preview

Architecture

Breakup with AI uses Claude Code's native extension points instead of building a new app or agent runtime.

flowchart TD
  A["/breakup-with-ai goal"] --> B["bwai brief"]
  B --> C["bwai lock"]
  C --> D["Claude Code works"]
  D --> E["PreToolUse blocks unsafe Bash"]
  D --> F["bwai run compacts noisy output"]
  D --> G["breakup-verifier checks build/test"]
  G --> H["breakup-reviewer checks risk"]
  H --> I["bwai receipt"]
  I --> J["Final answer is proof only"]

Loading

The repo has four layers:

• Skills: slash-command workflows like /breakup-with-ai, /breakup-with-ai-compress, and /breakup-with-ai-receipt.
• Hooks: hard gates for user prompts, dangerous Bash commands, noisy output, and missing receipts.
• Agents: focused builder, verifier, and reviewer roles.
• CLI: bin/bwai, a zero-dependency Python control plane for state, receipts, compression, and hook decisions.

Repository Layout

.claude-plugin/plugin.json       Claude Code plugin manifest
.claude-plugin/marketplace.json  Claude Code marketplace manifest
skills/                          Slash-command workflows
agents/                          Builder, reviewer, verifier roles
hooks/hooks.json                 Claude Code lifecycle hooks
bin/bwai                         Local control plane
docs/                            Thesis, architecture, operating model, research
tests/                           Zero-dependency Python tests

Start here if you want the full reasoning:

• Problem thesis
• Architecture
• Operating model
• Research notes

Token Discipline

Breakup with AI does not pretend to compress hidden model reasoning or magically erase provider billing.

It attacks the parts we can control:

• visible verbosity
• repeated user prompts
• bloated shell output
• giant always-loaded memory files
• missing verification loops
• missing final proof

Noisy commands are blocked during a locked run unless Claude routes them through:

bwai run -- npm run build

The wrapper keeps error signal, head, and tail while dropping bulk noise.

Safety Posture

This is not a sandbox.

It is a focus and control layer for Claude Code. The hook gate blocks obvious foot-guns, including:

• sudo
• broad rm -rf
• disk formatting commands
• global chmod/chown
• force push
• credential-token reads
• common secret-file reads
• curl-pipe-shell and wget-pipe-shell

For production repos, review the receipt and diff before merging. The point is not blind trust. The point is to stop confusing supervision with work.

CLI

bwai init
bwai brief --goal "Build demo"
bwai lock --goal "Build demo" --budget 45
bwai run -- npm run build
bwai receipt --status completed --verify "npm run build passed"
bwai unlock

Run command help:

bin/bwai --help

Development

Run tests:

python3 -m unittest discover -s tests

Validate manifests:

claude plugin validate .claude-plugin/plugin.json
claude plugin validate .claude-plugin/marketplace.json

Smoke-test the local lifecycle:

tmp=$(mktemp -d)
CLAUDE_PROJECT_DIR="$tmp" bin/bwai init
CLAUDE_PROJECT_DIR="$tmp" bin/bwai brief --goal "Build demo"
CLAUDE_PROJECT_DIR="$tmp" bin/bwai lock --goal "Build demo" --budget 15
CLAUDE_PROJECT_DIR="$tmp" bin/bwai receipt --status completed --verify "smoke passed"
rm -r "$tmp"

The Line

Breakup with AI is for the moment you realize:

I do not want to date my AI coding tool. I want the work done.

That is the product.