anchi-kit 1.1.2

package/.cursor/skills/problem-solving/references/simplification-cascades.md

@@ -0,0 +1,80 @@
+# Simplification Cascades
+
+Find one insight eliminating multiple components. "If this is true, we don't need X, Y, Z."
+
+## Core Principle
+
+**Everything is a special case of...** collapses complexity dramatically.
+
+One powerful abstraction > ten clever hacks.
+
+## When to Use
+
+| Symptom | Action |
+|---------|--------|
+| Same thing implemented 5+ ways | Abstract the common pattern |
+| Growing special case list | Find the general case |
+| Complex rules with exceptions | Find rule with no exceptions |
+| Excessive config options | Find defaults working for 95% |
+
+## The Pattern
+
+**Look for:**
+- Multiple implementations of similar concepts
+- Special case handling everywhere
+- "We need to handle A, B, C, D differently..."
+- Complex rules with many exceptions
+
+**Ask:** "What if they're all the same thing underneath?"
+
+## Examples
+
+### Example 1: Stream Abstraction
+- **Before:** Separate handlers for batch/real-time/file/network data
+- **Insight:** "All inputs are streams - just different sources"
+- **After:** One stream processor, multiple stream sources
+- **Eliminated:** 4 separate implementations
+
+### Example 2: Resource Governance
+- **Before:** Session tracking, rate limiting, file validation, connection pooling (all separate)
+- **Insight:** "All are per-entity resource limits"
+- **After:** One ResourceGovernor with 4 resource types
+- **Eliminated:** 4 custom enforcement systems
+
+### Example 3: Immutability
+- **Before:** Defensive copying, locking, cache invalidation, temporal coupling
+- **Insight:** "Treat everything as immutable data + transformations"
+- **After:** Functional programming patterns
+- **Eliminated:** Entire classes of synchronization problems
+
+## Process
+
+1. **List variations** - What's implemented multiple ways?
+2. **Find essence** - What's the same underneath?
+3. **Extract abstraction** - What's the domain-independent pattern?
+4. **Test fit** - Do all cases fit cleanly?
+5. **Measure cascade** - How many things become unnecessary?
+
+## Red Flags
+
+Signs you're missing a cascade:
+- "Just need to add one more case..." (repeating forever)
+- "These are similar but different" (maybe they're the same?)
+- Refactoring feels like whack-a-mole (fix one, break another)
+- Growing configuration file
+- "Don't touch that, it's complicated" (complexity hiding pattern)
+
+## Success Metrics
+
+- **10x wins, not 10% improvements**
+- Measure in "how many things can we delete?"
+- Lines of code removed > lines added
+- Configuration options eliminated
+- Special cases unified
+
+## Remember
+
+- The pattern is usually already there, just needs recognition
+- Valid cascades feel obvious in retrospect
+- Test with "can this handle all existing cases?"
+- Document the insight for future reference

package/.cursor/skills/problem-solving/references/when-stuck.md

@@ -0,0 +1,72 @@
+# When Stuck - Problem-Solving Dispatch
+
+Different stuck-types need different techniques. Match stuck-symptom to technique.
+
+## Dispatch Flowchart
+
+```
+YOU'RE STUCK
+│
+├─ Complexity spiraling? Same thing 5+ ways? Growing special cases?
+│  └─→ USE: Simplification Cascades
+│
+├─ Can't find fitting approach? Conventional solutions inadequate?
+│  └─→ USE: Collision-Zone Thinking
+│
+├─ Same issue different places? Reinventing wheels? Feels familiar?
+│  └─→ USE: Meta-Pattern Recognition
+│
+├─ Solution feels forced? "Must be done this way"? Stuck on assumptions?
+│  └─→ USE: Inversion Exercise
+│
+├─ Will this work at production? Edge cases unclear? Unsure of limits?
+│  └─→ USE: Scale Game
+│
+└─ Code broken? Wrong behavior? Test failing?
+   └─→ USE: Debugging skill (systematic-debugging)
+```
+
+## Stuck-Type → Technique Map
+
+| How You're Stuck | Symptom Details | Use This |
+|------------------|-----------------|----------|
+| **Complexity spiraling** | Same thing 5+ ways, growing special cases, excessive if/else | simplification-cascades.md |
+| **Need innovation** | Conventional inadequate, can't find fitting approach, need breakthrough | collision-zone-thinking.md |
+| **Recurring patterns** | Same issue different places, reinventing wheels, déjà vu feeling | meta-pattern-recognition.md |
+| **Forced by assumptions** | "Must be done this way", can't question premise, forced solution | inversion-exercise.md |
+| **Scale uncertainty** | Production unclear, edge cases unknown, unsure of limits | scale-game.md |
+| **Code broken** | Wrong behavior, test failing, unexpected output | debugging skill |
+
+## Process
+
+1. **Identify stuck-type** - What symptom matches above?
+2. **Load that technique** - Read the specific reference file
+3. **Apply technique** - Follow its process
+4. **Document attempt** - What worked/failed?
+5. **If still stuck** - Try different technique or combine
+
+## Combining Techniques
+
+Some problems need multiple techniques:
+
+- **Simplification + Meta-pattern** - Find pattern → simplify all instances
+- **Collision + Inversion** - Force metaphor → invert assumptions
+- **Scale + Simplification** - Test extremes → reveal what to eliminate
+- **Meta-pattern + Scale** - Universal pattern → test at extremes
+
+## When Nothing Works
+
+If no technique helps:
+1. **Reframe problem** - Are you solving the right problem?
+2. **Get fresh perspective** - Explain to someone else
+3. **Take break** - Distance often reveals solution
+4. **Simplify scope** - Solve smaller version first
+5. **Question constraints** - Are they real or assumed?
+
+## Remember
+
+- Match symptom to technique
+- One technique at a time
+- Combine if first doesn't work
+- Document what you tried
+- Not stuck forever, just temporarily

package/.cursor/skills/prompt-engineering/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: prompt-engineering
+description: Advanced prompt engineering techniques and Anthropic best practices for creating effective AI prompts, agents, and AI interactions. Use when creating AI agents, writing prompts, optimizing AI interactions, or building AI-powered features.
+---
+
+# Prompt Engineering
+
+Advanced techniques for crafting effective prompts and optimizing AI interactions.
+
+## When to Use
+
+- Creating AI agents or assistants
+- Writing prompts for Claude or other LLMs
+- Optimizing AI-powered features
+- Debugging AI responses
+- Building conversational interfaces
+- Implementing RAG systems
+
+## Core Principles
+
+### 1. Be Clear and Specific
+
+```markdown
+❌ Bad: "Write code for a login system"
+
+✅ Good: "Create a secure login system in Node.js with:
+
+- Email/password authentication
+- JWT tokens for sessions
+- Password hashing with bcrypt
+- Input validation
+- Rate limiting (5 attempts/minute)"
+```
+
+### 2. Provide Context
+
+```markdown
+Context: I'm building an e-commerce site with Next.js 14, PostgreSQL, and Stripe.
+Task: Create a checkout flow that handles...
+```
+
+### 3. Use Examples (Few-Shot Learning)
+
+```markdown
+Convert these user messages to structured data:
+
+Input: "Book a flight to NYC on Friday"
+Output: {"action": "book_flight", "destination": "NYC", "date": "friday"}
+
+Input: "Cancel my hotel reservation"
+Output: {"action": "cancel", "type": "hotel"}
+
+Now convert: "Find me a restaurant in Paris"
+```
+
+## Anthropic Best Practices
+
+See [references/anthropic-best-practices.md](references/anthropic-best-practices.md) for:
+
+- Claude-specific techniques
+- System prompts vs user prompts
+- Tool use patterns
+- Multi-turn conversations
+- Handling refusals
+
+## Prompt Patterns
+
+See [references/prompt-patterns.md](references/prompt-patterns.md) for:
+
+- Chain of Thought
+- ReAct (Reasoning + Acting)
+- Self-Consistency
+- Tree of Thoughts
+- Structured Output
+
+## Effective Techniques
+
+### Chain of Thought
+
+```markdown
+Solve this step-by-step:
+
+Problem: A store has 15% off all items. An item costs $80. What's the final price?
+
+Think through this:
+
+1. Calculate discount amount
+2. Subtract from original price
+3. Show your work
+```
+
+### Role Assignment
+
+```markdown
+You are a senior software architect specializing in microservices.
+Review this system design and provide:
+
+1. Potential bottlenecks
+2. Scalability concerns
+3. Recommended improvements
+```
+
+### Structured Output
+
+```markdown
+Analyze this code and respond in JSON format:
+{
+"issues": [...],
+"suggestions": [...],
+"complexity_score": 1-10
+}
+```
+
+## Debugging Prompts
+
+1. **Too vague** → Add specific requirements
+2. **Wrong format** → Provide output examples
+3. **Inconsistent** → Add constraints and validation
+4. **Verbose** → Request concise responses
+5. **Off-topic** → Clarify scope and boundaries
+
+## References
+
+- [Anthropic Best Practices](references/anthropic-best-practices.md)
+- [Prompt Patterns](references/prompt-patterns.md)
+- [Claude Documentation](https://docs.anthropic.com/en/docs/)

package/.cursor/skills/prompt-engineering/references/anthropic-best-practices.md

@@ -0,0 +1,160 @@
+# Anthropic Best Practices
+
+## Claude-Specific Techniques
+
+### System Prompts
+
+Define Claude's role and behavior:
+
+```xml
+<system>
+You are a helpful coding assistant specializing in Python and web development.
+Always provide working code examples.
+Explain your reasoning before showing code.
+Follow PEP 8 style guidelines.
+</system>
+```
+
+### XML Tags for Structure
+
+Claude works well with XML-like tags:
+
+```xml
+<context>
+The user is building a Next.js e-commerce site
+</context>
+
+<task>
+Create a product listing component with:
+- Image display
+- Price formatting
+- Add to cart button
+</task>
+
+<constraints>
+- Must be TypeScript
+- Use Tailwind CSS
+- Follow accessibility standards
+</constraints>
+```
+
+### Tool Use Pattern
+
+```javascript
+const tools = [
+  {
+    name: "search_database",
+    description: "Search the product database",
+    input_schema: {
+      type: "object",
+      properties: {
+        query: { type: "string" },
+        limit: { type: "number" },
+      },
+    },
+  },
+];
+
+// Claude will format tool calls as:
+// <function_calls>
+// <invoke name="search_database">
+// <parameter name="query">laptops</parameter>
+// </invoke>
+// </function_calls>
+```
+
+## Multi-Turn Conversations
+
+### Maintaining Context
+
+```markdown
+User: "Create a User model"
+Claude: [Creates User model]
+
+User: "Now add email validation"
+Claude: [Updates User model with validation]
+
+User: "Make it work with PostgreSQL"
+Claude: [Adds database integration]
+```
+
+**Best Practices:**
+
+- Reference previous messages explicitly
+- Maintain consistent naming
+- Ask clarifying questions when context is unclear
+
+## Handling Edge Cases
+
+### Clarification Requests
+
+```markdown
+I notice you mentioned "authentication" but didn't specify:
+
+1. Which method? (JWT, sessions, OAuth)
+2. Password requirements?
+3. Multi-factor authentication needed?
+
+Could you clarify these points?
+```
+
+### Graceful Refusals
+
+If Claude refuses a request:
+
+- Rephrase with clearer intent
+- Provide more context
+- Break into smaller sub-tasks
+- Explain the legitimate use case
+
+## Optimizing Responses
+
+### Request Specific Format
+
+```markdown
+Provide the solution in this format:
+
+## Problem Analysis
+
+[Analysis here]
+
+## Solution
+
+[Code here]
+
+## Trade-offs
+
+[Pros/cons here]
+```
+
+### Control Verbosity
+
+```markdown
+Concise mode: Provide only code with brief comments
+Detailed mode: Include explanations and examples
+Minimal mode: Code only, no explanations
+```
+
+## Long Context Usage
+
+Claude has 200K context window - use it effectively:
+
+1. **Include relevant files** - Paste full file contents
+2. **Provide documentation** - Include API docs, specs
+3. **Give examples** - Show desired patterns
+4. **Maintain conversation** - Don't reset unnecessarily
+
+## Extended Thinking
+
+For complex problems, enable extended thinking:
+
+```markdown
+<thinking>
+Take your time to think through this problem step by step.
+Consider edge cases, performance, and maintainability.
+</thinking>
+
+[Problem description]
+```
+
+This encourages Claude to show detailed reasoning before answering.

package/.cursor/skills/pypict-testing/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: pypict-testing
+description: Design comprehensive test cases using PICT (Pairwise Independent Combinatorial Testing) for optimized test suites with pairwise coverage. Scientific test case generation.
+---
+
+# PICT Testing
+
+Pairwise combinatorial testing for optimized test coverage.
+
+## When to Use
+
+- Complex input combinations
+- Configuration testing
+- Reducing test cases
+- Scientific test design
+- Maximum coverage with minimum tests
+
+## PICT Basics
+
+Test all pairs of parameters, not all combinations.
+
+```
+Parameters:
+- Browser: Chrome, Firefox, Safari (3 options)
+- OS: Windows, Mac, Linux (3 options)
+- User: Admin, Regular (2 options)
+
+All combinations: 3 × 3 × 2 = 18 tests
+Pairwise: ~6-9 tests (covers all pairs)
+```
+
+## Example Model
+
+```pict
+Browser: Chrome, Firefox, Safari
+OS: Windows, Mac, Linux
+UserType: Admin, Regular
+
+# Constraints
+IF [Browser] = "Safari" THEN [OS] = "Mac";
+```
+
+Generate tests:
+
+```bash
+pict model.txt > test-cases.txt
+```
+
+## Benefits
+
+- **Reduce tests** - 90% fewer than full coverage
+- **Find bugs** - Most bugs from 2-parameter interactions
+- **Scientific** - Mathematically proven coverage
+
+## Test Case Output
+
+```
+Browser   OS       UserType
+Chrome    Windows  Admin
+Firefox   Linux    Regular
+Safari    Mac      Admin
+...
+```
+
+## Integration
+
+```python
+import pypict
+
+# Generate test cases
+model = pypict.Model()
+model.add_parameter("Browser", ["Chrome", "Firefox"])
+model.add_parameter("OS", ["Windows", "Mac"])
+
+cases = model.generate()
+# Use cases for testing
+```
+
+See [references/combinatorial-testing.md](references/combinatorial-testing.md) and [scripts/generate-test-cases.py](scripts/generate-test-cases.py).