pi-skill-search 0.1.0

package/skills/ultragoal/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: ultragoal
+description: Durable multi-goal workflow that persists plan/ledger artifacts under .omc/ultragoal and prints Claude /goal handoff text for the active session
+---
+
+- The task is a single small change — use direct delegation or `ralph` instead
+- The user wants the assistant to literally invoke `/goal` itself from the shell — that is not possible; `omc ultragoal` only writes artifacts and prints handoff text
+- The user wants a planning-only artifact with no execution loop — use `plan` instead
+
+Claude Code `/goal` is a session-scoped Stop hook: it blocks the session from stopping until a condition holds, and auto-clears on success. That is a great single-session execution primitive, but it loses state across sessions and does not by itself enforce a final review gate. `omc ultragoal` adds a durable plan, ledger, and gating layer so a long multi-step initiative can survive session restarts, fresh worktrees, and review iterations while still leveraging Claude `/goal` to keep the active agent focused.
+
+1. Create a plan from a brief:
+   ```
+   omc ultragoal create-goals --brief-file plan.md
+   ```
+   Or with explicit stories:
+   ```
+   omc ultragoal create-goals --brief "ship the migration" \
+     --goal "Schema::Add new columns" \
+     --goal "Backfill::Backfill rows in batches" \
+     --goal "Cutover::Drop old columns and switch reads"
+   ```
+   The default mode is `aggregate` (one Claude `/goal` covers the run).
+   Pass `--claude-goal-mode per-story` if you want each story to have its own `/goal`.
+
+2. Start (or resume) the next story:
+   ```
+   omc ultragoal complete-goals
+   ```
+   This prints a model-facing handoff. The active Claude agent must read it and:
+   - Confirm/Set the active `/goal` condition in this session.
+   - Work the story.
+   - When the story is complete (and for the final story, after the full quality gate), share back a snapshot of the active `/goal` state and call `checkpoint`.
+
+3. Checkpoint a story:
+   ```
+   omc ultragoal checkpoint --goal-id G001-... --status complete \
+     --evidence "tests/files/PR evidence" \
+     --claude-goal-json '{"goal":{"objective":"...","status":"active"}}'
+   ```
+   For the final story, also pass `--quality-gate-json` containing
+   `aiSlopCleaner`, `verification`, and `codeReview` evidence (all clean).
+
+4. If the final review is not clean, do NOT mark complete. Record blockers:
+   ```
+   omc ultragoal record-review-blockers --goal-id G00X-... \
+     --title "Resolve final code-review blockers" \
+     --objective "Fix the listed review findings and rerun final gates" \
+     --evidence "<the review findings>" \
+     --claude-goal-json '{"goal":{"objective":"...","status":"active"}}'
+   ```
+   This appends a new blocker story and keeps the Claude `/goal` active.
+
+5. Inspect state at any time:
+   ```
+   omc ultragoal status
+   ```
+
+- The shell cannot invoke or mutate Claude Code `/goal` state. `omc ultragoal` only persists durable artifacts and prints instructions that the active Claude agent reads and acts on in-session.
+- Snapshots passed via `--claude-goal-json` are model-supplied proof of the active `/goal` state; OMC validates them for textual consistency with the plan's expected objective and ledger event, but it cannot independently observe Claude `/goal` state.
+- If the Claude `/goal` slash command is renamed or restructured, only the handoff wording needs to change; the reconciliation logic is name-agnostic.
+
+

