[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6CD0B06W23XFZZGZD0BR715":3,"skill-same:01M6CD0B06W23XFZZGZD0BR715":100},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":28,"linkOnly":29,"markdownContent":30,"markdownBody":31,"frontMatter":32,"refName":44,"commitSha":45,"skillDirectory":46,"forksCount":14,"repositoryHtmlUrl":47,"repositoryHomepageUrl":6,"ownerHtmlUrl":48,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":49,"install":50,"resources":63},"01M6CD0B06W23XFZZGZD0BR715","cva-analysis",null,"Systematic abstraction discovery using Commonality Variability Analysis. Build matrix of what varies vs what's constant, then let patterns emerge. Prevents wrong abstractions by deferring pattern selection until requirements are analyzed. Use when facing multiple similar requirements and need to discover natural abstractions.","loriensleafs\u002Fbrain","loriensleafs","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F315385?v=4","01M6CCYZETMCJPTHNS258YRCBC","Peter Kloss","01M6CCYZK25T8516A39S9PCJT7",0,"MIT","https:\u002F\u002Fgithub.com\u002Floriensleafs\u002Fbrain\u002Fblob\u002Fmain\u002Ftemplates\u002Fskills\u002Fcva-analysis\u002FSKILL.md",[],[19,20,21,22,23,24,25,26,27],"analysis","cva analysis","design","architecture","engineering","discovery","architect","critic","use","2026-11-10 10:12:30",false,"---\nname: cva-analysis\ndescription: Systematic abstraction discovery using Commonality Variability Analysis. Build matrix of what varies vs what's constant, then let patterns emerge. Prevents wrong abstractions by deferring pattern selection until requirements are analyzed. Use when facing multiple similar requirements and need to discover natural abstractions.\nlicense: MIT\nagents:\n  - analyst\n  - architect\n  - critic\n  - independent-thinker\nmodel: claude-opus-4-6[1m]\nmetadata:\n  version: 1.0.0\n  timelessness: 9\u002F10\n  domains:\n    - design\n    - architecture\n    - patterns\n    - abstraction-discovery\n  author: Multi-Paradigm Design (Coplien 1999), adapted for modern engineering\n---\n\n# CVA Analysis - Discover Natural Abstractions\n\nCommonality Variability Analysis (CVA) is a systematic technique for discovering abstractions from requirements. Instead of choosing patterns first, you build a matrix showing what's COMMON (constant across use cases) vs what VARIES (differs between cases). Patterns emerge naturally from the matrix structure.\n\n**Core Insight**: Rows (commonalities) map to Strategy pattern. Columns (variabilities) map to Abstract Factory pattern. The matrix reveals whether abstraction is needed at all.\n\n**From CLAUDE.md Design Philosophy**: \"Greatest vulnerability is wrong or missing abstraction.\" CVA prevents wrong abstractions by making pattern selection evidence-based, not intuition-based.\n\n## Triggers\n\nActivate CVA when you encounter:\n\n- `discover abstractions for [domain]`\n- `run CVA analysis on [requirements]`\n- `commonality variability analysis`\n- `prevent wrong abstraction`\n- `what patterns emerge from [use cases]`\n\n## Quick Reference\n\n| Phase                     | Purpose                                           | Input                     | Output                                 | Time     |\n| ------------------------- | ------------------------------------------------- | ------------------------- | -------------------------------------- | -------- |\n| 1. Identify Commonalities | Find what's constant across ALL use cases         | Use cases\u002Frequirements    | List of commonalities (matrix rows)    | 5-10 min |\n| 2. Identify Variabilities | Find what VARIES between use cases                | Commonalities + use cases | List of variabilities (matrix columns) | 5-10 min |\n| 3. Build Matrix           | Visualize commonality × variability relationships | Rows + columns            | CVA matrix (Markdown table)            | 5-15 min |\n| 4. Map to Patterns        | Translate matrix structure to design patterns     | Completed matrix          | Pattern recommendations + rationale    | 5-10 min |\n| 5. Validate & Handoff     | Validate choices, route to appropriate agents     | Pattern recommendations   | Validation report + ADR stub           | 5-10 min |\n\n**Total Time**: Quick (15 min), Standard (30 min), Deep (60 min)\n\n## When to Use\n\n**Use CVA when:**\n\n- Facing 2+ similar but varying requirements\n- About to select a design pattern (validate with CVA first)\n- Refactoring code with duplicated logic\n- Need evidence for abstraction decisions (ADR material)\n- Team debates whether to abstract (make implicit explicit)\n\n**Do NOT use CVA when:**\n\n- Only 1 use case exists (wait for 2nd per YAGNI)\n- Pattern is obvious and uncontested (don't over-analyze)\n- Time-critical decision (\u003C15 min available, use intuition)\n- Requirements are still highly uncertain (premature)\n\n## Process\n\n### Phase 1: Identify Commonalities\n\n**Purpose**: Establish what is ALWAYS true across ALL use cases. This becomes the stable foundation.\n\n**Steps**:\n\n1. **Start with first use case**: What does it need? List all capabilities.\n2. **Add second use case**: What do BOTH need? Extract shared capabilities.\n3. **For each additional use case**: What do ALL cases need?\n4. **Document as matrix ROWS**: Each row is a commonality present in every use case.\n\n**Example** (Payment Processing):\n\n```text\nUse Case 1: Credit card payment\nUse Case 2: PayPal payment\nUse Case 3: Bank transfer\n\nCommonalities (ALL cases need):\n- Validate payment amount\n- Authorize transaction\n- Record transaction\n- Handle transaction errors\n```\n\n**Verification**:\n\n- [ ] Each commonality appears in ALL use cases\n- [ ] At least 2 commonalities identified (if only 1, reconsider scope)\n- [ ] Commonalities are capabilities\u002Fbehaviors, not implementation details\n\n**Failure Handling**: If no commonalities exist, use cases may be unrelated. Analyze separately or reconsider grouping.\n\n---\n\n### Phase 2: Identify Variabilities\n\n**Purpose**: Discover what VARIES between use cases. This reveals extension points where Strategy or Abstract Factory patterns may apply.\n\n**Steps**:\n\n1. **For each commonality, ask**: \"How does this vary across cases?\"\n2. **List variations**: Document different implementations for each commonality.\n3. **Document as matrix COLUMNS**: Each column is a variation.\n4. **Optional**: Add \"Future Variations\" column for anticipated changes.\n\n**Example** (continuing Payment Processing):\n\n```text\nCommonality: Validate payment amount\n\nVariations:\n- Credit Card: Check card limit, validate CVV\n- PayPal: Check PayPal balance, validate account status\n- Bank Transfer: Check account balance, validate routing number\n\nCommonality: Authorize transaction\n\nVariations:\n- Credit Card: Contact card issuer API\n- PayPal: OAuth flow with PayPal\n- Bank Transfer: ACH authorization\n```\n\n**Verification**:\n\n- [ ] Each variability differs in at least 2 use cases\n- [ ] Variations are concrete implementations, not abstract\n- [ ] If ZERO variability (all cells identical), abstraction may not be needed\n\n**Failure Handling**: If all variability (no commonality), design may be too broad. Narrow scope or reconsider.\n\n---\n\n### Phase 3: Build CVA Matrix\n\n**Purpose**: Create visual artifact showing commonality × variability relationships. Makes implicit design explicit for team discussion.\n\n**Steps**:\n\n1. **Create Markdown table**: Commonalities as rows, variabilities as columns\n2. **Fill each cell**: Concrete implementation for that commonality\u002Fvariability pair\n3. **Highlight patterns**: Where cells are identical (sharing opportunity), where they differ (extension point)\n4. **Optional**: Export to Mermaid diagram using `bun run ${CLAUDE_SKILL_DIR}\u002Fscripts\u002Fexport-cva-matrix.ts`\n\n**Example Matrix**:\n\n| Commonality     | Credit Card              | PayPal                        | Bank Transfer                  |\n| --------------- | ------------------------ | ----------------------------- | ------------------------------ |\n| Validate amount | Check card limit, CVV    | Check PayPal balance, account | Check account balance, routing |\n| Authorize       | Card issuer API          | PayPal OAuth                  | ACH authorization              |\n| Record          | Log to CardTransactionDB | Log to PayPalTransactionDB    | Log to BankTransactionDB       |\n| Handle errors   | Card decline codes       | PayPal error codes            | ACH rejection codes            |\n\n**Interpretation**:\n\n- **Row perspective (Strategy pattern)**: \"Authorize\" varies across payment methods → Strategy pattern for authorization\n- **Column perspective (Abstract Factory pattern)**: Each payment method has consistent set of operations → Abstract Factory for payment providers\n- **Cell perspective**: \"Log to \\*TransactionDB\" shows common pattern with variation → Template Method or Strategy\n\n**Verification**:\n\n- [ ] Matrix is at least 2×2 (minimum for pattern discovery)\n- [ ] All cells are filled (no empty cells)\n- [ ] Patterns becoming visible (some cells identical, some divergent)\n\n**Failure Handling**: If matrix shows no useful patterns, abstraction may not be beneficial. Document rationale for concrete implementation.\n\n---\n\n### Phase 4: Map to Patterns\n\n**Purpose**: Translate matrix structure to design patterns. Patterns EMERGE from analysis, not imposed.\n\n**Steps**:\n\n1. **Read ROWS (commonalities)**:\n   - If each row has different implementations across columns → **Strategy pattern** (vary algorithm for same operation)\n   - Example: \"Authorize\" row has 3 implementations → `IAuthorizationStrategy`\n\n1. **Read COLUMNS (variabilities)**:\n   - If each column represents a coherent family of implementations → **Abstract Factory pattern** (vary implementations across product families)\n   - Example: \"Credit Card\" column has consistent set of card-specific operations → `CreditCardPaymentFactory`\n\n1. **Check for multidimensional variability**:\n   - If BOTH rows AND columns vary independently → Combination patterns or reconsider scope\n   - Start with dominant axis (more variance), note multidimensional case in Extension Points\n\n1. **Document recommendations**:\n   - Which pattern(s) fit?\n   - WHY do they fit? (cite matrix structure)\n   - What are alternatives? (if any)\n\n**Example Output**:\n\n````markdown\n## Pattern Recommendations\n\n### Primary: Abstract Factory Pattern\n\n**Rationale**: Each payment method (Credit Card, PayPal, Bank Transfer) requires a coherent family of related operations. Matrix columns show consistent product families.\n\n**Implementation**:\n\n```typescript\ninterface PaymentFactory {\n  createValidator(): AmountValidator;\n  createAuthorizer(): TransactionAuthorizer;\n  createRecorder(): TransactionRecorder;\n  createErrorHandler(): ErrorHandler;\n}\n\nclass CreditCardPaymentFactory implements PaymentFactory {\n  \u002F\u002F Concrete implementations from \"Credit Card\" column\n}\n```\n````\n\n**Alternative**: Strategy pattern per row (4 separate strategies). Rejected because operations are not independent - they share payment method context. Factory keeps cohesion.\n\n````\n\n**Create ADR stub** for architect agent:\n\n```markdown\n# ADR-XXX: Payment Processing Abstraction\n\n## Context\nCVA matrix revealed 3 payment methods with 4 common operations, each varying by method.\n\n## Decision\nUse Abstract Factory pattern with `IPaymentFactory` per method.\n\n## Rationale\n- Matrix columns show coherent product families\n- Operations share payment method context (not independent)\n- New payment methods extend without modifying existing\n\n## Alternatives Considered\n- Strategy per operation: Rejected (operations not independent, loses cohesion)\n- No abstraction: Rejected (3 methods with clear variations justify abstraction per YAGNI threshold)\n````\n\n**Verification**:\n\n- [ ] Recommended patterns align with matrix structure\n- [ ] Rationale explains WHY patterns fit (cites matrix evidence)\n- [ ] Edge cases addressed (single use case → don't abstract, all variability → reconsider)\n- [ ] ADR stub created with decision rationale\n\n**Failure Handling**: If no patterns fit cleanly, document rationale for concrete implementation. Abstraction may not be warranted yet.\n\n---\n\n### Phase 5: Validation and Handoff\n\n**Purpose**: Validate abstraction choices and route to appropriate agents for review.\n\n**Steps**:\n\n1. **Run validation script**:\n\n   ```bash\n   bun run ${CLAUDE_SKILL_DIR}\u002Fscripts\u002Fvalidate-cva-matrix.ts cva-matrix.md\n   ```\n\n   - Checks: ≥2 rows, ≥2 columns, all cells filled, patterns suggested\n   - Exit code 0 = pass, 10 = validation failure, 1 = error\n\n1. **Route to decision-critic** (if abstraction recommended):\n\n   ```bash\n   # Use decision-critic skill to validate abstraction choice\n   \u002Fdecision-critic \"Validate Abstract Factory pattern for payment processing per CVA analysis\"\n   ```\n\n1. **Route to architect agent** (for ADR creation):\n\n   ```bash\n   # Hand off ADR stub to architect agent\n   Agent(subagent_type=\"architect\", prompt=\"Create ADR from CVA analysis stub\")\n   ```\n\n1. **Document reassessment triggers**:\n\n   ```markdown\n   ## Reassessment Triggers\n\n   Re-run CVA when:\n\n   - 3+ new payment methods added\n   - Major architectural shift (e.g., microservices split)\n   - Performance issues with current abstraction\n   - Team feedback: abstraction is too complex or not pulling weight\n   ```\n\n**Outputs**:\n\n- Validation report (pass\u002Ffail with specific issues)\n- Handoff to decision-critic and\u002For architect agent\n- Reassessment triggers documented\n\n**Verification**:\n\n- [ ] Validation script exits with code 0\n- [ ] Decision-critic review completed (if abstraction recommended)\n- [ ] Reassessment triggers are specific, not vague\n\n**Failure Handling**: If validation fails, return to earlier phase based on issue:\n\n- Missing commonalities → Phase 1\n- Incomplete matrix → Phase 3\n- Pattern mismatch → Phase 4\n\n---\n\n## Anti-Patterns\n\n| Anti-Pattern                      | Why Bad                                                                            | Example                                                                          | Instead                                                                                                             |\n| --------------------------------- | ---------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |\n| **Pattern-First Design**          | Violates CVA principle: patterns emerge, not imposed. Leads to wrong abstractions. | Decide \"we need Strategy pattern\" BEFORE running CVA                             | Run CVA first. Let matrix reveal pattern. If no pattern emerges, abstraction may not be needed.                     |\n| **Forcing Abstractions**          | Creates complexity without benefit. Worse than no abstraction per CLAUDE.md.       | CVA shows no variability, but create Strategy anyway \"for future\"                | When CVA shows no variability, explicitly document decision NOT to abstract. Revisit when variability emerges.      |\n| **Skipping Matrix Visualization** | Loses pedagogical and collaborative benefits. Matrix makes assumptions explicit.   | Identify commonalities\u002Fvariabilities mentally, skip matrix, jump to pattern      | Always create visual matrix (Markdown table minimum). Use for team review, ADR rationale.                           |\n| **Analysis Paralysis**            | CVA is a tool, not an end. Over-analysis wastes time.                              | Spend 3 hours on CVA for 2 simple use cases                                      | Use tiered approach: Quick (15 min) for simple, Standard (30 min) moderate, Deep (60 min) architectural. Set timer. |\n| **Ignoring Temporal Dimension**   | Today's constant may be tomorrow's variable.                                       | CVA assumes \"currency\" constant (USD only). 6 months later, need multi-currency. | Include \"Future Variations\" column for anticipated changes. Balance YAGNI with known roadmap.                       |\n| **Using CVA for Single Use Case** | CVA requires 2+ cases to identify commonality\u002Fvariability.                         | Run CVA on payment before any other transaction exists                           | Wait for 2nd use case (YAGNI), OR document anticipated cases with stakeholder validation.                           |\n\n## Integration with Other Skills\n\n### architect Agent\n\nCVA produces ADR stub with pattern rationale. Architect agent creates formal ADR.\n\n**Handoff Protocol**:\n\n```python\nAgent(subagent_type=\"architect\", prompt=\"Create ADR from CVA analysis at cva-payment-processing.md\")\n```\n\n### decision-critic Skill\n\nValidates abstraction choices discovered via CVA. Applies inversion thinking to pattern recommendation.\n\n**Usage**:\n\n```bash\n\u002Fdecision-critic \"Validate Abstract Factory pattern for payment processing per CVA matrix\"\n```\n\n### independent-thinker Agent\n\nChallenges whether abstraction is needed at all. Use when CVA is borderline (minimal variability).\n\n**Usage**:\n\n```python\nAgent(subagent_type=\"independent-thinker\", prompt=\"Challenge whether payment abstraction is justified given only 2 current methods\")\n```\n\n## Verification Checklist\n\nAfter completing CVA:\n\n- [ ] Matrix has ≥2 rows (commonalities) and ≥2 columns (variabilities)\n- [ ] All matrix cells are filled with concrete implementations\n- [ ] Recommended patterns align with matrix structure (rows → Strategy, columns → Factory)\n- [ ] Rationale explains WHY patterns fit (cites matrix as evidence)\n- [ ] Edge cases handled (single use case, all variability, no commonality)\n- [ ] Validation script passes: `bun run ${CLAUDE_SKILL_DIR}\u002Fscripts\u002Fvalidate-cva-matrix.ts [file]`\n- [ ] ADR stub created with decision rationale\n- [ ] Reassessment triggers documented (when to re-run CVA)\n\n## Reassessment Triggers\n\nRe-run CVA when:\n\n1. **3+ new use cases** added (may reveal new patterns or invalidate current abstraction)\n2. **Major architectural shift** (e.g., monolith → microservices)\n3. **Performance issues** with current abstraction (overhead not justified)\n4. **Team feedback**: Abstraction is too complex, not pulling weight, or forcing designs\n5. **Quarterly review** (align with retrospective cycle)\n\n## Tiered Depth Levels\n\nChoose depth based on decision impact:\n\n| Tier     | Time   | Use Cases | When to Use                                          |\n| -------- | ------ | --------- | ---------------------------------------------------- |\n| Quick    | 15 min | 2-3       | Simple decisions, clear patterns, low risk           |\n| Standard | 30 min | 3-5       | Moderate complexity, some uncertainty, medium risk   |\n| Deep     | 60 min | 6+        | Architectural decisions, high uncertainty, high risk |\n\n**Time-boxing**: Set timer, commit to best-available analysis when time expires. CVA is a tool, not a perfectionist exercise.\n\n## TypeScript Examples\n\nSee `references\u002Fmatrix-building-examples.md` for complete TypeScript examples:\n\n- Middleware Pipeline (commonality: process request, variability: authentication, logging, compression)\n- Dependency Injection Providers (commonality: resolve dependencies, variability: lifetime scope, registration patterns)\n- Data Access Patterns (commonality: CRUD operations, variability: SQL, NoSQL, in-memory)\n\n## References\n\n- [Pattern Mapping Guide](references\u002Fpattern-mapping-guide.md) - How to read matrix and map to Strategy, Abstract Factory, combinations\n- [Matrix Building Examples](references\u002Fmatrix-building-examples.md) - TypeScript examples with complete CVA workflows\n\n## Scripts\n\n### validate-cva-matrix.ts\n\nCheck CVA matrix completeness and suggest patterns.\n\n**Usage**:\n\n```bash\nbun run ${CLAUDE_SKILL_DIR}\u002Fscripts\u002Fvalidate-cva-matrix.ts cva-matrix.md\n```\n\n**Exit Codes**:\n\n- 0: Valid matrix, patterns suggested\n- 10: Validation failure (missing rows\u002Fcolumns, empty cells)\n- 1: Error (file not found, invalid format)\n\n### generate-cva-template.ts\n\nCreate empty matrix template from user input.\n\n**Usage**:\n\n```bash\nbun run ${CLAUDE_SKILL_DIR}\u002Fscripts\u002Fgenerate-cva-template.ts \\\n  --commonalities \"Validate,Authorize,Record,Handle errors\" \\\n  --variabilities \"CreditCard,PayPal,BankTransfer\" \\\n  --output cva-matrix.md\n```\n\n### export-cva-matrix.ts\n\nConvert Markdown table to Mermaid diagram for presentations.\n\n**Usage**:\n\n```bash\nbun run ${CLAUDE_SKILL_DIR}\u002Fscripts\u002Fexport-cva-matrix.ts \\\n  --input cva-matrix.md \\\n  --format mermaid \\\n  --output cva-diagram.mmd\n```\n\n## Extension Points\n\n1. **Pattern Mapping**: Add new pattern types beyond Strategy\u002FAbstract Factory\n   - Edit `references\u002Fpattern-mapping-guide.md`\n   - Add Builder, Bridge, Visitor patterns with matrix signatures\n\n1. **Matrix Formats**: Add export formats beyond Markdown\n   - Use `bun run ${CLAUDE_SKILL_DIR}\u002Fscripts\u002Fexport-cva-matrix.ts --format \u003Cjson|plantuml|csv>`\n\n1. **Multidimensional Analysis**: Handle complex cases with 3+ axes\n\n1. **AI Integration**: Automated pattern suggestion\n   - Route to decision-critic or independent-thinker for automated review\n","# CVA Analysis - Discover Natural Abstractions\n\nCommonality Variability Analysis (CVA) is a systematic technique for discovering abstractions from requirements. Instead of choosing patterns first, you build a matrix showing what's COMMON (constant across use cases) vs what VARIES (differs between cases). Patterns emerge naturally from the matrix structure.\n\n**Core Insight**: Rows (commonalities) map to Strategy pattern. Columns (variabilities) map to Abstract Factory pattern. The matrix reveals whether abstraction is needed at all.\n\n**From CLAUDE.md Design Philosophy**: \"Greatest vulnerability is wrong or missing abstraction.\" CVA prevents wrong abstractions by making pattern selection evidence-based, not intuition-based.\n\n## Triggers\n\nActivate CVA when you encounter:\n\n- `discover abstractions for [domain]`\n- `run CVA analysis on [requirements]`\n- `commonality variability analysis`\n- `prevent wrong abstraction`\n- `what patterns emerge from [use cases]`\n\n## Quick Reference\n\n| Phase                     | Purpose                                           | Input                     | Output                                 | Time     |\n| ------------------------- | ------------------------------------------------- | ------------------------- | -------------------------------------- | -------- |\n| 1. Identify Commonalities | Find what's constant across ALL use cases         | Use cases\u002Frequirements    | List of commonalities (matrix rows)    | 5-10 min |\n| 2. Identify Variabilities | Find what VARIES between use cases                | Commonalities + use cases | List of variabilities (matrix columns) | 5-10 min |\n| 3. Build Matrix           | Visualize commonality × variability relationships | Rows + columns            | CVA matrix (Markdown table)            | 5-15 min |\n| 4. Map to Patterns        | Translate matrix structure to design patterns     | Completed matrix          | Pattern recommendations + rationale    | 5-10 min |\n| 5. Validate & Handoff     | Validate choices, route to appropriate agents     | Pattern recommendations   | Validation report + ADR stub           | 5-10 min |\n\n**Total Time**: Quick (15 min), Standard (30 min), Deep (60 min)\n\n## When to Use\n\n**Use CVA when:**\n\n- Facing 2+ similar but varying requirements\n- About to select a design pattern (validate with CVA first)\n- Refactoring code with duplicated logic\n- Need evidence for abstraction decisions (ADR material)\n- Team debates whether to abstract (make implicit explicit)\n\n**Do NOT use CVA when:**\n\n- Only 1 use case exists (wait for 2nd per YAGNI)\n- Pattern is obvious and uncontested (don't over-analyze)\n- Time-critical decision (\u003C15 min available, use intuition)\n- Requirements are still highly uncertain (premature)\n\n## Process\n\n### Phase 1: Identify Commonalities\n\n**Purpose**: Establish what is ALWAYS true across ALL use cases. This becomes the stable foundation.\n\n**Steps**:\n\n1. **Start with first use case**: What does it need? List all capabilities.\n2. **Add second use case**: What do BOTH need? Extract shared capabilities.\n3. **For each additional use case**: What do ALL cases need?\n4. **Document as matrix ROWS**: Each row is a commonality present in every use case.\n\n**Example** (Payment Processing):\n\n```text\nUse Case 1: Credit card payment\nUse Case 2: PayPal payment\nUse Case 3: Bank transfer\n\nCommonalities (ALL cases need):\n- Validate payment amount\n- Authorize transaction\n- Record transaction\n- Handle transaction errors\n```\n\n**Verification**:\n\n- [ ] Each commonality appears in ALL use cases\n- [ ] At least 2 commonalities identified (if only 1, reconsider scope)\n- [ ] Commonalities are capabilities\u002Fbehaviors, not implementation details\n\n**Failure Handling**: If no commonalities exist, use cases may be unrelated. Analyze separately or reconsider grouping.\n\n---\n\n### Phase 2: Identify Variabilities\n\n**Purpose**: Discover what VARIES between use cases. This reveals extension points where Strategy or Abstract Factory patterns may apply.\n\n**Steps**:\n\n1. **For each commonality, ask**: \"How does this vary across cases?\"\n2. **List variations**: Document different implementations for each commonality.\n3. **Document as matrix COLUMNS**: Each column is a variation.\n4. **Optional**: Add \"Future Variations\" column for anticipated changes.\n\n**Example** (continuing Payment Processing):\n\n```text\nCommonality: Validate payment amount\n\nVariations:\n- Credit Card: Check card limit, validate CVV\n- PayPal: Check PayPal balance, validate account status\n- Bank Transfer: Check account balance, validate routing number\n\nCommonality: Authorize transaction\n\nVariations:\n- Credit Card: Contact card issuer API\n- PayPal: OAuth flow with PayPal\n- Bank Transfer: ACH authorization\n```\n\n**Verification**:\n\n- [ ] Each variability differs in at least 2 use cases\n- [ ] Variations are concrete implementations, not abstract\n- [ ] If ZERO variability (all cells identical), abstraction may not be needed\n\n**Failure Handling**: If all variability (no commonality), design may be too broad. Narrow scope or reconsider.\n\n---\n\n### Phase 3: Build CVA Matrix\n\n**Purpose**: Create visual artifact showing commonality × variability relationships. Makes implicit design explicit for team discussion.\n\n**Steps**:\n\n1. **Create Markdown table**: Commonalities as rows, variabilities as columns\n2. **Fill each cell**: Concrete implementation for that commonality\u002Fvariability pair\n3. **Highlight patterns**: Where cells are identical (sharing opportunity), where they differ (extension point)\n4. **Optional**: Export to Mermaid diagram using `bun run ${CLAUDE_SKILL_DIR}\u002Fscripts\u002Fexport-cva-matrix.ts`\n\n**Example Matrix**:\n\n| Commonality     | Credit Card              | PayPal                        | Bank Transfer                  |\n| --------------- | ------------------------ | ----------------------------- | ------------------------------ |\n| Validate amount | Check card limit, CVV    | Check PayPal balance, account | Check account balance, routing |\n| Authorize       | Card issuer API          | PayPal OAuth                  | ACH authorization              |\n| Record          | Log to CardTransactionDB | Log to PayPalTransactionDB    | Log to BankTransactionDB       |\n| Handle errors   | Card decline codes       | PayPal error codes            | ACH rejection codes            |\n\n**Interpretation**:\n\n- **Row perspective (Strategy pattern)**: \"Authorize\" varies across payment methods → Strategy pattern for authorization\n- **Column perspective (Abstract Factory pattern)**: Each payment method has consistent set of operations → Abstract Factory for payment providers\n- **Cell perspective**: \"Log to \\*TransactionDB\" shows common pattern with variation → Template Method or Strategy\n\n**Verification**:\n\n- [ ] Matrix is at least 2×2 (minimum for pattern discovery)\n- [ ] All cells are filled (no empty cells)\n- [ ] Patterns becoming visible (some cells identical, some divergent)\n\n**Failure Handling**: If matrix shows no useful patterns, abstraction may not be beneficial. Document rationale for concrete implementation.\n\n---\n\n### Phase 4: Map to Patterns\n\n**Purpose**: Translate matrix structure to design patterns. Patterns EMERGE from analysis, not imposed.\n\n**Steps**:\n\n1. **Read ROWS (commonalities)**:\n   - If each row has different implementations across columns → **Strategy pattern** (vary algorithm for same operation)\n   - Example: \"Authorize\" row has 3 implementations → `IAuthorizationStrategy`\n\n1. **Read COLUMNS (variabilities)**:\n   - If each column represents a coherent family of implementations → **Abstract Factory pattern** (vary implementations across product families)\n   - Example: \"Credit Card\" column has consistent set of card-specific operations → `CreditCardPaymentFactory`\n\n1. **Check for multidimensional variability**:\n   - If BOTH rows AND columns vary independently → Combination patterns or reconsider scope\n   - Start with dominant axis (more variance), note multidimensional case in Extension Points\n\n1. **Document recommendations**:\n   - Which pattern(s) fit?\n   - WHY do they fit? (cite matrix structure)\n   - What are alternatives? (if any)\n\n**Example Output**:\n\n````markdown\n## Pattern Recommendations\n\n### Primary: Abstract Factory Pattern\n\n**Rationale**: Each payment method (Credit Card, PayPal, Bank Transfer) requires a coherent family of related operations. Matrix columns show consistent product families.\n\n**Implementation**:\n\n```typescript\ninterface PaymentFactory {\n  createValidator(): AmountValidator;\n  createAuthorizer(): TransactionAuthorizer;\n  createRecorder(): TransactionRecorder;\n  createErrorHandler(): ErrorHandler;\n}\n\nclass CreditCardPaymentFactory implements PaymentFactory {\n  \u002F\u002F Concrete implementations from \"Credit Card\" column\n}\n```\n````\n\n**Alternative**: Strategy pattern per row (4 separate strategies). Rejected because operations are not independent - they share payment method context. Factory keeps cohesion.\n\n````\n\n**Create ADR stub** for architect agent:\n\n```markdown\n# ADR-XXX: Payment Processing Abstraction\n\n## Context\nCVA matrix revealed 3 payment methods with 4 common operations, each varying by method.\n\n## Decision\nUse Abstract Factory pattern with `IPaymentFactory` per method.\n\n## Rationale\n- Matrix columns show coherent product families\n- Operations share payment method context (not independent)\n- New payment methods extend without modifying existing\n\n## Alternatives Considered\n- Strategy per operation: Rejected (operations not independent, loses cohesion)\n- No abstraction: Rejected (3 methods with clear variations justify abstraction per YAGNI threshold)\n````\n\n**Verification**:\n\n- [ ] Recommended patterns align with matrix structure\n- [ ] Rationale explains WHY patterns fit (cites matrix evidence)\n- [ ] Edge cases addressed (single use case → don't abstract, all variability → reconsider)\n- [ ] ADR stub created with decision rationale\n\n**Failure Handling**: If no patterns fit cleanly, document rationale for concrete implementation. Abstraction may not be warranted yet.\n\n---\n\n### Phase 5: Validation and Handoff\n\n**Purpose**: Validate abstraction choices and route to appropriate agents for review.\n\n**Steps**:\n\n1. **Run validation script**:\n\n   ```bash\n   bun run ${CLAUDE_SKILL_DIR}\u002Fscripts\u002Fvalidate-cva-matrix.ts cva-matrix.md\n   ```\n\n   - Checks: ≥2 rows, ≥2 columns, all cells filled, patterns suggested\n   - Exit code 0 = pass, 10 = validation failure, 1 = error\n\n1. **Route to decision-critic** (if abstraction recommended):\n\n   ```bash\n   # Use decision-critic skill to validate abstraction choice\n   \u002Fdecision-critic \"Validate Abstract Factory pattern for payment processing per CVA analysis\"\n   ```\n\n1. **Route to architect agent** (for ADR creation):\n\n   ```bash\n   # Hand off ADR stub to architect agent\n   Agent(subagent_type=\"architect\", prompt=\"Create ADR from CVA analysis stub\")\n   ```\n\n1. **Document reassessment triggers**:\n\n   ```markdown\n   ## Reassessment Triggers\n\n   Re-run CVA when:\n\n   - 3+ new payment methods added\n   - Major architectural shift (e.g., microservices split)\n   - Performance issues with current abstraction\n   - Team feedback: abstraction is too complex or not pulling weight\n   ```\n\n**Outputs**:\n\n- Validation report (pass\u002Ffail with specific issues)\n- Handoff to decision-critic and\u002For architect agent\n- Reassessment triggers documented\n\n**Verification**:\n\n- [ ] Validation script exits with code 0\n- [ ] Decision-critic review completed (if abstraction recommended)\n- [ ] Reassessment triggers are specific, not vague\n\n**Failure Handling**: If validation fails, return to earlier phase based on issue:\n\n- Missing commonalities → Phase 1\n- Incomplete matrix → Phase 3\n- Pattern mismatch → Phase 4\n\n---\n\n## Anti-Patterns\n\n| Anti-Pattern                      | Why Bad                                                                            | Example                                                                          | Instead                                                                                                             |\n| --------------------------------- | ---------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |\n| **Pattern-First Design**          | Violates CVA principle: patterns emerge, not imposed. Leads to wrong abstractions. | Decide \"we need Strategy pattern\" BEFORE running CVA                             | Run CVA first. Let matrix reveal pattern. If no pattern emerges, abstraction may not be needed.                     |\n| **Forcing Abstractions**          | Creates complexity without benefit. Worse than no abstraction per CLAUDE.md.       | CVA shows no variability, but create Strategy anyway \"for future\"                | When CVA shows no variability, explicitly document decision NOT to abstract. Revisit when variability emerges.      |\n| **Skipping Matrix Visualization** | Loses pedagogical and collaborative benefits. Matrix makes assumptions explicit.   | Identify commonalities\u002Fvariabilities mentally, skip matrix, jump to pattern      | Always create visual matrix (Markdown table minimum). Use for team review, ADR rationale.                           |\n| **Analysis Paralysis**            | CVA is a tool, not an end. Over-analysis wastes time.                              | Spend 3 hours on CVA for 2 simple use cases                                      | Use tiered approach: Quick (15 min) for simple, Standard (30 min) moderate, Deep (60 min) architectural. Set timer. |\n| **Ignoring Temporal Dimension**   | Today's constant may be tomorrow's variable.                                       | CVA assumes \"currency\" constant (USD only). 6 months later, need multi-currency. | Include \"Future Variations\" column for anticipated changes. Balance YAGNI with known roadmap.                       |\n| **Using CVA for Single Use Case** | CVA requires 2+ cases to identify commonality\u002Fvariability.                         | Run CVA on payment before any other transaction exists                           | Wait for 2nd use case (YAGNI), OR document anticipated cases with stakeholder validation.                           |\n\n## Integration with Other Skills\n\n### architect Agent\n\nCVA produces ADR stub with pattern rationale. Architect agent creates formal ADR.\n\n**Handoff Protocol**:\n\n```python\nAgent(subagent_type=\"architect\", prompt=\"Create ADR from CVA analysis at cva-payment-processing.md\")\n```\n\n### decision-critic Skill\n\nValidates abstraction choices discovered via CVA. Applies inversion thinking to pattern recommendation.\n\n**Usage**:\n\n```bash\n\u002Fdecision-critic \"Validate Abstract Factory pattern for payment processing per CVA matrix\"\n```\n\n### independent-thinker Agent\n\nChallenges whether abstraction is needed at all. Use when CVA is borderline (minimal variability).\n\n**Usage**:\n\n```python\nAgent(subagent_type=\"independent-thinker\", prompt=\"Challenge whether payment abstraction is justified given only 2 current methods\")\n```\n\n## Verification Checklist\n\nAfter completing CVA:\n\n- [ ] Matrix has ≥2 rows (commonalities) and ≥2 columns (variabilities)\n- [ ] All matrix cells are filled with concrete implementations\n- [ ] Recommended patterns align with matrix structure (rows → Strategy, columns → Factory)\n- [ ] Rationale explains WHY patterns fit (cites matrix as evidence)\n- [ ] Edge cases handled (single use case, all variability, no commonality)\n- [ ] Validation script passes: `bun run ${CLAUDE_SKILL_DIR}\u002Fscripts\u002Fvalidate-cva-matrix.ts [file]`\n- [ ] ADR stub created with decision rationale\n- [ ] Reassessment triggers documented (when to re-run CVA)\n\n## Reassessment Triggers\n\nRe-run CVA when:\n\n1. **3+ new use cases** added (may reveal new patterns or invalidate current abstraction)\n2. **Major architectural shift** (e.g., monolith → microservices)\n3. **Performance issues** with current abstraction (overhead not justified)\n4. **Team feedback**: Abstraction is too complex, not pulling weight, or forcing designs\n5. **Quarterly review** (align with retrospective cycle)\n\n## Tiered Depth Levels\n\nChoose depth based on decision impact:\n\n| Tier     | Time   | Use Cases | When to Use                                          |\n| -------- | ------ | --------- | ---------------------------------------------------- |\n| Quick    | 15 min | 2-3       | Simple decisions, clear patterns, low risk           |\n| Standard | 30 min | 3-5       | Moderate complexity, some uncertainty, medium risk   |\n| Deep     | 60 min | 6+        | Architectural decisions, high uncertainty, high risk |\n\n**Time-boxing**: Set timer, commit to best-available analysis when time expires. CVA is a tool, not a perfectionist exercise.\n\n## TypeScript Examples\n\nSee `references\u002Fmatrix-building-examples.md` for complete TypeScript examples:\n\n- Middleware Pipeline (commonality: process request, variability: authentication, logging, compression)\n- Dependency Injection Providers (commonality: resolve dependencies, variability: lifetime scope, registration patterns)\n- Data Access Patterns (commonality: CRUD operations, variability: SQL, NoSQL, in-memory)\n\n## References\n\n- [Pattern Mapping Guide](references\u002Fpattern-mapping-guide.md) - How to read matrix and map to Strategy, Abstract Factory, combinations\n- [Matrix Building Examples](references\u002Fmatrix-building-examples.md) - TypeScript examples with complete CVA workflows\n\n## Scripts\n\n### validate-cva-matrix.ts\n\nCheck CVA matrix completeness and suggest patterns.\n\n**Usage**:\n\n```bash\nbun run ${CLAUDE_SKILL_DIR}\u002Fscripts\u002Fvalidate-cva-matrix.ts cva-matrix.md\n```\n\n**Exit Codes**:\n\n- 0: Valid matrix, patterns suggested\n- 10: Validation failure (missing rows\u002Fcolumns, empty cells)\n- 1: Error (file not found, invalid format)\n\n### generate-cva-template.ts\n\nCreate empty matrix template from user input.\n\n**Usage**:\n\n```bash\nbun run ${CLAUDE_SKILL_DIR}\u002Fscripts\u002Fgenerate-cva-template.ts \\\n  --commonalities \"Validate,Authorize,Record,Handle errors\" \\\n  --variabilities \"CreditCard,PayPal,BankTransfer\" \\\n  --output cva-matrix.md\n```\n\n### export-cva-matrix.ts\n\nConvert Markdown table to Mermaid diagram for presentations.\n\n**Usage**:\n\n```bash\nbun run ${CLAUDE_SKILL_DIR}\u002Fscripts\u002Fexport-cva-matrix.ts \\\n  --input cva-matrix.md \\\n  --format mermaid \\\n  --output cva-diagram.mmd\n```\n\n## Extension Points\n\n1. **Pattern Mapping**: Add new pattern types beyond Strategy\u002FAbstract Factory\n   - Edit `references\u002Fpattern-mapping-guide.md`\n   - Add Builder, Bridge, Visitor patterns with matrix signatures\n\n1. **Matrix Formats**: Add export formats beyond Markdown\n   - Use `bun run ${CLAUDE_SKILL_DIR}\u002Fscripts\u002Fexport-cva-matrix.ts --format \u003Cjson|plantuml|csv>`\n\n1. **Multidimensional Analysis**: Handle complex cases with 3+ axes\n\n1. **AI Integration**: Automated pattern suggestion\n   - Route to decision-critic or independent-thinker for automated review\n",{"name":5,"model":33,"agents":34,"license":15,"metadata":37,"description":7},"claude-opus-4-6[1m]",[35,25,26,36],"analyst","independent-thinker",{"author":38,"domains":39,"version":42,"timelessness":43},"Multi-Paradigm Design (Coplien 1999), adapted for modern engineering",[21,22,40,41],"patterns","abstraction-discovery","1.0.0","9\u002F10","main","2bd10cb7ca989f88dbf338b57957763718eda59b","templates\u002Fskills\u002Fcva-analysis","https:\u002F\u002Fgithub.com\u002Floriensleafs\u002Fbrain","https:\u002F\u002Fgithub.com\u002Floriensleafs","2026-03-11 23:51:59",{"source":8,"skillName":5,"commands":51,"prompt":61,"zipAvailable":62},[52,55,58],{"tool":53,"command":54},"npx","npx skills add loriensleafs\u002Fbrain --skill cva-analysis",{"tool":56,"command":57},"bunx","bunx skills add loriensleafs\u002Fbrain --skill cva-analysis",{"tool":59,"command":60},"pnpm","pnpm dlx skills add loriensleafs\u002Fbrain --skill cva-analysis","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Floriensleafs\u002Fbrain\u002Fblob\u002Fmain\u002Ftemplates\u002Fskills\u002Fcva-analysis\u002FSKILL.md",true,[64,70,74,78,82,86,92,96],{"path":65,"resourceType":66,"resourceTypeDesc":67,"sizeBytes":68,"sourceHtmlUrl":69},"CRAFT.md","REFERENCE","参考文档",10770,"https:\u002F\u002Fgithub.com\u002Fmalinskibeniamin\u002Fskills\u002Fblob\u002Fmain\u002Fproduct\u002FCRAFT.md",{"path":71,"resourceType":66,"resourceTypeDesc":67,"sizeBytes":72,"sourceHtmlUrl":73},"references\u002Fmatrix-building-examples.md",11271,"https:\u002F\u002Fgithub.com\u002Floriensleafs\u002Fbrain\u002Fblob\u002Fmain\u002Ftemplates\u002Fskills\u002Fcva-analysis\u002Freferences\u002Fmatrix-building-examples.md",{"path":75,"resourceType":66,"resourceTypeDesc":67,"sizeBytes":76,"sourceHtmlUrl":77},"references\u002Fpattern-mapping-guide.md",10580,"https:\u002F\u002Fgithub.com\u002Floriensleafs\u002Fbrain\u002Fblob\u002Fmain\u002Ftemplates\u002Fskills\u002Fcva-analysis\u002Freferences\u002Fpattern-mapping-guide.md",{"path":79,"resourceType":66,"resourceTypeDesc":67,"sizeBytes":80,"sourceHtmlUrl":81},"references\u002FSKILL_SPEC.md",38859,"https:\u002F\u002Fgithub.com\u002Floriensleafs\u002Fbrain\u002Fblob\u002Fmain\u002Ftemplates\u002Fskills\u002Fcva-analysis\u002Freferences\u002FSKILL_SPEC.md",{"path":83,"resourceType":66,"resourceTypeDesc":67,"sizeBytes":84,"sourceHtmlUrl":85},"RULES.md",21221,"https:\u002F\u002Fgithub.com\u002Fmalinskibeniamin\u002Fskills\u002Fblob\u002Fmain\u002Fproduct\u002FRULES.md",{"path":87,"resourceType":88,"resourceTypeDesc":89,"sizeBytes":90,"sourceHtmlUrl":91},"scripts\u002Fexport-cva-matrix.ts","SCRIPT","脚本",6897,"https:\u002F\u002Fgithub.com\u002Floriensleafs\u002Fbrain\u002Fblob\u002Fmain\u002Ftemplates\u002Fskills\u002Fcva-analysis\u002Fscripts\u002Fexport-cva-matrix.ts",{"path":93,"resourceType":88,"resourceTypeDesc":89,"sizeBytes":94,"sourceHtmlUrl":95},"scripts\u002Fgenerate-cva-template.ts",3680,"https:\u002F\u002Fgithub.com\u002Floriensleafs\u002Fbrain\u002Fblob\u002Fmain\u002Ftemplates\u002Fskills\u002Fcva-analysis\u002Fscripts\u002Fgenerate-cva-template.ts",{"path":97,"resourceType":88,"resourceTypeDesc":89,"sizeBytes":98,"sourceHtmlUrl":99},"scripts\u002Fvalidate-cva-matrix.ts",9410,"https:\u002F\u002Fgithub.com\u002Floriensleafs\u002Fbrain\u002Fblob\u002Fmain\u002Ftemplates\u002Fskills\u002Fcva-analysis\u002Fscripts\u002Fvalidate-cva-matrix.ts",[101,116,133,154,175,199],{"skillNo":102,"name":103,"nameZh":6,"description":104,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":105,"categories":106,"keywords":107,"publishedAt":28},"01M6CD3KHDHPR633RVP95G4XWN","validation-authority","Treat upstream validators as authoritative. Align local config to them. Use when validation fails unexpectedly, before modifying validator behavior, or when tempted to change upstream tool code.","https:\u002F\u002Fgithub.com\u002Floriensleafs\u002Fbrain\u002Fblob\u002Fmain\u002Ftemplates\u002Fskills\u002Fvalidation-authority\u002FSKILL.md",[],[108,109,110,27,111,112,113,25,114,115],"validation authority","validation","config","implementer","behavior","tool","code","change",{"skillNo":117,"name":118,"nameZh":6,"description":119,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":120,"categories":121,"keywords":122,"publishedAt":28},"01M6CD3H29Q8FWN9YETT8YVQTS","using-brain-memory","Guidance for using Brain semantic memory effectively. Applies Zettelkasten atomic note principles with observations and relations. Use when deciding whether to query or create notes, structuring note content, or understanding the semantic knowledge graph.","https:\u002F\u002Fgithub.com\u002Floriensleafs\u002Fbrain\u002Fblob\u002Fmain\u002Ftemplates\u002Fskills\u002Fusing-forgetful-memory\u002FSKILL.md",[],[123,124,125,126,127,128,129,27,130,131,132],"using brain memory","memory","content","create","notes","graph","guidance","context","knowledge","knowledge graph",{"skillNo":134,"name":135,"nameZh":6,"description":136,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":137,"categories":138,"keywords":139,"publishedAt":28},"01M6CD3E2KTTMNSWXRJAAZA7D1","threat-modeling","Structured security analysis using OWASP Four-Question Framework and STRIDE methodology. Generates threat matrices with risk ratings, mitigations, and prioritization. Use for attack surface analysis, security architecture review, or when asking what can go wrong.","https:\u002F\u002Fgithub.com\u002Floriensleafs\u002Fbrain\u002Fblob\u002Fmain\u002Ftemplates\u002Fskills\u002Fthreat-modeling\u002FSKILL.md",[],[140,141,142,27,143,25,144,145,19,146,147,148,149,150,22,151,152,153],"threat","threat modeling","prioritization","question","architecture review","stride","risk","owasp","methodology","framework","security analysis","security","go","review",{"skillNo":155,"name":156,"nameZh":6,"description":157,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":158,"categories":159,"keywords":165,"publishedAt":28},"01M6CD3BC6G0Q2MDNW6X51XHBQ","taste-lints","Custom lints with agent-readable remediation instructions. Enforces taste invariants (file size, naming conventions, structured logging, complexity) and surfaces errors that agents can act on directly. Use when writing or reviewing code to catch style violations early.","https:\u002F\u002Fgithub.com\u002Floriensleafs\u002Fbrain\u002Fblob\u002Fmain\u002Ftemplates\u002Fskills\u002Ftaste-lints\u002FSKILL.md",[160],{"categoryNo":161,"categoryName":162,"taxonomyType":163,"taxonomyTypeDesc":164},"01JBSEEDCAT000000000000023","Skill与智能体开发","SCENARIO","使用场景",[166,111,167,168,27,169,170,171,172,173,114,174],"taste lints","surfaces","complexity","instructions","remediation","file","logging","qa","writing",{"skillNo":176,"name":177,"nameZh":6,"description":178,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":179,"categories":180,"keywords":181,"publishedAt":28},"01M6CD37Z7VD22BH42TG0GM66V","style-enforcement","Validate code against style rules from .editorconfig, StyleCop.json, and Directory.Build.props. Detects line ending violations, naming convention issues, indentation problems, and charset mismatches across C#, Python, TypeScript, and JavaScript. Produces JSON reports for pre-commit hooks and CI pipelines.","https:\u002F\u002Fgithub.com\u002Floriensleafs\u002Fbrain\u002Fblob\u002Fmain\u002Ftemplates\u002Fskills\u002Fstyle-enforcement\u002FSKILL.md",[],[182,183,184,185,186,187,111,188,189,190,191,192,173,193,114,194,195,196,197,198],"style enforcement","enforcement","ci","pipelines","directory","hooks","Rules","json","pre-commit","editorconfig","reports","issues","validate","commit","javascript","python","typescript",{"skillNo":200,"name":201,"nameZh":6,"description":202,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":203,"categories":204,"keywords":205,"publishedAt":28},"01M6CD35JW73TPMCZBF9DTDEE8","steering-matcher","Match file paths against steering file glob patterns to determine applicable steering guidance. Use when orchestrator needs to inject context-aware guidance based on files being modified.","https:\u002F\u002Fgithub.com\u002Floriensleafs\u002Fbrain\u002Fblob\u002Fmain\u002Ftemplates\u002Fskills\u002Fsteering-matcher\u002FSKILL.md",[],[206,27,207,208,130,209,129,171],"steering matcher","files","haiku","orchestrator"]