Debussy

Claude. Claude Debussy. 🎹

A Claude Code plugin marketplace from Oire: a small set of plugins for planning, review, documentation, and .NET work — plus an opt-in pack of opinionated Oire coding conventions. Packaged so both humans and Claude can navigate it, and so you can install just the pieces you want.

What's inside

debussy/
  .claude-plugin/marketplace.json   the marketplace manifest (lists the plugins)
  plugins/
    planning/        brainstorm + plan-make + plan-review + plan-exec
    review/          project-analyst (Nigel) + project-audit
    write-manual/    accessible user-manual pipeline
    dotnet-tools/    Oire .NET style corrector
    conventions/     opt-in convention hooks (American English, git-guard)
  settings/          settings.json snippets for manual hook wiring
  docs/              design notes (marketplace roadmap)
  install.* sync.* uninstall.*   helpers for the manual hook path

The plugins

Plugin	What it gives you	Install
planning	brainstorm, plan-make, plan-review, plan-exec	/plugin install planning@debussy
review	project-analyst (Nigel), project-audit	/plugin install review@debussy
write-manual	accessible user-manual pipeline	/plugin install write-manual@debussy
dotnet-tools	.NET style corrector	/plugin install dotnet-tools@debussy
conventions	opt-in convention hooks	/plugin install conventions@debussy

Add the marketplace once, then install whichever you want:

/plugin marketplace add Oire/debussy
/plugin install planning@debussy

To try a plugin from a local checkout without publishing, point Claude Code at the plugin directory: claude --plugin-dir plugins/planning (and /reload-plugins inside a session picks up edits). Or add the whole local repo as a marketplace: /plugin marketplace add <path-to-debussy>.

planning

The idea-to-execution pipeline; the four components chain via the docs/plans/<number>-<task>.md convention.

Component	Trigger	Description
brainstorm (skill)	/planning:brainstorm, or "brainstorm", "help me design"	One-question-at-a-time conversation that turns a rough idea into a validated design
plan-make (command)	/planning:plan-make	Writes a structured implementation plan to docs/plans/ on a new branch cut from the up-to-date base branch
plan-review (agent)	Task tool, or "review my plan"	Read-only review of a plan for completeness, correctness, and over-engineering before any code
plan-exec (skill)	/planning:plan-exec, or "execute plan"	Executes the plan task by task in isolated subagents with a commit per task, reviews the result (parallel reviewers, an independent skeptic, a fixer), and opens a pull request

review

Component	Trigger	Description
project-analyst (agent, "Nigel")	Task tool, or "what would a senior dev criticize?"	Holistic review of a project's polish, DX, docs, naming, packaging, and accessibility (WCAG 2.2 AA). Cross-stack
project-audit (skill)	/review:project-audit, or "audit the project"	Two-reviewer release audit pairing Nigel with an external Codex code review; their findings deliberately barely overlap

write-manual

Component	Trigger	Description
write-manual (skill)	/write-manual:write-manual, or "write manual"	Multi-agent pipeline (Haiku scouts → Sonnet research → Opus writing → Sonnet verify/translate) producing accessible, WCAG 2.2 AA desktop-app user manuals

dotnet-tools

Component	Trigger	Description
dotnet-style-corrector (agent)	Task tool, or "check my C# style"	Checks C# against Oire .NET coding standards and .editorconfig. Stack-specific, hence its own plugin

conventions (opt-in)

Opinionated Oire conventions enforced as PreToolUse hooks — organization policy, not universal truths, so opt in only if you want them. (The other plugins make no such assumptions and are meant for everyone.) When the plugin is enabled, its hooks.json wires the two cross-platform hooks via bash; see plugins/conventions/README.md for the full story and the PowerShell/manual alternative.

