Codebloom

🇫🇷 Version française

Codebloom — workflow ritual for Claude Code

Claude Code, structured — plan, verify, ship. No rush, no slop, no drift.

A Claude Code plugin that turns your AI agent into a structured teammate: it explains before coding, verifies before shipping, and documents before pushing.

Who this is for

If you use Claude Code seriously — not just to autocomplete a line — you know the drill. It rushes in, refactors five files when you asked for one, invents function names that don't exist, forgets the convention you just set, and declares done before running the tests. Codebloom is the missing workflow layer that fixes this.

It's built for:

• The solo dev who writes code with Claude every day, juggles three or four projects, and keeps hitting the same oversights.
• The freelance / consultant who jumps between WordPress, Node, Python, Rails, Flutter — and wants one consistent guardrail across all of them.
• The tech lead who needs to standardize how the team uses Claude Code, so reviews, tests, and conventional commits aren't optional anymore.

If none of that sounds like you, you probably don't need Codebloom. If it does, keep reading.

The problem

By default, Claude Code is a brilliant but undisciplined teammate. Ask it to fix one bug, it refactors five files. Ask it a question, it writes code. Ask it to review, it praises the diff and moves on. The result is a workflow that feels fast until the third time you undo something it "helpfully" changed.

Concretely:

• It rushes in. You ask for a share button, it modifies 8 files and installs a library.
• It over-engineers. Strategy patterns for a single function, any types, flags for features you never asked for.
• It hallucinates references. Function names that don't exist, WordPress hooks invented on the spot, API signatures that look plausible but aren't real.
• It forgets context. Your design system, your conventions, your CLAUDE.md — ignored the moment the session gets long.
• It says "done" without verifying. No test run, no build check, no proof. Just ✓ finished.
• It flatters. "Great question!", "You're absolutely right!", "I hope this helps!" — tokens you pay for, zero signal.

Codebloom fixes each of these with a layered system: 15 auto-invoked skills, 7 specialized agents working in isolated background contexts, 6 slash commands that structure your session, and 7 inviolable rules injected into every project's CLAUDE.md.

Before / After

A real request, a real difference.

Without Codebloom:

You:    "Add rate limiting to the /api/users endpoint"
Claude: [opens 6 files, installs express-rate-limit, refactors the auth
         middleware, changes the error handler signature, adds Redis as a
         dependency, "✓ done!" — no tests run, no security check]
You:    "... I just wanted rate limiting on one route."

With Codebloom:

You:    "Add rate limiting to the /api/users endpoint"
Claude: "Plan:
        - Add express-rate-limit middleware scoped to /api/users only
        - In-memory store, 100 req/min per IP
        - Files touched: routes/users.ts (1 line), middleware/rateLimit.ts (new)
        - Out of scope: auth middleware, error handler, global config
        Go?"
You:    "Go"
Claude: [implements, 2 files, minimal diff]

[you run /codebloom:push]

Claude: "Agents kicked off in parallel for the gate:
        ⏳ reviewer          — quality/security/footprint
        ⏳ tester            — test suite
        ⏳ security-auditor  — sensitive zones touched: /api/
        ⏳ researcher        — new dependency: [email protected]"

[pipeline runs in parallel, isolated contexts]

Claude: "✅ reviewer         9.1/10, clean
         ✅ tester           47/47 pass
         ✅ security-auditor 8.8/10, zero critical
         ✅ researcher       [email protected] — maintained, MIT, CVE-free
         📋 Aggregated report: 0 blockers, 2 suggestions → TODO.md [review]
         Ready to commit."

Same goal. Different outcome. The difference is not magic — it's a pipeline of skills and agents that enforce the discipline you'd apply yourself if you had infinite time.

The core loop

Every session with Codebloom goes through 4 moments. Skills and agents auto-invoke at each step.

1. Plan

Before touching a file, Claude stops and presents a plan: files it will change, what it will add, what's out of scope. You approve, it codes. You push back, it adjusts. No drive-by refactors. No tant qu'on y est.

intent-check enforces this on every message — a question gets a text answer, never code. Vague goals are reformulated into verifiable ones: "add validation" becomes "write tests for invalid inputs, make them pass".

2. Code

Minimal diff. No drive-by refactors. Every modified line must trace back to your request. code-quality enforces Karpathy principles (don't guess, code minimum, surgical, verify), zero invention of references, and the 3-strike rule (don't loop on the same error without changing approach).

context-guard saves tokens by delegating heavy explorations to subagents past 5 files and killing sycophantic openers/closers.

3. Verify

Before any commit, /codebloom:push runs a parallel pipeline of specialized agents in isolated background contexts:

• Always: reviewer (quality/security/footprint) + tester (run tests, check regressions)
• If the diff touches `auth|jwt|token|password|crypto|upload|.env|admin`: + security-auditor
• If a new dependency was added: + researcher
• If it's a structural change (new command, new dossier, new API): + doc-writer
• If you touched a file modified ≥5 times in the last 7 days: + git-historian

Claude waits for all of them. An aggregated report is shown, classified by severity. 🔴 blockers stop the commit — fix, rerun the impacted agents, loop until green. 🟠 important findings ask for your decision. 🟡 suggestions are auto-capitalized into TODO.md with source tags ([review], [sec], [audit], [research], [hotspot]) so nothing gets lost. The tester is the exception — it writes the missing tests instead of filing TODO items.

4. Ship

Once the gate passes, Codebloom handles the rest:

