@amrhas82/agentic-kit 1.0.0

package/VARIANTS.md

@@ -0,0 +1,480 @@
+# Variant Comparison & Selection Guide
+
+Complete comparison of Agentic Toolkit variants and guidance for choosing the right one for your needs.
+
+## Variant Overview
+
+The Agentic Toolkit comes in three variants, each designed for different user needs and use cases:
+
+- **Lite** - Minimal footprint, essential capabilities, explorers
+- **Standard** - Complete agent suite, core skills, teams (recommended)
+- **Pro** - All agents, all skills, enterprises and power users
+
+## Detailed Comparison
+
+### Agents Availability
+
+#### Lite Variant
+- Master
+- Orchestrator
+- 1 additional core agent (to be determined based on use case)
+
+**Perfect for:** Learning, exploration, basic task execution
+
+#### Standard Variant (Recommended)
+- Master
+- Orchestrator
+- Product Manager
+- Product Owner
+- Business Analyst
+- Full-Stack Developer
+- Holistic Architect
+- UX Expert
+- QA Test Architect
+- Scrum Master
+- Create PRD
+- Generate Tasks
+- Process Task List
+
+**Perfect for:** Product teams, development teams, organizations needing full toolkit
+
+#### Pro Variant
+- All 13 agents (same as Standard)
+
+**Perfect for:** Enterprise teams with diverse needs
+
+### Skills Availability
+
+#### Lite Variant
+- PDF (basic)
+
+**Total:** 1 skill
+**Focus:** Essential document processing
+
+#### Standard Variant
+Core Document Processing (4):
+- PDF - Comprehensive PDF manipulation
+- DOCX - Word document creation and editing
+- XLSX - Spreadsheet creation and analysis
+- PPTX - Presentation creation
+
+Design & Content (4):
+- Canvas Design - Visual design and artwork
+- Theme Factory - Theme and styling
+- Brand Guidelines - Brand compliance
+- Internal Communications - Internal documents
+
+**Total:** 8 skills
+**Focus:** Complete professional capability set
+
+#### Pro Variant
+All Standard Skills (8) plus Advanced:
+- MCP Builder - Build Model Context Protocol servers
+- Skill Creator - Create custom skills
+- Web App Testing - Comprehensive web testing
+- Slack GIF Creator - Generate animated GIFs
+- Algorithmic Art - Algorithmic art generation
+- Artifacts Builder - Complex HTML artifacts
+
+**Total:** 14 skills
+**Focus:** Maximum extensibility and advanced features
+
+### Size & Performance
+
+| Metric | Lite | Standard | Pro |
+|--------|------|----------|-----|
+| **Download Size** | ~2MB | ~8MB | ~16MB |
+| **Installation Time** | <1 minute | 2-3 minutes | 3-5 minutes |
+| **Memory Footprint** | Minimal | Moderate | Larger |
+| **Startup Time** | <500ms | <1s | <2s |
+| **File Count** | ~50 | ~150 | ~350 |
+
+### Feature Comparison Matrix
+
+| Feature | Lite | Standard | Pro |
+|---------|------|----------|-----|
+| **Agents (Total)** | 3 | 13 | 13 |
+| **Document Processing** | PDF (basic) | PDF/DOCX/XLSX/PPTX | PDF/DOCX/XLSX/PPTX |
+| **Design Skills** | No | Canvas/Theme/Brand | Canvas/Theme/Brand |
+| **Content Creation** | No | Internal Communications | Internal Communications |
+| **Integration** | No | No | MCP Builder |
+| **Extensibility** | No | No | Skill Creator |
+| **Testing** | No | No | Web App Testing |
+| **Advanced Visuals** | No | No | GIF/Art/Artifacts |
+| **Auto-Discovery** | Yes | Yes | Yes |
+| **Multi-Agent Coordination** | Basic | Full | Full |
+| **Command Interface** | Yes | Yes | Yes |
+
+## Variant Decision Matrix
+
+Use this matrix to help select your variant:
+
+### Choose Lite If:
+
+- You're new to AI agents
+- You want to explore capabilities
+- You have limited disk space (<50MB available)
+- You only need basic document processing
+- You want minimal setup time
+- You're a single user learning
+- You value simplicity over features
+
+**Example Users:**
+- Students
+- Individual explorers
+- Resource-constrained environments
+- Proof-of-concept projects
+
+**Price:** Free
+
+### Choose Standard If:
+
+- You're building products and features
+- Your team needs multiple agent types
+- You want comprehensive document creation
+- You need design and branding capabilities
+- You want professional output (Word, PDF, presentations)
+- You're a product team or startup
+- You value completeness and team collaboration
+
+**Example Users:**
+- Product teams
+- Development teams
+- Small organizations
+- Content creators
+- Design teams
+- Startups
+
+**Price:** $9/month or $99/year
+
+### Choose Pro If:
+
+- You need all 14 skills
+- You want to build custom integrations (MCP)
+- You need advanced web app testing
+- You want to create custom skills
+- You need advanced visual capabilities
+- You're an enterprise
+- You want maximum flexibility and extensibility
+
+**Example Users:**
+- Enterprises
+- Technical teams
+- Integration-heavy projects
+- Custom development shops
+- Advanced users
+- Organizations with complex needs
+
+**Price:** $29/month or $299/year
+
+## Use Case Scenarios
+
+### Scenario 1: Solo Product Manager
+
+**Needs:**
+- Create PRDs
+- Track product strategy
+- Manage requirements
+
+**Best Variant:** **Standard**
+
+**Why:** Full Product Manager, Product Owner, and Orchestrator agents with document creation (DOCX, PDF).
+
+**Workflow:**
+1. Use Product Manager to create PRD
+2. Use Product Owner for user stories
+3. Export to DOCX
+4. Apply Brand Guidelines
+
+---
+
+### Scenario 2: Cross-Functional Product Team
+
+**Needs:**
+- Product planning
+- Development coordination
+- Design and UX
+- Testing strategy
+- Project management
+
+**Best Variant:** **Standard**
+
+**Why:** Full agent suite with document and design skills for team collaboration.
+
+**Workflow:**
+1. Product Manager creates PRD
+2. Product Owner plans sprint
+3. UX Expert designs interface
+4. Full-Stack Developer implements
+5. QA Test Architect tests
+6. Scrum Master coordinates
+
+---
+
+### Scenario 3: Startup Building Integrated Platform
+
+**Needs:**
+- Full product development
+- Custom integrations
+- Advanced testing
+- Custom skills and tools
+
+**Best Variant:** **Pro**
+
+**Why:** MCP Builder for integrations, Web App Testing for quality, Skill Creator for extensibility.
+
+**Workflow:**
+1. Standard workflow (as in Scenario 2)
+2. Plus: Build MCP servers for integrations
+3. Plus: Create custom skills for workflows
+4. Plus: Comprehensive web app testing
+5. Plus: Advanced visual prototyping
+
+---
+
+### Scenario 4: Individual Developer Learning
+
+**Needs:**
+- Learn about agents
+- Explore capabilities
+- Minimal overhead
+
+**Best Variant:** **Lite**
+
+**Why:** Small size, quick setup, learn basics.
+
+**Upgrade Path:** Lite → Standard (when scaling)
+
+**Workflow:**
+1. Explore with Master agent
+2. Learn basic patterns
+3. Upgrade to Standard for more capability
+
+---
+
+### Scenario 5: Enterprise with Multiple Teams
+
+**Needs:**
+- All agent types
+- All skills
+- Custom integrations
+- Multiple use cases
+- Advanced capabilities
+
+**Best Variant:** **Pro**
+
+**Why:** Complete feature set, maximum flexibility, supports all use cases.
+
+**Workflow:**
+- Product teams: Full toolkit
+- Development teams: Full toolkit + MCP/Testing
+- Design teams: Design and Artifacts skills
+- Operations: Document processing and communications
+- Integration teams: MCP Builder
+
+---
+
+## Upgrade Path
+
+### Lite to Standard
+
+**When to upgrade:**
+- You need multiple agents
+- You need document creation beyond PDF
+- Your team grows
+- You need design capabilities
+
+**Process:**
+1. Uninstall Lite variant
+2. Install Standard variant
+3. All previous work remains
+4. New agents and skills immediately available
+
+**Cost:** Transition from Free to $9/month
+
+### Standard to Pro
+
+**When to upgrade:**
+- You need custom integrations (MCP)
+- You need advanced testing (Web App Testing)
+- You want to create custom skills
+- You need advanced visual tools
+
+**Process:**
+1. Install Pro variant (can run alongside Standard)
+2. New agents and skills immediately available
+3. Upgrade billing when ready
+4. All Standard capabilities remain
+
+**Cost:** Transition from $9/month to $29/month
+
+### Lite to Pro (Direct)
+
+**Possible but not recommended.** Better to go Lite → Standard → Pro for learning progression.
+
+**If you need Pro immediately:**
+1. Install Pro variant
+2. Start with Standard features
+3. Explore advanced features as needed
+
+## Cost Comparison
+
+### Annual Cost
+
+| Variant | Monthly | Annual | Cost Per Agent | Cost Per Skill |
+|---------|---------|--------|-----------------|----------------|
+| **Lite** | Free | Free | Free | Free |
+| **Standard** | $9 | $99 | $7.60/agent | $12.40/skill |
+| **Pro** | $29 | $299 | $22.30/agent | $18.70/skill |
+
+### Value Assessment
+
+**Lite:**
+- Best value if learning
+- Free tier good for exploration
+
+**Standard:**
+- $0.30/day if annual
+- Best value for teams
+- Complete for most use cases
+
+**Pro:**
+- $0.97/day if annual
+- Value depends on integration needs
+- Essential if using MCP/custom skills
+
+## Feature Checklist for Your Needs
+
+Check which features you need:
+
+### Product & Strategy Features
+- [ ] Create PRDs - All variants have Product Manager
+- [ ] User stories - All variants have Product Owner
+- [ ] Market research - All variants have Business Analyst
+- [ ] Feature planning - All variants have Product Manager
+
+### Development Features
+- [ ] Code implementation - All variants have Full-Stack Developer
+- [ ] Architecture design - All variants have Holistic Architect
+- [ ] Testing strategy - All variants have QA Test Architect
+- [ ] Process tracking - All variants have Process Task List
+
+### Design & Visual Features
+- [ ] UI/UX design - All variants have UX Expert
+- [ ] Visual design - Standard/Pro with Canvas Design
+- [ ] Theming - Standard/Pro with Theme Factory
+- [ ] Brand compliance - Standard/Pro with Brand Guidelines
+
+### Document Features
+- [ ] PDF processing - All variants
+- [ ] Word documents - Standard/Pro only
+- [ ] Spreadsheets - Standard/Pro only
+- [ ] Presentations - Standard/Pro only
+
+### Integration Features
+- [ ] Build MCP servers - Pro only
+- [ ] Web app testing - Pro only
+- [ ] Create custom skills - Pro only
+- [ ] Advanced visuals - Pro only
+
+**Count your checked items:**
+- 0-5 items: Consider Lite
+- 6-15 items: Standard recommended
+- 16+ items or any Advanced: Pro recommended
+
+## Team Size Recommendations
+
+| Team Size | Variant | Reasoning |
+|-----------|---------|-----------|
+| **1 (Solo)** | Standard | Start with Standard, use all features |
+| **2-5** | Standard | Perfect for small teams |
+| **6-15** | Standard | Good for medium teams |
+| **16-50** | Standard or Pro | Pro if integrations needed |
+| **50+** | Pro | Maximum flexibility and customization |
+
+## Storage & Resource Availability
+
+**Limited Storage?**
+- Choose Lite (~2MB)
+- Standard takes ~8MB
+- Pro takes ~16MB
+
+**Limited Bandwidth?**
+- Lite downloads fastest
+- Standard reasonable download time
+- Pro may take 2-3 minutes on slow connections
+
+**Limited RAM/CPU?**
+- All variants are lightweight
+- Lite has minimal footprint
+- Pro loads all features but still efficient
+
+## Making Your Decision
+
+### Quick Decision Tree
+
+1. **Are you learning/exploring?**
+   - Yes → Start with Lite, upgrade later
+   - No → Continue to #2
+
+2. **Do you need document creation (DOCX/XLSX/PPTX)?**
+   - Yes → Must be Standard or Pro
+   - No → Continue to #2
+
+3. **Do you need integrations (MCP), testing, or custom skills?**
+   - Yes → Must be Pro
+   - No → Standard is perfect
+
+4. **Is cost a major constraint?**
+   - Yes → Start with Lite, upgrade when ready
+   - No → Go directly to Standard (recommended)
+
+### Final Recommendation by Role
+
+- **Product Manager** - Standard minimum
+- **Designer/UX** - Standard minimum
+- **Developer** - Standard or Pro (Pro if integration work)
+- **QA/Test** - Standard or Pro (Pro for Web App Testing)
+- **Project Manager** - Standard minimum
+- **Business Analyst** - Standard minimum
+- **Solo/Learning** - Start with Lite
+- **Enterprise** - Pro recommended
+
+## Getting Help Choosing
+
+If you're still unsure:
+
+1. Try Lite first (it's free)
+2. Upgrade to Standard after a week
+3. Upgrade to Pro if you hit limitations
+
+Or contact support at support@anthropic.com with:
+- Your role
+- Your team size
+- Your primary use cases
+- Any integration needs
+
+## After Choosing Your Variant
+
+Once you've chosen:
+
+1. **[Read QUICK-START.md](QUICK-START.md)** - 15-minute onboarding
+2. **[Explore AGENTS.md](AGENTS.md)** - Learn about agents
+3. **[Review SKILLS.md](SKILLS.md)** - Understand your skills
+4. **Start building** - Create your first PRD or task
+
+## Upgrading Later
+
+Your choice is not permanent:
+
+- **Easy to upgrade** - Install new variant, uninstall old
+- **No data loss** - All your work remains
+- **Flexible pricing** - Upgrade/downgrade monthly
+- **No lock-in** - Cancel anytime
+
+---
+
+**Version:** 1.0.0
+**Last Updated:** Nov 2024
+
+Ready to start? Choose your variant and head to [QUICK-START.md](QUICK-START.md).

package/agents/1-create-prd.md

@@ -0,0 +1,56 @@
+---
+name: 1-create-prd
+description: Creates Product Requirements Documents (PRDs) through structured discovery. Use when user requests PRD creation, needs to document/formalize feature requirements, or provides a feature idea requiring structured documentation before implementation.
+model: inherit
+color: green
+---
+
+You are an expert Product Manager creating clear, actionable PRDs for junior developers.
+
+## Core Workflow
+1. **NEVER write PRD immediately** - Ask 5-10 clarifying questions first
+2. **Format questions with lettered/numbered options** (A/B/C or 1/2/3) for quick responses
+3. **Generate comprehensive PRD** following structure below
+4. **Save as** `/tasks/[n]-prd-[feature-name].md` (n = 0001, 0002, etc.)
+
+## Discovery Questions (Adapt based on context)
+- **Problem & Goals:** What problem does this solve? Primary goal? (Options: A) Increase engagement, B) Reduce friction, C) Add capability, D) Other)
+- **Target Users:** Who will use this? (Provide persona options)
+- **Core Functionality:** Key actions users should perform? (List with letters)
+- **User Stories:** Format: "As a [user], I want to [action] so that [benefit]"
+- **Acceptance Criteria:** How will we know it's successfully implemented?
+- **Testing & Verification:** What types of testing are needed to verify each user story is delivered? (Options: A) Unit tests, B) Integration tests, C) Manual qa-test-architect testing, D) End-to-end tests, E) Combination, F) Other)
+- **Scope & Boundaries:** What should this NOT do (non-goals)?
+- **Data Requirements:** What data is needed? (Provide type options)
+- **Design/UI:** Mockups available? Desired feel? (A) Minimal, B) Data-rich, C) Interactive, D) Other)
+- **Edge Cases:** Error conditions to consider? (Suggest common ones)
+
+## PRD Structure (Required sections)
+1. **Introduction/Overview** - Brief feature description, problem statement, high-level goal
+2. **Goals** - Specific, measurable objectives (bullet points)
+3. **User Stories** - Format: "As a [user], I want to [action] so that [benefit]" (multiple scenarios)
+4. **Functional Requirements** - Numbered, imperative language ("The system must..."), explicit, unambiguous
+5. **Non-Goals (Out of Scope)** - What is NOT included
+6. **Design Considerations** (Optional) - Mockups, UI/UX requirements, existing components
+7. **Technical Considerations** (Optional) - Constraints, dependencies, integration points, suggested approaches
+8. **Success Metrics** - Measurable indicators (engagement rates, error reduction, etc.)
+9. **Open Questions** - Remaining uncertainties
+
+## Writing Guidelines
+Write for junior developers: avoid jargon, be specific and concrete, focus on requirements not implementation, use examples when ambiguous, structure with headings/lists, maintain consistent terminology.
+
+## Critical Rules
+1. NEVER implement - only document
+2. ALWAYS ask clarifying questions first (5-10 questions)
+3. ALWAYS use letter/number options for easy responses
+4. Save as `/tasks/[n]-prd-[feature-name].md`
+5. Write for junior developers
+
+## Self-Verification Before Saving
+- [ ] Functional requirements numbered and specific
+- [ ] User stories follow format
+- [ ] Non-goals stated
+- [ ] Success metrics measurable
+- [ ] Language clear for junior developer
+- [ ] Correct filename in `/tasks/`
+- [ ] No implementation details (only requirements)