Hook	Fires on	Description
check-american-english (cross-platform)	Write/Edit/MultiEdit/NotebookEdit	Blocks writes containing non-American spellings
check-git-guard (cross-platform)	Bash/PowerShell	Blocks git writes that destroy work — bare force/deleting/mirroring push, reset --hard, restore, destructive checkout, clean -f, bulk staging, git mv/git rm, rebase -i. Staging named paths, committing, amending, a plain or leased push, and a non-interactive rebase are allowed
check-no-null-redirect (Windows-only)	Bash/PowerShell	Blocks null-device redirects that leave stray nul files. Shipped but not auto-wired (a plugin can't branch on OS); wire manually on Windows

Settings

plan-make, plan-exec, project-audit, and write-manual work on a new branch cut from the current tip of your base branch, commit as they go, push, and open a pull request with gh. To change that, or how you mark notes when you review a file by hand, create .claude/debussy.json in a project, or ~/.claude/debussy.json for all of them (a key in the project file wins):

{
  "git": "pr",
  "baseBranch": "",
  "aiAttribution": false,
  "noteMarkers": ["!USERNOTE!"]
}

• git: none leaves every change uncommitted, commit stops after committing on the branch, push also pushes it, and pr (the default) also opens the pull request.

• baseBranch: where work starts and what the pull request targets. Empty means detect it from origin/HEAD, falling back to main, master, trunk, or develop.

• aiAttribution: false (the default) keeps AI, Claude, co-author trailers, and session links out of branch names, commits, and pull requests.

• noteMarkers: how you leave notes in a plan or manual you are reviewing by hand. An entry is a single token (!USERNOTE!, @@, %%%), where the note runs to the end of the line, or an opening and closing pair written with ... ([usernote]...[/usernote]). When you then say "done", "go", or "continue", the skill acts on every note, removes it, and asks rather than guesses at the slightest doubt.

aiAttribution is an instruction to the model. To also switch off the attribution Claude Code itself adds, set attribution in your Claude Code settings.json (its commit, pr, and sessionUrl keys).

The full contract is in any skill's references/settings.md, git.md, and manual-review.md, for example under plugins/planning/skills/plan-exec/references/.

Updating plugins

Installed plugins don't update themselves. To pull the latest from the marketplace, refresh the catalog and then update the plugin:

/plugin marketplace update debussy
/plugin update planning@debussy

Or enable auto-update for a plugin from the /plugin menu.

Manual hook wiring (optional)

If you prefer the native PowerShell hook runners, or want the hooks always-on without enabling the plugin, wire them through settings.json instead:

1. Run install.ps1 (Windows) or install.sh (Unix) to copy the hook scripts into ~/.claude/hooks/.
2. Merge the matching snippet from settings/ into your ~/.claude/settings.json under hooks.PreToolUse, then restart Claude Code.

Windows + the plugin? If you enable the conventions plugin for the cross-platform hooks and only need to add the Windows-only check-no-null-redirect, you don't have to copy anything: wire a single settings.json entry pointing straight at the plugin's own shipped script, so it tracks marketplace auto-updates instead of drifting from a copy. Just don't also wire the cross-platform PowerShell runners while the plugin is enabled, or check-american-english and check-git-guard will fire twice. Full recipe in plugins/conventions/hooks/README.md.

sync.* pulls in-place hook edits back into the repo; uninstall.* removes the copied hooks (by name — it never touches your other hooks).

Conventions enforced here

debussy is developed with its own conventions plugin enabled, so the repo follows its own rules: American English everywhere, no null-device redirects on Windows, and no Claude-side git writes that destroy work (Claude may stage named paths, commit, amend, rebase, and push — including with --force-with-lease; it never pushes a bare --force, deletes a remote branch, discards changes, or uses git mv/git rm). Documenting a spelling checker means occasionally describing non-American spellings without spelling them out — see the authoring notes in plugins/conventions/hooks/README.md.

Acknowledgments

The planning plugin (brainstorm, plan-make, plan-review, plan-exec) is adapted from cc-thingz by Umputun — a mature, generous Claude Code marketplace that's well worth using directly. That material originates from his MIT-licensed work; his copyright notice is retained in NOTICE. Thank you, Eugene.

License

debussy is licensed under Apache-2.0. It incorporates MIT-licensed material from cc-thingz (the planning plugin); MIT and Apache-2.0 are compatible, and Umputun's MIT notice is retained in NOTICE as required. Copyright 2026 André Polykanine (Oire).