package/skills/ultraqa/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: ultraqa
+description: QA cycling workflow - test, verify, fix, repeat until goal met
+---
+
+# UltraQA Skill
+
+[ULTRAQA ACTIVATED - AUTONOMOUS QA CYCLING]
+
+## Overview
+
+You are now in **ULTRAQA** mode - an autonomous QA cycling workflow that runs until your quality goal is met.
+
+**Cycle**: qa-tester → architect verification → fix → repeat
+
+## Goal Parsing
+
+Parse the goal from arguments. Supported formats:
+
+| Invocation | Goal Type | What to Check |
+|------------|-----------|---------------|
+| `ultraqa --tests` | tests | All test suites pass |
+| `ultraqa --build` | build | Build succeeds with exit 0 |
+| `ultraqa --lint` | lint | No lint errors |
+| `ultraqa --typecheck` | typecheck | No TypeScript errors |
+| `ultraqa --custom "pattern"` | custom | Custom success pattern in output |
+
+If no structured goal provided, interpret the argument as a custom goal.
+
+## Cycle Workflow
+
+### Cycle N (Max 5)
+
+1. **RUN QA**: Execute verification based on goal type
+   - `--tests`: Run the project's test command
+   - `--build`: Run the project's build command
+   - `--lint`: Run the project's lint command
+   - `--typecheck`: Run the project's type check command
+   - `--custom`: Run appropriate command and check for pattern
+   - `--interactive`: Use qa-tester for interactive CLI/service testing:
+     ```
+     Task(subagent_type="oh-my-claudecode:qa-tester", model="sonnet", prompt="TEST:
+     Goal: [describe what to verify]
+     Service: [how to start]
+     Test cases: [specific scenarios to verify]")
+     ```
+
+2. **CHECK RESULT**: Did the goal pass?
+   - **YES** → Exit with success message
+   - **NO** → Continue to step 3
+
+3. **ARCHITECT DIAGNOSIS**: Spawn architect to analyze failure
+   ```
+   Task(subagent_type="oh-my-claudecode:architect", model="opus", prompt="DIAGNOSE FAILURE:
+   Goal: [goal type]
+   Output: [test/build output]
+   Provide root cause and specific fix recommendations.")
+   ```
+
+4. **FIX ISSUES**: Apply architect's recommendations
+   ```
+   Task(subagent_type="oh-my-claudecode:executor", model="sonnet", prompt="FIX:
+   Issue: [architect diagnosis]
+   Files: [affected files]
+   Apply the fix precisely as recommended.")
+   ```
+
+5. **REPEAT**: Go back to step 1
+
+## Exit Conditions
+
+| Condition | Action |
+|-----------|--------|
+| **Goal Met** | Exit with success: "ULTRAQA COMPLETE: Goal met after N cycles" |
+| **Cycle 5 Reached** | Exit with diagnosis: "ULTRAQA STOPPED: Max cycles. Diagnosis: ..." |
+| **Same Failure 3x** | Exit early: "ULTRAQA STOPPED: Same failure detected 3 times. Root cause: ..." |
+| **Environment Error** | Exit: "ULTRAQA ERROR: [tmux/port/dependency issue]" |
+
+## Observability
+
+Output progress each cycle:
+```
+[ULTRAQA Cycle 1/5] Running tests...
+[ULTRAQA Cycle 1/5] FAILED - 3 tests failing
+```

package/skills/ultrawork/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: ultrawork
+description: Parallel execution engine for high-throughput task completion
+---
+
+## Relationship to Other Modes
+
+```
+ralph (persistence wrapper)
+ \-- includes: ultrawork (this skill)
+     \-- provides: parallel execution only
+
+autopilot (autonomous execution)
+ \-- includes: ralph
+     \-- includes: ultrawork (this skill)
+```
+
+Ultrawork is the parallelism layer. Ralph adds persistence and verification. Autopilot adds the full lifecycle pipeline.
+
+