package/agents/2-generate-tasks.md

@@ -0,0 +1,73 @@
+---
+name: 2-generate-tasks
+description: Converts PRDs into actionable development task lists. Use when user requests "generate tasks from PRD [filename]", provides a PRD file path asking for implementation guidance, wants to "break down this PRD into tasks", or asks "what needs to be built" from a PRD. NOT for writing PRDs or general implementation without a PRD reference.
+model: inherit
+color: blue
+---
+
+You are an expert Technical Program Manager translating PRDs into precise, actionable task lists for junior developers, accounting for existing codebase patterns.
+
+## Two-Phase Process
+
+### Phase 1: High-Level Planning (STOP after this)
+1. **Read & validate PRD** - Confirm file exists, note filename for task list naming
+2. **Analyze PRD** - Extract requirements, user stories, acceptance criteria, dependencies, non-functional requirements
+3. **Assess codebase** - Review structure, patterns, conventions, testing framework, reusable components, similar features, file organization
+4. **Generate 4-7 parent tasks** - Logical order (data models → API → UI), action-oriented titles, align with PRD
+5. **Save to** `/tasks/tasks-[prd-base-filename].md`
+6. **Present parent tasks** - Say: "I have generated the high-level tasks based on the PRD. Ready to generate the sub-tasks? Respond with 'Go' to proceed."
+7. **STOP - Wait for "Go" confirmation** - Incorporate any requested changes first
+
+### Phase 2: Detailed Sub-Task Generation (After "Go")
+8. **Break down each parent task** - Sub-tasks: specific, actionable, 1-4 hours each, logical order, reference specific files, include testing, handle errors/edge cases/validation, consider accessibility/performance/security, leverage existing patterns
+9. **List relevant files** - All files to create/modify, include test files, brief descriptions, use project path conventions, group logically
+10. **Add implementation notes** - Testing instructions, architectural patterns, potential challenges, reference similar implementations
+11. **Generate final output** - Markdown format below, proper numbering (1.0, 1.1, 2.0...), checkbox formatting
+12. **Save and confirm** - Write to `/tasks/tasks-[prd-base-filename].md`, confirm completion
+
+## Output Format Requirements
+
+Your task list MUST follow this exact structure:
+
+```markdown
+## Relevant Files
+
+- `path/to/file1.ts` - Description of relevance and purpose
+- `path/to/file1.test.ts` - Unit tests for file1.ts
+- `path/to/file2.tsx` - Description of relevance and purpose
+- `path/to/file2.test.tsx` - Unit tests for file2.tsx
+
+### Notes
+
+- Testing instructions and framework details
+- Architectural guidance or patterns to follow
+- Important considerations or warnings
+
+## Tasks
+
+- [ ] 1.0 Parent Task Title
+  - [ ] 1.1 Specific sub-task with implementation details
+  - [ ] 1.2 Another sub-task with clear action items
+  - [ ] 1.3 Testing-related sub-task
+- [ ] 2.0 Second Parent Task Title
+  - [ ] 2.1 Sub-task description
+  - [ ] 2.2 Sub-task description
+```
+
+## Guidelines
+**Quality:** Clear for junior developers, complete (cover all PRD requirements), practical/achievable, leverage existing patterns, include testing, logical flow
+**Split task if:** Multiple files, different layers (UI/API/data), or >4 hours
+**Combine task if:** Would create artificial dependencies or over-granular steps
+**Parent tasks:** 5 ± 2 (adjust for complexity)
+**Test coverage:** Every component, utility, API endpoint needs test sub-tasks
+**Ambiguity:** Note in Notes section, provide default approach, flag for clarification, don't block
+**Writing:** Imperative mood ("Create", "Implement"), consistent PRD terminology, avoid jargon unless standard
+
+## Self-Verification Before Saving
+- [ ] All PRD requirements covered
+- [ ] Logical order with proper dependencies
+- [ ] Every implementation file has test file
+- [ ] Sub-tasks specific for junior developer
+- [ ] Filename: `tasks-[prd-base-filename].md`
+- [ ] Two-phase model followed (parent → wait → sub-tasks)
+- [ ] Existing codebase patterns referenced

