mikeparcewski/wicked-garden-persona
skills/persona/SKILL.md
On-demand persona invocation system for applying named perspectives to any task. Sub-actions: `as <name> <task>` (invoke a persona), `list [--role R]` (discover personas), `define <name> --focus "..." [--save]` (create or update a custom persona). Use when: invoking a named persona ("as platform, review this auth flow"), applying a specific perspective or role lens to a task, listing available personas, defining a house persona that encodes a failure-mode defense, or reviewing work through a specific role's perspective.
$ install --global
skillsauthnpx skillsauth add mikeparcewski/wicked-garden wicked-garden-personaInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
Security Scan Results
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
3
Scanners Passed
9
Scanners in report
Clean
TrivyContainer and dependency vulnerability scanner
95%
Clean
SemgrepStatic code analysis for vulnerabilities
95%
Clean
mcp-scan (Snyk)Model Context Protocol security validation
95%
Skipped
Snyk (dep)Open source security scanning
50%
Skipped
Socket.devSupply chain security analysis
50%
Skipped
VirusTotalMulti-engine malware detection
50%
Skipped
CrowdStrikeAdvanced threat intelligence
50%
Skipped
OSV-ScannerOpen Source Vulnerability database check
50%
Skipped
OWASP Dep-Check
50%
Last scanned: Jul 12, 2026, 7:08 AM95.9s4 files scanned
SKILL.md
- name:
- wicked-garden-persona
- user-invocable:
- true
- description:
- |
- Sub-actions:
- `as <name> <task>` (invoke a persona), `list [--role R]`
- Use when:
- invoking a named persona ("as platform, review this auth flow"),
- phase_relevance:
- ["*"]
- archetype_relevance:
- ["*"]
Persona System
On-demand persona invocation for applying named perspectives to any task. Personas are behavioral modifiers — they change the lens through which a task is executed, not the tools available.
Sub-Action Routing
Route on the first token of the args, then read the matching ref for the full flow:
| Sub-action | Args | Ref | Purpose |
|------------|------|-----|---------|
| as | <persona-name> <task description> | refs/as.md | Invoke a persona for any task — registry lookup, profile assembly, dispatch to the wicked-garden-persona-agent skill |
| list | [--role <role>] | refs/list.md | List all available personas, tiered Methodology vs Generic |
| define | <name> --focus "..." [--traits "..."] [--constraints "FAILURE MODE — ..."] [--not-focus "..."] [--role <role>] [--save] | refs/define.md | Create or update a custom persona — the enterprise house-persona injection mechanism; --save promotes to the plugin cache |
If the first token is none of these, treat the args as as <args> when they
start with a known persona name followed by a task; otherwise show the routing
table above and STOP.
Quick Start
/wicked-garden-persona as engineering "review this auth flow"
/wicked-garden-persona list
/wicked-garden-persona define pragmatic-tech-lead --focus "delivery over perfection"
How It Works
- Registry merges built-in specialists + custom personas + plugin cache
- The
asaction looks up a persona and dispatches to thewicked-garden-persona-agentskill (forked context) - persona-agent executes the task under the persona's behavioral profile
- Behavior emerges from personality, constraints, memories, and preferences
Built-in Personas
Names come from .claude-plugin/specialist.json; their rich profiles live in
scripts/persona/registry.py::_BUILTIN_RICH. The built-ins are illustrative
exemplars, not the product. A blinded, independently-graded lift eval
(tests/persona/EVAL_RESULTS.md, run 2026-06-12) found the built-in personas
produce lift=0 against a strong base model — it already flags the targeted
failure modes unprompted. So the curated surface was reduced: only the three
methodology exemplars keep rich profiles (they show the GOOD pattern); the
generic role personas were demoted to thin role records. For real leverage,
define your OWN house persona (see "Custom Personas") — that is the actual product.
Methodology personas (carry a failure-mode defense — the GOOD pattern)
Their registry records encode FAILURE MODE — … constraints + a not_focus
scope guard the base model does not reliably self-apply. Kept as illustrative
exemplars of what a worth-keeping persona looks like.
| Name | Role | Defends against | |------|------|-----------------| | platform | devsecops | Silent secret exposure, irreversible deploy, privilege creep, unbounded blast radius | | qe | quality-engineering | Self-graded "done", happy-path-only tests, untested recovery, coverage theater | | agentic | agentic-architecture | Runaway loops, ungated irreversible actions, over-broad tool access, non-idempotent retries |
(skeptic, a fallback persona, is also methodology — it forces an edge case
before any approval.)
Generic role names (thin lens — no curated profile)
These specialist names still resolve via the as action, but carry no curated
constraints — the eval showed the base model already plays these roles, so a
rich profile added surface without lift. They apply the role as a plain lens.
Any role name not in this list (e.g. an ad-hoc one) falls back gracefully —
the as action lists what's available rather than crashing. Want durable value
from one of these lenses? Use the define action to create your house version
with a failure-mode constraint.
| Name | Role | Plain lens for | |------|------|---------| | engineering | engineering | Code quality, architecture, implementation | | product | product | Requirements, UX, design review, business strategy | | data | data-engineering | Pipeline design, ML guidance, analytics | | jam | brainstorming | Ideation, exploration, multi-perspective analysis |
Custom Personas
Create your own with the define action — the mechanism that lets an
enterprise inject ITS house personas. Stored in project-scoped DomainStore.
/wicked-garden-persona define pragmatic-tech-lead \
--focus "delivery over perfection — ship iteratively, measure, adjust" \
--traits "direct,pragmatic,cost-aware" \
--role engineering
Use --save to promote to plugin-level cache for cross-project reuse:
/wicked-garden-persona define my-persona --focus "..." --save
Persona Schema
Each persona has rich characteristics that create a genuine perspective:
name — kebab-case identifier
description — one-line summary
focus — the lens this persona applies
traits — behavioral adjectives
role — category for --role filtering
personality — style, temperament, humor
constraints — non-negotiable rules (MUST follow)
memories — formative experiences that inform judgment
preferences — communication, code_style, review_focus, decision_making
Cross-Domain Integration
Route any code review through a persona's lens via the engineering domain's
review action with --persona:
engineering review --persona platform
engineering review --persona qe
Falls back to the built-in architect persona if the named persona is not found.
Fallback Personas
If specialist.json is unavailable, three built-in personas are always available:
- architect — system design, trade-offs, structural decisions
- skeptic — challenges assumptions, finds edge cases
- advocate — champions end-user perspective and simplicity
Source Priority
When names collide across sources, higher priority wins:
custom (DomainStore) > cache (~/.claude/plugins/...) > builtin > fallback
This lets you override a built-in persona with a project-specific version.
Related Skills
mikeparcewski/wicked-garden-engineering-conformance-reviewer
development
VerifiedTrustedCommunity
Pattern-conformance agent-half: evaluates a produced artifact or diff against a set of architectural/design pattern rules from the conformance-rule store (wicked_governance schema). Returns structured findings with rule ID, severity, and rationale — the deterministic half (mechanical rule recall) is done by the guard pipeline; this is the semantic evaluation step. Triggered by: the guard_pipeline `outgov_pattern` check (session-close), or explicitly by an engineering review when WICKED_OUTGOV_RULES_DIR is populated. NOT a replacement for the full `engineering` review skill — focuses only on conformance to stored Pattern rules; architecture and code-quality checks live in the `engineering` skill. Semantic evaluation reuses `wicked-garden-qe-semantic-reviewer` as the designated agent-half evaluator (per garden#983 spec). This skill is the orchestrating wrapper that loads applicable Pattern rules and delegates the per-rule semantic judgment to qe-semantic-reviewer.
8SKILL.mdUpdated Jul 22, 2026
mikeparcewski/wicked-garden-domain
tools
VerifiedTrustedCommunity
The FOUNDATIONAL domain-model capability: extract a codebase's domain — testable business rules (with confidence + provenance), entities, requirements — as a schema-conformant model on the estate graph. The workers annotate the store; wicked-core reads it and builds the requirements graph, coverage-gating fail-closed. Steers three fork workers. A shared substrate, not a modernization tool. The `modernize` archetype DERIVES from it; build / migrate / review / specify / explore consume the SAME domain model — none OWN it. Understanding a codebase's domain is upstream of almost everything else garden does. Use when: "extract the business rules / domain model from this codebase", "build a requirements graph from the code", "what does this system actually require", "reverse-engineer the domain before we build/port/migrate". Works on ANY codebase (modern or legacy) — the value is the domain model, not the porting. NOT the code transform itself (that is the archetype consuming this model). This skill produces the DOMAIN MODEL, not new code.
8SKILL.mdUpdated Jul 15, 2026
mikeparcewski/wicked-garden-domain-modeler
development
VerifiedTrustedCommunity
Domain-graph fork worker for the modernize archetype. Groups the estate's Louvain communities into business domains, attaches each requirement to its cluster (advisory cluster_id provenance), and invokes wicked-core's domain-graph build (which reads the annotated estate store, recomputes coverage fail-closed, and builds the requirements graph) — then validates core's output against the vendored schema. Use when: dispatched by wicked-garden-domain after rule extraction to turn a flat rule set into cluster-keyed domains; "group these into domains", "build the requirements graph", "translate clusters into a domain model". NOT for mining the rules themselves (that is domain-extractor) or threat-modeling (that is domain-coverage).
8SKILL.mdUpdated Jul 15, 2026
mikeparcewski/wicked-garden-domain-extractor
tools
VerifiedTrustedCommunity
Rule-extraction fork worker for the FOUNDATIONAL domain-model capability. Mines testable business rules from a codebase — each with a numeric confidence and a provenance{source, ref, source_kinds} — and annotates them into the estate store so wicked-core can build the domain-model requirements graph (coverage-gated). This is a substrate, not a modernization tool: the `modernize` archetype DERIVES from it, and build / migrate / review / specify / explore can consume the same domain model — none OWN it. Use when: dispatched by wicked-garden-domain to mine the business_rules of a codebase (or a module); "extract the domain rules", "what does this system require", building the requirements half of a domain model. NOT for grouping into domains (that is domain-modeler) or judging coverage (that is domain-coverage — a seat-distinct evaluator).
8SKILL.mdUpdated Jul 15, 2026