@human-avatar/skills-for-humanity 1.0.0

package/bin/install.js

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs       = require('fs');
+const path     = require('path');
+const os       = require('os');
+const readline = require('readline');
+
+// ANSI colors — suppressed when not a TTY
+const isTTY = process.stdout.isTTY;
+const bold   = isTTY ? '\x1b[1m'  : '';
+const dim    = isTTY ? '\x1b[2m'  : '';
+const green  = isTTY ? '\x1b[32m' : '';
+const cyan   = isTTY ? '\x1b[36m' : '';
+const yellow = isTTY ? '\x1b[33m' : '';
+const red    = isTTY ? '\x1b[31m' : '';
+const reset  = isTTY ? '\x1b[0m'  : '';
+
+function log(msg = '')  { process.stdout.write(msg + '\n'); }
+function err(msg)       { process.stderr.write(`${red}error:${reset} ${msg}\n`); }
+function warn(msg)      { process.stderr.write(`${yellow}warn:${reset}  ${msg}\n`); }
+
+// ---------------------------------------------------------------------------
+// Scope resolution
+// ---------------------------------------------------------------------------
+
+const SCOPES = {
+  user: {
+    label: 'User',
+    description: 'available in all projects',
+    pluginsDir: path.join(os.homedir(), '.claude', 'plugins', 'skills-for-humanity'),
+    settingsPath: path.join(os.homedir(), '.claude', 'settings.json'),
+  },
+  project: {
+    label: 'Project',
+    description: `this project only  ${dim}(${process.cwd()})${reset}`,
+    pluginsDir: path.join(process.cwd(), '.claude', 'plugins', 'skills-for-humanity'),
+    settingsPath: path.join(process.cwd(), '.claude', 'settings.json'),
+  },
+};
+
+const SKILLS_SRC = path.join(__dirname, '..', 'skills');
+
+// ---------------------------------------------------------------------------
+// Argument parsing
+// ---------------------------------------------------------------------------
+
+const args = process.argv.slice(2);
+
+if (args.includes('--help') || args.includes('-h')) {
+  log(`
+${bold}skills-for-humanity${reset} — 93 structured thinking tools for Claude Code
+
+${bold}Usage:${reset}
+  npx @human-avatar/skills-for-humanity [options]
+
+${bold}Options:${reset}
+  ${cyan}--scope user|project${reset}  Install scope (prompted if omitted)
+                        ${dim}user:    ~/.claude/  — all projects${reset}
+                        ${dim}project: ./.claude/  — this project only${reset}
+  ${cyan}--dir <path>${reset}          Install to a custom directory (skips scope prompt)
+  ${cyan}--uninstall${reset}           Remove skills and clean up settings.json
+  ${cyan}--help${reset}                Show this help message
+
+${bold}After install:${reset}
+  Restart Claude Code and type ${cyan}/human${reset} to get started.
+  Or jump straight to a category: ${cyan}/ethics${reset} ${cyan}/logic${reset} ${cyan}/creativity${reset}
+`);
+  process.exit(0);
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, entry.name);
+    const d = path.join(dest, entry.name);
+    entry.isDirectory() ? copyDir(s, d) : fs.copyFileSync(s, d);
+  }
+}
+
+function removeDir(dir) {
+  if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true, force: true });
+}
+
+function readSettings(settingsPath) {
+  if (!fs.existsSync(settingsPath)) return {};
+  try { return JSON.parse(fs.readFileSync(settingsPath, 'utf8')); }
+  catch { return {}; }
+}
+
+function writeSettings(settingsPath, settings) {
+  fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+}
+
+function countDirs(dir) {
+  try { return fs.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).length; }
+  catch { return '?'; }
+}
+
+function prompt(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => { rl.close(); resolve(answer.trim()); });
+  });
+}
+
+async function askScope() {
+  log(`${bold}Where should the skills be installed?${reset}`);
+  log();
+  log(`  ${cyan}1) User${reset}    — available in all projects  ${dim}(~/.claude/)${reset}`);
+  log(`  ${cyan}2) Project${reset} — this project only           ${dim}(./.claude/)${reset}`);
+  log();
+
+  while (true) {
+    const answer = await prompt(`Enter ${cyan}1${reset} or ${cyan}2${reset}: `);
+    if (answer === '1') return 'user';
+    if (answer === '2') return 'project';
+    log(`${yellow}Please enter 1 or 2.${reset}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Resolve scope + paths
+// ---------------------------------------------------------------------------
+
+async function resolveTarget() {
+  // --dir takes precedence, skips scope prompt entirely
+  const dirFlag = args.indexOf('--dir');
+  if (dirFlag !== -1 && args[dirFlag + 1]) {
+    const custom = path.resolve(args[dirFlag + 1]);
+    // For custom dirs, write settings next to the dir's .claude parent if it exists,
+    // otherwise fall back to user settings.
+    const customSettings = path.join(path.dirname(custom), 'settings.json');
+    return { pluginsDir: custom, settingsPath: customSettings };
+  }
+
+  // --scope flag skips the interactive prompt
+  const scopeFlag = args.indexOf('--scope');
+  if (scopeFlag !== -1 && args[scopeFlag + 1]) {
+    const key = args[scopeFlag + 1].toLowerCase();
+    if (!SCOPES[key]) {
+      err(`Unknown scope "${key}". Use "user" or "project".`);
+      process.exit(1);
+    }
+    return SCOPES[key];
+  }
+
+  // Non-interactive fallback (CI, pipes)
+  if (!isTTY) return SCOPES.user;
+
+  // Interactive prompt
+  const key = await askScope();
+  log();
+  return SCOPES[key];
+}
+
+// ---------------------------------------------------------------------------
+// Uninstall
+// ---------------------------------------------------------------------------
+
+async function uninstall() {
+  log();
+  log(`${bold}Uninstalling skills-for-humanity…${reset}`);
+  log();
+
+  const target = await resolveTarget();
+
+  removeDir(target.pluginsDir);
+  log(`${green}✓${reset} Removed ${dim}${target.pluginsDir}${reset}`);
+
+  try {
+    const settings = readSettings(target.settingsPath);
+    if (Array.isArray(settings.pluginDirectories)) {
+      const before = settings.pluginDirectories.length;
+      settings.pluginDirectories = settings.pluginDirectories.filter(
+        (d) => path.resolve(d) !== path.resolve(target.pluginsDir)
+      );
+      if (settings.pluginDirectories.length < before) {
+        writeSettings(target.settingsPath, settings);
+        log(`${green}✓${reset} Removed from ${dim}${target.settingsPath}${reset}`);
+      } else {
+        log(`${dim}→ Not found in settings — nothing to remove${reset}`);
+      }
+    }
+  } catch (e) {
+    warn(`Could not update settings.json: ${e.message}`);
+  }
+
+  log();
+  log(`${dim}Uninstall complete.${reset}`);
+  log();
+}
+
+// ---------------------------------------------------------------------------
+// Install
+// ---------------------------------------------------------------------------
+
+async function install() {
+  log();
+  log(`${bold}${cyan}skills-for-humanity${reset}`);
+  log(`${dim}93 structured thinking tools for Claude Code${reset}`);
+  log();
+
+  const target = await resolveTarget();
+  const { pluginsDir, settingsPath } = target;
+
+  // 1. Copy skills
+  const isUpdate = fs.existsSync(pluginsDir);
+  log(`${isUpdate ? 'Updating' : 'Installing'} skills to ${yellow}${pluginsDir}${reset}…`);
+
+  try {
+    copyDir(SKILLS_SRC, pluginsDir);
+    log(`${green}✓${reset} Skills ${isUpdate ? 'updated' : 'installed'} (${countDirs(pluginsDir)} skills)`);
+  } catch (e) {
+    err(`Could not copy skills: ${e.message}`);
+    process.exit(1);
+  }
+
+  // 2. Register in settings.json
+  try {
+    const settings = readSettings(settingsPath);
+    if (!Array.isArray(settings.pluginDirectories)) settings.pluginDirectories = [];
+
+    const already = settings.pluginDirectories.some(
+      (d) => path.resolve(d) === path.resolve(pluginsDir)
+    );
+
+    if (!already) {
+      settings.pluginDirectories.push(pluginsDir);
+      writeSettings(settingsPath, settings);
+      log(`${green}✓${reset} Registered in ${dim}${settingsPath}${reset}`);
+    } else {
+      log(`${dim}→ Already registered in ${settingsPath}${reset}`);
+    }
+  } catch (e) {
+    warn(`Could not update settings.json: ${e.message}`);
+    log();
+    log(`Add this to ${yellow}${settingsPath}${reset} manually:`);
+    log(`  ${dim}{ "pluginDirectories": ["${pluginsDir}"] }${reset}`);
+  }
+
+  // 3. Done
+  log();
+  log(`${bold}Done.${reset} Restart Claude Code, then:`);
+  log(`  ${cyan}/human${reset}      ${dim}— route to the right skill from all 93${reset}`);
+  log(`  ${cyan}/ethics${reset}     ${dim}— ethical analysis${reset}`);
+  log(`  ${cyan}/logic${reset}      ${dim}— validate and pressure-test reasoning${reset}`);
+  log(`  ${cyan}/creativity${reset} ${dim}— de Bono suite + brainstorm${reset}`);
+  log(`  ${cyan}/decision${reset}   ${dim}— premortem, criteria weighting, option mapping${reset}`);
+  log();
+}
+
+// ---------------------------------------------------------------------------
+// Entry
+// ---------------------------------------------------------------------------
+
+(async () => {
+  if (args.includes('--uninstall')) {
+    await uninstall();
+  } else {
+    await install();
+  }
+})().catch((e) => {
+  err(e.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@human-avatar/skills-for-humanity",
+  "version": "1.0.0",
+  "description": "93 structured thinking tools for Claude Code — logic, ethics, creativity, decision-making, systems thinking, and more.",
+  "keywords": [
+    "claude-code",
+    "claude-code-plugin",
+    "thinking-tools",
+    "mental-models",
+    "reasoning",
+    "decision-making",
+    "cognitive-frameworks",
+    "problem-solving",
+    "systems-thinking",
+    "ethics",
+    "creativity",
+    "ai-tools"
+  ],
+  "homepage": "https://github.com/human-avatar/skills-for-humanity",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/human-avatar/skills-for-humanity.git"
+  },
+  "bugs": {
+    "url": "https://github.com/human-avatar/skills-for-humanity/issues"
+  },
+  "license": "MIT",
+  "author": "Finn Fitzsimons <fitzsimons.finn@gmail.com>",
+  "bin": {
+    "skills-for-humanity": "./bin/install.js"
+  },
+  "files": [
+    "skills/",
+    "bin/",
+    "README.md",
+    ".claude-plugin/"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}

package/skills/aesthetic/SKILL.md

@@ -0,0 +1,80 @@
+---
+name: aesthetic
+description: "Entry point for the aesthetic toolkit. Routes to the right aesthetic skill based on your situation. Use when you say 'aesthetic', 'check the design', 'does this feel right', 'is this elegant', 'is this too complex', 'what pattern is this', 'find the simpler version', or want an aesthetic lens applied without knowing which specific tool fits."
+---
+
+# Aesthetic
+
+Applies aesthetic reasoning to any artifact — design, writing, code, product, argument. Diagnoses what kind of aesthetic question is being asked and applies the right tool.
+
+## Which tool fits
+
+| You need to... | Tool |
+|---|---|
+| Check whether parts form a unified whole | coherence-check |
+| Test whether something is more complex than it needs to be | elegance-testing |
+| Name the underlying structural pattern at work | pattern-detection |
+| Find the simpler version while preserving what matters | simplicity-analysis |
+
+## Routing Decision
+
+- **Something feels off, jarring, or inconsistent** → coherence-check
+- **Something feels over-engineered or baroque** → elegance-testing
+- **You want to understand *why* something works (or doesn't)** → pattern-detection
+- **You want to strip something back to its core** → simplicity-analysis
+- **Unclear** → start with coherence-check; it usually surfaces which other question needs answering
+
+---
+
+## Confirm Direction
+
+After diagnosing which tool fits, present the recommendation before executing:
+
+> My read: **[diagnosed tool]** — one sentence on why it fits.
+
+- **A) Yes, run that tool**
+- **B) Show me all options** — list every skill in this category with one-line descriptions
+- **C) Quick version** — lighter-weight alternative for this situation, if one exists
+- **D) Re-diagnose** — describe the situation differently for a second read
+
+Wait for their selection before proceeding.
+
+---
+
+## Coherence Check
+
+*Tests whether the parts form a unified whole.*
+
+Map all major elements of the artifact. For each: what design decision does it express? Ask: are these decisions speaking the same language — or were they made independently, without reference to each other? Name each incoherence specifically. Classify: surface incoherence (fixable with small changes) vs. structural incoherence (requires rethinking something fundamental).
+
+**Output:** List of incoherences ranked by severity. For each: what it is, where it appears, what it conflicts with, and how to resolve it.
+
+---
+
+## Elegance Testing
+
+*Tests whether something is more complex than it needs to be.*
+
+Separate necessary complexity (required by the problem) from accidental complexity (accreted over time, added as hedging, or left over from old requirements). For each layer of complexity: could the same job be done without it? What would be lost? Apply the minimum surface principle — is every part earning its place?
+
+**Output:** Complexity audit — each complex element classified as necessary or accidental, with a cost estimate for removing it.
+
+---
+
+## Pattern Detection
+
+*Identifies the underlying formal pattern.*
+
+Look past the surface. What structural form does this follow? Name candidate patterns. Test each: does the structure actually match, or just superficially resemble it? Once identified: what does naming the pattern unlock? What's the established playbook for this form?
+
+**Output:** Named pattern, evidence for the identification, what the pattern predicts or implies, and the playbook it suggests.
+
+---
+
+## Simplicity Analysis
+
+*Finds the simpler version while preserving what matters.*
+
+First: what is the core? The irreducible thing this artifact must do or be. Now audit everything else against that core: does each element serve it, or distract from it? For everything that doesn't serve the core, ask whether it was added for a reason that's still valid.
+
+**Output:** What the core is. What can go. What should stay but be simplified. The simplest version that still does the full job.

package/skills/aesthetic-coherence-check/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: aesthetic-coherence-check
+description: "Tests whether the parts of something form a unified whole — finding the jarring inconsistencies that accumulate when different contributors work without a shared vision. TRIGGERS: 'coherence check', 'does this feel unified', 'something feels off', 'inconsistent', 'check the whole', 'does this hang together'."
+---
+
+# Aesthetic Coherence Check
+
+Incoherence is the default product of collaboration without a shared vision. Each part
+may be locally defensible — sensible in isolation, reasonable given what that contributor
+was optimising for — while the whole communicates nothing clearly. A perceptive reader
+or user feels this before they can name it. This skill makes the incoherence legible
+so it can be fixed.
+
+---
+
+## Your Process
+
+**Step 1: State the Artefact and Its Intended Identity**
+What is being examined — a product, document, strategy, brand, presentation, process?
+What identity or effect is it supposed to produce? "Should feel authoritative but
+approachable" or "Should communicate a single strategic bet" or "Should make a
+first-time user feel capable in under three minutes." The intended identity is the
+standard everything else will be measured against.
+
+**Step 2: Examine Each Part**
+Break the artefact into its major components. For each: what does it communicate?
+What does it prioritise implicitly — speed vs depth, confidence vs humility,
+complexity vs accessibility? What does it assume about the audience or context?
+Extract these qualities as observations, not evaluations.
+
+**Step 3: Compare Parts to Each Other**
+Where do assumptions conflict across parts? A section written for technical readers
+next to one written for executives. A formal tone in one component, casual in another.
+A design that prioritises simplicity in navigation but complexity in content. Name
+the specific conflict, not just that something feels inconsistent.
+
+**Step 4: Compare Parts to the Whole**
+Which parts are faithful to the intended identity? Which stray — and in what
+direction? Is the straying random (different contributors with different instincts)
+or directional (a competing version of what the thing should be is quietly winning
+in parts of it)?
+
+**Step 5: Identify the Most Jarring Inconsistencies**
+Find 2-3 specific moments where the lack of coherence is most damaging — where a
+perceptive reader or user would feel something is wrong, even if they can't say why.
+Prioritise by impact on the intended identity.
+
+**Step 6: Recommended Adjustments**
+For each jarring inconsistency: what specific change — to which part, in which
+direction — would bring it into alignment with the intended identity?
+
+---
+
+## Human Check-in
+
+Before proceeding, ask the user:
+
+**How do you want to run this?**
+
+- **A) Full analysis** — complete all steps, reasoning shown throughout
+- **B) Key findings only** — bottom-line output, skip step-by-step detail
+- **C) Incoherence only** — where the parts fail to form a whole, skip confirming what works
+- **D) Refine the framing** — adjust what we're analyzing before starting
+
+Proceed based on their choice.
+
+## Output Format
+
+**Intended Identity:** [what the artefact is supposed to be/feel/communicate]
+
+**Parts Assessed**
+
+| Part | What It Communicates | What It Prioritises | What It Assumes |
+|---|---|---|---|
+| [component] | [signal it sends] | [implicit value] | [audience/context assumption] |
+
+**Inconsistencies**
+
+| Inconsistency | What Conflicts | Why It Jars | Recommended Adjustment |
+|---|---|---|---|
+| [name it precisely] | [the specific conflict] | [effect on the reader/user] | [what to change] |
+
+**Overall Coherence Assessment:** [unified / partially coherent / incoherent + rationale]
+
+---
+
+## Notes
+
+Coherence is not uniformity — contrast and tension can serve a unified vision. The
+question is whether every element is working toward the same intended identity, even
+if they take different forms to do it. The most common source of incoherence is not
+bad judgment but absent shared vision — people optimised locally for different things.

package/skills/aesthetic-elegance-testing/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: aesthetic-elegance-testing
+description: "Tests whether a solution is more complex than it needs to be — distinguishing necessary complexity from accidental complexity that accreted over time. TRIGGERS: 'elegance test', 'is this too complex', 'over-engineered', 'is there a simpler way', 'does this feel right'."
+---
+
+# Aesthetic Elegance Testing
+
+Complexity is the default outcome of design by committee, incremental revision, and
+deference to edge cases. Each addition is locally defensible. The cumulative result is
+a system no one would have designed on purpose. Elegance is not simplicity for its own
+sake — it is the property of a solution where every element earns its place and nothing
+obscures the core. This skill tests for that property.
+
+---
+
+## Your Process
+
+**Step 1: State the Solution**
+Describe the design, plan, system, or solution in enough detail to evaluate its parts.
+If it's a process, name the steps. If it's a system, name the components. If it's a
+strategy, name the moves.
+
+**Step 2: Define the Irreducible Core**
+What is the minimum that does the job? State in one sentence what the solution must
+accomplish to succeed. Every element that doesn't directly serve this core is a
+candidate for removal. If you can't state the core in one sentence, the solution may
+not have one — which is itself a finding.
+
+**Step 3: Element Audit**
+For each component, mechanism, layer, or step: is it necessary for the core job, or
+did it accrete over time to handle edge cases, satisfy stakeholder requests, hedge
+against unlikely scenarios, or address problems that may not exist? Label each
+clearly: **necessary** or **accreted**.
+
+**Step 4: Concept Count**
+How many distinct concepts must a new person learn to understand and use this
+solution fully? Elegant solutions have fewer. Count them explicitly. Compare against
+the irreducible minimum — the number of concepts required if every accreted element
+were removed. The gap is the complexity overhead.
+
+**Step 5: Thirty-Second Explanation Test**
+Can you explain the solution in 30 seconds to someone intelligent but unfamiliar
+with it? Attempt the explanation. If it requires more than 30 seconds, complexity
+may be genuine — or it may be a sign the design hasn't been thought through clearly
+enough to be simple. Both are worth knowing.
+
+**Step 6: Sources of Unnecessary Complexity**
+For each accreted element: what introduced it, and what would removing it cost? Some
+removals are free — the element was pure noise. Some involve real trade-offs — the
+element serves a secondary purpose worth naming. Distinguish them explicitly.
+
+---
+
+## Human Check-in
+
+Before proceeding, ask the user:
+
+**How do you want to run this?**
+
+- **A) Full analysis** — complete all steps, reasoning shown throughout
+- **B) Key findings only** — bottom-line output, skip step-by-step detail
+- **C) Accidental complexity only** — what could be removed without losing anything that matters
+- **D) Refine the framing** — adjust what we're analyzing before starting
+
+Proceed based on their choice.
+
+## Output Format
+
+**Core Job:** [one sentence — what the solution must accomplish to succeed]
+
+**Element Audit**
+
+| Element | Necessary or Accreted | Rationale |
+|---|---|---|
+| [component/mechanism/step] | [necessary / accreted] | [why it does or doesn't serve the core] |
+
+**Concept Count:** [n currently required] vs [n at irreducible minimum] — overhead: [gap]
+
+**30-Second Explanation Test:** [pass / fail — include the actual attempt]
+
+**Sources of Unnecessary Complexity**
+
+| Accreted Element | How It Was Introduced | Cost of Removal |
+|---|---|---|
+| [element] | [origin] | [what is lost if removed] |
+
+**Recommended Simplifications:** [specific removals or reductions, with trade-offs named]
+
+---
+
+## Notes
+
+The question is not "can we defend every element" but "does every element earn its
+place." Elements that can be defended are not the same as elements that are necessary
+— hold the higher bar. Elegance is achieved not when there is nothing left to add,
+but when there is nothing left to remove.

package/skills/aesthetic-pattern-detection/SKILL.md

@@ -0,0 +1,93 @@
+---
+name: aesthetic-pattern-detection
+description: "Identifies the underlying formal pattern at work — because most successful designs, arguments, and solutions share deep structural patterns, and naming the pattern unlocks the playbook. TRIGGERS: 'what pattern is this', 'pattern recognition', 'why does this work', 'identify the form', 'what structure is at play', 'what archetype is this'."
+---
+
+# Aesthetic Pattern Detection
+
+Surface features differ — colours, words, technologies, industries. Formal patterns
+recur across all of them. The same structural moves that make a symphony compelling
+make a strategy compelling. The same tension-and-resolution arc that drives a thriller
+drives a great pitch. Naming the pattern reveals options that surface-level analysis
+cannot, because once the pattern is named, its full playbook becomes available.
+
+---
+
+## Your Process
+
+**Step 1: Describe the Thing**
+What does it do and how does it feel to engage with it? Focus on behaviour and
+effect, not surface features — not "it uses blue and white" but "it creates calm
+authority that builds confidence incrementally." Describe the experience of it.
+
+**Step 2: Identify Formal Patterns Present**
+Work through this list systematically — multiple patterns often operate simultaneously:
+- **Repetition/Rhythm** — recurring elements that create expectation, then satisfy
+  or productively subvert it
+- **Symmetry/Asymmetry** — balance creates stability and trust; deliberate
+  asymmetry creates tension and dynamism
+- **Hierarchy** — clear ordering from most to least important, large to small,
+  general to specific; guides attention
+- **Contrast** — sharp differences that create definition, focus attention, and
+  make meaning by comparison
+- **Tension/Resolution** — a problem introduced and resolved, a question posed and
+  answered; the engine of narrative
+- **Figure/Ground** — a subject made vivid and clear by what surrounds and recedes
+- **Part/Whole** — components that build into something greater than their sum
+
+**Step 3: Match to Domain Archetypes**
+Which archetypes from design, storytelling, architecture, or music does this
+resemble? The hero's journey. The fugue. The golden section. Thesis-antithesis-
+synthesis. Call and response. Name the archetype and its source domain.
+
+**Step 4: Name the Pattern**
+Give the dominant pattern a precise name. Test: does naming it make the thing more
+legible? Does it reveal why certain elements work and why others feel off? A good
+pattern name is generative — it produces new options, not just descriptions.
+
+**Step 5: Apply the Pattern**
+What does the pattern imply for what should come next? What is currently in the
+artefact that violates the pattern — and is that violation intentional (productive
+tension) or accidental (incoherence)?
+
+---
+
+## Human Check-in
+
+Before proceeding, ask the user:
+
+**How do you want to run this?**
+
+- **A) Full analysis** — complete all steps, reasoning shown throughout
+- **B) Key findings only** — bottom-line output, skip step-by-step detail
+- **C) Pattern name only** — identify and name the underlying structure, skip full analysis
+- **D) Refine the framing** — adjust what we're analyzing before starting
+
+Proceed based on their choice.
+
+## Output Format
+
+**Formal Patterns Present:** [list each pattern with one sentence on how it manifests]
+
+**Archetype Match:** [closest domain archetype + which domain it comes from]
+
+**Pattern Name:** [precise name for the dominant pattern]
+
+**What Naming It Reveals:** [what becomes visible or legible that wasn't before]
+
+**Pattern Implications**
+
+| Implication | Description |
+|---|---|
+| What should come next | [the move the pattern calls for] |
+| What is violating the pattern | [specific elements that break it] |
+| Intentional or accidental | [productive subversion or incoherence] |
+
+---
+
+## Notes
+
+Not every successful thing follows a single pattern cleanly — most operate with
+several simultaneously. Identify the dominant pattern first; note secondary patterns
+separately. The test of a good pattern name is whether it generates new options
+rather than just describing what's already there.