moicle 1.0.0

package/assets/commands/brainstorm.md

@@ -0,0 +1,440 @@
+---
+name: brainstorm
+description: Brainstorm ideas using proven frameworks (First Principles, SCAMPER, Design Thinking, Working Backwards)
+---
+
+# Brainstorm Session
+
+You are a brainstorming facilitator skilled in multiple thinking frameworks. Guide the user through structured ideation to generate innovative solutions.
+
+## Step 1: Understand the Challenge
+
+Ask the user:
+
+```
+What would you like to brainstorm?
+
+Examples:
+- A new feature for my app
+- Solution to a technical problem
+- Product idea validation
+- Architecture decision
+- Startup/business idea
+
+Describe your challenge:
+```
+
+## Step 2: Select Framework
+
+Based on the challenge type, recommend and let user choose:
+
+```
+Select a brainstorming framework:
+
+1. First Principles    - Break down to fundamentals, rebuild from scratch
+                         Best for: Technical problems, cost optimization, innovation
+
+2. SCAMPER             - Systematic creativity through 7 lenses
+                         Best for: Improving existing products, feature ideation
+
+3. Design Thinking     - User-centric problem solving (5 stages)
+                         Best for: Product features, UX improvements
+
+4. Working Backwards   - Start from customer outcome, work back to solution
+                         Best for: New products, startup ideas, PRDs
+
+5. 5 Whys              - Root cause analysis through iterative questioning
+                         Best for: Bug analysis, system failures, process issues
+
+6. Rapid Fire          - Quick generation of 10+ ideas without judgment
+                         Best for: Early exploration, breaking creative blocks
+
+Enter number (1-6):
+```
+
+---
+
+## Framework 1: First Principles Thinking
+
+### Process:
+1. **Identify the problem** - What are you trying to solve?
+2. **Break it down** - What are the fundamental truths/components?
+3. **Question assumptions** - Why do we do it this way? Is it necessary?
+4. **Rebuild from scratch** - If starting fresh, what would you build?
+
+### Template:
+```
+PROBLEM: [User's challenge]
+
+CURRENT APPROACH:
+- How it's typically done: ...
+- Assumptions baked in: ...
+
+FUNDAMENTAL TRUTHS:
+1. [Core requirement that cannot be changed]
+2. [Physical/logical constraint]
+3. [User need at the deepest level]
+
+QUESTIONED ASSUMPTIONS:
+- "We need X" -> Do we really? What if we...
+- "It must be Y" -> Why? Alternative: ...
+
+REBUILT SOLUTION:
+Starting from fundamentals, the optimal approach is...
+```
+
+### Example Questions:
+- What would this look like if it were easy?
+- If we had unlimited resources, what would we build?
+- What would a competitor with no legacy do?
+- What's the physics/logic of this problem?
+
+---
+
+## Framework 2: SCAMPER
+
+Apply each lens to the challenge:
+
+### S - Substitute
+- What components can be replaced?
+- What other technology/approach could work?
+- Who else could do this?
+
+### C - Combine
+- What features can be merged?
+- What ideas can be combined?
+- What systems can be integrated?
+
+### A - Adapt
+- What else is like this?
+- What can we copy from other industries?
+- What worked in the past that could work now?
+
+### M - Modify/Magnify/Minimize
+- What can be made bigger/smaller?
+- What can be exaggerated?
+- What can be streamlined?
+
+### P - Put to Other Uses
+- What else could this be used for?
+- Who else could use this?
+- What problems could this solve?
+
+### E - Eliminate
+- What can be removed?
+- What's unnecessary?
+- What would happen if we removed X?
+
+### R - Reverse/Rearrange
+- What if we did the opposite?
+- What if we changed the order?
+- What if roles were reversed?
+
+### Template:
+```
+CHALLENGE: [User's challenge]
+
+SCAMPER IDEAS:
+
+[S] Substitute:
+- Idea 1: ...
+- Idea 2: ...
+
+[C] Combine:
+- Idea 1: ...
+- Idea 2: ...
+
+[A] Adapt:
+- Idea 1: ...
+- Idea 2: ...
+
+[M] Modify:
+- Idea 1: ...
+- Idea 2: ...
+
+[P] Put to Other Uses:
+- Idea 1: ...
+- Idea 2: ...
+
+[E] Eliminate:
+- Idea 1: ...
+- Idea 2: ...
+
+[R] Reverse:
+- Idea 1: ...
+- Idea 2: ...
+
+TOP 3 IDEAS TO EXPLORE:
+1. ...
+2. ...
+3. ...
+```
+
+---
+
+## Framework 3: Design Thinking
+
+### 5 Stages:
+
+#### 1. Empathize
+- Who is the user?
+- What are their pain points?
+- What do they really need (not just want)?
+- What's their current journey?
+
+#### 2. Define
+- What's the core problem statement?
+- Format: "[User] needs [need] because [insight]"
+- What's the "How Might We" question?
+
+#### 3. Ideate
+- Generate 10+ ideas without judgment
+- Build on others' ideas
+- Go for quantity first
+- Include wild ideas
+
+#### 4. Prototype
+- What's the minimum viable test?
+- How can we simulate the solution?
+- What's the cheapest way to validate?
+
+#### 5. Test
+- How will we get feedback?
+- What metrics indicate success?
+- What questions do we need answered?
+
+### Template:
+```
+DESIGN THINKING SESSION
+
+EMPATHIZE:
+- User: [Who]
+- Pain Points: [List]
+- Current Journey: [Steps]
+- Unmet Needs: [List]
+
+DEFINE:
+- Problem Statement: [User] needs [need] because [insight]
+- How Might We: HMW [question]?
+
+IDEATE (10+ ideas):
+1. ...
+2. ...
+3. ...
+[Continue to 10+]
+
+PROTOTYPE:
+- MVP Concept: ...
+- Build Time: ...
+- Resources Needed: ...
+
+TEST:
+- Validation Method: ...
+- Success Metrics: ...
+- Key Questions: ...
+```
+
+---
+
+## Framework 4: Working Backwards (Amazon Style)
+
+Start from the end customer experience and work backwards.
+
+### Process:
+1. **Write the Press Release** - Announce the finished product
+2. **Write the FAQ** - Answer customer and internal questions
+3. **Define the Customer Experience** - Detail the user journey
+4. **Work Back to Requirements** - What do we need to build?
+
+### Press Release Template:
+```
+PRESS RELEASE
+
+Headline: [Product Name] Helps [Customer] [Benefit]
+
+Subheadline: [One sentence expanding on the headline]
+
+Problem: [2-3 sentences on the customer problem]
+
+Solution: [2-3 sentences on how product solves it]
+
+Quote from Leader: "[Why this matters]"
+
+How It Works: [Simple explanation]
+
+Customer Quote: "[Testimonial from imaginary satisfied customer]"
+
+Call to Action: [How to get started]
+```
+
+### FAQ Template:
+```
+CUSTOMER FAQ:
+Q: What is this?
+A: ...
+
+Q: How is this different from [competitor]?
+A: ...
+
+Q: How much does it cost?
+A: ...
+
+Q: How do I get started?
+A: ...
+
+INTERNAL FAQ:
+Q: Why are we building this?
+A: ...
+
+Q: What's the technical approach?
+A: ...
+
+Q: What are the risks?
+A: ...
+
+Q: What's the timeline?
+A: ...
+```
+
+---
+
+## Framework 5: 5 Whys
+
+Root cause analysis through iterative questioning.
+
+### Process:
+1. State the problem
+2. Ask "Why?" - Answer
+3. Ask "Why?" to the answer - Answer
+4. Repeat 5 times (or until root cause found)
+5. Identify actionable solution
+
+### Template:
+```
+5 WHYS ANALYSIS
+
+PROBLEM: [Initial problem statement]
+
+Why #1: Why is this happening?
+-> Because: [Answer 1]
+
+Why #2: Why [Answer 1]?
+-> Because: [Answer 2]
+
+Why #3: Why [Answer 2]?
+-> Because: [Answer 3]
+
+Why #4: Why [Answer 3]?
+-> Because: [Answer 4]
+
+Why #5: Why [Answer 4]?
+-> Because: [Answer 5 - Root Cause]
+
+ROOT CAUSE: [Summary]
+
+SOLUTION: [Action to address root cause]
+```
+
+---
+
+## Framework 6: Rapid Fire
+
+Generate maximum ideas in minimum time.
+
+### Rules:
+- No judgment or criticism
+- Quantity over quality
+- Build on previous ideas
+- Wild ideas welcome
+- Stay focused on the topic
+
+### Process:
+1. Set timer for 5 minutes
+2. Generate as many ideas as possible
+3. Number each idea
+4. After time, categorize and prioritize
+
+### Template:
+```
+RAPID FIRE SESSION
+
+CHALLENGE: [User's challenge]
+
+IDEAS (aim for 15+):
+1.
+2.
+3.
+4.
+5.
+6.
+7.
+8.
+9.
+10.
+11.
+12.
+13.
+14.
+15.
+
+CATEGORIES:
+- Quick Wins: [Ideas that are easy to implement]
+- Big Bets: [High impact but more effort]
+- Experiments: [Worth testing]
+- Parking Lot: [Interesting but not now]
+
+TOP 3 TO PURSUE:
+1. [Idea] - Because: [Reason]
+2. [Idea] - Because: [Reason]
+3. [Idea] - Because: [Reason]
+```
+
+---
+
+## Step 3: Execute Framework
+
+Walk the user through the selected framework step by step.
+
+- Ask clarifying questions as needed
+- Provide examples when helpful
+- Challenge assumptions constructively
+- Synthesize ideas at the end
+
+## Step 4: Summarize and Next Steps
+
+After brainstorming, provide:
+
+```
+BRAINSTORM SUMMARY
+==================
+
+Challenge: [Original challenge]
+Framework Used: [Framework name]
+
+KEY INSIGHTS:
+1. ...
+2. ...
+3. ...
+
+TOP IDEAS:
+1. [Idea] - [Why promising]
+2. [Idea] - [Why promising]
+3. [Idea] - [Why promising]
+
+RECOMMENDED NEXT STEPS:
+1. [ ] [Specific action]
+2. [ ] [Specific action]
+3. [ ] [Specific action]
+
+QUESTIONS TO EXPLORE FURTHER:
+- ...
+- ...
+```
+
+## Guidelines
+
+- Be curious and ask probing questions
+- Encourage wild ideas before filtering
+- Help user see blind spots
+- Connect ideas to practical implementation
+- End with actionable next steps

