@agentskillkit/agent-skills 1.0.1 → 3.2.1

package/.agent/skills/plan-writing/SKILL.md

@@ -1,152 +0,0 @@
----
-name: plan-writing
-description: Structured task planning with clear breakdowns, dependencies, and verification criteria. Use when implementing features, refactoring, or any multi-step work.
-allowed-tools: Read, Glob, Grep
----
-
-# Plan Writing
-
-> Source: obra/superpowers
-
-## Overview
-This skill provides a framework for breaking down work into clear, actionable tasks with verification criteria.
-
-## Task Breakdown Principles
-
-### 1. Small, Focused Tasks
-- Each task should take 2-5 minutes
-- One clear outcome per task
-- Independently verifiable
-
-### 2. Clear Verification
-- How do you know it's done?
-- What can you check/test?
-- What's the expected output?
-
-### 3. Logical Ordering
-- Dependencies identified
-- Parallel work where possible
-- Critical path highlighted
-- **Phase X: Verification is always LAST**
-
-### 4. Dynamic Naming in Project Root
-- Plan files are saved as `{task-slug}.md` in the PROJECT ROOT
-- Name derived from task (e.g., "add auth" → `auth-feature.md`)
-- **NEVER** inside `.claude/`, `docs/`, or temp folders
-
-## Planning Principles (NOT Templates!)
-
-> 🔴 **NO fixed templates. Each plan is UNIQUE to the task.**
-
-### Principle 1: Keep It SHORT
-
-| ❌ Wrong | ✅ Right |
-|----------|----------|
-| 50 tasks with sub-sub-tasks | 5-10 clear tasks max |
-| Every micro-step listed | Only actionable items |
-| Verbose descriptions | One-line per task |
-
-> **Rule:** If plan is longer than 1 page, it's too long. Simplify.
-
----
-
-### Principle 2: Be SPECIFIC, Not Generic
-
-| ❌ Wrong | ✅ Right |
-|----------|----------|
-| "Set up project" | "Run `npx create-next-app`" |
-| "Add authentication" | "Install next-auth, create `/api/auth/[...nextauth].ts`" |
-| "Style the UI" | "Add Tailwind classes to `Header.tsx`" |
-
-> **Rule:** Each task should have a clear, verifiable outcome.
-
----
-
-### Principle 3: Dynamic Content Based on Project Type
-
-**For NEW PROJECT:**
-- What tech stack? (decide first)
-- What's the MVP? (minimal features)
-- What's the file structure?
-
-**For FEATURE ADDITION:**
-- Which files are affected?
-- What dependencies needed?
-- How to verify it works?
-
-**For BUG FIX:**
-- What's the root cause?
-- What file/line to change?
-- How to test the fix?
-
----
-
-### Principle 4: Scripts Are Project-Specific
-
-> 🔴 **DO NOT copy-paste script commands. Choose based on project type.**
-
-| Project Type | Relevant Scripts |
-|--------------|------------------|
-| Frontend/React | `ux_audit.py`, `accessibility_checker.py` |
-| Backend/API | `api_validator.py`, `security_scan.py` |
-| Mobile | `mobile_audit.py` |
-| Database | `schema_validator.py` |
-| Full-stack | Mix of above based on what you touched |
-
-**Wrong:** Adding all scripts to every plan
-**Right:** Only scripts relevant to THIS task
-
----
-
-### Principle 5: Verification is Simple
-
-| ❌ Wrong | ✅ Right |
-|----------|----------|
-| "Verify the component works correctly" | "Run `npm run dev`, click button, see toast" |
-| "Test the API" | "curl localhost:3000/api/users returns 200" |
-| "Check styles" | "Open browser, verify dark mode toggle works" |
-
----
-
-## Plan Structure (Flexible, Not Fixed!)
-
-```
-# [Task Name]
-
-## Goal
-One sentence: What are we building/fixing?
-
-## Tasks
-- [ ] Task 1: [Specific action] → Verify: [How to check]
-- [ ] Task 2: [Specific action] → Verify: [How to check]
-- [ ] Task 3: [Specific action] → Verify: [How to check]
-
-## Done When
-- [ ] [Main success criteria]
-```
-
-> **That's it.** No phases, no sub-sections unless truly needed.
-> Keep it minimal. Add complexity only when required.
-
-## Notes
-[Any important considerations]
-```
-
----
-
-## Best Practices (Quick Reference)
-
-1. **Start with goal** - What are we building/fixing?
-2. **Max 10 tasks** - If more, break into multiple plans
-3. **Each task verifiable** - Clear "done" criteria
-4. **Project-specific** - No copy-paste templates
-5. **Update as you go** - Mark `[x]` when complete
-
----
-
-## When to Use
-
-- New project from scratch
-- Adding a feature
-- Fixing a bug (if complex)
-- Refactoring multiple files

package/.agent/skills/powershell-windows/SKILL.md

@@ -1,167 +0,0 @@
----
-name: powershell-windows
-description: PowerShell Windows patterns. Critical pitfalls, operator syntax, error handling.
-allowed-tools: Read, Write, Edit, Glob, Grep, Bash
----
-
-# PowerShell Windows Patterns
-
-> Critical patterns and pitfalls for Windows PowerShell.
-
----
-
-## 1. Operator Syntax Rules
-
-### CRITICAL: Parentheses Required
-
-| ❌ Wrong | ✅ Correct |
-|----------|-----------|
-| `if (Test-Path "a" -or Test-Path "b")` | `if ((Test-Path "a") -or (Test-Path "b"))` |
-| `if (Get-Item $x -and $y -eq 5)` | `if ((Get-Item $x) -and ($y -eq 5))` |
-
-**Rule:** Each cmdlet call MUST be in parentheses when using logical operators.
-
----
-
-## 2. Unicode/Emoji Restriction
-
-### CRITICAL: No Unicode in Scripts
-
-| Purpose | ❌ Don't Use | ✅ Use |
-|---------|-------------|--------|
-| Success | ✅ ✓ | [OK] [+] |
-| Error | ❌ ✗ 🔴 | [!] [X] |
-| Warning | ⚠️ 🟡 | [*] [WARN] |
-| Info | ℹ️ 🔵 | [i] [INFO] |
-| Progress | ⏳ | [...] |
-
-**Rule:** Use ASCII characters only in PowerShell scripts.
-
----
-
-## 3. Null Check Patterns
-
-### Always Check Before Access
-
-| ❌ Wrong | ✅ Correct |
-|----------|-----------|
-| `$array.Count -gt 0` | `$array -and $array.Count -gt 0` |
-| `$text.Length` | `if ($text) { $text.Length }` |
-
----
-
-## 4. String Interpolation
-
-### Complex Expressions
-
-| ❌ Wrong | ✅ Correct |
-|----------|-----------|
-| `"Value: $($obj.prop.sub)"` | Store in variable first |
-
-**Pattern:**
-```
-$value = $obj.prop.sub
-Write-Output "Value: $value"
-```
-
----
-
-## 5. Error Handling
-
-### ErrorActionPreference
-
-| Value | Use |
-|-------|-----|
-| Stop | Development (fail fast) |
-| Continue | Production scripts |
-| SilentlyContinue | When errors expected |
-
-### Try/Catch Pattern
-
-- Don't return inside try block
-- Use finally for cleanup
-- Return after try/catch
-
----
-
-## 6. File Paths
-
-### Windows Path Rules
-
-| Pattern | Use |
-|---------|-----|
-| Literal path | `C:\Users\User\file.txt` |
-| Variable path | `Join-Path $env:USERPROFILE "file.txt"` |
-| Relative | `Join-Path $ScriptDir "data"` |
-
-**Rule:** Use Join-Path for cross-platform safety.
-
----
-
-## 7. Array Operations
-
-### Correct Patterns
-
-| Operation | Syntax |
-|-----------|--------|
-| Empty array | `$array = @()` |
-| Add item | `$array += $item` |
-| ArrayList add | `$list.Add($item) | Out-Null` |
-
----
-
-## 8. JSON Operations
-
-### CRITICAL: Depth Parameter
-
-| ❌ Wrong | ✅ Correct |
-|----------|-----------|
-| `ConvertTo-Json` | `ConvertTo-Json -Depth 10` |
-
-**Rule:** Always specify `-Depth` for nested objects.
-
-### File Operations
-
-| Operation | Pattern |
-|-----------|---------|
-| Read | `Get-Content "file.json" -Raw | ConvertFrom-Json` |
-| Write | `$data | ConvertTo-Json -Depth 10 | Out-File "file.json" -Encoding UTF8` |
-
----
-
-## 9. Common Errors
-
-| Error Message | Cause | Fix |
-|---------------|-------|-----|
-| "parameter 'or'" | Missing parentheses | Wrap cmdlets in () |
-| "Unexpected token" | Unicode character | Use ASCII only |
-| "Cannot find property" | Null object | Check null first |
-| "Cannot convert" | Type mismatch | Use .ToString() |
-
----
-
-## 10. Script Template
-
-```powershell
-# Strict mode
-Set-StrictMode -Version Latest
-$ErrorActionPreference = "Continue"
-
-# Paths
-$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
-
-# Main
-try {
-    # Logic here
-    Write-Output "[OK] Done"
-    exit 0
-}
-catch {
-    Write-Warning "Error: $_"
-    exit 1
-}
-```
-
----
-
-> **Remember:** PowerShell has unique syntax rules. Parentheses, ASCII-only, and null checks are non-negotiable.

package/.agent/skills/problem-solving/ABOUT.md

@@ -1,40 +0,0 @@
-# Problem-Solving Skills - Attribution
-
-These skills were derived from agent patterns in the [Amplifier](https://github.com/microsoft/amplifier) project.
-
-**Source Repository:**
-- Name: Amplifier
-- URL: https://github.com/microsoft/amplifier
-- Commit: 2adb63f858e7d760e188197c8e8d4c1ef721e2a6
-- Date: 2025-10-10
-
-## Skills Derived from Amplifier Agents
-
-**From insight-synthesizer agent:**
-- simplification-cascades - Finding insights that eliminate multiple components
-- collision-zone-thinking - Forcing unrelated concepts together for breakthroughs
-- meta-pattern-recognition - Spotting patterns across 3+ domains
-- inversion-exercise - Flipping assumptions to reveal alternatives
-- scale-game - Testing at extremes to expose fundamental truths
-
-**From ambiguity-guardian agent:**
-- (architecture) preserving-productive-tensions - Preserving multiple valid approaches
-
-**From knowledge-archaeologist agent:**
-- (research) tracing-knowledge-lineages - Understanding how ideas evolved
-
-**Dispatch pattern:**
-- when-stuck - Maps stuck-symptoms to appropriate technique
-
-## What Was Adapted
-
-The amplifier agents are specialized long-lived agents with structured JSON output. These skills extract the core problem-solving techniques and adapt them as:
-
-- Scannable quick-reference guides (~60 lines each)
-- Symptom-based discovery via when_to_use
-- Immediate application without special tooling
-- Composable through dispatch pattern
-
-## Core Insight
-
-Agent capabilities are domain-agnostic patterns. Whether packaged as "amplifier agent" or "superpowers skill", the underlying technique is the same. We extracted the techniques and made them portable.

package/.agent/skills/problem-solving/SKILL.md

@@ -1,69 +0,0 @@
----
-name: problem-solving
-description: Creative problem-solving techniques for breaking through stuck points - includes collision-zone thinking, inversion, pattern recognition, and simplification
-when_to_use: when stuck on a problem, need innovation beyond conventional approaches, or want to find elegant solutions
-version: 1.0.0
----
-
-# Problem-Solving Skills
-
-A collection of techniques for breaking through stuck points and finding elegant solutions.
-
-## Available Sub-Skills
-
-### When Stuck (Dispatch)
-**Location:** `when-stuck/SKILL.md`
-
-Start here when stuck. Matches your stuck-type to the right technique. Quick dispatch table for routing to the appropriate sub-skill.
-
-### Collision-Zone Thinking
-**Location:** `collision-zone-thinking/SKILL.md`
-
-Force unrelated concepts together to discover emergent properties. "What if we treated X like Y?" Revolutionary insights come from deliberate metaphor-mixing.
-
-### Inversion Exercise
-**Location:** `inversion-exercise/SKILL.md`
-
-Flip every assumption and see what still works. "What if the opposite were true?" Exposes hidden constraints and alternative approaches.
-
-### Meta-Pattern Recognition
-**Location:** `meta-pattern-recognition/SKILL.md`
-
-Spot patterns appearing in 3+ domains to find universal principles. Extract abstract forms that apply across domains.
-
-### Scale Game
-**Location:** `scale-game/SKILL.md`
-
-Test at extremes (1000x bigger/smaller) to expose fundamental truths. What breaks? What survives? Extremes reveal what normal scales hide.
-
-### Simplification Cascades
-**Location:** `simplification-cascades/SKILL.md`
-
-Find one insight that eliminates multiple components. "If this is true, we don't need X, Y, or Z." Look for unifying principles.
-
-## When to Use
-
-| How You're Stuck | Use This |
-|------------------|----------|
-| **Don't know which technique** | when-stuck |
-| **Need breakthrough innovation** | collision-zone-thinking |
-| **Forced by assumptions** | inversion-exercise |
-| **Same issue in different places** | meta-pattern-recognition |
-| **Unsure about production scale** | scale-game |
-| **Complexity spiraling** | simplification-cascades |
-
-## Quick Reference
-
-```
-Conventional solutions inadequate?  → collision-zone-thinking
-"This must be done this way"?       → inversion-exercise
-Same pattern 3+ places?             → meta-pattern-recognition
-Will it work at scale?              → scale-game
-Same thing implemented 5+ ways?     → simplification-cascades
-```
-
-## Core Philosophy
-
-> "One powerful abstraction > ten clever hacks"
-
-These techniques help you find the elegant solution that makes complexity unnecessary, rather than managing complexity through brute force.

package/.agent/skills/problem-solving/collision-zone-thinking/SKILL.md

@@ -1,62 +0,0 @@
----
-name: Collision-Zone Thinking
-description: Force unrelated concepts together to discover emergent properties - "What if we treated X like Y?"
-when_to_use: when conventional approaches feel inadequate and you need breakthrough innovation by forcing unrelated concepts together
-version: 1.1.0
----
-
-# Collision-Zone Thinking
-
-## Overview
-
-Revolutionary insights come from forcing unrelated concepts to collide. Treat X like Y and see what emerges.
-
-**Core principle:** Deliberate metaphor-mixing generates novel solutions.
-
-## Quick Reference
-
-| Stuck On | Try Treating As | Might Discover |
-|----------|-----------------|----------------|
-| Code organization | DNA/genetics | Mutation testing, evolutionary algorithms |
-| Service architecture | Lego bricks | Composable microservices, plug-and-play |
-| Data management | Water flow | Streaming, data lakes, flow-based systems |
-| Request handling | Postal mail | Message queues, async processing |
-| Error handling | Circuit breakers | Fault isolation, graceful degradation |
-
-## Process
-
-1. **Pick two unrelated concepts** from different domains
-2. **Force combination**: "What if we treated [A] like [B]?"
-3. **Explore emergent properties**: What new capabilities appear?
-4. **Test boundaries**: Where does the metaphor break?
-5. **Extract insight**: What did we learn?
-
-## Example Collision
-
-**Problem:** Complex distributed system with cascading failures
-
-**Collision:** "What if we treated services like electrical circuits?"
-
-**Emergent properties:**
-- Circuit breakers (disconnect on overload)
-- Fuses (one-time failure protection)
-- Ground faults (error isolation)
-- Load balancing (current distribution)
-
-**Where it works:** Preventing cascade failures
-**Where it breaks:** Circuits don't have retry logic
-**Insight gained:** Failure isolation patterns from electrical engineering
-
-## Red Flags You Need This
-
-- "I've tried everything in this domain"
-- Solutions feel incremental, not breakthrough
-- Stuck in conventional thinking
-- Need innovation, not optimization
-
-## Remember
-
-- Wild combinations often yield best insights
-- Test metaphor boundaries rigorously
-- Document even failed collisions (they teach)
-- Best source domains: physics, biology, economics, psychology

package/.agent/skills/problem-solving/inversion-exercise/SKILL.md

@@ -1,58 +0,0 @@
----
-name: Inversion Exercise
-description: Flip core assumptions to reveal hidden constraints and alternative approaches - "what if the opposite were true?"
-when_to_use: when stuck on unquestioned assumptions or feeling forced into "the only way" to do something
-version: 1.1.0
----
-
-# Inversion Exercise
-
-## Overview
-
-Flip every assumption and see what still works. Sometimes the opposite reveals the truth.
-
-**Core principle:** Inversion exposes hidden assumptions and alternative approaches.
-
-## Quick Reference
-
-| Normal Assumption | Inverted | What It Reveals |
-|-------------------|----------|-----------------|
-| Cache to reduce latency | Add latency to enable caching | Debouncing patterns |
-| Pull data when needed | Push data before needed | Prefetching, eager loading |
-| Handle errors when occur | Make errors impossible | Type systems, contracts |
-| Build features users want | Remove features users don't need | Simplicity >> addition |
-| Optimize for common case | Optimize for worst case | Resilience patterns |
-
-## Process
-
-1. **List core assumptions** - What "must" be true?
-2. **Invert each systematically** - "What if opposite were true?"
-3. **Explore implications** - What would we do differently?
-4. **Find valid inversions** - Which actually work somewhere?
-
-## Example
-
-**Problem:** Users complain app is slow
-
-**Normal approach:** Make everything faster (caching, optimization, CDN)
-
-**Inverted:** Make things intentionally slower in some places
-- Debounce search (add latency → enable better results)
-- Rate limit requests (add friction → prevent abuse)
-- Lazy load content (delay → reduce initial load)
-
-**Insight:** Strategic slowness can improve UX
-
-## Red Flags You Need This
-
-- "There's only one way to do this"
-- Forcing solution that feels wrong
-- Can't articulate why approach is necessary
-- "This is just how it's done"
-
-## Remember
-
-- Not all inversions work (test boundaries)
-- Valid inversions reveal context-dependence
-- Sometimes opposite is the answer
-- Question "must be" statements

package/.agent/skills/problem-solving/meta-pattern-recognition/SKILL.md

@@ -1,54 +0,0 @@
----
-name: Meta-Pattern Recognition
-description: Spot patterns appearing in 3+ domains to find universal principles
-when_to_use: when noticing the same pattern across 3+ different domains or experiencing déjà vu in problem-solving
-version: 1.1.0
----
-
-# Meta-Pattern Recognition
-
-## Overview
-
-When the same pattern appears in 3+ domains, it's probably a universal principle worth extracting.
-
-**Core principle:** Find patterns in how patterns emerge.
-
-## Quick Reference
-
-| Pattern Appears In | Abstract Form | Where Else? |
-|-------------------|---------------|-------------|
-| CPU/DB/HTTP/DNS caching | Store frequently-accessed data closer | LLM prompt caching, CDN |
-| Layering (network/storage/compute) | Separate concerns into abstraction levels | Architecture, organization |
-| Queuing (message/task/request) | Decouple producer from consumer with buffer | Event systems, async processing |
-| Pooling (connection/thread/object) | Reuse expensive resources | Memory management, resource governance |
-
-## Process
-
-1. **Spot repetition** - See same shape in 3+ places
-2. **Extract abstract form** - Describe independent of any domain
-3. **Identify variations** - How does it adapt per domain?
-4. **Check applicability** - Where else might this help?
-
-## Example
-
-**Pattern spotted:** Rate limiting in API throttling, traffic shaping, circuit breakers, admission control
-
-**Abstract form:** Bound resource consumption to prevent exhaustion
-
-**Variation points:** What resource, what limit, what happens when exceeded
-
-**New application:** LLM token budgets (same pattern - prevent context window exhaustion)
-
-## Red Flags You're Missing Meta-Patterns
-
-- "This problem is unique" (probably not)
-- Multiple teams independently solving "different" problems identically
-- Reinventing wheels across domains
-- "Haven't we done something like this?" (yes, find it)
-
-## Remember
-
-- 3+ domains = likely universal
-- Abstract form reveals new applications
-- Variations show adaptation points
-- Universal patterns are battle-tested

package/.agent/skills/problem-solving/scale-game/SKILL.md

@@ -1,63 +0,0 @@
----
-name: Scale Game
-description: Test at extremes (1000x bigger/smaller, instant/year-long) to expose fundamental truths hidden at normal scales
-when_to_use: when uncertain about scalability, edge cases unclear, or validating architecture for production volumes
-version: 1.1.0
----
-
-# Scale Game
-
-## Overview
-
-Test your approach at extreme scales to find what breaks and what surprisingly survives.
-
-**Core principle:** Extremes expose fundamental truths hidden at normal scales.
-
-## Quick Reference
-
-| Scale Dimension | Test At Extremes | What It Reveals |
-|-----------------|------------------|-----------------|
-| Volume | 1 item vs 1B items | Algorithmic complexity limits |
-| Speed | Instant vs 1 year | Async requirements, caching needs |
-| Users | 1 user vs 1B users | Concurrency issues, resource limits |
-| Duration | Milliseconds vs years | Memory leaks, state growth |
-| Failure rate | Never fails vs always fails | Error handling adequacy |
-
-## Process
-
-1. **Pick dimension** - What could vary extremely?
-2. **Test minimum** - What if this was 1000x smaller/faster/fewer?
-3. **Test maximum** - What if this was 1000x bigger/slower/more?
-4. **Note what breaks** - Where do limits appear?
-5. **Note what survives** - What's fundamentally sound?
-
-## Examples
-
-### Example 1: Error Handling
-**Normal scale:** "Handle errors when they occur" works fine
-**At 1B scale:** Error volume overwhelms logging, crashes system
-**Reveals:** Need to make errors impossible (type systems) or expect them (chaos engineering)
-
-### Example 2: Synchronous APIs
-**Normal scale:** Direct function calls work
-**At global scale:** Network latency makes synchronous calls unusable
-**Reveals:** Async/messaging becomes survival requirement, not optimization
-
-### Example 3: In-Memory State
-**Normal duration:** Works for hours/days
-**At years:** Memory grows unbounded, eventual crash
-**Reveals:** Need persistence or periodic cleanup, can't rely on memory
-
-## Red Flags You Need This
-
-- "It works in dev" (but will it work in production?)
-- No idea where limits are
-- "Should scale fine" (without testing)
-- Surprised by production behavior
-
-## Remember
-
-- Extremes reveal fundamentals
-- What works at one scale fails at another
-- Test both directions (bigger AND smaller)
-- Use insights to validate architecture early