wicked-garden

Wicked Garden — AI-Native SDLC A full software development lifecycle as a single Claude Code plugin. 14 domains, 80 specialist agents, 152 c

Open source Open in the app JSON README (API)

About

Wicked Garden — AI-Native SDLC A full software development lifecycle as a single Claude Code plugin. 14 domains, 80 specialist agents, 152 commands — covering everything from requirements through production operations. What makes it different from a good CLAUDE.md: it's executable infrastructure, not passive guidance. Hooks enforce workflow gates before Claude sees your prompt. Context from memory, search, and project state is assembled automatically on every turn. Decisions persist across sessions. Quality gates actually block progression when evidence is missing. Works standalone with zero external dependencies. Local SQLite storage. No API keys, no cloud services, no setup beyond install. Core systems: - Crew — Signal-driven project workflows with 8 phases (clarify → design → build → test → review → operate), 7-dimension complexity scoring, hard-enforced quality gates, and multi-perspective consensus review for high-stakes decisions - Smaht — Automatic context assembly on every prom

Details

Kind: Plugins
Topic: AI, RAG & memory
Publisher: mikeparcewski
Origin: marketplace
Category: ferramentas
Stars: 9
Forks: 2
Open pull requests: 7
Last push: 2026-09-07T17:54:04Z
Repository state: ativo
Language: Python
License: MIT
Added: 2026-08-30 01:48:58
Updated: 2026-08-30 01:48:58
Origin id: mikeparcewski/wicked-garden/wicked-garden

README

