@tech-leads-club/agent-skills 0.1.0-beta.2

package/skills/spec-driven-dev/references/tasks.md

@@ -0,0 +1,221 @@
+# Phase 3: Tasks
+
+**Goal**: Break into GRANULAR, ATOMIC tasks. Clear dependencies. Right tools. Parallel execution plan.
+
+## Why Granular Tasks?
+
+| Vague Task (BAD) | Granular Tasks (GOOD) |
+|------------------|----------------------|
+| "Create form" | T1: Create email input component |
+|               | T2: Add email validation function |
+|               | T3: Create submit button |
+|               | T4: Add form state management |
+|               | T5: Connect form to API |
+| "Implement auth" | T1: Create login form |
+|                  | T2: Create register form |
+|                  | T3: Add token storage utility |
+|                  | T4: Create auth API service |
+|                  | T5: Add route protection |
+
+**Benefits of granular:**
+- **Agents don't err** - Single focus, no ambiguity
+- **Easy to test** - Each task = one verifiable outcome
+- **Parallelizable** - Independent tasks run simultaneously
+- **Errors isolated** - One failure doesn't block everything
+
+**Rule**: One task = ONE of these:
+- One component
+- One function
+- One API endpoint
+- One file change
+
+---
+
+## Process
+
+### 1. Review Design
+Read `.specs/[feature]/design.md` before creating tasks.
+
+### 2. Break Into Atomic Tasks
+
+**Task = ONE deliverable**. Examples:
+- ✅ "Create UserService interface" (one file, one concept)
+- ❌ "Implement user management" (too vague, multiple files)
+
+### 3. Define Dependencies
+
+What MUST be done before this task can start?
+
+### 4. Create Execution Plan
+
+Group tasks into phases. Identify what can run in parallel.
+
+### 5. ASK About MCPs and Skills
+
+**CRITICAL**: Before execution, ask the user:
+
+> "For each task, which tools should I use?"
+> 
+> **Available MCPs**: [list from project or user]
+> **Available Skills**: [list from project or user]
+
+---
+
+## Template: `.specs/[feature]/tasks.md`
+
+```markdown
+# [Feature] Tasks
+
+**Design**: `.specs/[feature]/design.md`
+**Status**: Draft | Approved | In Progress | Done
+
+---
+
+## Execution Plan
+
+### Phase 1: Foundation (Sequential)
+Tasks that must be done first, in order.
+
+```
+T1 → T2 → T3
+```
+
+### Phase 2: Core Implementation (Parallel OK)
+After foundation, these can run in parallel.
+
+```
+     ┌→ T4 ─┐
+T3 ──┼→ T5 ─┼──→ T8
+     └→ T6 ─┘
+       T7 ──────→
+```
+
+### Phase 3: Integration (Sequential) 
+Bringing it all together.
+
+```
+T8 → T9
+```
+
+---
+
+## Task Breakdown
+
+### T1: [Create X Interface]
+
+**What**: [One sentence: exact deliverable]
+**Where**: `src/path/to/file.ts`
+**Depends on**: None
+**Reuses**: `src/existing/BaseInterface.ts`
+
+**Tools**:
+- MCP: `filesystem` (or NONE)
+- Skill: NONE
+
+**Done when**:
+- [ ] Interface defined with all methods from design
+- [ ] Types exported correctly
+- [ ] No TypeScript errors
+
+---
+
+### T2: [Implement Y Service] [P]
+
+**What**: [Exact deliverable]
+**Where**: `src/services/YService.ts`
+**Depends on**: T1
+**Reuses**: `src/services/BaseService.ts` patterns
+
+**Tools**:
+- MCP: `filesystem`, `context7`
+- Skill: NONE
+
+**Done when**:
+- [ ] Implements interface from T1
+- [ ] Handles error cases from design
+- [ ] Unit test passes
+
+---
+
+### T3: [Create Z Component] [P]
+
+**What**: [Exact deliverable]
+**Where**: `src/components/ZComponent.tsx`
+**Depends on**: T1
+**Reuses**: `src/components/BaseComponent.tsx`
+
+**Tools**:
+- MCP: `filesystem`
+- Skill: NONE
+
+**Done when**:
+- [ ] Component renders correctly
+- [ ] Handles props from interface
+- [ ] Follows existing component patterns
+
+---
+
+### T4: [Add A Feature to Y]
+
+**What**: [Exact deliverable]
+**Where**: `src/services/YService.ts` (modify)
+**Depends on**: T2, T3
+**Reuses**: Existing service patterns
+
+**Tools**:
+- MCP: `filesystem`, `github`
+- Skill: `api-design`
+
+**Done when**:
+- [ ] Feature works per acceptance criteria
+- [ ] Integration test passes
+
+---
+
+## Parallel Execution Map
+
+Visual representation of what can run simultaneously:
+
+```
+Phase 1 (Sequential):
+  T1 ──→ T2 ──→ T3
+
+Phase 2 (Parallel):
+  T3 complete, then:
+    ├── T4 [P]
+    ├── T5 [P]  } Can run simultaneously
+    └── T6 [P]
+
+Phase 3 (Sequential):
+  T4, T5, T6 complete, then:
+    T7 ──→ T8
+```
+
+---
+
+## Task Granularity Check
+
+Before approving tasks, verify they are granular enough:
+
+| Task | Scope | Status |
+|------|-------|--------|
+| T1: Create email input | 1 component | ✅ Granular |
+| T2: Add validation function | 1 function | ✅ Granular |
+| T3: Create form with all fields | 5+ components | ❌ Split it! |
+| T4: Connect to API | 1 function | ✅ Granular |
+
+**Granularity check**:
+- ✅ 1 component / 1 function / 1 endpoint = Good
+- ⚠️ 2-3 related things in same file = OK if cohesive
+- ❌ Multiple components or files = MUST split
+```
+
+---
+
+## Tips
+
+- **[P] = Parallel OK** - Mark tasks that can run simultaneously
+- **Reuses = Token saver** - Always reference existing code
+- **Tools per task** - MCPs and Skills prevent wrong approaches
+- **Dependencies are gates** - Clear what blocks what
+- **Done when = Testable** - If you can't verify it, rewrite it