package/skills/umap-learn/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: umap-learn
+description: UMAP dimensionality reduction. Fast nonlinear manifold learning for 2D/3D visualization, clustering preprocessing (HDBSCAN), supervised/parametric UMAP, for high-dimensional data.
+---
+
+# UMAP-Learn
+
+## Overview
+
+UMAP (Uniform Manifold Approximation and Projection) is a dimensionality reduction technique for visualization and general non-linear dimensionality reduction. Apply this skill for fast, scalable embeddings that preserve local and global structure, supervised learning, and clustering preprocessing.
+
+## Quick Start
+
+### Basic Usage
+
+UMAP follows scikit-learn conventions and can be used as a drop-in replacement for t-SNE or PCA.
+
+```python
+import umap
+from sklearn.preprocessing import StandardScaler
+
+# Prepare data (standardization is essential)
+scaled_data = StandardScaler().fit_transform(data)
+
+# Method 1: Single step (fit and transform)
+embedding = umap.UMAP().fit_transform(scaled_data)
+
+# Method 2: Separate steps (for reusing trained model)
+reducer = umap.UMAP(random_state=42)
+reducer.fit(scaled_data)
+embedding = reducer.embedding_  # Access the trained embedding
+```
+
+**Critical preprocessing requirement:** Always standardize features to comparable scales before applying UMAP to ensure equal weighting across dimensions.
+
+### Typical Workflow
+
+```python
+import umap
+import matplotlib.pyplot as plt
+from sklearn.preprocessing import StandardScaler
+
+# 1. Preprocess data
+scaler = StandardScaler()
+scaled_data = scaler.fit_transform(raw_data)
+
+# 2. Create and fit UMAP
+reducer = umap.UMAP(
+    n_neighbors=15,
+    min_dist=0.1,
+    n_components=2,
+    metric='euclidean',
+    random_state=42
+)
+embedding = reducer.fit_transform(scaled_data)
+
+# 3. Visualize
+plt.scatter(embedding[:, 0], embedding[:, 1], c=labels, cmap='Spectral', s=5)
+plt.colorbar()
+plt.title('UMAP Embedding')
+plt.show()
+```
+
+## Parameter Tuning Guide
+
+UMAP has four primary parameters that control the embedding behavior. Understanding these is crucial for effective usage.
+
+### n_neighbors (default: 15)
+
+**Purpose:** Balances local versus global structure in the embedding.
+
+**How it works:** Controls the size of the local neighborhood UMAP examines when learning manifold structure.
+
+**Effects by value:**
+- **Low values (2-5):** Emphasizes fine local detail but may fragment data into disconnected components
+- **Medium values (15-20):** Balanced view of both local structure and global relationships (recommended starting point)
+- **High values (50-200):** Prioritizes broad topological structure at the expense of fine-grained details
+
+**Recommendation:** Start with 15 and adjust based on results. Increase for more global structure, decrease for more local detail.
+
+### min_dist (default: 0.1)
+
+**Purpose:** Controls how tightly points cluster in the low-dimensional space.
+
+**How it works:** Sets the minimum distance apart that points are allowed to be in the output representation.
+
+**Effects by value:**
+- **Low values (0.0-0.1):** Creates clumped embeddings useful for clustering; reveals fine topological details
+- **High values (0.5-0.99):** Prevents tight packing; emphasizes broad topological preservation over local structure
+
+**Recommendation:** Use 0.0 for clustering applications, 0.1-0.3 for visualization, 0.5+ for loose structure.
+
+### n_components (default: 2)
+
+**Purpose:** Determines the dimensionality of the embedded output space.
+
+**Key feature:** Unlike t-SNE, UMAP scales well in the embedding dimension, enabling use beyond visualization.
+
+**Common uses:**
+- **2-3 dimensions:** Visualization
+- **5-10 dimensions:** Clustering preprocessing (better preserves density than 2D)
+- **10-50 dimensions:** Feature engineering for downstream ML models
+
+**Recommendation:** Use 2 for visualization, 5-10 for clustering, higher for ML pipelines.
+
+### metric (default: 'euclidean')
+
+**Purpose:** Specifies how distance is calculated between input data points.
+
+**Supported metrics:**
+- **Minkowski variants:** euclidean, manhattan, chebyshev
+- **Spatial metrics:** canberra, braycurtis, haversine
+- **Correlation metrics:** cosine, correlation (good for text/document embeddings)
+- **Binary data metrics:** hamming, jaccard, dice, russellrao, kulsinski, rogerstanimoto, sokalmichener, sokalsneath, yule
+- **Custom metrics:** User-defined distance functions via Numba
+
+**Recommendation:** Use euclidean for numeric data, cosine for text/document vectors, hamming for binary data.
+
+