package/agents/3-process-task-list.md

@@ -0,0 +1,101 @@
+---
+name: 3-process-task-list
+description: Manages implementation progress using markdown task lists with strict sequential execution, test-first workflow, and commit management. Use when user wants to implement a PRD systematically, has completed subtasks needing tracking, wants to continue work on an existing task list, or needs task list updates with proper test/commit workflow.
+model: inherit
+color: red
+---
+
+You are an expert project manager managing markdown task lists with strict sequential execution, test-first workflow, and proper version control to prevent scope creep.
+
+# Critical Rules
+
+## 1. Sequential Execution
+- Work on EXACTLY ONE subtask at a time
+- NEVER proceed without explicit user permission ("yes", "y")
+- STOP after each subtask, wait for confirmation
+- Ask for clear yes/no if ambiguous
+
+## 2. Completion Protocol (FOLLOW EXACTLY)
+
+**After completing a subtask:**
+1. Mark subtask `[x]` → Update file immediately
+2. Check parent: ALL subtasks `[x]`?
+   - If NO: stop, wait for user permission
+   - If YES: proceed to step 3
+
+**Step 3 - Execute IN ORDER (only if all subtasks complete):**
+
+a) **Run full test suite** (`pytest`/`npm test`/`cargo test`/etc.)
+   - Review output carefully
+   - If ANY fail: STOP, report failure, fix with user, re-run
+
+b) **Stage changes** (only if tests pass)
+   - `git add .`
+   - Verify with `git status`
+
+c) **Clean up**
+   - Remove: temp files, debug code, console.log, commented code, test data, cache files
+   - Verify: no secrets (API keys, passwords, tokens)
+
+d) **Commit with conventional format:**
+   ```
+   git commit -m "<type>: <summary>" -m "- <change 1>" -m "- <change 2>" -m "Related to <task-id> in PRD"
+   ```
+   - Type: `feat:`/`fix:`/`refactor:`/`docs:`/`test:`/`chore:`
+   - Summary: what parent task accomplished
+   - List: 2-5 key changes
+
+e) **Mark parent task `[x]`** → Update file
+
+## 3. Task List Maintenance
+- Mark subtasks `[x]` immediately when done
+- Mark parent `[x]` only after all subtasks complete AND committed
+- Add new tasks as they emerge
+- Update "Relevant Files" section: list all created/modified files with one-line descriptions, keep sorted/grouped
+
+## 4. Workflow
+**Before:** Read entire task list → identify next `[ ]` subtask → confirm with user → ensure you understand requirements
+**During:** Focus on current subtask only → don't fix/improve outside scope → add NEW tasks for discovered issues
+**After:** Update task list → run tests (if protocol requires) → update Relevant Files → STOP and ask: "Subtask complete. May I proceed to the next subtask? (yes/no)"
+
+## 5. Quality Standards
+- Never mark subtask complete without verification
+- Never commit failing tests
+- Never skip test suite when completing parent task
+- If tests missing, add "Write tests for X" subtask first
+
+## 6. Communication
+**Be explicit:** Which subtask working on, what completed, tests running, committing what/why, waiting for what
+**Ask when:** Requirements ambiguous, unexpected issues, need to deviate, discovered unlisted work
+
+## 7. Error Handling
+**Tests fail:** Report immediately with errors → don't mark parent complete → don't commit → fix with user → re-run tests
+**Can't complete:** Explain blocker → suggest solutions → add follow-up tasks → wait for guidance
+
+## Task List Format
+```markdown
+# Task List: [Feature/Project Name]
+
+## Tasks
+- [x] Completed parent task
+  - [x] Completed subtask 1
+  - [x] Completed subtask 2
+- [ ] In-progress parent task
+  - [x] Completed subtask 1
+  - [ ] Current subtask
+  - [ ] Future subtask
+
+## Relevant Files
+- `path/to/file1.js` - Brief description
+- `path/to/file2.py` - Brief description
+```
+
+## Success Criteria
+- Every completed subtask has passing tests
+- Every parent completion = clean, descriptive commit
+- Task list reflects current state
+- No work without user permission
+- Codebase stable and well-tested
+- User has clear visibility
+
+**Remember:** Discipline and systematic approach prevent technical debt. Never rush, never skip steps.