package/skills/spec-driven-dev/references/validate.md

@@ -0,0 +1,126 @@
+# Phase 4b: Validate
+
+**Goal**: Verify implementation meets spec requirements.
+
+## When to Validate
+
+- After completing a user story (all tasks for P1, P2, etc.)
+- After completing all tasks
+- When user requests validation
+
+## Process
+
+### 1. Check Completed Tasks
+
+Go through tasks.md:
+- [ ] All tasks marked done?
+- [ ] Any blocked or partial?
+
+### 2. Verify Acceptance Criteria
+
+For each user story in spec.md:
+
+```markdown
+### P1: [Story Title]
+
+**Acceptance Criteria**:
+1. WHEN [X] THEN [Y] → [PASS/FAIL]
+2. WHEN [X] THEN [Y] → [PASS/FAIL]
+```
+
+### 3. Check Edge Cases
+
+From spec.md edge cases:
+- [ ] [Edge case 1] handled correctly
+- [ ] [Edge case 2] handled correctly
+
+### 4. Run Tests (if applicable)
+
+```bash
+npm test  # or project test command
+```
+
+### 5. Report
+
+---
+
+## Validation Report Template
+
+```markdown
+# [Feature] Validation
+
+**Date**: [YYYY-MM-DD]
+**Spec**: `.specs/[feature]/spec.md`
+
+---
+
+## Task Completion
+
+| Task | Status | Notes |
+|------|--------|-------|
+| T1 | ✅ Done | - |
+| T2 | ✅ Done | - |
+| T3 | ⚠️ Partial | [Issue] |
+
+---
+
+## User Story Validation
+
+### P1: [Story Title] ⭐ MVP
+
+| Criterion | Result |
+|-----------|--------|
+| WHEN X THEN Y | ✅ PASS |
+| WHEN A THEN B | ✅ PASS |
+
+**Status**: ✅ P1 Complete
+
+### P2: [Story Title]
+
+| Criterion | Result |
+|-----------|--------|
+| WHEN X THEN Y | ❌ FAIL - [reason] |
+
+**Status**: ⚠️ P2 Issues
+
+---
+
+## Edge Cases
+
+- [x] Edge case 1: Handled correctly
+- [ ] Edge case 2: NOT handled - needs fix
+
+---
+
+## Tests
+
+- **Ran**: `npm test`
+- **Result**: 15 passed, 2 failed
+- **Failures**: [list]
+
+---
+
+## Summary
+
+**Overall**: ✅ Ready | ⚠️ Issues | ❌ Not Ready
+
+**What works**:
+- [List]
+
+**Issues found**:
+- [Issue 1]: [How to fix]
+- [Issue 2]: [How to fix]
+
+**Recommended next steps**:
+1. [Action]
+2. [Action]
+```
+
+---
+
+## Tips
+
+- **P1 first** - MVP must work before P2/P3
+- **WHEN/THEN = Test** - Each criterion is a test case
+- **Be specific** - "Doesn't work" isn't helpful
+- **Recommend fixes** - Don't just report problems

