opencode-starterkit 1.0.1

package/baseline/skill/tool-priority/SKILL.md

@@ -0,0 +1,299 @@
+---
+name: tool-priority
+description: Use when choosing between tools or need tool reference - covers LSP, search, swarm, memory, and research tools with correct syntax
+version: 1.0.0
+tags: [workflow, context]
+dependencies: []
+---
+
+# Tool Priority Skill
+
+## When to Use
+
+- You need to decide which tool to use for a task or recall tool syntax
+- You are about to edit code and want the correct discovery/order of operations
+
+## When NOT to Use
+
+- You already know the exact tool and syntax required
+- The task is purely conceptual with no tool usage
+
+## Priority Order
+
+**LSP → Search → Swarm → Memory → File Operations**
+
+1. **LSP** - Semantic code intelligence (9 operations via unified tool)
+2. **tilth** (MCP) - AST-aware code search + smart file reading. Replaces grep/glob/read for code navigation when available
+3. **grep** - Fast text search (logs, config, code patterns). Replaces bash rg/grep
+4. **glob** - File discovery by name pattern. Replaces bash find/ls
+5. **skill** - Load skills for specialized knowledge
+6. **task** - Parallel subagent execution
+7. **Swarm tool** - swarm (plan, monitor, delegate, sync operations)
+8. **Memory tools** - memory-search, memory-read, memory-update, memory-admin
+9. **Research tools** - context7, websearch, codesearch, grepsearch
+10. **read/edit/write** - File operations (always read before edit)
+
+**Golden Rule**: Always `read` before `edit` to verify content.
+
+## Choosing the Right Tool
+
+Ask: **"Am I looking for semantic understanding or just text?"**
+
+### Code Understanding (Use LSP)
+
+The `lsp` tool provides 9 operations via a unified interface:
+
+| Need                 | Operation              | Example                                                                                                       |
+| -------------------- | ---------------------- | ------------------------------------------------------------------------------------------------------------- |
+| Type info at cursor  | `hover`                | `lsp({ operation: "hover", filePath: "src/file.ts", line: 42, character: 10 })`                               |
+| Jump to definition   | `goToDefinition`       | `lsp({ operation: "goToDefinition", filePath: "src/file.ts", line: 42, character: 10 })`                      |
+| Find all usages      | `findReferences`       | `lsp({ operation: "findReferences", filePath: "src/file.ts", line: 42, character: 10 })`                      |
+| File structure       | `documentSymbol`       | `lsp({ operation: "documentSymbol", filePath: "src/file.ts", line: 1, character: 1 })`                        |
+| Workspace search     | `workspaceSymbol`      | `lsp({ operation: "workspaceSymbol", filePath: "src/file.ts", line: 1, character: 1, query: "UserService" })` |
+| Find implementations | `goToImplementation`   | `lsp({ operation: "goToImplementation", filePath: "src/file.ts", line: 42, character: 10 })`                  |
+| Call hierarchy       | `prepareCallHierarchy` | `lsp({ operation: "prepareCallHierarchy", filePath: "src/file.ts", line: 42, character: 10 })`                |
+| Incoming calls       | `incomingCalls`        | `lsp({ operation: "incomingCalls", filePath: "src/file.ts", line: 42, character: 10 })`                       |
+| Outgoing calls       | `outgoingCalls`        | `lsp({ operation: "outgoingCalls", filePath: "src/file.ts", line: 42, character: 10 })`                       |
+
+**Critical**: Run ALL 9 LSP operations before editing. See AGENTS.md for the full checklist.
+
+### Text Search (Use grep)
+
+| Need              | Pattern          | Example                                    |
+| ----------------- | ---------------- | ------------------------------------------ |
+| Function calls    | `functionName\(` | `grep({ pattern: "fetchUser\(" })`         |
+| Import statements | `import.*from`   | `grep({ pattern: "import.*from.*react" })` |
+| Error messages    | `FATAL\|ERROR`   | `grep({ pattern: "ERROR\|FATAL" })`        |
+| TODO comments     | `TODO\|FIXME`    | `grep({ pattern: "TODO\|FIXME" })`         |
+| Hook usage        | `useState\(`     | `grep({ pattern: "useState\(" })`          |
+| Debug logs        | `console\.log`   | `grep({ pattern: "console\.log" })`        |
+
+### Load Skills (Use skill tool)
+
+Load specialized knowledge before starting work:
+
+```typescript
+// Essential skills for most work
+skill({ name: "verification-before-completion" });
+skill({ name: "test-driven-development" });
+
+// Domain-specific skills
+skill({ name: "beads" }); // Task tracking
+skill({ name: "beads-bridge" }); // Swarm coordination
+skill({ name: "swarm-coordination" }); // Parallel execution
+skill({ name: "frontend-design" }); // UI implementation
+skill({ name: "prd" }); // Requirements documents
+```
+
+### Parallel Execution (Use Task tool)
+
+Launch multiple subagents simultaneously:
+
+```typescript
+// Workers run in parallel when multiple Task calls in one message
+Task({
+  subagent_type: "explore",
+  description: "Find patterns",
+  prompt: `Find auth patterns in codebase...`,
+});
+
+Task({
+  subagent_type: "scout",
+  description: "Research docs",
+  prompt: `Research best practices for...`,
+});
+// Results return when both complete
+```
+
+**Subagent types**: `general`, `explore`, `scout`, `review`, `plan`
+
+### Swarm Coordination Tools
+
+| Tool      | Purpose                    | Key Operations                        |
+| --------- | -------------------------- | ------------------------------------- |
+| **swarm** | Unified swarm coordination | `plan`, `monitor`, `delegate`, `sync` |
+
+**swarm operations:**
+
+- `plan`: Task analysis (actions: analyze, classify, check, allocate)
+- `monitor`: Progress tracking (actions: progress_update, render_block, status, clear)
+- `delegate`: Create delegation packets for workers
+- `sync`: Beads ↔ OpenCode sync (actions: push, pull, create_shared, update_shared)
+
+### Memory Tools
+
+| Tool              | Purpose                   | When to Use                         |
+| ----------------- | ------------------------- | ----------------------------------- |
+| **memory-search** | Find past learnings       | "Have we solved this before?"       |
+| **memory-read**   | Load specific memory file | "What did we decide about X?"       |
+| **memory-update** | Save context              | "Document this for future sessions" |
+| **observation**   | Record decisions/patterns | "This is worth remembering"         |
+
+### Research Tools
+
+| Tool              | Purpose                                                         | When to Use             |
+| ----------------- | --------------------------------------------------------------- | ----------------------- |
+| **context7**      | Library documentation lookup. Replaces manual doc searching     | API reference, examples |
+| **websearch**     | Web search. Replaces browser for current info                   | Docs not in Context7    |
+| **codesearch**    | Code examples from GitHub. Replaces manual GitHub search        | Real-world patterns     |
+| **grepsearch**    | Cross-repo code patterns. Replaces browsing GitHub for examples | grep.app search         |
+| **webfetch**      | Fetch specific URL content. Replaces curl/browser               | User-provided links     |
+| **review (Task)** | Second opinion                                                  | Validate approach       |
+
+**context7 operations:**
+
+- `resolve`: Find library ID from name (e.g., "react" → "/reactjs/react.dev")
+- `query`: Get documentation for a library topic
+
+### With tilth MCP (When Available)
+
+tilth provides AST-aware code intelligence. When installed, prefer tilth tools over built-in equivalents:
+
+| Need            | Without tilth        | With tilth                      | Why tilth wins                                          |
+| --------------- | -------------------- | ------------------------------- | ------------------------------------------------------- |
+| Find symbol     | `grep` + `read`      | `tilth_search` (expand: 2)      | Returns definitions with inline source — no second read |
+| Read large file | `read` (full)        | `tilth_read`                    | Auto-outlines, shows structure; section drill-down      |
+| Find files      | `glob`               | `tilth_files`                   | Adds token estimates per file                           |
+| Find callers    | `lsp(incomingCalls)` | `tilth_search(kind: "callers")` | Cross-language, structural matching                     |
+| Blast radius    | Manual tracing       | `tilth_deps`                    | Shows imports + downstream callers automatically        |
+
+**WHEN to use tilth_deps**: Before renaming, removing, or changing the signature of an export.
+**SKIP**: When adding new code, fixing internal bugs, or just reading.
+
+**IMPORTANT**: Expanded tilth_search results include full source code — do NOT re-read files already shown in search output.
+
+## Workflow Pattern
+
+```typescript
+// Step 1: Load skills
+skill({ name: "verification-before-completion" });
+skill({ name: "beads" });
+
+// Step 2: Find it (text search)
+grep({ pattern: "functionName", path: "src/" });
+
+// Step 3: Understand it (LSP - ALL 9 operations)
+lsp({ operation: "documentSymbol", filePath: "src/file.ts", line: 1, character: 1 });
+lsp({ operation: "goToDefinition", filePath: "src/file.ts", line: 42, character: 10 });
+lsp({ operation: "findReferences", filePath: "src/file.ts", line: 42, character: 10 });
+lsp({ operation: "hover", filePath: "src/file.ts", line: 42, character: 10 });
+// ... remaining 5 operations
+
+// Step 4: Check memory
+memory_search({ query: "auth patterns" });
+
+// Step 5: Read before edit
+read({ filePath: "/absolute/path/to/file.ts" });
+
+// Step 6: Modify
+edit({ filePath: "/absolute/path/to/file.ts", oldString: "...", newString: "..." });
+
+// Step 7: Verify
+bash({ command: "npm run typecheck && npm run lint" });
+```
+
+## Tool Comparison
+
+### grep vs LSP
+
+| Scenario           | Use                         | Why                                         |
+| ------------------ | --------------------------- | ------------------------------------------- |
+| "Find all X"       | `grep`                      | Fast text search, includes comments/strings |
+| "Where is X used?" | `lsp` with `findReferences` | Semantic, tracks actual code dependencies   |
+| "What type is X?"  | `lsp` with `hover`          | Type system intelligence                    |
+| "Find TODOs"       | `grep`                      | Text search across all files                |
+
+### When to Use What
+
+**Start with LSP when:**
+
+- Understanding code structure
+- Before any edit (ALL 9 operations)
+- Tracing dependencies
+- Getting type information
+
+**Start with grep when:**
+
+- Quick exploration ("are there any X?")
+- Finding error patterns, logs, configs
+- Searching across file types (JSON, YAML, etc.)
+
+**Use skill when:**
+
+- Starting any significant work
+- Need specialized knowledge
+- Following established patterns
+
+**Use Task when:**
+
+- Multiple independent research questions
+- Parallel implementation tasks
+- 3+ files need simultaneous work
+
+## Common Mistakes
+
+❌ **Wrong**: Edit without LSP
+
+```typescript
+// DON'T: Edit without understanding structure
+edit({ filePath: "src/file.ts", oldString: "...", newString: "..." });
+```
+
+✅ **Right**: LSP before edit
+
+```typescript
+// DO: Run all 9 LSP operations first
+lsp({ operation: "documentSymbol", filePath: "src/file.ts", line: 1, character: 1 });
+lsp({ operation: "goToDefinition", filePath: "src/file.ts", line: 10, character: 5 });
+// ... 7 more operations
+read({ filePath: "src/file.ts" });
+edit({ filePath: "src/file.ts", oldString: "...", newString: "..." });
+```
+
+❌ **Wrong**: Old LSP syntax
+
+```typescript
+// DON'T: This syntax doesn't exist
+lsp_lsp_hover((filePath = "src/file.ts"), (line = 42), (character = 10));
+```
+
+✅ **Right**: Correct LSP syntax
+
+```typescript
+// DO: Use operation parameter
+lsp({ operation: "hover", filePath: "src/file.ts", line: 42, character: 10 });
+```
+
+## Quick Reference
+
+```
+BEFORE EDITING:
+  lsp({ operation: "documentSymbol", ... })     → File structure
+  lsp({ operation: "goToDefinition", ... })     → Where defined
+  lsp({ operation: "findReferences", ... })     → All usages
+  lsp({ operation: "hover", ... })              → Type info
+  lsp({ operation: "goToImplementation", ... }) → Implementations
+  lsp({ operation: "prepareCallHierarchy", ... }) → Call hierarchy
+  lsp({ operation: "incomingCalls", ... })      → What calls this
+  lsp({ operation: "outgoingCalls", ... })      → What this calls
+  lsp({ operation: "workspaceSymbol", ... })    → Workspace search
+
+SEARCHING:
+  grep({ pattern: "...", path: "src/" })        → Text search
+  glob({ pattern: "**/*.ts" })                  → File discovery
+
+PARALLEL WORK:
+  Task({ subagent_type: "explore", ... })       → Parallel subagent
+  swarm({ operation: "sync", action: "push" }) → Sync to todos
+  swarm({ operation: "monitor", action: "progress_update" }) → Track progress
+
+RESEARCH:
+  context7({ operation: "resolve", libraryName: "..." })
+  context7({ operation: "query", libraryId: "...", topic: "..." })
+  websearch({ query: "..." })
+  Task({ subagent_type: "review", description: "Second opinion", prompt: "Review the approach." })
+
+MEMORY:
+  memory_search({ query: "..." })               → Find past learnings
+  observation({ type: "learning", ... })        → Record for future
+```

