agentleFS
mikeparcewskimikeparcewski/wicked-garden/skills/deliberate/SKILL.md

wicked-garden-deliberate

Skill9 starsChanged 7 months agoMITView on GitHub

Critical thinking framework applied before doing work. Challenges assumptions, reframes problems, identifies hidden opportunities, and validates whether the stated ask is the right ask. A way of approaching work, not a specialist discipline.

  • Installs packages

The file

We split this skill into the rules it gives an agent

6 rules. About 0 are common, 5 are distinctive, and 1 is very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈5

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 1

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    If none of these is available, or Python 3 is missing, skip the script-backed step, say so, and follow the manual alternative where one is …

    line 28
  2. Distinctive:

    Before accepting any work request at face value

    line 33
  3. Distinctive:

    When triaging issues, tickets, or ad-hoc asks

    line 35
  4. Distinctive:

    If the problem is real, dig to the root.

    line 51
  5. Very specific:

    Every change is a window into the surrounding code/content/system.

    line 60
  6. Distinctive:

    Before committing to the obvious solution, explore alternatives.

    line 82

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Deliberate

A structured way of thinking about work before doing it. Applied to any request — bugs, features, enhancements, content, design, infrastructure — to ensure we're solving the right problem the right way.

Runtime

Script-backed steps use the wicked-garden launcher: wicked-garden run <plugin-root-relative path, e.g. scripts/…> [args]. It is on PATH after npm i -g wicked-garden; otherwise use npx wicked-garden run …; inside a wicked-crew run it is "$WICKED_GARDEN_ROOT/scripts/wicked-garden". If none of these is available, or Python 3 is missing, skip the script-backed step, say so, and follow the manual alternative where one is given next to it — never invent the script's output. Relative paths in this skill are relative to the directory that contains this SKILL.md.

When to Use

  • Before accepting any work request at face value
  • During crew clarify and design phases (auto-integrated)
  • When triaging issues, tickets, or ad-hoc asks
  • Any time the gut response is "just do it" — pause and deliberate first

The Five Lenses

1. Is This Real?

Challenge the premise before solving it.

  • Is the reported problem actually a problem, or is it working as intended?
  • Is this a symptom or the root cause? Would fixing it just move the pain?
  • What's the evidence? Observed behavior, user feedback, or speculation?
  • What's the cost of doing nothing? Sometimes inaction is the right action.

2. What's Actually Going On?

If the problem is real, dig to the root.

  • Trace the issue to its origin — don't stop at the first explanation
  • Is this a design flaw wearing a different mask?
  • Map the blast radius: what else shares the same root cause?
  • Is the framing itself wrong? (e.g., "the button is broken" vs "the flow is confusing")

3. What Else Can We Fix While We're Here?

Every change is a window into the surrounding code/content/system.

  • Are there adjacent areas suffering from the same weakness?
  • Can we generalize instead of point-fixing?
  • Is there duplication that should be consolidated?
  • Would a structural change prevent entire categories of similar asks?

See refs/opportunity-patterns.md for common patterns.

4. Should We Rethink the Design?

Step back further. Is the current approach the right one?

  • Would a different structure make this problem disappear entirely?
  • Are we patching around a leaky abstraction or flawed model?
  • Is the boundary in the wrong place?
  • What would we build if starting fresh with today's knowledge?

See refs/rethink-framework.md for evaluation.

5. Is There a Better Way?

Before committing to the obvious solution, explore alternatives.

  • Can we solve this by removing instead of adding?
  • Can we solve this with configuration instead of code?
  • Is there a simpler approach that covers 90% of cases?
  • What are we trading off with each option?

Output: Deliberation Brief

## Deliberation Brief: {title}

### Assessment
**Validity**: Real problem / Symptom / Not a problem / Wrong framing
**Root cause**: {actual cause, not what was reported}
**Blast radius**: {what else is affected by the same root cause}

### Opportunities
**Cleanup**: {what can be improved alongside}
**Generalization**: {can we abstract or consolidate?}
**Rethink**: {should we redesign the approach?}

### Recommendation
**Strategy**: Fix / Redesign / Generalize / Defer / Close
**Rationale**: {why this approach over alternatives}
**Scope**: Expand / Contract / Same — {what changed from original ask}

### Guidance
{specific direction for whoever does the work}

Domain-Specific Depth

The five lenses are universal. The refs provide depth for specific contexts:

  • refs/run-workflow.md — Operational runbook for user-invoked deliberations: GH issue parsing, context gathering, Explore-agent dispatch, brief presentation, memory storage, crew integration, batch mode
  • refs/opportunity-patterns.md — Structural patterns that signal cleanup opportunities
  • refs/rethink-framework.md — When and how to propose a redesign
  • refs/code-lens.md — Code-specific patterns (error handling, abstractions, tech debt)
  • refs/content-lens.md — Content/docs patterns (messaging, structure, audience)
  • refs/design-lens.md — Design patterns (UX flows, information architecture)
  • refs/architecture-lens.md — System patterns (boundaries, dependencies, scaling)
  • refs/data-lens.md — Data patterns (pipelines, schemas, quality, contracts)
  • refs/ops-lens.md — Ops patterns (incidents, reliability, deployment, observability)
  • refs/security-lens.md — Security patterns (auth, vulnerabilities, threat models, compliance)
  • refs/product-lens.md — Product patterns (user needs, prioritization, value, strategy)
  • refs/testing-lens.md — Testing patterns (test strategy, flakiness, coverage, test design)
  • refs/timing-lens.md — Timing patterns (urgency, sequencing, premature optimization)
  • refs/assumptions-lens.md — Assumption patterns (hidden dependencies, fragile premises)

Integration

  • Crew workflow: Auto-invoked during clarify and design phases
  • Standalone: invoke this skill with {description or GH#} [--deep] [--batch] — then follow refs/run-workflow.md
  • Batch: --batch "280,281" — process multiple issues together to find shared root causes (see the runbook)

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.