package/skills/usfiscaldata/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: usfiscaldata
+description: Query the U.S. Treasury Fiscal Data API for federal financial data including national debt, government spending, revenue, interest rates, exchange rates, and savings bonds. Access 54 datasets and 182 data tables with no API key required. Use when working with U.S. federal fiscal data, national debt tracking (Debt to the Penny), Daily Treasury Statements, Monthly Treasury Statements, Treasury securities auctions, interest rates on Treasury securities, foreign exchange rates, savings bonds, or any U.S. government financial statistics.
+---
+
+# U.S. Treasury Fiscal Data API
+
+Free, open REST API from the U.S. Department of the Treasury for federal financial data. No API key or registration required.
+
+**Base URL:** `https://api.fiscaldata.treasury.gov/services/api/fiscal_service`
+
+## Quick Start
+
+```python
+import requests
+import pandas as pd
+
+BASE_URL = "https://api.fiscaldata.treasury.gov/services/api/fiscal_service"
+
+# Get the current national debt (Debt to the Penny)
+resp = requests.get(f"{BASE_URL}/v2/accounting/od/debt_to_penny", params={
+    "sort": "-record_date",
+    "page[size]": 1
+})
+data = resp.json()["data"][0]
+print(f"Total public debt as of {data['record_date']}: ${float(data['tot_pub_debt_out_amt']):,.0f}")
+```
+
+```python
+# Get Treasury exchange rates for recent quarters
+resp = requests.get(f"{BASE_URL}/v1/accounting/od/rates_of_exchange", params={
+    "fields": "country_currency_desc,exchange_rate,record_date",
+    "filter": "record_date:gte:2024-01-01",
+    "sort": "-record_date",
+    "page[size]": 100
+})
+df = pd.DataFrame(resp.json()["data"])
+```
+
+## Authentication
+
+None required. The API is fully open and free.
+
+## Core Parameters
+
+| Parameter | Example | Description |
+|-----------|---------|-------------|
+| `fields=` | `fields=record_date,tot_pub_debt_out_amt` | Select specific columns |
+| `filter=` | `filter=record_date:gte:2024-01-01` | Filter records |
+| `sort=` | `sort=-record_date` | Sort (prefix `-` for descending) |
+| `format=` | `format=json` | Output format: `json`, `csv`, `xml` |
+| `page[size]=` | `page[size]=100` | Records per page (default 100) |
+| `page[number]=` | `page[number]=2` | Page index (starts at 1) |
+
+**Filter operators:** `lt`, `lte`, `gt`, `gte`, `eq`, `in`
+
+```python
+# Multiple filters separated by comma
+"filter=country_currency_desc:in:(Canada-Dollar,Mexico-Peso),record_date:gte:2024-01-01"
+
+## Key Datasets & Endpoints
+
+### Debt
+
+| Dataset | Endpoint | Frequency |
+|---------|----------|-----------|
+| Debt to the Penny | `/v2/accounting/od/debt_to_penny` | Daily |
+| Historical Debt Outstanding | `/v2/accounting/od/historical_debt_outstanding` | Annual |
+| Schedules of Federal Debt | `/v1/accounting/od/schedules_fed_debt` | Monthly |
+
+### Daily & Monthly Statements
+
+| Dataset | Endpoint | Frequency |
+|---------|----------|-----------|
+| DTS Operating Cash Balance | `/v1/accounting/dts/operating_cash_balance` | Daily |
+| DTS Deposits & Withdrawals | `/v1/accounting/dts/deposits_withdrawals_operating_cash` | Daily |
+| Monthly Treasury Statement (MTS) | `/v1/accounting/mts/mts_table_1` (16 tables) | Monthly |
+
+### Interest Rates & Exchange
+
+| Dataset | Endpoint | Frequency |
+|---------|----------|-----------|
+| Average Interest Rates on Treasury Securities | `/v2/accounting/od/avg_interest_rates` | Monthly |
+| Treasury Reporting Rates of Exchange | `/v1/accounting/od/rates_of_exchange` | Quarterly |
+| Interest Expense on Public Debt | `/v2/accounting/od/interest_expense` | Monthly |
+
+### Securities & Auctions
+
+| Dataset | Endpoint | Frequency |
+|---------|----------|-----------|
+| Treasury Securities Auctions Data | `/v1/accounting/od/auctions_query` | As Needed |
+| Treasury Securities Upcoming Auctions | `/v1/accounting/od/upcoming_auctions` | As Needed |
+| Average Interest Rates | `/v2/accounting/od/avg_interest_rates` | Monthly |
+
+### Savings Bonds
+
+| Dataset | Endpoint | Frequency |
+|---------|----------|-----------|
+| I Bonds Interest Rates | `/v2/accounting/od/i_bond_interest_rates` | Semi-Annual |
+| U.S. Treasury Savings Bonds: Issues, Redemptions & Maturities | `/v1/accounting/od/sb_issues_redemptions` | Monthly |
+
+## Response Structure
+
+```json
+{
+  "data": [...],
+  "meta": {
+    "count": 100,
+    "total-count": 3790,
+    "total-pages": 38,
+    "labels": {"field_name": "Human Readable Label"},
+    "dataTypes": {"field_name": "STRING|NUMBER|DATE|CURRENCY"},
+    "dataFormats": {"field_name": "String|10.2|YYYY-MM-DD"}
+  },
+  "links": {"self": "...", "first": "...", "prev": null, "next": "...", "last": "..."}
+}
+
+