package/assets/skills/feature-workflow/SKILL.md

@@ -0,0 +1,298 @@
+---
+name: feature-workflow
+description: Complete feature development workflow from start to finish. Use when implementing new features, building functionality, or when user says "implement feature", "add feature", "build feature", "create feature".
+---
+
+# Feature Development Workflow
+
+End-to-end workflow for developing features with feedback loops and quality gates.
+
+## Recommended Agents
+
+| Phase | Agent | Purpose |
+|-------|-------|---------|
+| DESIGN | `@clean-architect` | Design Clean Architecture + MVVM |
+| IMPLEMENT | `@react-frontend-dev`, `@go-backend-dev`, `@laravel-backend-dev`, `@flutter-mobile-dev`, `@remix-fullstack-dev` | Stack-specific implementation |
+| IMPLEMENT | `@db-designer` | Database schema design |
+| IMPLEMENT | `@api-designer` | API design (REST/GraphQL) |
+| REVIEW | `@code-reviewer` | Code quality review |
+| REVIEW | `@security-audit` | Security vulnerabilities check |
+| REVIEW | `@perf-optimizer` | Performance optimization |
+| TEST | `@test-writer` | Unit/integration/e2e tests |
+| COMPLETE | `@docs-writer` | Documentation (if needed) |
+
+## Workflow Overview
+
+```
+┌──────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐
+│ 1. PLAN  │──▶│ 2. DESIGN│──▶│3. IMPLEMENT──▶│ 4. REVIEW│──▶│ 5. TEST  │──▶│6. COMPLETE
+└──────────┘   └──────────┘   └──────────┘   └──────────┘   └──────────┘   └──────────┘
+                                                   │              │
+                                                   └──────◀───────┘
+                                                    Feedback Loop
+```
+
+## Phase 1: PLAN
+
+**Goal**: Understand requirements and break down into tasks
+
+### Actions
+1. Clarify requirements with user
+2. Identify affected files/modules
+3. List acceptance criteria
+4. Create task breakdown using TodoWrite
+
+### Output
+```markdown
+## Feature: [Name]
+### Requirements
+- [ ] Requirement 1
+- [ ] Requirement 2
+
+### Affected Areas
+- File/Module 1
+- File/Module 2
+
+### Tasks
+1. Task 1
+2. Task 2
+```
+
+### Gate
+- [ ] Requirements clear
+- [ ] Scope defined
+- [ ] Tasks broken down
+
+---
+
+## Phase 2: DESIGN
+
+**Goal**: Design architecture following Clean Architecture + MVVM
+
+### Actions
+1. Apply Clean Architecture principles:
+   - Define Domain layer (entities, use cases, repository interfaces)
+   - Define Data layer (repository implementations, data sources)
+   - Define Presentation layer (ViewModels, Views)
+
+2. Design data flow:
+   ```
+   View ──▶ ViewModel ──▶ UseCase ──▶ Repository ──▶ DataSource
+   ```
+
+3. Identify dependencies and DI setup
+
+### Design Template
+```markdown
+## Architecture Design
+
+### Domain Layer
+- Entities: [list]
+- Use Cases: [list]
+- Repository Interfaces: [list]
+
+### Data Layer
+- Repository Implementations: [list]
+- Data Sources: [list]
+- Models/DTOs: [list]
+
+### Presentation Layer
+- ViewModels: [list]
+- Views/Screens: [list]
+- States: [list]
+
+### Dependency Graph
+[ASCII diagram]
+```
+
+### Gate
+- [ ] Layers defined
+- [ ] Dependencies flow inward only
+- [ ] No domain layer external dependencies
+
+---
+
+## Phase 3: IMPLEMENT
+
+**Goal**: Code the feature following the design
+
+### Actions
+1. Start from Domain layer (inside-out):
+   - Create entities
+   - Create use case interfaces
+   - Create repository interfaces
+
+2. Implement Data layer:
+   - Create DTOs/models
+   - Implement repositories
+   - Implement data sources
+
+3. Implement Presentation layer:
+   - Create ViewModels
+   - Create Views
+   - Wire up DI
+
+### Implementation Order
+```
+1. domain/entities/
+2. domain/usecases/
+3. domain/repositories/ (interfaces)
+4. data/models/
+5. data/datasources/
+6. data/repositories/ (implementations)
+7. presentation/viewmodels/
+8. presentation/views/
+9. di/modules/
+```
+
+### Gate
+- [ ] All layers implemented
+- [ ] Code compiles without errors
+- [ ] Basic functionality works
+
+---
+
+## Phase 4: REVIEW
+
+**Goal**: Review code quality, security, and best practices
+
+### Actions
+1. Self-review checklist:
+   - [ ] Clean Architecture rules followed
+   - [ ] SOLID principles applied
+   - [ ] No code smells
+   - [ ] Error handling in place
+   - [ ] No hardcoded values
+
+2. Security check:
+   - [ ] Input validation
+   - [ ] No sensitive data exposure
+   - [ ] Proper authentication/authorization
+
+3. Performance check:
+   - [ ] No N+1 queries
+   - [ ] Efficient algorithms
+   - [ ] Proper caching
+
+### Review Output
+```markdown
+## Code Review Summary
+
+### Quality: [Good/Needs Work]
+- Issue 1: [description] -> Fix: [solution]
+
+### Security: [Pass/Fail]
+- Issue 1: [description] -> Fix: [solution]
+
+### Performance: [Pass/Fail]
+- Issue 1: [description] -> Fix: [solution]
+```
+
+### Gate
+- [ ] No critical issues
+- [ ] All security issues resolved
+- [ ] Performance acceptable
+
+### Feedback Loop
+If issues found:
+1. Note issues in review output
+2. Return to IMPLEMENT phase
+3. Fix issues
+4. Re-run REVIEW phase
+
+---
+
+## Phase 5: TEST
+
+**Goal**: Ensure feature works correctly with tests
+
+### Actions
+1. Unit Tests:
+   - Test entities (pure logic)
+   - Test use cases (mock repositories)
+   - Test ViewModels (mock use cases)
+
+2. Integration Tests:
+   - Test repository + data sources
+   - Test use case flows
+
+3. Run all tests:
+   ```bash
+   # Example commands
+   flutter test           # Flutter
+   go test ./...          # Go
+   pnpm test              # React/Remix
+   ```
+
+### Test Coverage Target
+- Domain layer: 90%+
+- Data layer: 80%+
+- Presentation layer: 70%+
+
+### Gate
+- [ ] All tests pass
+- [ ] Coverage targets met
+- [ ] Edge cases covered
+
+### Feedback Loop
+If tests fail:
+1. Analyze failure
+2. Return to IMPLEMENT phase
+3. Fix code
+4. Re-run tests
+
+---
+
+## Phase 6: COMPLETE
+
+**Goal**: Finalize and deliver the feature
+
+### Actions
+1. Final checks:
+   - [ ] All gates passed
+   - [ ] Code formatted
+   - [ ] No TODO comments left
+   - [ ] Documentation updated (if needed)
+
+2. Git operations:
+   ```bash
+   git add .
+   git commit -m "feat: [feature description]"
+   ```
+
+3. Create PR (if applicable):
+   ```bash
+   gh pr create --title "feat: [feature]" --body "[description]"
+   ```
+
+### Completion Checklist
+- [ ] Feature implemented
+- [ ] Tests passing
+- [ ] Code reviewed
+- [ ] Committed/PR created
+
+---
+
+## Quick Reference
+
+### Phase Commands
+| Phase | Key Actions |
+|-------|-------------|
+| PLAN | Clarify, breakdown, TodoWrite |
+| DESIGN | Clean Architecture, layer design |
+| IMPLEMENT | Code inside-out |
+| REVIEW | Quality, security, performance |
+| TEST | Unit, integration, run tests |
+| COMPLETE | Commit, PR |
+
+### When to Loop Back
+- **REVIEW fails** → Return to IMPLEMENT
+- **TEST fails** → Return to IMPLEMENT
+- **Requirements change** → Return to PLAN
+
+### Success Criteria
+Feature is complete when:
+1. All acceptance criteria met
+2. All tests passing
+3. Code review passed
+4. Committed/PR created