## File: README.md

# ClaudeKit - Agent Skills

[**Agent Skills**](https://docs.claude.com/en/docs/agents-and-tools/agent-skills/overview) are specialized workflows that empower Claude to perform complex, multi-step tasks with precision and reliability. They combine mission briefs, guardrails, and integration hints to transform generic AI assistance into disciplined automation.

Learn more about Agent Skills: https://docs.claude.com/en/docs/agents-and-tools/agent-skills/overview

## My other projects

- [My Blog](https://zuey.me)
- [ClaudeKit](https://claudekit.cc)
- [UI UX Pro Max Skill](https://uupm.cc)
- [GoClaw - OpenClaw for Enterprise](https://goclaw.sh)
- [AgentWiki - Knowledge Base for both humans & AI agents](https://agentwiki.cc)
- [TOSE - The Outstanding Shipping Solution](https://tose.sh)

## 🎉 NEW [Dec 2025]: Claude Code Marketplace!

ClaudeKit Skills is now available as a **Plugin Marketplace** for seamless installation and automatic updates!

```bash
/plugin marketplace add mrgoonie/claudekit-skills
/plugin install ai-ml-tools@claudekit-skills
```

No more manual git clones! Install and update skills with simple commands. See [Getting Started](#getting-started) for full installation guide.

## Update [Nov 2025]: No more context bloat with "mcp-manager" subagent + "mcp-management" skills!



📖 Read more here: [MCP_MANAGEMENT.md](MCP_MANAGEMENT.md)

## ✨ Skills just got refactored!

📖 Read more here: [REFACTOR.md](REFACTOR.md)

## Skills catalog

### 🔐 Authentication & Security
- **[better-auth](.claude/skills/better-auth)** - Comprehensive TypeScript authentication framework supporting email/password, OAuth, 2FA, passkeys, and multi-tenancy. Works with any framework (Next.js, Nuxt, SvelteKit, etc.).

### 🤖 AI & Agent Development
- **[context-engineering](.claude/skills/context-engineering)** - Master context engineering for AI agent systems. Covers context fundamentals, degradation patterns, optimization techniques (compaction, masking, caching), compression strategies, memory architectures, multi-agent patterns, LLM-as-Judge evaluation, tool design, and project development. Use when designing agent architectures, debugging context failures, optimizing token usage, implementing memory systems, or building multi-agent coordination.
- **[google-adk-python](.claude/skills/google-adk-python)** - Google's Agent Development Kit (ADK) for building AI agents with tool integration, multi-agent orchestration, workflow patterns (sequential, parallel, loop), and deployment to Vertex AI or custom infrastructure.

### 💻 Backend Development
- **[backend-development](.claude/skills/backend-development)** - Build robust backend systems with modern technologies (Node.js, Python, Go, Rust), frameworks (NestJS, FastAPI, Django), databases (PostgreSQL, MongoDB, Redis), APIs (REST, GraphQL, gRPC), authentication (OAuth 2.1, JWT), testing strategies, security best practices (OWASP Top 10), performance optimization, scalability patterns (microservices, caching, sharding), DevOps practices (Docker, Kubernetes, CI/CD), and monitoring. Use when designing APIs, implementing authentication, optimizing database queries, setting up CI/CD pipelines, handling security vulnerabilities, building microservices, or developing production-ready backend systems.

### 🧠 AI & Machine Learning
- **[ai-multimodal](.claude/skills/ai-multimodal)** - Process and generate multimedia content using Google Gemini API. Capabilities include analyze audio (transcription, summarization up to 9.5 hours), understand images (captioning, object detection, OCR, visual Q&A), process videos (scene detection, Q&A, temporal analysis, YouTube URLs up to 6 hours), extract from documents (PDF tables, forms, charts, diagrams), generate images (text-to-image, editing, composition). Supports Gemini 2.5/2.0 with context windows up to 2M tokens.
- **[context-engineering](.claude/skills/context-engineering)** - Master context engineering for AI agent systems. Use when designing agent architectures, debugging context failures, optimizing token usage, implementing memory systems, building multi-agent coordination, or evaluating agent performance. Covers context fundamentals, degradation patterns, optimization techniques (compaction, masking, caching), compression strategies, and memory architectures.

### 🎨 Design & Aesthetics
- **[aesthetic](.claude/skills/aesthetic)** - Create aesthetically beautiful interfaces following proven design principles. Use when building UI/UX, analyzing designs from inspiration sites, generating design images with ai-multimodal, implementing visual hierarchy and color theory, adding micro-interactions, or creating design documentation. Includes workflows for capturing and analyzing inspiration screenshots with chrome-devtools and ai-multimodal, iterative design image generation until aesthetic standards are met, and comprehensive design system guidance covering BEAUTIFUL (aesthetic principles), RIGHT (functionality/accessibility), SATISFYING (micro-interactions), and PEAK (storytelling) stages.

### 🌐 Web Development
- **[web-frameworks](.claude/skills/web-frameworks)** - Build modern full-stack web applications with Next.js (App Router, Server Components, RSC, PPR, SSR, SSG, ISR), Turborepo (monorepo management, task pipelines, remote caching, parallel execution), and RemixIcon (3100+ SVG icons). Create React applications, implement server-side rendering, set up monorepos, optimize build performance, manage shared dependencies.
- **[ui-styling](.claude/skills/ui-styling)** - Create beautiful, accessible user interfaces with shadcn/ui components (built on Radix UI + Tailwind), Tailwind CSS utility-first styling, and canvas-based visual designs. Build design systems, create responsive layouts, add accessible components, customize themes, implement dark mode, generate visual designs and posters.
- **[frontend-design](.claude/skills/frontend-design)** - Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.
- **[frontend-development](.claude/skills/frontend-development)** - 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.
- **[threejs](.claude/skills/threejs)** - Build 3D web apps with Three.js (WebGL/WebGPU). Use for 3D scenes, animations, custom shaders, PBR materials, VR/XR experiences, games, data visualizations, product configurators. Includes asset loading (GLTF, FBX, OBJ), post-processing effects, physics simulations, and performance optimization.

### 🌐 Browser Automation & Testing
- **[chrome-devtools](.claude/skills/chrome-devtools)** - Browser automation, debugging, and performance analysis using Puppeteer CLI scripts. Automate browsers, take screenshots, analyze performance, monitor network traffic, web scraping, and form automation.
- **[web-testing](.claude/skills/web-testing)** - Comprehensive web testing with Playwright, Vitest, k6. E2E/unit/integration/load/security/visual/accessibility testing. Use for test automation, flakiness mitigation, Core Web Vitals, mobile gestures, cross-browser testing.

### ☁️ Cloud Platforms & DevOps
- **[bunny](.claude/skills/bunny)** - Integrate with Bunny.net's cloud platform: CDN (Pull Zones, Edge Rules, Cache), Edge Storage (HTTP/FTP, SDKs), Stream (video upload/encode/DRM), DNS (Zones, DNSSEC, Scriptable DNS), Edge Scripting (JS/TS at the edge), Shield (WAF, DDoS, Rate Limiting), Magic Containers (deploy/autoscale), Optimizer (dynamic images), Database (distributed SQLite), and AI Image Generation. Includes Terraform provider and token authentication.
- **[devops](.claude/skills/devops)** - Deploy and manage cloud infrastructure on Cloudflare (Workers, R2, D1, KV, Pages, Durable Objects, Browser Rendering), Docker containers, and Google Cloud Platform (Compute Engine, GKE, Cloud Run, App Engine, Cloud Storage). Deploy serverless functions to the edge, configure edge computing solutions, manage containers, set up CI/CD pipelines, optimize cloud infrastructure costs.

### 🗄️ Databases
- **[databases](.claude/skills/databases)** - Work with MongoDB (document database, BSON documents, aggregation pipelines, Atlas cloud) and PostgreSQL (relational database, SQL queries, psql CLI, pgAdmin). Design database schemas, write queries and aggregations, optimize indexes, perform migrations, configure replication and sharding, implement backup and restore strategies.

### 🛠️ Development Tools
- **[claude-code](.claude/skills/claude-code)** - Complete guide to Claude Code features: slash commands, hooks, plugins, MCP servers, agent skills, IDE integration, and enterprise deployment.
- **[mcp-builder](.claude/skills/mcp-builder)** - Build high-quality MCP servers in Python (FastMCP) or TypeScript. Includes agent-centric design principles, evaluation harnesses, and best practices.
- **[mcp-management](.claude/skills/mcp-management)** - Manage Model Context Protocol (MCP) servers - discover, analyze, and execute tools/prompts/resources from configured MCP servers. Use when working with MCP integrations, need to discover available MCP capabilities, filter MCP tools for specific tasks, execute MCP tools programmatically, access MCP prompts/resources, or implement MCP client functionality. Supports intelligent tool selection, multi-server management, and context-efficient capability discovery.
- **[repomix](.claude/skills/repomix)** - Package entire repositories into single AI-friendly files (XML, Markdown, JSON). Perfect for codebase analysis, security audits, and LLM context generation.
- **[media-processing](.claude/skills/media-processing)** - Process multimedia files with FFmpeg (video/audio encoding, conversion, streaming, filtering, hardware acceleration) and ImageMagick (image manipulation, format conversion, batch processing, effects, composition). Supports 100+ formats, hardware acceleration (NVENC, QSV), and complex filtergraphs.

### 📚 Documentation & Research
- **[docs-seeker](.claude/skills/docs-seeker)** - Intelligent documentation discovery using llms.txt standard, GitHub repository analysis via Repomix, and parallel exploration agents for comprehensive coverage.

### 🧪 Code Quality & Review
- **[code-review](.claude/skills/code-review)** - Use when receiving code review feedback (especially if unclear or technically questionable), when completing tasks or major features requiring review before proceeding, or before making any completion/success claims. Essential for subagent-driven development, pull requests, and preventing false completion claims.

### 🐛 Debugging & Quality
- **[debugging/defense-in-depth](.claude/skills/debugging/defense-in-depth)** - Validate at every layer data passes through. Make bugs structurally impossible with entry validation, business logic checks, environment guards, and debug logging.
- **[debugging/root-cause-tracing](.claude/skills/debugging/root-cause-tracing)** - Trace bugs backward through the call stack to find original triggers. Fix at the source, not the symptom.
- **[debugging/systematic-debugging](.claude/skills/debugging/systematic-debugging)** - Four-phase framework ensuring root cause investigation before fixes. Never jump to solutions.
- **[debugging/verification-before-completion](.claude/skills/debugging/verification-before-completion)** - Run verification commands and confirm output before claiming success. Evidence before claims, always.

### 📄 Document Processing
- **[document-skills/docx](.claude/skills/document-skills/docx)** - Create, edit, and analyze Word documents with tracked changes, comments, formatting preservation, and redlining workflows for professional documents.
- **[document-skills/pdf](.claude/skills/document-skills/pdf)** - Extract text/tables, create PDFs, merge/split documents, fill forms. Uses pypdf and command-line tools for programmatic PDF processing.
- **[document-skills/pptx](.claude/skills/document-skills/pptx)** - Create and edit PowerPoint presentations with layouts, speaker notes, comments, animations, and design elements.
- **[document-skills/xlsx](.claude/skills/document-skills/xlsx)** - Build spreadsheets with formulas, formatting, data analysis, and visualization. Includes financial modeling standards and zero-error formula requirements.

### 🛍️ E-commerce & Platforms
- **[shopify](.claude/skills/shopify)** - Build Shopify apps, extensions, and themes using GraphQL/REST APIs, Shopify CLI, Polaris UI. Includes checkout extensions, admin customization, Liquid templating, and Shopify Functions.

### 💳 Payments & Billing
- **[payment-integration](.claude/skills/payment-integration)** - Comprehensive payment integration for SePay (Vietnamese VietQR/bank transfers), Polar (SaaS monetization with MoR), Stripe (global payments), Paddle (MoR subscriptions), and Creem.io (software licensing). Includes webhook verification, checkout helpers, subscription management, and usage-based billing.

### 🧠 Problem-Solving Frameworks
- **[problem-solving/collision-zone-thinking](.claude/skills/problem-solving/collision-zone-thinking)** - Force unrelated concepts together to discover emergent properties. "What if we treated X like Y?"
- **[problem-solving/inversion-exercise](.claude/skills/problem-solving/inversion-exercise)** - Flip core assumptions to reveal hidden constraints and alternative approaches. "What if the opposite were true?"
- **[problem-solving/meta-pattern-recognition](.claude/skills/problem-solving/meta-pattern-recognition)** - Spot patterns appearing in 3+ domains to find universal principles worth extracting.
- **[problem-solving/scale-game](.claude/skills/problem-solving/scale-game)** - Test at extremes (1000x bigger/smaller, instant/year-long) to expose fundamental truths hidden at normal scales.
- **[problem-solving/simplification-cascades](.claude/skills/problem-solving/simplification-cascades)** - Find one insight that eliminates multiple components. "If this is true, we don't need X, Y, or Z."
- **[problem-solving/when-stuck](.claude/skills/problem-solving/when-stuck)** - Dispatch to the right problem-solving technique based on your specific type of stuck-ness.

### 🧠 Advanced Reasoning
- **[sequential-thinking](.claude/skills/sequential-thinking)** - Use when complex problems require systematic step-by-step reasoning with ability to revise thoughts, branch into alternative approaches, or dynamically adjust scope. Ideal for multi-stage analysis, design planning, problem decomposition, or tasks with initially unclear scope.

### 📊 Visualization & Diagramming
- **[mermaidjs-v11](.claude/skills/mermaidjs-v11)** - Create diagrams and visualizations using Mermaid.js v11 syntax. Generate flowcharts, sequence diagrams, class diagrams, state diagrams, ER diagrams, Gantt charts, user journeys, timelines, architecture diagrams, or any of 24+ diagram types. Supports JavaScript API integration, CLI rendering to SVG/PNG/PDF, theming, configuration, and accessibility features. Essential for documentation, technical diagrams, project planning, system architecture, and visual communication.

### 🔧 Meta Skills (from Anthropic)
- **[skill-creator](.claude/skills/skill-creator)** - Guide for creating effective skills with specialized workflows, tool integrations, domain expertise, and bundled resources.

## Getting started

### 🚀 Marketplace Installation (Recommended)

ClaudeKit Skills is now available as a **Claude Code Plugin Marketplace** for seamless installation and automatic updates!

```bash
# Add marketplace
/plugin marketplace add mrgoonie/claudekit-skills

# Install plugins you need
/plugin install ai-ml-tools@claudekit-skills
/plugin install web-dev-tools@claudekit-skills
/plugin install devops-tools@claudekit-skills
# ... and more!
```

**Available Plugin Categories:**
- `ai-ml-tools` - AI and ML with Gemini API, context engineering
- `web-dev-tools` - React, Next.js, Tailwind CSS
- `devops-tools` - Cloudflare, Docker, GCP, Databases
- `backend-tools` - Node.js, Python, Go, Authentication
- `document-processing` - Word, PDF, PowerPoint, Excel
- `debugging-tools` - Systematic debugging frameworks
- `problem-solving-tools` - Advanced thinking techniques
- `platform-tools` - Bunny.net, Shopify, payments (SePay, Polar, Stripe, Paddle, Creem), MCP management
- `meta-tools` - Skill creation, code review
- `media-tools` - FFmpeg, ImageMagick
- `research-tools` - Documentation discovery
- `specialized-tools` - Sequential thinking, diagrams

📖 **Full installation guide:** [docs/MARKETPLACE.md](docs/MARKETPLACE.md)

### 📦 Manual Installation (Legacy)

For users who prefer manual installation:

```bash
git clone https://github.com/mrgoonie/claudekit-skills
cp -r claudekit-skills/.claude/* /path/to/your/project/.claude/
```

**Note:** Manual installation is deprecated. Marketplace installation is recommended for automatic updates and version management.

### 🎯 Usage

- **Select Skills**: After installation, Claude Code will automatically discover available skills
- **Activate**: Skills are activated based on your task context
- **Customize**: Edit skill instructions to match your processes and tools
- **Execute**: Claude follows the skill's playbook while you supervise the diffs

## Star History

[](https://www.star-history.com/#mrgoonie/claudekit-skills&type=date&legend=top-left)

## Extend beyond the free tier
This collection covers the essentials. If you need advanced regulated-industry skills, analytics dashboards, or tailored onboarding, explore the full ClaudeKit package at [ClaudeKit.cc](https://claudekit.cc). The commercial bundle stays subtle but unlocks deeper automation while keeping the same transparent workflow philosophy.

**I've been spending 6+ months to dig into every aspect of Claude Code so you don't have to.**

[](https://claudekit.cc)

I've basically been sharing everything I learned about Claude Code on Substack: https://faafospecialist.substack.com/

So if you find this collection useful, please consider supporting my product at [ClaudeKit.cc](https://claudekit.cc).

Thanks for your support! 🥰

---

## File: .claude/skills/chrome-devtools/scripts/README.md

# Chrome DevTools Scripts

CLI scripts for browser automation using Puppeteer.

**CRITICAL**: Always check `pwd` before running scripts.

## Installation

### Quick Install

```bash
pwd  # Should show current working directory
cd .claude/skills/chrome-devtools/scripts
./install.sh  # Auto-checks dependencies and installs
```

### Manual Installation

**Linux/WSL** - Install system dependencies first:
```bash
./install-deps.sh  # Auto-detects OS (Ubuntu, Debian, Fedora, etc.)
```

Or manually:
```bash
sudo apt-get install -y libnss3 libnspr4 libasound2t64 libatk1.0-0 libatk-bridge2.0-0 libcups2 libdrm2 libxkbcommon0 libxcomposite1 libxdamage1 libxfixes3 libxrandr2 libgbm1
```

**All platforms** - Install Node dependencies:
```bash
npm install
```

## Scripts

**CRITICAL**: Always check `pwd` before running scripts.

### navigate.js
Navigate to a URL.

```bash
node navigate.js --url https://example.com [--wait-until networkidle2] [--timeout 30000]
```

### screenshot.js
Take a screenshot with automatic compression.

**Important**: Always save screenshots to `./docs/screenshots` directory.

```bash
node screenshot.js --output screenshot.png [--url https://example.com] [--full-page true] [--selector .element] [--max-size 5] [--no-compress]
```

**Automatic Compression**: Screenshots >5MB are automatically compressed using ImageMagick to ensure compatibility with Gemini API and Claude Code. Install ImageMagick for this feature:
- macOS: `brew install imagemagick`
- Linux: `sudo apt-get install imagemagick`

Options:
- `--max-size N` - Custom size threshold in MB (default: 5)
- `--no-compress` - Disable automatic compression
- `--format png|jpeg` - Output format (default: png)
- `--quality N` - JPEG quality 0-100 (default: auto)

### click.js
Click an element.

```bash
node click.js --selector ".button" [--url https://example.com] [--wait-for ".result"]
```

### fill.js
Fill form fields.

```bash
node fill.js --selector "#input" --value "text" [--url https://example.com] [--clear true]
```

### evaluate.js
Execute JavaScript in page context.

```bash
node evaluate.js --script "document.title" [--url https://example.com]
```

### snapshot.js
Get DOM snapshot with interactive elements.

```bash
node snapshot.js [--url https://example.com] [--output snapshot.json]
```

### console.js
Monitor console messages.

```bash
node console.js --url https://example.com [--types error,warn] [--duration 5000]
```

### network.js
Monitor network requests.

```bash
node network.js --url https://example.com [--types xhr,fetch] [--output requests.json]
```

### performance.js
Measure performance metrics and record trace.

```bash
node performance.js --url https://example.com [--trace trace.json] [--metrics] [--resources true]
```

## Common Options

- `--headless false` - Show browser window
- `--close false` - Keep browser open
- `--timeout 30000` - Set timeout in milliseconds
- `--wait-until networkidle2` - Wait strategy (load, domcontentloaded, networkidle0, networkidle2)

## Selector Support

Scripts that accept `--selector` (click.js, fill.js, screenshot.js) support both **CSS** and **XPath** selectors.

### CSS Selectors (Default)

```bash
# Element tag
node click.js --selector "button" --url https://example.com

# Class selector
node click.js --selector ".btn-submit" --url https://example.com

# ID selector
node fill.js --selector "#email" --value "user@example.com" --url https://example.com

# Attribute selector
node click.js --selector 'button[type="submit"]' --url https://example.com

# Complex selector
node screenshot.js --selector "div.container > button.btn-primary" --output btn.png
```

### XPath Selectors

XPath selectors start with `/` or `(//` and are automatically detected:

```bash
# Text matching - exact
node click.js --selector '//button[text()="Submit"]' --url https://example.com

# Text matching - contains
node click.js --selector '//button[contains(text(),"Submit")]' --url https://example.com

# Attribute matching
node fill.js --selector '//input[@type="email"]' --value "user@example.com"

# Multiple conditions
node click.js --selector '//button[@type="submit" and contains(text(),"Save")]'

# Descendant selection
node screenshot.js --selector '//div[@class="modal"]//button[@class="close"]' --output modal.png

# Nth element
node click.js --selector '(//button)[2]'  # Second button on page
```

### Discovering Selectors

Use `snapshot.js` to discover correct selectors:

```bash
# Get all interactive elements
node snapshot.js --url https://example.com | jq '.elements[]'

# Find buttons
node snapshot.js --url https://example.com | jq '.elements[] | select(.tagName=="BUTTON")'

# Find inputs
node snapshot.js --url https://example.com | jq '.elements[] | select(.tagName=="INPUT")'
```

### Security

XPath selectors are validated to prevent injection attacks. The following patterns are blocked:
- `javascript:`
- `<script`
- `onerror=`, `onload=`, `onclick=`
- `eval(`, `Function(`, `constructor(`

Selectors exceeding 1000 characters are rejected (DoS prevention).

## Output Format

All scripts output JSON to stdout:

```json
{
  "success": true,
  "url": "https://example.com",
  "title": "Example Domain",
  ...
}
```

Errors are output to stderr:

```json
{
  "success": false,
  "error": "Error message",
  "stack": "..."
}
```

---

## File: .claude/skills/common/README.md

# Common Skill Utilities

This directory contains shared utilities used across multiple skills.

## API Key Helper

`api_key_helper.py` provides standardized configuration for all Gemini-based skills, supporting both Google AI Studio and Vertex AI endpoints.

### Usage in Skills

```python
import sys
from pathlib import Path

# Add common directory to path
common_dir = Path(__file__).parent.parent.parent / 'common'
sys.path.insert(0, str(common_dir))

from api_key_helper import get_api_key_or_exit

# Get API key with automatic error handling
api_key = get_api_key_or_exit()
```

### API Key Lookup Order

The helper checks for `GEMINI_API_KEY` in this order:

1. **Process environment variable** (recommended for development)
   ```bash
   export GEMINI_API_KEY='your-api-key'
   ```

2. **Project root `.env` file**
   ```bash
   echo 'GEMINI_API_KEY=your-api-key' > .env
   ```

3. **.claude/.env file**
   ```bash
   echo 'GEMINI_API_KEY=your-api-key' > .claude/.env
   ```

4. **.claude/skills/.env file** (shared across all Gemini skills)
   ```bash
   echo 'GEMINI_API_KEY=your-api-key' > .claude/skills/.env
   ```

5. **Skill directory `.env` file**
   ```bash
   echo 'GEMINI_API_KEY=your-api-key' > .claude/skills/your-skill/.env
   ```

### Vertex AI Support

To use Vertex AI instead of Google AI Studio:

```bash
# Enable Vertex AI
export GEMINI_USE_VERTEX=true
export VERTEX_PROJECT_ID=your-gcp-project-id
export VERTEX_LOCATION=us-central1  # Optional, defaults to us-central1
```

Or in `.env` file:
```
GEMINI_USE_VERTEX=true
VERTEX_PROJECT_ID=your-gcp-project-id
VERTEX_LOCATION=us-central1
```

### Using get_client() Helper

For automatic client selection (AI Studio or Vertex AI):

```python
from api_key_helper import get_client

# Get appropriate client based on configuration
client_info = get_client()

if client_info['type'] == 'vertex':
    # Using Vertex AI
    from vertexai.generative_models import GenerativeModel
    model = GenerativeModel('gemini-2.5-flash')
    response = model.generate_content("Hello")
else:
    # Using AI Studio
    client = client_info['client']
    response = client.models.generate_content(
        model='gemini-2.5-flash',
        contents="Hello"
    )
```

### Using get_vertex_config() Helper

For checking Vertex AI configuration:

```python
from api_key_helper import get_vertex_config

vertex_config = get_vertex_config()
if vertex_config['use_vertex']:
    print(f"Using Vertex AI")
    print(f"Project: {vertex_config['project_id']}")
    print(f"Location: {vertex_config['location']}")
```

### Error Handling

If the API key is not found, the helper will:
- Print a clear error message
- Show all available methods to set the API key
- Provide the URL to obtain an API key
- Exit with status code 1

For Vertex AI, if `VERTEX_PROJECT_ID` is missing when `GEMINI_USE_VERTEX=true`, the helper will provide clear instructions.

This ensures users get immediate, actionable feedback when configuration is missing.

---

## File: .claude/skills/mcp-management/README.md

# MCP Management Skill

Intelligent management and execution of Model Context Protocol (MCP) servers.

## Overview

This skill enables Claude to discover, analyze, and execute MCP server capabilities without polluting the main context window. Perfect for context-efficient MCP integration using subagent-based architecture.

## Features

- **Multi-Server Management**: Connect to multiple MCP servers from single config
- **Intelligent Tool Discovery**: Analyze which tools are relevant for specific tasks
- **Progressive Disclosure**: Load only necessary tool definitions
- **Execution Engine**: Call MCP tools with proper parameter handling
- **Context Efficiency**: Delegate MCP operations to `mcp-manager` subagent

## Quick Start

### 1. Install Dependencies

```bash
cd .claude/skills/mcp-management/scripts
npm install
```

### 2. Configure MCP Servers

Create `.claude/.mcp.json`:

```json
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/allowed/path"]
    }
  }
}
```

See `.claude/.mcp.json.example` for more examples.

### 3. Test Connection

```bash
cd .claude/skills/mcp-management/scripts
npm run list-tools
# Or directly:
npx tsx cli.ts list-tools
```

**Note**: The CLI automatically looks for config at `~/.claude/.mcp.json`. You can run it from any directory.

## Usage Patterns

### Pattern 1: Discover Available Tools

```bash
cd .claude/skills/mcp-management/scripts
npm run list-tools
npm run list-prompts
npm run list-resources
# Or directly:
npx tsx cli.ts list-tools
npx tsx cli.ts list-prompts
npx tsx cli.ts list-resources
```

### Pattern 2: LLM-Driven Tool Selection

The LLM reads `assets/tools.json` and intelligently selects tools. No separate analysis command needed - the LLM's understanding of context and intent is superior to keyword matching.

### Pattern 3: Execute MCP Tools

```bash
npx tsx cli.ts call-tool memory add '{"key":"name","value":"Alice"}'
```

### Pattern 4: Use with Subagent

In main Claude conversation:

```
User: "I need to search the web and save results"
Main Agent: [Spawns mcp-manager subagent]
mcp-manager: Discovers brave-search + memory tools, reports back
Main Agent: Uses recommended tools for implementation
```

## Architecture

```
Main Agent (Claude)
    ↓ (delegates MCP tasks)
mcp-manager Subagent
    ↓ (uses skill)
mcp-management Skill
    ↓ (connects via)
MCP Servers (memory, filesystem, etc.)
```

**Benefits**:
- Main agent context stays clean
- MCP discovery happens in isolated subagent context
- Only relevant tool definitions loaded when needed
- Reduced token usage

## File Structure

```
mcp-management/
├── SKILL.md                    # Skill definition
├── README.md                   # This file
├── scripts/
│   ├── mcp-client.ts          # Core MCP client manager
│   ├── analyze-tools.ts       # Intelligent tool selection
│   ├── cli.ts                 # Command-line interface
│   ├── package.json           # Dependencies
│   ├── tsconfig.json          # TypeScript config
│   └── .env.example           # Environment template
└── references/
    ├── mcp-protocol.md        # MCP protocol reference
    └── configuration.md       # Config guide
```

## Scripts Reference

### mcp-client.ts

Core client manager class:
- Load config from `.claude/.mcp.json`
- Connect to multiple MCP servers
- List/execute tools, prompts, resources
- Lifecycle management

### cli.ts

Command-line interface:
- `list-tools` - Show all tools and save to assets/tools.json
- `list-prompts` - Show all prompts
- `list-resources` - Show all resources
- `call-tool <server> <tool> <json>` - Execute tool

**Note**: Tool analysis is performed by the LLM reading `assets/tools.json`, which provides better context understanding than algorithmic matching.

## Configuration

### Environment Variables

Scripts check for variables in this order:

1. `process.env` (runtime)
2. `.claude/skills/mcp-management/.env`
3. `.claude/skills/.env`
4. `.claude/.env`

### MCP Config Format

```json
{
  "mcpServers": {
    "server-name": {
      "command": "executable",          // Required
      "args": ["arg1", "arg2"],        // Required
      "env": {                          // Optional
        "VAR": "value",
        "API_KEY": "${ENV_VAR}"        // Reference env vars
      }
    }
  }
}
```

## Common MCP Servers

Install with `npx`:

- `@modelcontextprotocol/server-memory` - Key-value storage
- `@modelcontextprotocol/server-filesystem` - File operations
- `@modelcontextprotocol/server-brave-search` - Web search
- `@modelcontextprotocol/server-puppeteer` - Browser automation
- `@modelcontextprotocol/server-fetch` - HTTP requests

## Integration with mcp-manager Agent

The `mcp-manager` agent (`.claude/agents/mcp-manager.md`) uses this skill to:

1. **Discover**: Connect to MCP servers, list capabilities
2. **Analyze**: Filter relevant tools for tasks
3. **Execute**: Call MCP tools on behalf of main agent
4. **Report**: Send concise results back to main agent

This architecture keeps main context clean and enables efficient MCP integration.

## Troubleshooting

### "Config not found"

Ensure `.claude/.mcp.json` exists and is valid JSON.

### "Server connection failed"

Check:
- Server command is installed (`npx` packages installed?)
- Server args are correct
- Environment variables are set

### "Tool not found"

List available tools first:
```bash
cd .claude/skills/mcp-management/scripts
npm run list-tools
```

## Resources

- [MCP Specification](https://modelcontextprotocol.io/specification/latest)
- [MCP TypeScript SDK](https://github.com/modelcontextprotocol/typescript-sdk)
- [Official MCP Servers](https://github.com/modelcontextprotocol/servers)
- [Skill References](./references/)

## License

MIT

---

## File: .claude/skills/payment-integration/README.md

# Payment Integration Skill

Comprehensive payment integration skill for SePay (Vietnamese payment gateway), Polar (global SaaS monetization platform), and Stripe (global payment infrastructure).

## Features

### SePay Integration
- Vietnamese payment gateway with VietQR, NAPAS, bank transfers, and cards
- 44+ supported banks
- Webhook verification with API Key/OAuth2 authentication
- QR code generation API
- Order-based virtual accounts
- SDK support for Node.js, PHP, and Laravel

### Polar Integration
- Global SaaS monetization platform
- Merchant of Record (handles global tax compliance)
- Subscription management with trials, upgrades, downgrades
- Usage-based billing with events and meters
- Automated benefit delivery (GitHub repos, Discord roles, license keys, files)
- Customer self-service portal
- Multi-language SDKs (TypeScript, Python, PHP, Go)
- Framework adapters (Next.js, Laravel, Remix, etc.)

### Stripe Integration
- Global payment infrastructure
- CheckoutSessions, PaymentIntents, SetupIntents APIs
- Billing and subscriptions at scale
- Connect for marketplaces and platforms
- Payment Element for custom checkout experiences
- Multi-language SDKs (Node.js, Python, Ruby, PHP, Java, Go, .NET)
- Best practices for integration design and API version upgrades

## Structure

```
/* Detailed source-code truncated for AI context efficiency. */
```

## Usage

### Activate the Skill

Claude Code will automatically activate this skill when you mention payment integration, subscriptions, webhooks, or platform-specific terms (SePay, Polar).

### Manual Activation

In conversations, simply reference the platforms:
- "Implement SePay payment integration"
- "Set up Polar subscriptions with usage-based billing"
- "Create webhook handler for payment notifications"

### Using Scripts

**SePay Webhook Verification:**
```bash
cd $HOME/.claude/skills/payment-integration/scripts
node sepay-webhook-verify.js '{"id":12345,"gateway":"Vietcombank",...}'
```

**Polar Webhook Verification:**
```bash
node polar-webhook-verify.js '{"type":"order.paid","data":{...}}' base64secret
```

**Checkout Helper:**
```bash
# SePay
node checkout-helper.js sepay '{"orderInvoiceNumber":"ORD001","orderAmount":100000,...}'

# Polar
node checkout-helper.js polar '{"productPriceId":"price_xxx","successUrl":"https://..."}'
```

**Run Tests:**
```bash
npm test
```

## Environment Variables

Copy `.env.example` to `.env` and configure:

```env
# SePay
SEPAY_MERCHANT_ID=SP-TEST-XXXXXXX
SEPAY_SECRET_KEY=spsk_test_xxxxxxxxxxxxx
SEPAY_ENV=sandbox
SEPAY_WEBHOOK_API_KEY=your_key

# Polar
POLAR_ACCESS_TOKEN=polar_xxxxxxxxxxxxxxxx
POLAR_SERVER=sandbox
POLAR_WEBHOOK_SECRET=base64_secret
```

## Progressive Disclosure

The skill uses progressive disclosure to minimize context usage:
1. **SKILL.md** - Overview and quick reference (~99 lines)
2. **references/** - Detailed guides loaded as needed (<100 lines each)
3. **scripts/** - Executable helpers with embedded examples

Load only the references you need for your current task.

## Platform Selection Guide

**Choose SePay for:**
- Vietnamese market targeting
- Bank transfer automation
- Local payment methods
- QR code payments (VietQR/NAPAS)
- Direct bank monitoring

**Choose Polar for:**
- Global market
- SaaS/subscription business
- Usage-based billing
- Automated benefit delivery
- Tax compliance (Merchant of Record)
- Customer self-service

**Choose Stripe for:**
- Global payment infrastructure
- Enterprise-grade payment processing
- Connect platforms (marketplaces)
- Billing/subscriptions at scale
- Custom checkout experiences (Payment Element)
- Maximum payment method coverage

## Examples

### SePay Payment Flow
1. Load `references/sepay/overview.md` for authentication
2. Load `references/sepay/sdk.md` for integration
3. Use `checkout-helper.js` to generate payment form
4. Load `references/sepay/webhooks.md` for notifications
5. Use `sepay-webhook-verify.js` to verify authenticity

### Polar Subscription Flow
1. Load `references/polar/overview.md` for setup
2. Load `references/polar/products.md` for pricing
3. Load `references/polar/checkouts.md` for payment
4. Load `references/polar/subscriptions.md` for lifecycle
5. Load `references/polar/webhooks.md` for events
6. Load `references/polar/benefits.md` for automation

### Stripe Integration Flow
1. Load `references/stripe/stripe-best-practices.md` for integration design
2. Choose: Checkout (hosted/embedded) or Payment Element
3. Use CheckoutSessions API for most use cases
4. Load `references/stripe/stripe-upgrade.md` when upgrading API versions

## Testing

All scripts include comprehensive test coverage:
- SePay webhook verification (with/without authentication)
- Polar webhook signature validation
- Checkout configuration generation
- Error handling and edge cases

Run `npm test` in the scripts directory to verify functionality.

## Support

### SePay
- Docs: https://developer.sepay.vn/en
- Email: info@sepay.vn
- Hotline: 02873059589

### Polar
- Docs: https://polar.sh/docs
- API Reference: https://polar.sh/docs/api-reference
- GitHub: https://github.com/polarsource/polar

### Stripe
- Docs: https://docs.stripe.com
- API Reference: https://docs.stripe.com/api
- Changelog: https://docs.stripe.com/changelog
- Go Live Checklist: https://docs.stripe.com/get-started/checklist/go-live

## License

MIT

## Version

1.1.0

---

## File: .claude/skills/repomix/scripts/README.md

# Repomix Scripts

Utility scripts for batch processing repositories with Repomix.

## repomix_batch.py

Batch process multiple repositories (local or remote) using the repomix CLI tool.

### Features

- Process multiple repositories in one command
- Support local and remote repositories
- Configurable output formats (XML, Markdown, JSON, Plain)
- Environment variable loading from multiple .env file locations
- Comprehensive error handling
- Progress reporting

### Installation

Requires Python 3.10+ and repomix CLI:

```bash
# Install repomix
npm install repomix

# Install Python dependencies (if needed)
pip install pytest pytest-cov pytest-mock  # For running tests
```

### Usage

**Process single repository:**
```bash
python repomix_batch.py /path/to/repo
```

**Process multiple repositories:**
```bash
python repomix_batch.py /repo1 /repo2 /repo3
```

**Process remote repositories:**
```bash
python repomix_batch.py owner/repo1 owner/repo2 --remote
```

**From JSON file:**
```bash
python repomix_batch.py -f repos.json
```

**With options:**
```bash
python repomix_batch.py /repo1 /repo2 \
  --style markdown \
  --output-dir output \
  --remove-comments \
  --include "src/**/*.ts" \
  --ignore "tests/**" \
  --verbose
```

### Configuration File Format

Create `repos.json` with repository configurations:

```json
[
  {
    "path": "/path/to/local/repo",
    "output": "custom-output.xml"
  },
  {
    "path": "owner/repo",
    "remote": true
  },
  {
    "path": "https://github.com/owner/repo",
    "remote": true,
    "output": "repo-output.md"
  }
]
```

### Environment Variables

Loads .env files in order of precedence:
1. Process environment (highest priority)
2. `./repomix/.env` (skill-specific)
3. `./skills/.env` (skills directory)
4. `./.claude/.env` (lowest priority)

### Command Line Options

```
positional arguments:
  repos                  Repository paths or URLs to process

options:
  -h, --help            Show help message
  -f, --file FILE       JSON file containing repository configurations
  --style {xml,markdown,json,plain}
                        Output format (default: xml)
  -o, --output-dir DIR  Output directory (default: repomix-output)
  --remove-comments     Remove comments from source files
  --include PATTERN     Include pattern (glob)
  --ignore PATTERN      Ignore pattern (glob)
  --no-security-check   Disable security checks
  -v, --verbose         Verbose output
  --remote              Treat all repos as remote URLs
```

### Examples

**Process local repositories:**
```bash
python repomix_batch.py /path/to/repo1 /path/to/repo2 --style markdown
```

**Process remote repositories:**
```bash
python repomix_batch.py yamadashy/repomix facebook/react --remote
```

**Mixed configuration:**
```bash
python repomix_batch.py \
  /local/repo \
  --remote owner/remote-repo \
  -f additional-repos.json \
  --style json \
  --remove-comments
```

**TypeScript projects only:**
```bash
python repomix_batch.py /repo1 /repo2 \
  --include "**/*.ts,**/*.tsx" \
  --ignore "**/*.test.ts,dist/" \
  --remove-comments \
  --style markdown
```

### Testing

Run tests with coverage:

```bash
cd tests
pytest test_repomix_batch.py -v --cov=repomix_batch --cov-report=term-missing
```

Current coverage: 99%

### Exit Codes

- `0` - All repositories processed successfully
- `1` - One or more repositories failed or error occurred

### Troubleshooting

**repomix not found:**
```bash
npm install repomix
```

**Permission denied:**
```bash
chmod +x repomix_batch.py
```

**Timeout errors:**
- Default timeout: 5 minutes per repository
- Reduce scope with `--include` patterns
- Exclude large directories with `--ignore`

**No repositories specified:**
- Provide repository paths as arguments
- Or use `-f` flag with JSON config file

---

## File: .claude/skills/sequential-thinking/README.md

# Sequential Thinking Skill

Agent skill for systematic problem-solving through iterative reasoning with revision and branching capabilities.

## What This Skill Does

Enables Claude to break down complex problems into sequential thought steps, revise conclusions when needed, and explore alternative solution paths—all while maintaining context throughout the reasoning process.

## Installation

This skill requires the Sequential Thinking MCP server to be installed and configured in your Claude Desktop or Claude Code environment.

### Step 1: Install MCP Server

Choose one of the following methods:

#### NPX (Recommended)

Add to your `claude_desktop_config.json` or MCP settings:

```json
{
  "mcpServers": {
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    }
  }
}
```

#### Docker

```json
{
  "mcpServers": {
    "sequentialthinking": {
      "command": "docker",
      "args": ["run", "--rm", "-i", "mcp/sequentialthinking"]
    }
  }
}
```

### Step 2: Add Skill to Project

Copy this skill folder to your project's `.claude/skills/` directory:

```bash
cp -r sequential-thinking /path/to/your/project/.claude/skills/
```

### Step 3: Verify Installation

Restart Claude and check that the `mcp__reasoning__sequentialthinking` tool is available.

## Usage

Once installed, Claude will automatically use this skill when:
- Facing complex multi-step problems
- Needing to revise earlier conclusions
- Exploring alternative solution approaches
- Working through uncertain or evolving scopes

You can also explicitly request it:
```
"Let's think through this step-by-step using sequential thinking"
```

## Configuration

### Disable Logging (Optional)

To suppress thought information logging, set environment variable:

```json
{
  "mcpServers": {
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"],
      "env": {
        "DISABLE_THOUGHT_LOGGING": "true"
      }
    }
  }
}
```

## Skill Structure

```
sequential-thinking/
├── SKILL.md              # Main skill definition
├── README.md             # This file
└── references/
    ├── advanced.md       # Revision and branching patterns
    └── examples.md       # Real-world use cases
```

## When Claude Uses This Skill

The skill activates for:
- **Complex analysis**: Breaking down multi-faceted problems
- **Design decisions**: Exploring and comparing alternatives
- **Debugging**: Systematic investigation with course correction
- **Planning**: Multi-stage project planning with evolving scope
- **Architecture**: Evaluating trade-offs across approaches

## Learn More

- [MCP Sequential Thinking Server](https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking)
- [Model Context Protocol](https://modelcontextprotocol.io/)
- [Agent Skills Documentation](https://docs.claude.com/en/docs/agents-and-tools/agent-skills/overview.md)

## License

MIT

---

## File: .claude/skills/shopify/README.md

# Shopify API Research Documentation

This directory contains comprehensive research and analysis of various APIs for integration purposes.

## Contents

### Shopify GraphQL Admin API Analysis
**File:** `shopify-graphql-admin-api-analysis.md`  
**Date:** 2025-10-25  
**Status:** Complete  
**Thoroughness:** Very Thorough

A comprehensive analysis of Shopify's GraphQL Admin API covering:
- API overview and capabilities
- Key features and operations
- Common query and mutation patterns
- Best practices and optimization strategies
- Authentication and security considerations
- Rate limiting and performance optimization
- Typical use cases and implementation patterns
- Troubleshooting guide
- Code examples in multiple languages
- Resources and further learning

**Key Sections:**
1. Executive Summary
2. API Overview
3. Key Features
4. Common Operations (Queries & Mutations)
5. API Structure (Types, Connections, Errors)
6. Best Practices
7. Typical Use Cases
8. API Versions and Deprecation
9. Tools and SDKs
10. Security Considerations
11. Performance Optimization
12. Common Patterns
13. Troubleshooting
14. Resources and Further Learning

**Size:** 1,348 lines, ~26KB

---

## Usage

These documents are intended for:
- Development planning and architecture decisions
- Team onboarding and training
- Integration implementation reference
- Best practices guidance
- Troubleshooting support

---

## Maintenance

- Documents should be reviewed quarterly
- Update when API versions change
- Add new findings from implementation experience
- Keep code examples current with latest SDK versions

---

**Last Updated:** 2025-10-25  
**Maintained By:** Claude Code Engineering Team

---

## File: .claude/skills/README.md

# Skills
Skills are folders of instructions, scripts, and resources that Claude loads dynamically to improve performance on specialized tasks. Skills teach Claude how to complete specific tasks in a repeatable way, whether that's creating documents with your company's brand guidelines, analyzing data using your organization's specific workflows, or automating personal tasks.

For more information, check out:
- [What are skills?](https://support.claude.com/en/articles/12512176-what-are-skills)
- [Using skills in Claude](https://support.claude.com/en/articles/12512180-using-skills-in-claude)
- [How to create custom skills](https://support.claude.com/en/articles/12512198-creating-custom-skills)
- [Equipping agents for the real world with Agent Skills](https://anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills)

# About This Repository

This repository contains example skills that demonstrate what's possible with Claude's skills system. These examples range from creative applications (art, music, design) to technical tasks (testing web apps, MCP server generation) to enterprise workflows (communications, branding, etc.).

Each skill is self-contained in its own directory with a `SKILL.md` file containing the instructions and metadata that Claude uses. Browse through these examples to get inspiration for your own skills or to understand different patterns and approaches.

The example skills in this repo are open source (Apache 2.0). We've also included the document creation & editing skills that power [Claude's document capabilities](https://www.anthropic.com/news/create-files) under the hood in the [`document-skills/`](./document-skills/) folder. These are source-available, not open source, but we wanted to share these with developers as a reference for more complex skills that are actively used in a production AI application.

**Note:** These are reference examples for inspiration and learning. They showcase general-purpose capabilities rather than organization-specific workflows or sensitive content.

## Disclaimer

**These skills are provided for demonstration and educational purposes only.** While some of these capabilities may be available in Claude, the implementations and behaviors you receive from Claude may differ from what is shown in these examples. These examples are meant to illustrate patterns and possibilities. Always test skills thoroughly in your own environment before relying on them for critical tasks.

# Example Skills

This repository includes a diverse collection of example skills demonstrating different capabilities:

## Creative & Design
- **algorithmic-art** - Create generative art using p5.js with seeded randomness, flow fields, and particle systems
- **canvas-design** - Design beautiful visual art in .png and .pdf formats using design philosophies
- **slack-gif-creator** - Create animated GIFs optimized for Slack's size constraints

## Development & Technical
- **artifacts-builder** - Build complex claude.ai HTML artifacts using React, Tailwind CSS, and shadcn/ui components
- **mcp-server** - Guide for creating high-quality MCP servers to integrate external APIs and services
- **webapp-testing** - Test local web applications using Playwright for UI verification and debugging

## Enterprise & Communication
- **brand-guidelines** - Apply Anthropic's official brand colors and typography to artifacts
- **internal-comms** - Write internal communications like status reports, newsletters, and FAQs
- **theme-factory** - Style artifacts with 10 pre-set professional themes or generate custom themes on-the-fly

## Meta Skills
- **skill-creator** - Guide for creating effective skills that extend Claude's capabilities
- **template-skill** - A basic template to use as a starting point for new skills

# Document Skills

The `document-skills/` subdirectory contains skills that Anthropic developed to help Claude create various document file formats. These skills demonstrate advanced patterns for working with complex file formats and binary data:

- **docx** - Create, edit, and analyze Word documents with support for tracked changes, comments, formatting preservation, and text extraction
- **pdf** - Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms
- **pptx** - Create, edit, and analyze PowerPoint presentations with support for layouts, templates, charts, and automated slide generation
- **xlsx** - Create, edit, and analyze Excel spreadsheets with support for formulas, formatting, data analysis, and visualization

**Important Disclaimer:** These document skills are point-in-time snapshots and are not actively maintained or updated. Versions of these skills ship pre-included with Claude. They are primarily intended as reference examples to illustrate how Anthropic approaches developing more complex skills that work with binary file formats and document structures.

# Try in Claude Code, Claude.ai, and the API

## Claude Code
You can register this repository as a Claude Code Plugin marketplace by running the following command in Claude Code:
```
/plugin marketplace add anthropics/skills
```

After installing the plugin, you can use the skill by just mentioning it. For instance, if you install the document-skills plugin from the marketplace, you can ask Claude Code to do something like: "use the pdf skill to extract the form fields from path/to/some-file.pdf"

## Claude.ai

These example skills are all already available to paid plans in Claude.ai. 

To use any skill from this repository or upload custom skills, follow the instructions in [Using skills in Claude](https://support.claude.com/en/articles/12512180-using-skills-in-claude#h_a4222fa77b).

## Claude API

You can use Anthropic's pre-built skills, and upload custom skills, via the Claude API. See the [Skills API Quickstart](https://docs.claude.com/en/api/skills-guide#creating-a-skill) for more.

# Creating a Basic Skill

Skills are simple to create - just a folder with a `SKILL.md` file containing YAML frontmatter and instructions. You can use the **template-skill** in this repository as a starting point:

```markdown
---
name: my-skill-name
---

# My Skill Name

[Add your instructions here that Claude will follow when this skill is active]

## Examples
- Example usage 1
- Example usage 2

## Guidelines
- Guideline 1
- Guideline 2
```

The frontmatter requires only two fields:
- `name` - A unique identifier for your skill (lowercase, hyphens for spaces)
- `description` - A complete description of what the skill does and when to use it

The markdown content below contains the instructions, examples, and guidelines that Claude will follow. For more details, see [How to create custom skills](https://support.claude.com/en/articles/12512198-creating-custom-skills).

# Partner Skills

Skills are a great way to teach Claude how to get better at using specific pieces of software. As we see awesome example skills from partners, we may highlight some of them here:

- **Notion** - [Notion Skills for Claude](https://www.notion.so/notiondevs/Notion-Skills-for-Claude-28da4445d27180c7af1df7d8615723d0)

---

## File: docs/MARKETPLACE.md

# ClaudeKit Skills Marketplace

ClaudeKit Skills is now available as a **Claude Code Plugin Marketplace**, enabling seamless installation and automatic updates.

## Quick Start

### 1. Add Marketplace

```bash
/plugin marketplace add mrgoonie/claudekit-skills
```

### 2. Install Plugins

Install specific plugin categories based on your needs:

```bash
# AI & ML Tools
/plugin install ai-ml-tools@claudekit-skills

# Web Development
/plugin install web-dev-tools@claudekit-skills

# DevOps & Infrastructure
/plugin install devops-tools@claudekit-skills

# Backend Development
/plugin install backend-tools@claudekit-skills

# Document Processing
/plugin install document-processing@claudekit-skills

# Debugging Frameworks
/plugin install debugging-tools@claudekit-skills

# Problem Solving Techniques
/plugin install problem-solving-tools@claudekit-skills

# Platform Integrations
/plugin install platform-tools@claudekit-skills

# Meta Development
/plugin install meta-tools@claudekit-skills

# Media Processing
/plugin install media-tools@claudekit-skills

# Research Tools
/plugin install research-tools@claudekit-skills

# Specialized Skills
/plugin install specialized-tools@claudekit-skills
```

### 3. Update Plugins

```bash
# Update specific plugin
/plugin update ai-ml-tools@claudekit-skills

# Update all plugins
/plugin update --all
```

## Available Plugins

### 🤖 ai-ml-tools
**AI and ML capabilities with Google Gemini API integration**

**Includes:**
- `ai-multimodal` - Process images, videos, audio, and documents with Gemini API
- `google-adk-python` - Google's Agent Development Kit for building AI agents

**Dependencies:**
- Python 3.8+
- `google-genai`, `pypdf`, `python-docx`, `Pillow`
- Environment: `GEMINI_API_KEY`

---

### 🌐 web-dev-tools
**Comprehensive web development skills**

**Includes:**
- `frontend-development` - React/TypeScript patterns with Suspense, TanStack Router
- `frontend-design` - Production-grade UI/UX with creative, polished code
- `ui-styling` - shadcn/ui components with Tailwind CSS
- `web-frameworks` - Next.js App Router, Turborepo monorepos
- `aesthetic` - Design principles and visual hierarchy
- `web-testing` - Playwright, Vitest, k6 for E2E/unit/integration/load/security/a11y testing

**Dependencies:**
- Node.js 18+
- npm/pnpm/yarn
- Playwright (for E2E)
- k6 (for load testing)

---

### ☁️ devops-tools
**DevOps and infrastructure management**

**Includes:**
- `devops` - Cloudflare Workers, Docker, Google Cloud Platform
- `databases` - MongoDB and PostgreSQL administration
- `chrome-devtools` - Browser automation with Puppeteer

**Dependencies:**
- Docker (optional)
- Cloudflare Wrangler (optional)
- Google Cloud CLI (optional)
- PostgreSQL client (optional)
- MongoDB Shell (optional)

---

### 💻 backend-tools
**Backend development frameworks**

**Includes:**
- `backend-development` - Node.js, Python, Go, REST/GraphQL APIs
- `better-auth` - TypeScript authentication framework

**Dependencies:**
- Node.js 18+ (for better-auth)
- Python 3.8+ (for backend patterns)

---

### 📄 document-processing
**Document creation and processing**

**Includes:**
- `document-skills/docx` - Word documents with tracked changes
- `document-skills/pdf` - PDF extraction, creation, merging
- `document-skills/pptx` - PowerPoint presentations
- `document-skills/xlsx` - Excel spreadsheets and financial modeling

**Dependencies:**
- Python 3.8+
- `pypdf`, `python-docx`, `python-pptx`, `openpyxl`

---

### 🐛 debugging-tools
**Systematic debugging frameworks**

**Includes:**
- `debugging/defense-in-depth` - Multi-layer validation
- `debugging/root-cause-tracing` - Backward call stack analysis
- `debugging/systematic-debugging` - Four-phase debugging process
- `debugging/verification-before-completion` - Evidence-based completion

---

### 🧠 problem-solving-tools
**Advanced problem-solving techniques**

**Includes:**
- `problem-solving/collision-zone-thinking` - Force unrelated concepts together
- `problem-solving/inversion-exercise` - Flip core assumptions
- `problem-solving/meta-pattern-recognition` - Spot universal principles
- `problem-solving/scale-game` - Test at extremes
- `problem-solving/simplification-cascades` - Find eliminating insights
- `problem-solving/when-stuck` - Dispatch to right technique

---

### 🛍️ platform-tools
**Platform and payment integrations**

**Includes:**
- `shopify` - Build apps, extensions, and themes
- `payment-integration` - SePay (Vietnamese VietQR), Polar (SaaS MoR), Stripe, Paddle, Creem.io
- `mcp-management` - Manage MCP servers
- `mcp-builder` - Build MCP servers in Python/TypeScript

**Agents:**
- `mcp-manager` - MCP server management agent

**Commands:**
- `/use-mcp` - MCP integration command

**Dependencies:**
- Node.js 18+
- Shopify CLI (optional)
- Environment: `SEPAY_*`, `POLAR_*`, `STRIPE_*` (for payment integrations)

---

### 🔧 meta-tools
**Meta development tools**

**Includes:**
- `skill-creator` - Create new Claude Code skills
- `code-review` - Review workflows and quality gates

**Commands:**
- `/git/*` - Git workflow commands
- `/skill/*` - Skill management commands

---

### 🎬 media-tools
**Media processing capabilities**

**Includes:**
- `media-processing` - FFmpeg (video/audio) and ImageMagick (images)

**Dependencies:**
- FFmpeg
- ImageMagick

**Installation:**
```bash
# macOS
brew install ffmpeg imagemagick

# Ubuntu/Debian
sudo apt-get install ffmpeg imagemagick

# Windows
choco install ffmpeg imagemagick
```

---

### 📚 research-tools
**Research and documentation**

**Includes:**
- `docs-seeker` - llms.txt documentation discovery
- `repomix` - Package repositories for AI analysis

**Dependencies:**
- Node.js 18+ (for repomix)
- `repomix` CLI tool

---

### ⚡ specialized-tools
**Specialized capabilities**

**Includes:**
- `sequential-thinking` - Step-by-step reasoning with extended thinking
- `mermaidjs-v11` - Diagram generation (flowcharts, sequence, etc.)

---

## Auto-Enable in Projects

Add to your project's `.claude/settings.json`:

```json
{
  "extraKnownMarketplaces": {
    "claudekit-skills": {
      "source": {
        "source": "github",
        "repo": "mrgoonie/claudekit-skills"
      }
    }
  },
  "enabledPlugins": {
    "ai-ml-tools@claudekit-skills": true,
    "web-dev-tools@claudekit-skills": true,
    "devops-tools@claudekit-skills": true
  }
}
```

## Version Pinning

Pin to specific version for stability:

```json
{
  "extraKnownMarketplaces": {
    "claudekit-skills": {
      "source": {
        "source": "github",
        "repo": "mrgoonie/claudekit-skills",
        "ref": "v1.0.0"
      }
    }
  }
}
```

## Enterprise Configuration

Restrict to approved marketplaces in managed settings:

```json
{
  "strictKnownMarketplaces": [
    {
      "source": "github",
      "repo": "mrgoonie/claudekit-skills",
      "ref": "v1.0.0"
    }
  ]
}
```

## Manual Installation (Legacy)

For users who prefer manual installation:

```bash
git clone https://github.com/mrgoonie/claudekit-skills
cp -r claudekit-skills/.claude/* /path/to/your/project/.claude/
```

**Note:** Manual installation is deprecated. Marketplace installation is recommended for automatic updates and version management.

## Troubleshooting

### Plugin Not Found

```bash
# Refresh marketplace
/plugin marketplace remove claudekit-skills
/plugin marketplace add mrgoonie/claudekit-skills
```

### Update Not Working

```bash
# Force update
/plugin uninstall ai-ml-tools@claudekit-skills
/plugin install ai-ml-tools@claudekit-skills
```

### Dependencies Missing

Each plugin documents its dependencies. Install required system tools and Python packages as needed. See [INSTALLATION.md](../INSTALLATION.md) for detailed dependency installation instructions.

## Support

- **GitHub Issues:** https://github.com/mrgoonie/claudekit-skills/issues
- **Documentation:** https://claudekit.cc
- **Substack:** https://faafospecialist.substack.com/

## License

MIT License - see [LICENSE](../LICENSE) for details.