package/skills/using-git-worktrees/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: using-git-worktrees
+description: Use when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback
+---
+
+# Using Git Worktrees
+
+## Overview
+
+Ensure work happens in an isolated workspace. Prefer your platform's native worktree tools. Fall back to manual git worktrees only when no native tool is available.
+
+**Core principle:** Detect existing isolation first. Then use native tools. Then fall back to git. Never fight the harness.
+
+**Announce at start:** "I'm using the using-git-worktrees skill to set up an isolated workspace."
+
+## Step 0: Detect Existing Isolation
+
+**Before creating anything, check if you are already in an isolated workspace.**
+
+```bash
+GIT_DIR=$(cd "$(git rev-parse --git-dir)" 2>/dev/null && pwd -P)
+GIT_COMMON=$(cd "$(git rev-parse --git-common-dir)" 2>/dev/null && pwd -P)
+BRANCH=$(git branch --show-current)
+```
+
+**Submodule guard:** `GIT_DIR != GIT_COMMON` is also true inside git submodules. Before concluding "already in a worktree," verify you are not in a submodule:
+
+```bash
+# If this returns a path, you're in a submodule, not a worktree — treat as normal repo
+git rev-parse --show-superproject-working-tree 2>/dev/null
+```
+
+**If `GIT_DIR != GIT_COMMON` (and not a submodule):** You are already in a linked worktree. Skip to Step 3 (Project Setup). Do NOT create another worktree.
+
+Report with branch state:
+- On a branch: "Already in isolated workspace at `<path>` on branch ``."
+- Detached HEAD: "Already in isolated workspace at `<path>` (detached HEAD, externally managed). Branch creation needed at finish time."
+
+**If `GIT_DIR == GIT_COMMON` (or in a submodule):** You are in a normal repo checkout.
+
+Has the user already indicated their worktree preference in your instructions? If not, ask for consent before creating a worktree:
+
+> "Would you like me to set up an isolated worktree? It protects your current branch from changes."
+
+Honor any existing declared preference without asking. If the user declines consent, work in place and skip to Step 3.
+
+## Step 1: Create Isolated Workspace
+
+**You have two mechanisms. Try them in this order.**
+
+### 1a. Native Worktree Tools (preferred)
+
+The user has asked for an isolated workspace (Step 0 consent). Do you already have a way to create a worktree? It might be a tool with a name like `EnterWorktree`, `WorktreeCreate`, a `/worktree` command, or a `--worktree` flag. If you do, use it and skip to Step 3.
+
+Native tools handle directory placement, branch creation, and cleanup automatically. Using `git worktree add` when you have a native tool creates phantom state your harness can't see or manage.
+
+Only proceed to Step 1b if you have no native worktree tool available.
+
+### 1b. Git Worktree Fallback
+
+**Only use this if Step 1a does not apply** — you have no native worktree tool available. Create a worktree manually using git.
+
+#### Directory Selection
+
+Follow this priority order. Explicit user preference always beats observed filesystem state.
+
+1. **Check your instructions for a declared worktree directory preference.** If the user has already specified one, use it without asking.
+
+2. **Check for an existing project-local worktree directory:**
+   ```bash
+   ls -d .worktrees 2>/dev/null     # Preferred (hidden)
+   ls -d worktrees 2>/dev/null      # Alternative
+   ```
+
+# Determine path based on chosen location
+# For project-local: path="$LOCATION/$BRANCH_NAME"
+# For global: path="~/.config/superpowers/worktrees/$project/$BRANCH_NAME"
+
+git worktree add "$path" -b "$BRANCH_NAME"
+cd "$path"
+```
+
+**Sandbox fallback:** If `git worktree add` fails with a permission error (sandbox denial), tell the user the sandbox blocked worktree creation and you're working in the current directory instead. Then run setup and baseline tests in place.
+
+## Step 3: Project Setup
+
+Auto-detect and run appropriate setup:
+
+```bash
+# Node.js
+if [ -f package.json ]; then npm install; fi
+
+# Rust
+if [ -f Cargo.toml ]; then cargo build; fi
+
+# Python
+if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+if [ -f pyproject.toml ]; then poetry install; fi
+
+# Go
+if [ -f go.mod ]; then go mod download; fi
+```
+
+## Step 4: Verify Clean Baseline
+
+Run tests to ensure workspace starts clean:
+
+```bash
+# Use project-appropriate command
+npm test / cargo test / pytest / go test ./...
+
+