package/baseline/skill/ui-ux-research/SKILL.md

@@ -0,0 +1,9 @@
+---
+description: "Merged into design-system-audit. Load that skill instead."
+---
+
+# UI/UX Research
+
+> This skill has been merged into `design-system-audit` which now covers UI pattern analysis, design token auditing, and visual comparison.
+> 
+> Load `design-system-audit` instead.

package/baseline/skill/using-git-worktrees/SKILL.md

@@ -0,0 +1,259 @@
+---
+name: using-git-worktrees
+description: Use when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory selection and safety verification
+version: 1.0.0
+tags: [git, workflow]
+dependencies: []
+---
+
+# Using Git Worktrees
+
+## When to Use
+
+- When starting feature work that needs an isolated workspace or before executing an implementation plan.
+
+## When NOT to Use
+
+- When a simple change can safely be done in the current working tree or the repo does not allow worktrees.
+
+## Overview
+
+Git worktrees create isolated workspaces sharing the same repository, allowing work on multiple branches simultaneously without switching.
+
+**Core principle:** Systematic directory selection + safety verification = reliable isolation.
+
+**Announce at start:** "I'm using the using-git-worktrees skill to set up an isolated workspace."
+
+## Directory Selection Process
+
+Follow this priority order:
+
+### 1. Check Existing Directories
+
+```bash
+# Check in priority order
+ls -d .worktrees 2>/dev/null     # Preferred (hidden)
+ls -d worktrees 2>/dev/null      # Alternative
+```
+
+**If found:** Use that directory. If both exist, `.worktrees` wins.
+
+### 2. Check AGENTS.md
+
+```bash
+grep -i "worktree.*director" AGENTS.md 2>/dev/null
+```
+
+**If preference specified:** Use it without asking.
+
+### 3. Ask User
+
+If no directory exists and no AGENTS.md preference:
+
+```
+No worktree directory found. Where should I create worktrees?
+
+1. .worktrees/ (project-local, hidden)
+2. ~/.opencode/worktrees/<project-name>/ (global location)
+
+Which would you prefer?
+```
+
+## Safety Verification
+
+### For Project-Local Directories (.worktrees or worktrees)
+
+**MUST verify .gitignore before creating worktree:**
+
+```bash
+# Check if directory pattern in .gitignore
+grep -q "^\.worktrees/$" .gitignore || grep -q "^worktrees/$" .gitignore
+```
+
+**If NOT in .gitignore:**
+
+Per Jesse's rule "Fix broken things immediately":
+
+1. Add appropriate line to .gitignore
+2. Commit the change
+3. Proceed with worktree creation
+
+**Why critical:** Prevents accidentally committing worktree contents to repository.
+
+### For Global Directory (~/.opencode/worktrees)
+
+No .gitignore verification needed - outside project entirely.
+
+## Creation Steps
+
+### 1. Detect Project Name
+
+```bash
+project=$(basename "$(git rev-parse --show-toplevel)")
+```
+
+### 2. Create Worktree
+
+```bash
+# Determine full path
+case $LOCATION in
+  .worktrees|worktrees)
+    path="$LOCATION/$BRANCH_NAME"
+    ;;
+  ~/.opencode/worktrees/*)
+    path="~/.opencode/worktrees/$project/$BRANCH_NAME"
+    ;;
+esac
+
+# Create worktree with new branch
+git worktree add "$path" -b "$BRANCH_NAME"
+cd "$path"
+```
+
+## Worktree Tracking
+
+After creating a worktree, persist its absolute path for session resume:
+
+```bash
+# After creating worktree
+mkdir -p .beads/artifacts/$BEAD_ID
+echo "/absolute/path/to/worktree" > .beads/artifacts/$BEAD_ID/worktree.txt
+```
+
+On session resume, restore the active worktree if tracking exists:
+
+```bash
+# Check if worktree exists for active bead
+if [ -f .beads/artifacts/$BEAD_ID/worktree.txt ]; then
+  WORKTREE_PATH=$(cat .beads/artifacts/$BEAD_ID/worktree.txt)
+  cd "$WORKTREE_PATH"
+fi
+```
+
+On worktree cleanup (after merge), remove the tracking file:
+
+```bash
+rm -f .beads/artifacts/$BEAD_ID/worktree.txt
+```
+
+### 3. Run 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
+```
+
+### 4. Verify Clean Baseline
+
+Run tests to ensure worktree starts clean:
+
+```bash
+# Examples - use project-appropriate command
+npm test
+cargo test
+pytest
+go test ./...
+```
+
+**If tests fail:** Report failures, ask whether to proceed or investigate.
+
+**If tests pass:** Report ready.
+
+### 5. Report Location
+
+```
+Worktree ready at <full-path>
+Tests passing (<N> tests, 0 failures)
+Ready to implement <feature-name>
+```
+
+## Quick Reference
+
+| Situation                   | Action                      |
+| --------------------------- | --------------------------- |
+| `.worktrees/` exists        | Use it (verify .gitignore)  |
+| `worktrees/` exists         | Use it (verify .gitignore)  |
+| Both exist                  | Use `.worktrees/`           |
+| Neither exists              | Check AGENTS.md → Ask user  |
+| Directory not in .gitignore | Add it immediately + commit |
+| Tests fail during baseline  | Report failures + ask       |
+| No package.json/Cargo.toml  | Skip dependency install     |
+
+## Common Mistakes
+
+**Skipping .gitignore verification**
+
+- **Problem:** Worktree contents get tracked, pollute git status
+- **Fix:** Always grep .gitignore before creating project-local worktree
+
+**Assuming directory location**
+
+- **Problem:** Creates inconsistency, violates project conventions
+- **Fix:** Follow priority: existing > AGENTS.md > ask
+
+**Proceeding with failing tests**
+
+- **Problem:** Can't distinguish new bugs from pre-existing issues
+- **Fix:** Report failures, get explicit permission to proceed
+
+**Hardcoding setup commands**
+
+- **Problem:** Breaks on projects using different tools
+- **Fix:** Auto-detect from project files (package.json, etc.)
+
+## Example Workflow
+
+```
+You: I'm using the using-git-worktrees skill to set up an isolated workspace.
+
+[Check .worktrees/ - exists]
+[Verify .gitignore - contains .worktrees/]
+[Create worktree: git worktree add .worktrees/auth -b feature/auth]
+[Run npm install]
+[Run npm test - 47 passing]
+
+Worktree ready at /Users/jesse/myproject/.worktrees/auth
+Tests passing (47 tests, 0 failures)
+Ready to implement auth feature
+```
+
+## Red Flags
+
+**Never:**
+
+- Create worktree without .gitignore verification (project-local)
+- Skip baseline test verification
+- Proceed with failing tests without asking
+- Assume directory location when ambiguous
+- Skip AGENTS.md check
+
+**Always:**
+
+- Follow directory priority: existing > AGENTS.md > ask
+- Verify .gitignore for project-local
+- Auto-detect and run project setup
+- Verify clean test baseline
+
+## Integration
+
+**Called by:**
+
+- **brainstorming** (Phase 4) - REQUIRED when design is approved and implementation follows
+- Any skill needing isolated workspace
+
+**Pairs with:**
+
+- **finishing-a-development-branch** - REQUIRED for cleanup after work complete
+- **executing-plans** or **subagent-driven-development** - Work happens in this worktree

package/baseline/skill/using-skills/SKILL.md

@@ -0,0 +1,117 @@
+---
+name: using-skills
+description: Use when starting any conversation - establishes mandatory workflows for finding and using skills, including using Skill tool before announcing usage, following brainstorming before coding, and creating TodoWrite todos for checklists
+version: 1.0.0
+tags: [workflow, context]
+dependencies: []
+---
+
+<EXTREMELY-IMPORTANT>
+If you think there is even a 1% chance a skill might apply to what you are doing, you ABSOLUTELY MUST read the skill.
+
+IF A SKILL APPLIES TO YOUR TASK, YOU DO NOT HAVE A CHOICE. YOU MUST USE IT.
+
+This is not negotiable. This is not optional. You cannot rationalize your way out of this.
+</EXTREMELY-IMPORTANT>
+
+# Getting Started with Skills
+
+## When to Use
+
+- At the start of any conversation or task to determine applicable skills
+- Whenever you are about to act and need to check for mandatory workflows
+
+## When NOT to Use
+
+- After you already loaded the correct skill and are executing it
+- For a task that explicitly says to follow a different skill workflow
+
+## MANDATORY FIRST RESPONSE PROTOCOL
+
+Before responding to ANY user message, you MUST complete this checklist:
+
+1. ☐ List available skills in your mind
+2. ☐ Ask yourself: "Does ANY skill match this request?"
+3. ☐ If yes → Use the Skill tool to read and run the skill file
+4. ☐ Announce which skill you're using
+5. ☐ Follow the skill exactly
+
+**Responding WITHOUT completing this checklist = automatic failure.**
+
+## Critical Rules
+
+1. **Follow mandatory workflows.** Brainstorming before coding. Check for relevant skills before ANY task.
+
+2. Execute skills with the Skill tool
+
+## Common Rationalizations That Mean You're About To Fail
+
+If you catch yourself thinking ANY of these thoughts, STOP. You are rationalizing. Check for and use the skill.
+
+- "This is just a simple question" → WRONG. Questions are tasks. Check for skills.
+- "I can check git/files quickly" → WRONG. Files don't have conversation context. Check for skills.
+- "Let me gather information first" → WRONG. Skills tell you HOW to gather information. Check for skills.
+- "This doesn't need a formal skill" → WRONG. If a skill exists for it, use it.
+- "I remember this skill" → WRONG. Skills evolve. Run the current version.
+- "This doesn't count as a task" → WRONG. If you're taking action, it's a task. Check for skills.
+- "The skill is overkill for this" → WRONG. Skills exist because simple things become complex. Use it.
+- "I'll just do this one thing first" → WRONG. Check for skills BEFORE doing anything.
+
+**Why:** Skills document proven techniques that save time and prevent mistakes. Not using available skills means repeating solved problems and making known errors.
+
+If a skill for your task exists, you must use it or you will fail at your task.
+
+## Skills with Checklists
+
+If a skill has a checklist, YOU MUST create TodoWrite todos for EACH item.
+
+**Don't:**
+
+- Work through checklist mentally
+- Skip creating todos "to save time"
+- Batch multiple items into one todo
+- Mark complete without doing them
+
+**Why:** Checklists without TodoWrite tracking = steps get skipped. Every time. The overhead of TodoWrite is tiny compared to the cost of missing steps.
+
+## Announcing Skill Usage
+
+Before using a skill, announce that you are using it.
+"I'm using [Skill Name] to [what you're doing]."
+
+**Examples:**
+
+- "I'm using the brainstorming skill to refine your idea into a design."
+- "I'm using the test-driven-development skill to implement this feature."
+
+**Why:** Transparency helps your human partner understand your process and catch errors early. It also confirms you actually read the skill.
+
+# About these skills
+
+**Many skills contain rigid rules (TDD, debugging, verification).** Follow them exactly. Don't adapt away the discipline.
+
+**Some skills are flexible patterns (architecture, naming).** Adapt core principles to your context.
+
+The skill itself tells you which type it is.
+
+## Instructions ≠ Permission to Skip Workflows
+
+Your human partner's specific instructions describe WHAT to do, not HOW.
+
+"Add X", "Fix Y" = the goal, NOT permission to skip brainstorming, TDD, or RED-GREEN-REFACTOR.
+
+**Red flags:** "Instruction was specific" • "Seems simple" • "Workflow is overkill"
+
+**Why:** Specific instructions mean clear requirements, which is when workflows matter MOST. Skipping process on "simple" tasks is how simple tasks become complex problems.
+
+## Summary
+
+**Starting any task:**
+
+1. If relevant skill exists → Use the skill
+2. Announce you're using it
+3. Follow what it says
+
+**Skill has checklist?** TodoWrite for every item.
+
+**Finding a relevant skill = mandatory to read and use it. Not optional.**