package/skills/subagent-creator/SKILL.md

@@ -0,0 +1,283 @@
+---
+name: subagent-creator
+description: Guide for creating AI subagents with isolated context for complex multi-step workflows. Use when users want to create a subagent, specialized agent, verifier, debugger, or orchestrator that requires isolated context and deep specialization. Works with any agent that supports subagent delegation. Triggers on "create subagent", "new agent", "specialized assistant", "create verifier".
+---
+
+# Subagent Creator
+
+This skill provides guidance for creating effective, agent-agnostic subagents.
+
+## What are Subagents?
+
+Subagents are specialized assistants that an AI agent can delegate tasks to. Characteristics:
+
+- **Isolated context**: Each subagent has its own context window
+- **Parallel execution**: Multiple subagents can run simultaneously
+- **Specialization**: Configured with specific prompts and expertise
+- **Reusable**: Defined once, used in multiple contexts
+
+### When to Use Subagents vs Skills
+
+```
+Is the task complex with multiple steps?
+├─ YES → Does it require isolated context?
+│         ├─ YES → Use SUBAGENT
+│         └─ NO → Use SKILL
+│
+└─ NO → Use SKILL
+```
+
+**Use Subagents for:**
+- Complex workflows requiring isolated context
+- Long-running tasks that benefit from specialization
+- Verification and auditing (independent perspective)
+- Parallel workstreams
+
+**Use Skills for:**
+- Quick, one-off actions
+- Domain knowledge without context isolation
+- Reusable procedures that don't need isolation
+
+## Subagent Structure
+
+A subagent is typically a markdown file with frontmatter metadata:
+
+```markdown
+---
+name: agent-name
+description: Description of when to use this subagent.
+model: inherit  # or fast, or specific model ID
+readonly: false  # true to restrict write permissions
+---
+
+You are an [expert in X].
+
+When invoked:
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+
+[Detailed instructions about expected behavior]
+
+Report [type of expected result]:
+- [Output format]
+- [Metrics or specific information]
+```
+
+## Subagent Creation Process
+
+### 1. Define the Purpose
+
+- What specific responsibility does the subagent have?
+- Why does it need isolated context?
+- Does it involve multiple complex steps?
+- Does it require deep specialization?
+
+### 2. Configure the Metadata
+
+#### name (required)
+Unique identifier. Use kebab-case.
+
+```yaml
+name: security-auditor
+```
+
+#### description (critical)
+CRITICAL for automatic delegation. Explains when to use this subagent.
+
+**Good descriptions:**
+- "Security specialist. Use when implementing auth, payments, or handling sensitive data."
+- "Debugging specialist for errors and test failures. Use when encountering issues."
+- "Validates completed work. Use after tasks are marked done."
+
+**Phrases that encourage automatic delegation:**
+- "Use proactively when..."
+- "Always use for..."
+- "Automatically delegate when..."
+
+#### model (optional)
+```yaml
+model: inherit  # Uses same model as parent (default)
+model: fast     # Uses fast model for quick tasks
+```
+
+#### readonly (optional)
+```yaml
+readonly: true  # Restricts write permissions
+```
+
+### 3. Write the Subagent Prompt
+
+Define:
+1. **Identity**: "You are an [expert]..."
+2. **When invoked**: Context of use
+3. **Process**: Specific steps to follow
+4. **Expected output**: Format and content
+
+**Template:**
+
+```markdown
+You are an [expert in X] specialized in [Y].
+
+When invoked:
+1. [First action]
+2. [Second action]
+3. [Third action]
+
+[Detailed instructions about approach]
+
+Report [type of result]:
+- [Specific format]
+- [Information to include]
+- [Metrics or criteria]
+
+[Philosophy or principles to follow]
+```
+
+## Common Subagent Patterns
+
+### 1. Verification Agent
+
+**Purpose**: Independently validates that completed work actually works.
+
+```markdown
+---
+name: verifier
+description: Validates completed work. Use after tasks are marked done.
+model: fast
+---
+
+You are a skeptical validator.
+
+When invoked:
+1. Identify what was declared as complete
+2. Verify the implementation exists and is functional
+3. Execute tests or relevant verification steps
+4. Look for edge cases that may have been missed
+
+Be thorough. Report:
+- What was verified and passed
+- What is incomplete or broken
+- Specific issues to address
+```
+
+### 2. Debugger
+
+**Purpose**: Expert in root cause analysis.
+
+```markdown
+---
+name: debugger
+description: Debugging specialist. Use when encountering errors or test failures.
+---
+
+You are a debugging expert.
+
+When invoked:
+1. Capture the error message and stack trace
+2. Identify reproduction steps
+3. Isolate the failure location
+4. Implement minimal fix
+5. Verify the solution works
+
+For each issue, provide:
+- Root cause explanation
+- Evidence supporting the diagnosis
+- Specific code fix
+- Testing approach
+```
+
+### 3. Security Auditor
+
+**Purpose**: Security expert auditing code.
+
+```markdown
+---
+name: security-auditor
+description: Security specialist. Use for auth, payments, or sensitive data.
+---
+
+You are a security expert.
+
+When invoked:
+1. Identify security-sensitive code paths
+2. Check for common vulnerabilities
+3. Confirm secrets are not hardcoded
+4. Review input validation
+
+Report findings by severity:
+- **Critical** (must fix before deploy)
+- **High** (fix soon)
+- **Medium** (address when possible)
+- **Low** (suggestions)
+```
+
+### 4. Code Reviewer
+
+**Purpose**: Code review with focus on quality.
+
+```markdown
+---
+name: code-reviewer
+description: Code review specialist. Use when changes are ready for review.
+---
+
+You are a code review expert.
+
+When invoked:
+1. Analyze the code changes
+2. Check readability, performance, patterns, error handling
+3. Identify code smells and potential bugs
+4. Suggest specific improvements
+
+Report:
+**✅ Approved / ⚠️ Approved with caveats / ❌ Changes needed**
+
+**Issues Found:**
+- **[Severity]** [Location]: [Issue]
+  - Suggestion: [How to fix]
+```
+
+## Best Practices
+
+### ✅ DO
+
+- **Write focused subagents**: One clear responsibility
+- **Invest in the description**: Determines when to delegate
+- **Keep prompts concise**: Direct and specific
+- **Share with team**: Version control subagent definitions
+- **Test the description**: Check correct subagent is triggered
+
+### ❌ AVOID
+
+- **Vague descriptions**: "Use for general tasks" gives no signal
+- **Prompts too long**: 2000 words don't make it smarter
+- **Too many subagents**: Start with 2-3 focused ones
+
+## Quality Checklist
+
+Before finalizing:
+
+- [ ] Description is specific about when to delegate
+- [ ] Name uses kebab-case
+- [ ] One clear responsibility (not generic)
+- [ ] Prompt is concise but complete
+- [ ] Instructions are actionable
+- [ ] Output format is well defined
+- [ ] Model configuration appropriate
+
+## Output Messages
+
+When creating a subagent:
+
+```
+✅ Subagent created successfully!
+
+📁 Location: .agent/subagents/[name].md
+🎯 Purpose: [brief description]
+🔧 How to invoke:
+   - Automatic: Agent delegates when it detects [context]
+   - Explicit: /[name] [instruction]
+
+💡 Tip: Include keywords like "use proactively" to encourage delegation.
+```