package/skills/using-superpowers/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: using-superpowers
+description: Use when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions
+---
+
+## Instruction Priority
+
+Superpowers skills override default system prompt behavior, but **user instructions always take precedence**:
+
+1. **User's explicit instructions** (CLAUDE.md, GEMINI.md, AGENTS.md, direct requests) — highest priority
+2. **Superpowers skills** — override default system behavior where they conflict
+3. **Default system prompt** — lowest priority
+
+If CLAUDE.md, GEMINI.md, or AGENTS.md says "don't use TDD" and a skill says "always use TDD," follow the user's instructions. The user is in control.
+
+## How to Access Skills
+
+**In Claude Code:** Use the `Skill` tool. When you invoke a skill, its content is loaded and presented to you—follow it directly. Never use the Read tool on skill files.
+
+**In Copilot CLI:** Use the `skill` tool. Skills are auto-discovered from installed plugins. The `skill` tool works the same as Claude Code's `Skill` tool.
+
+**In Gemini CLI:** Skills activate via the `activate_skill` tool. Gemini loads skill metadata at session start and activates the full content on demand.
+
+**In other environments:** Check your platform's documentation for how skills are loaded.
+
+## Platform Adaptation
+
+Skills use Claude Code tool names. Non-CC platforms: see `(see docs)` (Copilot CLI), `(see docs)` (Codex) for tool equivalents. Gemini CLI users get the tool mapping loaded automatically via GEMINI.md.
+
+# Using Skills
+
+## The Rule
+
+**Invoke relevant or requested skills BEFORE any response or action.** Even a 1% chance a skill might apply means that you should invoke the skill to check. If an invoked skill turns out to be wrong for the situation, you don't need to use it.
+
+```dot
+digraph skill_flow {
+    "User message received" [shape=doublecircle];
+    "About to EnterPlanMode?" [shape=doublecircle];
+    "Already brainstormed?" [shape=diamond];
+    "Invoke brainstorming skill" [shape=box];
+    "Might any skill apply?" [shape=diamond];
+    "Invoke Skill tool" [shape=box];
+    "Announce: 'Using [skill] to [purpose]'" [shape=box];
+    "Has checklist?" [shape=diamond];
+    "Create TodoWrite todo per item" [shape=box];
+
+## Red Flags
+
+These thoughts mean STOP—you're rationalizing:
+
+| Thought | Reality |
+|---------|---------|
+| "This is just a simple question" | Questions are tasks. Check for skills. |
+| "I need more context first" | Skill check comes BEFORE clarifying questions. |
+| "Let me explore the codebase first" | Skills tell you HOW to explore. Check first. |
+| "I can check git/files quickly" | Files lack conversation context. Check for skills. |
+| "Let me gather information first" | Skills tell you HOW to gather information. |
+| "This doesn't need a formal skill" | If a skill exists, use it. |
+| "I remember this skill" | Skills evolve. Read current version. |
+| "This doesn't count as a task" | Action = task. Check for skills. |
+| "The skill is overkill" | Simple things become complex. Use it. |
+
+## Skill Priority
+
+When multiple skills could apply, use this order:
+
+1. **Process skills first** (brainstorming, debugging) - these determine HOW to approach the task
+2. **Implementation skills second** (frontend-design, mcp-builder) - these guide execution
+
+"Let's build X" → brainstorming first, then implementation skills.
+"Fix this bug" → debugging first, then domain-specific skills.
+
+## Skill Types
+
+**Rigid** (TDD, debugging): Follow exactly. Don't adapt away discipline.
+
+**Flexible** (patterns): Adapt principles to context.
+
+The skill itself tells you which.
+
+## User Instructions
+
+Instructions say WHAT, not HOW. "Add X" or "Fix Y" doesn't mean skip workflows.
+```