```
           _      _            _                           _            
 __      _(_) ___| | _____  __| |       __ _  __ _ _ __ __| | ___ _ __  
 \ \ /\ / / |/ __| |/ / _ \/ _` |_____ / _` |/ _` | '__/ _` |/ _ \ '_ \ 
  \ V  V /| | (__|   <  __/ (_| |_____| (_| | (_| | | | (_| |  __/ | | |
   \_/\_/ |_|\___|_|\_\___|\__,_|      \__, |\__,_|_|  \__,_|\___|_| |_|
                                       |___/                             
```

# wicked-garden

**Your coding agent already plans and swarms. wicked-garden is the curated toolkit for what it can't do alone.**

> 📖 Docs → [wg.wickedagile.com](https://wg.wickedagile.com). Identity & beliefs → [`ETHOS.md`](ETHOS.md). How it works → [`CLAUDE.md`](.claude/CLAUDE.md).

---

## The premise

Coding agents grew up. Claude Code, Codex, Cursor, Antigravity, Aider, OpenCode, Zed/ACP — they're not autocomplete anymore. They plan. They parallelize. And each has *strong opinions* about how it likes to work.

Most plugins try to boss them around — re-implement planning, impose a workflow, make the agent dance. You end up fighting your own tools.

**wicked-garden refuses to wrestle the harness.** It assumes your agent is good at the things it's good at, and fills the gaps it *can't* fill on its own.

## The gaps it fills

| Your harness… | wicked-garden… |
|---|---|
| says *"tests pass"* (sometimes it's lying) | re-runs the proof. False "done" → **rejected.** Missing backend → **fails closed.** Never a vacuous green. |
| greps and reads — blind to string-wired links | sees the **injected edges** (event→consumer, command→agent, agent→capability) grep never will → `blast-radius`, `lineage` |
| refactors on a hope and a prayer | renames across files as a **graph operation**, not find-replace roulette → wicked-patch |
| forgets everything at `exit` | remembers what session 1 decided when you're in session 47 → the mem domain over wicked-estate |
| re-derives *how to work in this repo* every task — which file owns the bug, the wiring step, the test command | loads the repo's own playbooks (`fix-bug`/`add-feature`/`verify`…), generated from HEAD → wicked-understanding |
| asks *itself* for a second opinion | convenes a **real multi-model panel** (Antigravity / Codex / …) → the jam skill's `council` action |
| re-derives WCAG/CWE/SOC2 from memory every time | loads the rubric on demand, ships it to any repo |
| grades its own homework | author ≠ executor ≠ reviewer → evidence-gated testing |

The throughline: **done is re-derived, not asserted.** Verdicts you can trust on the first read — not green checkmarks you can't.

## What it's *not*

- **Not a workflow it forces on you.** Your harness still drives. wicked-garden reads the *shape* of the work, applies the right amount of rigor, and steps back.
- **Not a reinvention** of the planning and swarm your agent already nails.
- **Not Claude-only under the hood.** Ships as a Claude Code plugin, but the engine is CLI/npm peers — and the gate **compiles into any repo and runs with no wicked-garden installed** (`/wicked-garden-prove compile`). Stand on the harness, fill its gaps, hand off. Never absorb.

<details><summary><b>How it stays out of the way: work-shape, not pipeline</b></summary>

No universal pipeline to obey. A hook reads each prompt's *shape* and that decides one thing: **how much rigor this work earns.** A typo (`triage`) gets none; a migration cutover (`migrate`) gets a hard, independently-attested gate with a rollback proof. Ten shapes — `triage · explore · specify · decide · build · review · ship · incident · migrate · modernize` — steering, not blocking. Why shapes and not one pipeline → [`docs/v11/archetypes.md`](docs/v11/archetypes.md).
</details>

---

## Install

```bash
claude plugins marketplace add mikeparcewski/wicked-garden
claude plugins install wicked-garden
```

Or use the family installer — [`npx wicked-installer`](https://www.npmjs.com/package/wicked-installer)
installs/updates the whole wicked-\* family (garden, its peers, and the rest).

Then, in a Claude Code session:

```bash
/wicked-garden-core setup          # verifies peers; blocks only on the one the gate needs
```

**One required peer, the rest opt-in.** The evidence gate is the floor we won't fake, so it needs one external peer — setup blocks without it:

```bash
npm i -g wicked-vault          # wicked-vault (≥ 0.5.0), the honest-evidence backend the gate re-derives against
```

> The gate/resolve engine (formerly the separate `wicked-loom` package) is now **absorbed in-package** as of v12.27.0 (`scripts/loom/`) — nothing extra to install. The gate re-hashes recorded evidence and re-runs its verifier through that engine; a false "tests pass" is **rejected**, a missing backend **fails closed**.

The rest of the kit is **opt-in layers** — add what you want, skip the rest and the toolkit still works:

```bash
# wicked-estate — the memory/knowledge layer (cross-session recall + cited search, the "what"):
#   install the `wicked-estate` + `wicked-estate-mcp` binaries onto PATH or ~/.local/bin
npm i -g wicked-bus && npx wicked-bus-install   # the audit-trail layer (fire-and-forget; fail-open without it)
```

> Evidence-gated acceptance testing (author ≠ executor ≠ reviewer) needs no extra install — it ships **in-catalog** as the `qe` domain (`wicked-garden-qe`).

Optional, lights up the code graph: **wicked-estate** (single binary; `wicked-estate index <path>` + the estate MCP server) → powers `blast-radius` / `lineage` / `hotspots` / wicked-patch (ADR 0005 — no external codegraph engine, no Node version floor). Details: [`docs/required-peers.md`](docs/required-peers.md).

## Try it

```bash
# Just work — the hook applies the right rigor underneath, quietly
"implement caching for the dashboard"

# Or reach for a gap-filler on purpose — everything is a skill now
/wicked-garden-prove                              # re-derive "done" from evidence (fail-closed)
/wicked-garden-search blast-radius emit_event     # impact, incl. edges grep can't see
/wicked-garden-engineering-patch rename oldField newField  # deterministic, graph-driven
/wicked-garden-jam council "redis or memcached?"  # a panel that isn't just you

# Stamp the evidence gate into ANY repo (runs with no wicked-garden installed)
/wicked-garden-prove compile ~/path/to/repo --trigger ci
```

---

## Build on it

The catalog is open: ship your own domain pack — a `wicked-pack.json`
manifest plus `{vendor}-{domain}` router / `{vendor}-{domain}-{role}` fork
workers — and the runtime discovers it without a garden PR: catalog listing,
crew specialist routing, peer-floor probing, same evidence discipline.

```bash
npx wicked-garden pack check ./acme-seo-pack   # the shipped conformance gate
npx wicked-installer pack add acme-seo-pack    # acquire + validate + install + register
npx wicked-garden pack list                    # what the runtime sees
```

Full author guide: [`docs/extending.md`](docs/extending.md).

---

## Principles

- **Don't fight the harness.** Fill the gaps; never re-implement what it already does well.
- **Done is re-derived, not asserted.** Every gate recomputes the evidence; the gates that matter are signed by someone who isn't the author.
- **Steering, not blocking.** Rigor follows the shape of the work, applied only where it earns its keep.
- **Enforcement that travels.** The gate compiles into any repo and runs without wicked-garden present.
- **Borrow the harness's primitives.** Extend `TaskCreate`/`Task()`/skills/hooks — don't rebuild them.

## More

[`ETHOS.md`](ETHOS.md) · [`docs/getting-started.md`](docs/getting-started.md) · [`docs/domains.md`](docs/domains.md) · [`docs/required-peers.md`](docs/required-peers.md) · [`docs/compiler.md`](docs/compiler.md) · [`docs/extending.md`](docs/extending.md)

## Requirements

A coding-agent harness ([Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview) ≥ 1.0 for the plugin surface; the peers + compiled gate are harness-agnostic) · Python 3.9+ (stdlib-only hooks) · Node + `npx` · the gate's one required peer (`wicked-vault` ≥ 0.5.0) plus opt-in layers (`wicked-estate` · `wicked-bus`).

## License

MIT. See [LICENSE](LICENSE).