• Updates CHANGELOG.md (Keep a Changelog format)
• Runs a health-check on CLAUDE.md (size, obsolete commands, broken imports)
• Syncs structural changes via doc-writer
• Bumps the WordPress plugin zip if applicable (cross-platform, no rm prompts)
• Writes a conventional commit message (feat:, fix:, refactor:, chore:…)
• Pushes

Quick start

/plugin marketplace add vendeesign/codebloom
/plugin install codebloom@codebloom

That's it. Then in any project:

/codebloom:setup     ← configure once per project
/codebloom:hello     ← start of every session
(you work)           ← guardrails auto-load
/codebloom:push      ← end of session: verify, document, commit, push

What's inside

15 auto-invoked skills

Skills are contextual guardrails. Claude loads them automatically based on what you're doing — no command needed.

Permanent (active every session):

Contextual (load based on what you're touching):

7 specialized agents

Agents work in isolated background contexts. Their output is compact — it doesn't pollute your conversation. Every agent has:

• Zero-invention rule — nothing cited without being confirmed by a tool.
• Capitalization into TODO.md — non-critical findings end up as - [ ] [tag] description so you can triage later.
• Isolated context — each agent runs in its own window, returns a compact summary, never pollutes the main conversation.

6 slash commands

The inviolable rules

Codebloom injects a versioned block of 7 inviolable rules into every project's CLAUDE.md. This block is a safety net that works even when auto-invoked skills fail to load. Synchronized automatically by /codebloom:update, editable by you outside the markers.

1. STOP before writing code        — plan → approval → code, always
2. Question → text answer          — never Write/Edit on a question
3. Zero invention                  — cite only what a tool confirmed
4. Trace-test on every diff        — each line must trace to the request
5. Orphans vs pre-existing         — clean your own mess, leave the rest
6. Verification before completion  — no "done" without fresh proof
7. User override                   — your explicit instructions always win

These are the minimum contract. Everything else is guidance — these seven are enforced.

Tooling & goodies

Codebloom ships with a handful of cross-platform tools that sit quietly in the background and make the daily workflow more bearable. Zero config — all of them are enabled the moment you install the plugin.

Statusline

A permanent status bar at the bottom of Claude Code, with everything you actually want to see during a session:

Model: Opus 4.6 | /home/user/project | Session: 1h23 | Cost: $1.45
Context: 35% | 70k/200k tokens | 42k consumed
5h: $1.45/$5.00 ▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░ 48% | Reset 2h13 | Weekly: ▓▓▓░░░░░░░ 28%

Model, CWD, session duration, cumulative cost, context usage, 5-hour rate limit window with progress bar and reset countdown, weekly quota. Cached every 5 minutes to avoid rate-limit hits, with a 24-hour stale window and 429 backoff.

Cross-platform notifications

Claude notifies you when it finishes a turn or is waiting for your input — so you can tab away without missing the moment it needs you.

Powered by hooks/notify.js, a single Node.js script that Claude Code runs natively. Zero setup.

Screenshot → Claude Code

/codebloom:hello starts a watcher on your screenshots folder. Take a screenshot → the path is automatically copied to your clipboard → paste it into Claude Code to send the image. No save dialog, no drag-and-drop, no friction.

WordPress zip builder

A Node.js cross-platform packaging script (hooks/wp-pack.js) that handles PowerShell Compress-Archive on Windows and zip on Unix. It auto-detects plugin/theme headers, bumps version, cleans old zips via fs.unlinkSync (zero rm permission prompts during packaging), and verifies the final zip before handing it back.

Philosophy

• Karpathy minimalism — three similar lines beat a premature abstraction. If 200 lines could be 50, rewrite. No abstractions for single-use code. No features beyond what was asked.
• Zero invention — if a path, function, or API wasn't confirmed by a tool (Read, Grep, Glob, Bash, WebFetch), it doesn't get cited. Hallucinations are the fastest way to lose trust — especially in agent pipelines where downstream systems break on fake values.
• Trace-test — every modified line must be justifiable by the user's request. Drive-by refactors are reverted on sight.
• Anti-slop — UI output is distinctive: Fraunces or Instrument Serif, not Inter everywhere. Earth tones, not indigo-violet gradients. No glassmorphism. No bg-indigo-500 buttons by default.
• User override — every rule bends to explicit user instructions. The plugin guides the default behavior, never fights you.
• Skills over CLAUDE.md bloat — your CLAUDE.md stays under ~120 lines (warns past 150, alerts past 200). Contextual knowledge lives in skills that auto-load, not in a bloated instruction file the model eventually ignores. This follows Anthropic's official best practices.

Requirements

• Claude Code installed
• Git configured
• Node.js (bundled with Claude Code — powers the cross-platform hooks)

Install

/plugin marketplace add vendeesign/codebloom
/plugin install codebloom@codebloom

Then in any project:

/codebloom:setup

Update

/plugin marketplace update codebloom
/plugin update codebloom@codebloom

Then in each project (once):

/codebloom:update

/codebloom:hello tells you when a new version is available on the marketplace.

Contributing

Commands, skills, and agents are Markdown files with YAML frontmatter. Easy to read, easy to edit, easy to fork. See CONTRIBUTING.md.

License

MIT — free to use, modify, distribute, fork.

Support

If Codebloom saves you hours of work every week and you want to keep it growing:

Solana (SOL): CNJ81Uz9mjeudEcV2xcqPzwT9WPDLB3sifjfpLcbSWzw