
Expert knowledge for CSS/JS-based 3D animations - perspective transforms, depth effects, card flips, cube rotations, and parallax depth without WebGL.
Patterns from "Agentic Design Patterns" (Gulli & Sauco, 2025) applied to web animation composition, performance optimization, and multi-library orchestration for React and TypeScript.
Expert knowledge for creating stunning animated backgrounds - gradient flows, particle systems, mesh gradients, aurora effects, wave patterns, and dynamic textures that bring depth and life to your interfaces.
This skill should be used when the user asks to "configure Harness delegates", "set up Harness RBAC", "manage connectors/secrets/templates", "apply OPA policy as code", or "review audit logs" — Harness platform administration and governance.
Expert knowledge for GSAP (GreenSock Animation Platform) - the industry-standard JavaScript animation library for professional-grade animations with precise timeline control.
Expert knowledge for creative text animations - typewriter effects, character-by-character reveals, kinetic typography, split text animations, and expressive text motion.
Documentation intelligence engine with graph-based API docs, algorithm library, and drift detection
Expert knowledge for SVG path animations, morphing shapes, and vector graphics effects that create stunning visual experiences with resolution-independent graphics.
Patterns from "Agentic Design Patterns" (Gulli & Sauco, 2025) applied to enterprise team development, DevOps tooling, and multi-cloud workflow automation
Expert knowledge for decorative accent animations - floating shapes, glowing orbs, animated borders, sparkle effects, and embellishments that add visual polish and delight to interfaces.
Expert knowledge for physics-based spring animations - natural, organic motion that follows real-world physics principles for delightful user experiences.
Deploy and integrate local LLMs with Ollama, LocalAI, and Home Assistant for privacy-focused voice assistants and automation.
Patterns from "Agentic Design Patterns" (Gulli & Sauco, 2025) applied to enterprise Microsoft ecosystem orchestration for multi-entity, multi-tenant deployment
Automation YAML patterns, triggers, conditions, actions, and best practices for Home Assistant.
Patterns from "Agentic Design Patterns" (Gulli & Sauco, 2025) applied to plugin marketplace orchestration and agent-as-tool composition
Enhanced plan-authoring skill with Pre-Writing context gathering, task metadata, non-TDD templates, Red Flags, telemetry, and an automated plan linter. Use when you have a spec or requirements for a multi-step task, before touching code.
Patterns from "Agentic Design Patterns" (Gulli & Sauco, 2025) applied to AI-powered codebase upgrade intelligence
Expert knowledge for artistic and creative animation effects - morphing shapes, liquid animations, glitch effects, distortion, and experimental visual techniques that push creative boundaries.
Expert knowledge for Framer Motion - the production-ready motion library for React. This skill enables declarative animations, gesture recognition, and layout animations with optimal performance.
Expert knowledge for scroll-triggered animations, parallax effects, and scroll-linked interactions that create immersive storytelling experiences.
Patterns from "Agentic Design Patterns" (Gulli & Sauco, 2025) applied to design token management, component scaffolding, multi-tenant theming, and accessibility-compliant UI generation.
Patterns from "Agentic Design Patterns" (Gulli & Sauco, 2025) applied to universal project templating and scaffold automation
Patterns from "Agentic Design Patterns" (Gulli & Sauco, 2025) applied to AI-powered diagram generation and multi-platform embedding
Patterns from "Agentic Design Patterns" (Gulli & Sauco, 2025) applied to CD orchestration and state-machine deployment workflows
Design, install, and debug Claude Code hooks across the full lifecycle (PreToolUse, PostToolUse, PostToolUseFailure, UserPromptSubmit, Notification, Stop, SessionStart, SessionEnd, PreCompact, SubagentStart, SubagentStop, TeammateIdle, PermissionRequest, Setup). Use this skill whenever a user asks to "install hooks", "add a pre-tool hook", "format on save", "block dangerous commands", "protect sensitive files", "restore context after compact", "enforce tests before stop", capture subagent telemetry, or runs /cc-hooks. Also triggers on "hooks not firing", "hook keeps blocking", or any configuration of .claude/settings.json hook sections.
Patterns from "Agentic Design Patterns" (Gulli & Sauco, 2025) applied to async Python API development, MongoDB/Beanie data modeling, and production-ready backend services
Ultraplan cloud planning — kick off a plan in the cloud from your terminal, review and revise in the browser, then execute remotely or send back to CLI
Patterns from "Agentic Design Patterns" (Gulli & Sauco, 2025) applied to executive director automation for trade associations and nonprofits
This skill should be used when the user asks to "deploy with Harness", "set up Harness CD", "configure a canary/blue-green/rolling deployment", "add approval gates", or "roll back a deployment" — Kubernetes, Helm, Terraform, ECS, and serverless delivery via Harness.
This skill should be used when the user asks to "enrich a task", "add task details", "analyze requirements", "add context to an issue", "expand a ticket", or "estimate complexity" — enriching Jira issues with requirements, dependencies, and technical context.
This skill should be used when the user asks to "review code", "check changes", "analyze a PR", "do a security review", or "assess code quality" — providing comprehensive review across correctness, security, performance, accessibility, and testing.
This skill should be used when the user asks to "set up Harness CI", "build a CI pipeline", "configure test intelligence", or "cache/parallelize builds" — container-native build infrastructure on Harness.
--- name: mcp description: Configure MCP servers for Claude Code — stdio vs HTTP, authentication, Tools/Resources/Prompts distinction, channels (CI webhook, mobile relay, Discord bridge, fakechat), and cost of always-loaded tools. Use this skill whenever adding an MCP server, debugging connection issues, choosing between MCP Tools vs Prompts vs Resources, installing channel servers, or managing .mcp.json. Triggers on: "MCP server", "mcp config", "add Obsidian MCP", "install context7", "channels"
Advanced Lovelace dashboard patterns for Home Assistant.
Comprehensive knowledge for interactive setup and validation of the AWS EKS + Helm + Keycloak + Harness ecosystem.
Patterns from "Agentic Design Patterns" (Gulli & Sauco, 2025) applied to cloud-native Kubernetes infrastructure, authentication, and CI/CD orchestration.
--- name: agent-teams description: Select and coordinate multi-agent teams (topology kits, role-based squads, lifecycle, worktree isolation). Use this skill whenever launching parallel agents, designing a review board, running a debug council, scheduling an orchestrator-workers team, configuring agent tool restrictions, or deciding between solo and team execution. Triggers on: "launch a team", "parallel agents", "review board", "debug council", "architect-implementer-reviewer", "swarm", "multi-a
Home Assistant camera integration and Frigate NVR patterns.
Patterns from "Agentic Design Patterns" (Gulli & Sauco, 2025) applied to smart home automation and IoT orchestration
Syncfusion Blazor component library with DataGrid, Charts, Scheduler, PDF, and 80+ components
--- name: model-routing description: Pick the right Claude model (Opus, Sonnet, Haiku) for a task and manage cost — decision matrix, cost tables, budget planning, cascading strategy. Use this skill whenever choosing a model, setting a token budget, optimizing session cost, or deciding whether to upgrade/downgrade mid-task. Triggers on: "which model", "cost", "budget", "haiku vs sonnet", "opus for this", "save tokens", "model cascading", "/cc-budget". --- # Model Routing Claude model choice is
Home Assistant energy monitoring and optimization patterns.
Deploy and manage Home Assistant on Ubuntu servers with Docker, security hardening, and complementary services.
Knowledge for launching, managing, and monitoring cowork sessions that orchestrate multiple plugin agents in parallel
Core Home Assistant API integration patterns, authentication, and entity management.
This skill should be used when the user asks about "agentic design patterns", "multi-agent orchestration patterns", "routing/planning/reflection patterns", "the blackboard pattern", "coordinator-of-coordinators", or "saga/circuit-breaker for agents", or needs to apply agentic design patterns to Jira workflow orchestration and the 81-agent hierarchy.
This skill should be used when the user asks to "create a Confluence page", "write documentation", "write a TDD", "create an ADR", "write a runbook", or "publish to Confluence" — authoring and linking technical documentation in Confluence from Jira work.
This skill should be used when the user asks to "run a Harness pipeline", "trigger a deployment pipeline", "monitor a Harness execution", or "check pipeline status" — executing and watching Harness pipelines with Jira integration.
This skill should be used when the user asks to "use the Harness MCP", "connect Harness to Jira", "manage Harness pipelines/repos/PRs from AI", or "sync Jira to Harness" — AI-driven Harness CD operations and Git/PR automation.
Patterns from "Agentic Design Patterns" (Gulli & Sauco, 2025) applied to multi-tenant MERN platform management and Keycloak orchestration
Home Assistant sensor configuration and analytics patterns.
This skill should be used when the user asks to "apply clean architecture", "follow SOLID principles", "add dependency injection", "separate layers", "use hexagonal/onion architecture", "domain-driven design", or needs guidance on structuring code into clean, testable, decoupled layers.
This skill should be used when the user asks to "create a PR", "open a pull request", "merge changes", "set up a git/PR workflow", or "request review" — creating, managing, and merging pull requests linked to Jira issues.
Patterns from "Agentic Design Patterns" (Gulli & Sauco, 2025) applied to plugin marketplace architecture — federated registry, supply chain security, intent-based composition, and trust-scored plugin discovery.
Expert knowledge for pure CSS animations - lightweight, performant animations using CSS keyframes, transitions, and modern CSS features without JavaScript dependencies.
This skill should be used when uploading files to Linear, linking external URLs as attachments, or downloading existing attachments with auth. Activates on "linear attachment", "linear file upload", "fileUpload mutation", "attachmentLinkCreate".
This skill should be used when writing or reviewing GraphQL queries against the Linear API — selecting fragments, navigating connection types, batching, and avoiding deprecated fields. Activates on "linear graphql", "linear query", "linear api", "linear schema".
This skill should be used when building or registering an agent that operates inside Linear — agent signals, agent interaction, OAuth actor mode, AIG (Agent Intelligence Gateway). Activates on "linear agent", "agent signal", "agent interaction", "linear aig", "agents in linear".
This skill should be used when implementing Linear OAuth 2.0, OAuth actor authorization, or file-storage authentication. Activates on "linear oauth", "linear auth", "actor token", "linear-actor-token", "file storage".
This skill should be used when fetching large result sets from Linear — cursor pagination, filter DSL, sorting, and complexity budgeting. Activates on "linear pagination", "linear filter", "linear cursor", "linear filtering".
This skill should be used when registering, verifying, or processing Linear webhooks — HMAC signatures, replay protection, idempotency, dead-letter queues. Activates on "linear webhook", "webhook signature", "Linear-Signature", "webhook secret".
This skill should be used when implementing or debugging two-way sync between Linear issues and Microsoft Planner via Microsoft Graph delta queries. Activates on "planner sync", "planner bridge", "microsoft planner", "graph delta", "tasks.readwrite".
This skill should be used when implementing or debugging two-way sync between Linear issues and Harness Code (branches, PRs, deploys, Git Experience, custom approvals, triggers). Activates on "harness sync", "harness bridge", "linear-harness", "harness code linear".
This skill should be used when designing bulk operations against Linear — complexity budgets, exponential backoff, request pacing, and avoiding 429s. Activates on "linear rate limit", "linear 429", "linear throttle", "complexity budget".
This skill should be used when implementing Linear integrations using the official @linear/sdk — creating issues programmatically, advanced fetch/modify patterns, error handling, and type safety. Activates on "linear sdk", "@linear/sdk", "linear client", "linear typescript".
Evidence-driven deep analysis for hard coding problems — architecture decisions, root-cause investigation, high-stakes refactor planning, performance bottleneck isolation. Use this skill whenever the user asks for "the best approach", a "deep analysis", "root cause", "principal engineer review", or runs /cc-intel. Also triggers on hard debugging questions, major architectural choices, tricky performance problems, or any task where a hypothesis tree and evidence table matter more than a fast answer.
Generate TRID Loan Estimate and Closing Disclosure timing and accuracy specifications. Use when designing the disclosure workflow for a mortgage lender or broker to ensure TRID compliance.
Intelligent model selection for Claude Code — decision matrices, cost tables, budget planning, and subagent model assignment for optimal cost/quality tradeoffs
Evidence-driven workflow for hard coding problems, architecture decisions, root-cause analysis, and high-stakes implementation planning in Claude Code
Enterprise-grade security patterns for Claude Code — audit logging, compliance frameworks, secrets management, permission hardening, network security, and managed settings enforcement
# Claude Code Extended Thinking Complete guide to extended thinking modes and thinking budget configuration. ## Overview Extended thinking (also called "ultrathink") allows Claude to perform deeper reasoning before responding. This uses additional tokens for internal reasoning that improves quality on complex tasks. ## Thinking Modes ### Trigger Phrases (CLI) Use these phrases in your prompts to activate thinking levels: | Phrase | Thinking Tokens | Approx Cost | |--------|----------------
Design E&O (Errors and Omissions) exposure tracking and mitigation workflows for insurance agencies. Use when building systems to document client interactions, track coverage recommendations, and reduce E&O liability exposure.
Define time-based escalation paths when approvals stall or SLAs breach. Use when configuring automatic escalation for insurance underwriting queues, loan processing pipelines, or compliance review workflows.
# Claude Code Git Integration Complete guide to Git workflows and version control within Claude Code. ## Git Awareness Claude Code automatically detects Git repositories and understands: - Current branch and status - Uncommitted changes (staged and unstaged) - Recent commit history - Remote tracking branches - Merge conflicts ## Commit Workflow ### Claude's Commit Protocol When asked to commit, Claude follows this exact workflow: 1. **Inspect state** (parallel): - `git status` — see unt
Universal Harness Code + CI/CD + Pipeline automation patterns. Uses mcp__harness__* tools when available; falls back to hc CLI. Invoke for pipeline ops, PR workflow, deployment, feature flags, GitOps, IaCM, or when user says "harness", "pipeline", "run ci", "deploy".
Security-hardened hook script implementations — ready-to-paste templates for security-guard, auto-format, inject-context, session-init, on-stop, and lessons-learned-capture
Security-hardened hook script implementations — ready-to-paste templates for security-guard, auto-format, inject-context, session-init, on-stop, and lessons-learned-capture
# Claude Code IDE Integrations Complete guide to using Claude Code with VS Code, JetBrains, and terminal editors. ## VS Code Extension ### Installation 1. Open VS Code Extensions (Ctrl+Shift+X / Cmd+Shift+X) 2. Search for "Claude Code" 3. Install the official Anthropic extension 4. Or: `code --install-extension anthropic.claude-code` ### Features - **Inline chat** — Ask Claude about selected code - **Terminal integration** — Claude Code runs in VS Code terminal - **File context** — Automatic
# Claude Code IDE Integrations Complete guide to using Claude Code with VS Code, JetBrains, and terminal editors. ## VS Code Extension ### Installation 1. Open VS Code Extensions (Ctrl+Shift+X / Cmd+Shift+X) 2. Search for "Claude Code" 3. Install the official Anthropic extension 4. Or: `code --install-extension anthropic.claude-code` ### Features - **Inline chat** — Ask Claude about selected code - **Terminal integration** — Claude Code runs in VS Code terminal - **File context** — Automatic
Validate insurance agency workflows against state insurance department requirements and NAIC model laws. Use when designing a workflow for a new state market or when conducting a compliance review of existing agency operations.
Design integration test plans with mock, contract, and end-to-end testing specifications to validate API integrations before go-live and after changes.
Define KPI frameworks with targets, thresholds, calculation methods, and business owners for insurance and financial services executive dashboards and operational reporting.
Design loan origination pipeline tracking and status workflow specifications for mortgage brokers and lenders. Use when automating loan status tracking, milestone notifications, or pipeline reporting for a mortgage operation.
LSP server detection, installation, and Claude Code integration — auto-invoke when setting up a new project, running /cc-setup, or configuring IDE tooling
Design Microsoft 365 audit log query specifications and compliance reporting for FINRA, state insurance examiner, and internal audit requirements in financial services tenants.
# MCP Servers in Claude Code Complete guide to Model Context Protocol server configuration and usage. ## Overview MCP (Model Context Protocol) allows Claude Code to connect to external servers that provide additional tools, resources, and capabilities. Supports 300+ external tools and services. ## Transport Types | Transport | Description | Recommended | |-----------|-------------|-------------| | `http` | HTTP-based (streamable) | Yes (recommended) | | `sse` | Server-Sent Events | Deprecat
Monitor tool for streaming background process events into conversations — tail logs, watch CI, auto-fix dev server crashes, and /loop self-pacing without Bash sleep loops
Validate mortgage workflows against RESPA, TRID, HMDA, QM/ATR, ECOA, and FCRA requirements. Use when designing a new mortgage workflow for compliance review or auditing an existing process for regulatory gaps.
Build email and Microsoft Teams notification templates for workflow events. Use when creating approval request notifications, escalation alerts, SLA breach warnings, or workflow completion confirmations.
Design OneDrive for Business folder structure and governance policy specifications to ensure consistent file organization, security, and compliance for financial services firms.
Design AI extraction configurations for structured and semi-structured insurance and mortgage PDFs. Use when configuring a document AI model to extract data fields from applications, policy documents, EOBs, pay stubs, tax returns, or bank statements.
# Claude Code Permissions & Security Complete reference for the permission model and security features. ## Permission Modes Claude Code operates in one of several permission modes: ### Default Mode (`default`) - Prompts on first use of each tool type - User approves/denies each tool call - Safest mode for general use ### Accept Edits Mode (`acceptEdits`) - Auto-approves file edits (Read, Write, Edit) - Still asks for Bash commands and other tools - Good balance for code-focused work ### Pl
Design producer and independent agent self-service portal specifications for insurance agencies. Use when building or specifying a portal where agents can submit business, check policy status, download documents, and track commissions.
Design webhook event routing, payload validation, and retry logic for real-time event-driven integrations where source systems push policy changes, loan status updates, or payment events.
# Claude Code Context Management Complete guide to managing context window, compression, and conversation flow. ## Context Window Overview Claude Code manages a conversation context window that accumulates messages, tool calls, and results throughout a session. ### Context Limits - The context window has a fixed token limit based on the model - Claude Code automatically warns when approaching limits - Auto-compact triggers when threshold is reached (configurable) ### Configuration ```json
Workflow packs for the 7 most common Claude Code tasks — codebase exploration, bug fixing, safe refactoring, TDD, repo review before merge, CLAUDE.md generation, and migration planning. Each pack has a start prompt, verification steps, subagent opportunities, failure modes, and completion checklist.
# Research Tool Routing Optimal routing of research tasks across Perplexity MCP, Firecrawl MCP, and Context7 MCP. Each tool has distinct strengths — use the right one for each job. ## Tool Strengths at a Glance | Tool | Best For | Cost | Speed | |------|----------|------|-------| | **Context7** | Library/framework docs, API reference | Free | Fast (cached <5ms) | | **Perplexity Ask** | Knowledge Q&A, current events, fact-checking | ~$0.02/query | Fast | | **Perplexity Research** | Deep invest
# Context Anchoring System Preserve critical information across `/compact` events, session boundaries, and agent handoffs. Context anchoring ensures your most important rules, decisions, and state survive compression. ## What Survives Compaction ``` ┌─────────────────────────────────────────────────┐ │ ANCHORED (survives /compact) │ │ │ │ CLAUDE.md ← Full file, re-injected │ │ .claude/rules/* ← All matching ru
# Agent Lifecycle Management Complete guide to managing sub-agent and teammate lifecycle in Claude Code — health checks, idle detection, cleanup, retention, and the mandatory audit loop. ## The Orchestration-First Principle Claude should **prefer to orchestrate** rather than do work directly. When a task has multiple components or would benefit from specialized review: 1. Break the task into work units 2. Assign each to the best-fit agent type 3. Run agents in parallel where possible 4. Audi
# Claude Code Permissions & Security Complete reference for the permission model and security features. ## Permission Modes Claude Code operates in one of several permission modes: ### Default Mode (`default`) - Prompts on first use of each tool type - User approves/denies each tool call - Safest mode for general use ### Accept Edits Mode (`acceptEdits`) - Auto-approves file edits (Read, Write, Edit) - Still asks for Bash commands and other tools - Good balance for code-focused work ### Pl
Plan schema or API migrations safely with rollback strategies
Shared filesystem-backed blackboard for multi-agent runs. Parallel subagents append findings for a given run-id; subsequent-round subagents read them via MCP tools without the orchestrator having to paste everything into their prompts. Use for any fan-out pattern with more than one round of deliberation.
# Claude Code Troubleshooting & Debugger Complete guide to diagnosing, debugging, and fixing Claude Code setup and runtime issues. ## Quick Diagnostics ### /doctor Command ``` /doctor ``` Runs automated health checks: - API key validation - Network connectivity - CLI version check - MCP server status - Configuration validation - Node.js version check ### Verbose Mode ```bash claude --verbose ``` Shows detailed debug output including: - API calls and responses - MCP server communication - Too
# Claude Code Settings Deep Dive Complete reference for every settings option, configuration key, and customization. ## Settings File Locations | Location | Scope | Git Tracked | |----------|-------|-------------| | Managed (system-level) | Organization | `/Library/...` (macOS), `/etc/claude-code/` (Linux), `C:\Program Files\...` (Win) | | `~/.claude/settings.json` | User (all projects) | N/A | | `.claude/settings.json` | Project (shared) | Yes | | `.claude/settings.local.json` | Project (per
Complete guide to building Claude Code plugins — manifest schema, command/skill/agent/hook authoring, MCP server development, marketplace publishing, and testing
# Claude Code Memory & Instructions System Complete guide to CLAUDE.md, project instructions, auto-memory, and rules. ## CLAUDE.md — Project Instructions ### Purpose CLAUDE.md files contain natural-language instructions that Claude Code loads as system context. They tell Claude about your project's conventions, build commands, architecture, and preferences. ### Hierarchy (All Additive) ``` Enterprise/Managed CLAUDE.md (highest priority, cannot be overridden) └── User ~/.claude/CLAUDE.
Hook policy engine with 8 installable packs for safety, verification, context recovery, and teammate quality gates
# Claude Code Cost Optimization Complete guide to managing costs, model routing, token usage, and caching. ## Cost Tracking ### /cost Command ``` /cost ``` Shows: - Input tokens consumed - Output tokens consumed - Cache read tokens (cheaper) - Cache write tokens - Total estimated cost (USD) ## Model Selection & Routing ### Available Models | Model | ID | Best For | Cost | |-------|-----|---------|------| | Opus 4.6 | `claude-opus-4-6` | Architecture, complex decisions | Highest | | Sonnet 4
# Claude Agent SDK Complete guide to the Claude Agent SDK for building custom AI agents. ## Overview The Claude Agent SDK allows you to programmatically spawn and control Claude Code sessions from TypeScript/JavaScript or Python applications. ## Installation ### TypeScript/JavaScript ```bash npm install @anthropic-ai/claude-agent-sdk # or pnpm add @anthropic-ai/claude-agent-sdk ``` ### Python ```bash # Using uv (recommended) uv init && uv add claude-agent-sdk # Using pip python3 -m venv .
# Claude Code Testing Workflows Complete guide to testing patterns, TDD, and test execution within Claude Code. ## Test Execution ### Running Tests ```bash # Common test commands npm test pnpm test yarn test bun test pytest go test ./... cargo test # Single test file npm test -- path/to/test.ts pytest path/to/test.py # Pattern matching npm test -- --grep "authentication" pytest -k "test_auth" # Watch mode npm test -- --watch pytest --watch ``` ### Claude's Testing Protocol 1. **Before co
# Scheduled Tasks > Use `/loop` and cron scheduling tools to run prompts repeatedly, poll for status, or set one-time reminders within a Claude Code session. > Requires Claude Code v2.1.72+. ## Overview Scheduled tasks let Claude re-run a prompt automatically on an interval. Use them to: - Poll a deployment status - Babysit a PR review cycle - Check on a long-running build - Set reminders during a session Tasks are **session-scoped**: they live in the current process and are gone when you ex
# Claude Code Memory & Instructions System Complete guide to CLAUDE.md, project instructions, auto-memory, and rules. ## CLAUDE.md — Project Instructions ### Purpose CLAUDE.md files contain natural-language instructions that Claude Code loads as system context. They tell Claude about your project's conventions, build commands, architecture, and preferences. ### Hierarchy (All Additive) ``` Enterprise/Managed CLAUDE.md (highest priority, cannot be overridden) └── User ~/.claude/CLAUDE.
Evidence-driven workflow for hard coding problems, architecture decisions, root-cause analysis, and high-stakes implementation planning in Claude Code
# Claude Code Context Management Complete guide to managing context window, compression, and conversation flow. ## Context Window Overview Claude Code manages a conversation context window that accumulates messages, tool calls, and results throughout a session. ### Context Limits - The context window has a fixed token limit based on the model - Claude Code automatically warns when approaching limits - Auto-compact triggers when threshold is reached (configurable) ### Configuration ```json
Computer use and GUI automation patterns — when to use GUI automation vs shell/MCP/browser tools, visual validation techniques, native app testing, and guardrails for visual regression workflows
# Checkpointing > Track, rewind, and summarize Claude's edits and conversation to manage session state. > Built-in feature — no configuration required. ## Overview Claude Code automatically tracks file edits as you work, allowing you to quickly undo changes and rewind to previous states. This safety net lets you pursue ambitious, wide-scale tasks knowing you can always return to a prior code state. ## How Checkpoints Work ### Automatic Tracking - Every user prompt creates a new checkpoint -
# Channels User Guide > Push events into a running Claude Code session with channels. > Forward CI results, chat messages, monitoring alerts, and webhook events so Claude can react while you're away. > Requires Claude Code v2.1.80+. Research preview — requires claude.ai login. ## Overview A channel is an MCP server that pushes events into your running Claude Code session, so Claude can react to things that happen while you're not at the terminal. Channels can be two-way: Claude reads the even
Production-ready channel server implementations — CI webhook receiver, mobile approval relay, Discord/Telegram bridge, and local fakechat dev profile. Copy-paste starter code with sender allowlists, permission relay, and security hardening.
Runtime behavior specs for the four autonomy profiles, the three autonomy agents (planner, verifier, reviewer), memory integration, context survival, and anti-patterns. Activate this skill to run the autonomy system — not just to read about it.
# Agent Teams > Orchestrate teams of Claude Code sessions working together with shared tasks, inter-agent messaging, and centralized management. > Experimental feature — requires `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` environment variable. > Requires Claude Code v2.1.32+. ## Overview Agent teams let you coordinate multiple Claude Code instances working together. One session acts as the **team lead**, coordinating work, assigning tasks, and synthesizing results. Teammates work independently, e
# Agent Lifecycle Management Complete guide to managing sub-agent and teammate lifecycle in Claude Code — health checks, idle detection, cleanup, retention, and the mandatory audit loop. ## The Orchestration-First Principle Claude should **prefer to orchestrate** rather than do work directly. When a task has multiple components or would benefit from specialized review: 1. Break the task into work units 2. Assign each to the best-fit agent type 3. Run agents in parallel where possible 4. Audi
Deploy or audit the full 5-layer Claude Code stack (CLAUDE.md + skills + hooks + agents + memory) in a repository. Use this skill whenever the user runs /cc-setup, asks to "set up Claude Code on this repo", "configure a new repo for Claude", "audit my Claude Code setup", "generate CLAUDE.md", "install hooks", "wire up the 4-layer stack", or starts work in a repo that lacks .claude/. Also triggers on "bootstrap Claude Code", "add claude setup", or whenever a fresh repo needs Claude Code configuration.
--- name: plugin-development description: Build, validate, and publish Claude Code plugins — manifest schema, skill/command/agent/hook authoring, MCP server integration, marketplace publishing, version management. Use this skill whenever creating a new plugin, adding a skill/command/agent to an existing plugin, validating plugin.json, debugging plugin load failures, or publishing to a marketplace. Triggers on: "create plugin", "plugin.json", "add skill to plugin", "publish plugin", "plugin valid
Complete guide to building Claude Code plugins — manifest schema, command/skill/agent/hook authoring, MCP server development, marketplace publishing, and testing
Design policy submission, underwriting review, and issuance workflows for insurance agencies and MGAs. Use when automating new business intake, quote-to-bind processes, or policy change endorsement workflows.
Conduct a post-go-live assessment and identify optimization opportunities for a completed automation engagement. Use 30-60 days after an automation launch to validate outcomes, capture lessons learned, and identify expansion opportunities.
Design Power Automate flow specifications for business process automation including approvals, document routing, notifications, and M365 system synchronization.
Decomposing projects into granular micro-tasks using 5-level hierarchy and INVEST principles
Interview-driven project setup that generates complete Claude Code configuration
Interview-driven project setup that generates complete Claude Code configuration
Project sync and configuration propagation — auto-invoke when running /cc-sync or updating Claude Code setup across repos
--- name: prompt-engineering description: Craft effective CLAUDE.md routing, agent system prompts, skill descriptions, rule files, and task framings. Use this skill whenever writing a CLAUDE.md, authoring a subagent, writing a skill description, crafting a /command prompt, framing an ambiguous task for Claude, or debugging why Claude isn't picking up guidance. Triggers on: "write a CLAUDE.md", "agent prompt", "skill description", "pushy description", "task framing", "claude isn't following", "ma
Crafting effective prompts, CLAUDE.md instructions, rules, agent system prompts, and skill bodies for optimal Claude Code behavior
Crafting effective prompts, CLAUDE.md instructions, rules, agent system prompts, and skill bodies for optimal Claude Code behavior
Validating task completion against acceptance criteria with per-type automated checks
Design Power BI dataset refresh scheduling, on-premises gateway configuration, and failure alerting to ensure dashboards display current data for operational decision-making.
Map business processes to specific regulatory requirements and identify compliance obligations. Use when onboarding a new insurance or financial services client, assessing impact of a regulatory change, or designing a compliance program for a new product line.
Generate changelog entries from diffs and PRs
Design automated renewal workflows with retention scoring and proactive outreach sequences. Use when building renewal automation for insurance agencies to reduce lapse rates and improve client retention.
Design automated Power BI report distribution workflows via email and Microsoft Teams for scheduled delivery to executives and operational managers who do not log into Power BI directly.
Deep research before task execution using 4-source protocol: codebase→Perplexity→Context7→Firecrawl
# Research Tool Routing Optimal routing of research tasks across Perplexity MCP, Firecrawl MCP, and Context7 MCP. Each tool has distinct strengths — use the right one for each job. ## Tool Strengths at a Glance | Tool | Best For | Cost | Speed | |------|----------|------|-------| | **Context7** | Library/framework docs, API reference | Free | Fast (cached <5ms) | | **Perplexity Ask** | Knowledge Q&A, current events, fact-checking | ~$0.02/query | Fast | | **Perplexity Research** | Deep invest
Calculate automation ROI from current manual effort data and project investment figures. Use when quantifying the business case for an automation engagement or validating the financial return for a client decision-maker.
Create intelligent routing logic based on document attributes, request type, risk score, or customer profile. Use when building workflow routing for insurance claims, loan applications, or compliance reviews.
Execution environment selection guide — helps choose between local CLI, Desktop, web, remote SSH, cloud tasks, and cowork sessions based on task requirements. Decision matrix with concrete examples.
Analyze source and target system schemas to map structural differences and identify migration complexity at the start of a data migration engagement.
Generate a fixed-scope project definition document with explicit inclusions, exclusions, and acceptance criteria. Use at project kickoff to establish the boundaries of a fixed-price engagement and prevent scope creep disputes.
# Advanced Self-Healing & Lessons Learned Enhanced error capture, pattern detection, automated rotation, and rule promotion for the lessons-learned system. ## The Self-Healing Loop ``` Tool fails → PostToolUseFailure hook captures error ↓ Appends to .claude/rules/lessons-learned.md ↓ Claude fixes the issue in current session ↓ Claude updates entry: NEEDS_FIX → RESOLVED + Fix + Prevention ↓ Next session: lessons-learned.md loaded as rule ↓ Claude avoids repeating the mistak
# Advanced Self-Healing & Lessons Learned Enhanced error capture, pattern detection, automated rotation, and rule promotion for the lessons-learned system. ## The Self-Healing Loop ``` Tool fails → PostToolUseFailure hook captures error ↓ Appends to .claude/rules/lessons-learned.md ↓ Claude fixes the issue in current session ↓ Claude updates entry: NEEDS_FIX → RESOLVED + Fix + Prevention ↓ Next session: lessons-learned.md loaded as rule ↓ Claude avoids repeating the mistak
Understanding and optimizing Claude Code session performance — token tracking, bottleneck identification, caching behavior, and cost estimation
Understanding and optimizing Claude Code session performance — token tracking, bottleneck identification, caching behavior, and cost estimation
# Claude Code Slash Commands Complete reference for all built-in and custom slash commands. ## Built-in Slash Commands ### Session Management | Command | Description | |---------|-------------| | `/clear` | Clear conversation and start fresh (same session) | | `/compact` | Compress conversation to reduce context usage | | `/compact [instructions]` | Compact with custom focus instructions | | `/resume` | Resume a previous session | | `/continue` | Continue current session | | `/status` | Curre
# Claude Code Slash Commands Complete reference for all built-in and custom slash commands. ## Built-in Slash Commands ### Session Management | Command | Description | |---------|-------------| | `/clear` | Clear conversation and start fresh (same session) | | `/compact` | Compress conversation to reduce context usage | | `/compact [instructions]` | Compact with custom focus instructions | | `/resume` | Resume a previous session | | `/continue` | Continue current session | | `/status` | Curre
Validate financial controls and workflows against SOX Section 302 and 404 requirements. Use when a client needs to ensure their financial reporting workflows meet Sarbanes-Oxley requirements for internal controls over financial reporting.
# Claude Code Teams & Collaboration Complete guide to team features, multi-user workflows, and organizational settings. ## Team Plans ### Overview Claude Code supports team/organizational plans that provide: - Shared billing and usage tracking - Managed settings and policies - Centralized API key management - Team member management - Usage analytics and reporting ### Organization Setup ```bash # Login with organization credentials claude auth login # Check organization status claude config
Design Microsoft Teams team, channel, tab, and app provisioning specifications for insurance agency operations, loan processing, and financial services collaboration.
# Claude Code Testing Workflows Complete guide to testing patterns, TDD, and test execution within Claude Code. ## Test Execution ### Running Tests ```bash # Common test commands npm test pnpm test yarn test bun test pytest go test ./... cargo test # Single test file npm test -- path/to/test.ts pytest path/to/test.py # Pattern matching npm test -- --grep "authentication" pytest -k "test_auth" # Watch mode npm test -- --watch pytest --watch ``` ### Claude's Testing Protocol 1. **Before co
# Claude Code Tools Reference Complete reference for every built-in tool available in Claude Code. ## File Tools ### Read Read file contents from the filesystem. ``` Parameters: file_path: string (required) — Absolute path to file offset: number (optional) — Start line number limit: number (optional) — Number of lines to read pages: string (optional) — Page range for PDFs (e.g., "1-5") Capabilities: - Text files with line numbers (cat -n format) - Image files (PNG, JPG, etc.) — r
# Claude Code Tools Reference Complete reference for every built-in tool available in Claude Code. ## File Tools ### Read Read file contents from the filesystem. ``` Parameters: file_path: string (required) — Absolute path to file offset: number (optional) — Start line number limit: number (optional) — Number of lines to read pages: string (optional) — Page range for PDFs (e.g., "1-5") Capabilities: - Text files with line numbers (cat -n format) - Image files (PNG, JPG, etc.) — r
# Claude Code Troubleshooting & Debugger Complete guide to diagnosing, debugging, and fixing Claude Code setup and runtime issues. ## Quick Diagnostics ### /doctor Command ``` /doctor ``` Runs automated health checks: - API key validation - Network connectivity - CLI version check - MCP server status - Configuration validation - Node.js version check ### Verbose Mode ```bash claude --verbose ``` Shows detailed debug output including: - API calls and responses - MCP server communication - Too
Checkpoint-between-waves cadence for multi-file refactors. After each logical batch (wave) of edits, run typecheck + tests; commit only on green; roll back the wave (not the whole branch) on red. Use for any refactor touching more than three files or three distinct concerns.
Step-by-step tutorials and worked examples for common Claude Code workflows — setup, debugging, code review, agent teams, hooks, memory, optimization, and CI/CD
Step-by-step tutorials and worked examples for common Claude Code workflows — setup, debugging, code review, agent teams, hooks, memory, optimization, and CI/CD
Generate audit trail specifications for regulatory compliance in insurance and financial services. Use when designing audit logging for FINRA, state insurance department, SOX, or internal compliance requirements.
Git worktree creation, agent isolation, parallel task execution with EnterWorktree/ExitWorktree, branch-per-worktree patterns, and cleanup lifecycle for Claude Code
Use when starting, tracking, or closing a discrete unit of work. Enforces ULTRA §13 reporting contract — what/why/tests/deps/reuse/risks/follow-ups/completion table. Invoke when user says "start work unit", "close work unit", "work unit report", or when a multi-step implementation task begins.
# Context Anchoring System Preserve critical information across `/compact` events, session boundaries, and agent handoffs. Context anchoring ensures your most important rules, decisions, and state survive compression. ## What Survives Compaction ``` ┌─────────────────────────────────────────────────┐ │ ANCHORED (survives /compact) │ │ │ │ CLAUDE.md ← Full file, re-injected │ │ .claude/rules/* ← All matching ru
Enterprise-grade security patterns for Claude Code — audit logging, compliance frameworks, secrets management, permission hardening, network security, and managed settings enforcement
Hook policy engine with 8 installable packs for safety, verification, context recovery, and teammate quality gates
# MCP Servers in Claude Code Complete guide to Model Context Protocol server configuration and usage. ## Overview MCP (Model Context Protocol) allows Claude Code to connect to external servers that provide additional tools, resources, and capabilities. Supports 300+ external tools and services. ## Transport Types | Transport | Description | Recommended | |-----------|-------------|-------------| | `http` | HTTP-based (streamable) | Yes (recommended) | | `sse` | Server-Sent Events | Deprecat
# Claude Code Settings Deep Dive Complete reference for every settings option, configuration key, and customization. ## Settings File Locations | Location | Scope | Git Tracked | |----------|-------|-------------| | Managed (system-level) | Organization | `/Library/...` (macOS), `/etc/claude-code/` (Linux), `C:\Program Files\...` (Win) | | `~/.claude/settings.json` | User (all projects) | N/A | | `.claude/settings.json` | Project (shared) | Yes | | `.claude/settings.local.json` | Project (per
# Agent Teams > Orchestrate teams of Claude Code sessions working together with shared tasks, inter-agent messaging, and centralized management. > Experimental feature — requires `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` environment variable. > Requires Claude Code v2.1.32+. ## Overview Agent teams let you coordinate multiple Claude Code instances working together. One session acts as the **team lead**, coordinating work, assigning tasks, and synthesizing results. Teammates work independently, e
Production-ready channel server implementations — CI webhook receiver, mobile approval relay, Discord/Telegram bridge, and local fakechat dev profile. Copy-paste starter code with sender allowlists, permission relay, and security hardening.
# Agentic Design Patterns — Claude Code Expert > Comprehensive pattern catalog integrating Andrew Ng's four foundational patterns, Anthropic's > workflow/agent taxonomy, and the extended patterns from Gulli & Sauco (2025). Each pattern > includes a concrete Claude Code implementation template mapped to the 4-layer extension stack. ## Two Taxonomies, One Stack ### Andrew Ng's Four Foundational Patterns Reflection, Tool Use, Planning, Multi-Agent — the building blocks that kicked off the field.
# Channels Reference > Build MCP servers that push webhooks, alerts, and chat messages into a Claude Code session. > Requires Claude Code v2.1.80+ (permission relay requires v2.1.81+). > Research preview — requires claude.ai login; Console/API key auth not supported. ## What Is a Channel A channel is an MCP server that pushes events into a Claude Code session so Claude can react to things happening outside the terminal. Claude Code spawns it as a subprocess and communicates over stdio. **One
# Channels User Guide > Push events into a running Claude Code session with channels. > Forward CI results, chat messages, monitoring alerts, and webhook events so Claude can react while you're away. > Requires Claude Code v2.1.80+. Research preview — requires claude.ai login. ## Overview A channel is an MCP server that pushes events into your running Claude Code session, so Claude can react to things that happen while you're not at the terminal. Channels can be two-way: Claude reads the even
# Claude Code CLI Reference Complete reference for the Claude Code command-line interface. ## Installation ### System Requirements - macOS 13.0+, Windows 10 1809+, Ubuntu 20.04+, Debian 10+, Alpine 3.19+ - 4GB+ RAM - Internet connection required - Shell: Bash, Zsh, PowerShell, CMD - Windows: Git for Windows required ### Methods ```bash # Native (Recommended) curl -fsSL https://claude.ai/install.sh | bash # Homebrew (macOS) brew install --cask claude-code # WinGet (Windows) winget install
Computer use and GUI automation patterns — when to use GUI automation vs shell/MCP/browser tools, visual validation techniques, native app testing, and guardrails for visual regression workflows
Advanced context window management — token arithmetic, anchor budget math, compact strategies, progressive loading, and large codebase partitioning
Domain knowledge for multi-agent council review protocols, orchestration patterns, scoring systems, and deliberation frameworks
# Claude Code Extended Thinking Complete guide to extended thinking modes and thinking budget configuration. ## Overview Extended thinking (also called "ultrathink") allows Claude to perform deeper reasoning before responding. This uses additional tokens for internal reasoning that improves quality on complex tasks. ## Thinking Modes ### Trigger Phrases (CLI) Use these phrases in your prompts to activate thinking levels: | Phrase | Thinking Tokens | Approx Cost | |--------|----------------
# Claude Code Hooks System Complete reference for the hooks lifecycle system. ## Overview Hooks are user-defined shell commands that execute at specific points in the Claude Code lifecycle. They run synchronously and can modify Claude's behavior by returning structured JSON. ## Hook Types ### All Lifecycle Events | Event | When | Can Block? | |-------|------|-----------| | `SessionStart` | Session begins/resumes | No | | `UserPromptSubmit` | Before processing user prompt | Yes (exit 2) | |
LSP server detection, installation, and Claude Code integration — auto-invoke when setting up a new project, running /cc-setup, or configuring IDE tooling
Intelligent model selection for Claude Code — decision matrices, cost tables, budget planning, and subagent model assignment for optimal cost/quality tradeoffs
Project sync and configuration propagation — auto-invoke when running /cc-sync or updating Claude Code setup across repos
# Scheduled Tasks > Use `/loop` and cron scheduling tools to run prompts repeatedly, poll for status, or set one-time reminders within a Claude Code session. > Requires Claude Code v2.1.72+. ## Overview Scheduled tasks let Claude re-run a prompt automatically on an interval. Use them to: - Poll a deployment status - Babysit a PR review cycle - Check on a long-running build - Set reminders during a session Tasks are **session-scoped**: they live in the current process and are gone when you ex
Manage the three-tier memory system (engram + Obsidian vault + plugin rules) for Claude Code setups. Use this skill whenever saving CC-setup findings, consolidating engram into durable knowledge, writing repo docs to the Obsidian vault, or running /cc-memory subcommands. Triggers on phrases like "save this pattern", "promote to memory", "update the vault", "consolidate memory", "write an ADR", and whenever work on CC plugins, hooks, agents, skills, or autonomy profiles concludes.
# Claude Code Teams & Collaboration Complete guide to team features, multi-user workflows, and organizational settings. ## Team Plans ### Overview Claude Code supports team/organizational plans that provide: - Shared billing and usage tracking - Managed settings and policies - Centralized API key management - Team member management - Usage analytics and reporting ### Organization Setup ```bash # Login with organization credentials claude auth login # Check organization status claude config
Pre-flight check to run before any Agent-tool spawn. Prevents the "Prompt is too long" rejection class by enforcing a 5-section minimum-viable-prompt template and estimating forwarded context cost. Use whenever you are about to call the Agent tool with more than a one-paragraph prompt.
Structured code review using checklist and knowledge graph context
Categorize and prioritize bug reports using codebase and documentation context
Categorize and prioritize bug reports using codebase and documentation context
Plan schema or API migrations safely with rollback strategies
Structured code review using checklist and knowledge graph context
Design Power BI data model relationships and Power Query transformation specifications for combining insurance and financial services data from multiple source systems.
Generate SLA measurement configurations and breach-alert rules. Use when defining service level agreements for workflow steps, queue processing times, or customer response commitments.
Generate changelog entries from diffs and PRs
Managing project and task state in .claude/projects/{id}/ with atomic writes and session continuity
Design REST and SOAP API connector specifications with authentication, pagination, and error handling for insurance and financial services system integrations.
# Claude Code Hooks System Complete reference for the hooks lifecycle system. ## Overview Hooks are user-defined shell commands that execute at specific points in the Claude Code lifecycle. They run synchronously and can modify Claude's behavior by returning structured JSON. ## Hook Types ### All Lifecycle Events | Event | When | Can Block? | |-------|------|-----------| | `SessionStart` | Session begins/resumes | No | | `UserPromptSubmit` | Before processing user prompt | Yes (exit 2) | |
Design field mapping specifications between source and destination systems for synchronizing insurance AMS and CRM data, LOS to reporting systems, or data migrations between platforms.
Connecting and syncing with GitHub Projects, Linear, Notion, Asana, Trello, ClickUp, Monday.com, Todoist, and Local
--- name: security-compliance description: Claude Code security and compliance — permissions model, settings.json allowlists/denylists, enterprise managed settings, audit logging, secrets handling, SOC2/HIPAA/GDPR patterns. Use this skill whenever configuring permissions, auditing a setup for security, handling secrets, preparing for compliance, or tightening access. Triggers on: "permissions", "allowlist", "security audit", "compliance", "SOC2", "HIPAA", "GDPR", "secrets", "enterprise settings"
Execution environment selection guide — helps choose between local CLI, Desktop, web, remote SSH, cloud tasks, and cowork sessions based on task requirements. Decision matrix with concrete examples.
Detect scope creep in client requests and generate formal change order documentation. Use when a client requests something outside the agreed project scope during an active engagement.
--- name: autonomy description: Configure Claude Code's autonomous operating mode — profile selection (conservative, balanced, aggressive, unattended-review), permission blocks, and the three gate agents (planner, verifier, reviewer). Use this skill whenever enabling autonomous mode, switching profiles, tightening permissions for production branches, or setting up unattended execution. Triggers on: "autonomy", "unattended mode", "auto-approve", "permission mode", "autonomy profile", "gates", "/c
Domain knowledge for multi-agent council review protocols, orchestration patterns, scoring systems, and deliberation frameworks
Using and creating project templates for webapp, API, ML pipeline, mobile, and infrastructure projects
Rendering ASCII progress dashboards with phase/epic/task breakdown and velocity metrics
--- name: agentic-patterns description: Select and wire an agentic design pattern (reflection, prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer, ReAct, blackboard) into the 5-layer Claude Code stack. Use this skill whenever deciding how to structure a multi-step task, whether to spawn subagents, how to run parallel review, or when to use which pattern. Triggers on: "which pattern", "orchestrate", "parallel review", "self-review", "chain of thought", "eval-opti
Auto mode permission handling — classifier-based approvals, PermissionDenied hook, defer permissionDecision, and autonomy profiles for hands-off Claude Code usage
# Claude Agent SDK Complete guide to the Claude Agent SDK for building custom AI agents. ## Overview The Claude Agent SDK allows you to programmatically spawn and control Claude Code sessions from TypeScript/JavaScript or Python applications. ## Installation ### TypeScript/JavaScript ```bash npm install @anthropic-ai/claude-agent-sdk # or pnpm add @anthropic-ai/claude-agent-sdk ``` ### Python ```bash # Using uv (recommended) uv init && uv add claude-agent-sdk # Using pip python3 -m venv .
# Claude Code CLI Reference Complete reference for the Claude Code command-line interface. ## Installation ### System Requirements - macOS 13.0+, Windows 10 1809+, Ubuntu 20.04+, Debian 10+, Alpine 3.19+ - 4GB+ RAM - Internet connection required - Shell: Bash, Zsh, PowerShell, CMD - Windows: Git for Windows required ### Methods ```bash # Native (Recommended) curl -fsSL https://claude.ai/install.sh | bash # Homebrew (macOS) brew install --cask claude-code # WinGet (Windows) winget install
# Claude Code Git Integration Complete guide to Git workflows and version control within Claude Code. ## Git Awareness Claude Code automatically detects Git repositories and understands: - Current branch and status - Uncommitted changes (staged and unstaged) - Recent commit history - Remote tracking branches - Merge conflicts ## Commit Workflow ### Claude's Commit Protocol When asked to commit, Claude follows this exact workflow: 1. **Inspect state** (parallel): - `git status` — see unt
# Agentic Design Patterns — Claude Code Expert > Comprehensive pattern catalog integrating Andrew Ng's four foundational patterns, Anthropic's > workflow/agent taxonomy, and the extended patterns from Gulli & Sauco (2025). Each pattern > includes a concrete Claude Code implementation template mapped to the 4-layer extension stack. ## Two Taxonomies, One Stack ### Andrew Ng's Four Foundational Patterns Reflection, Tool Use, Planning, Multi-Agent — the building blocks that kicked off the field.
Design rate limit detection, throttling, and backoff strategy specifications to prevent API lockouts in insurance and financial services system integrations.
Design integration error classification, retry strategies, and dead-letter handling for insurance and financial services system integrations.
Design pre-closing and post-closing checklist automation for mortgage loan closings. Use when automating the closing preparation workflow, closing day coordination, and post-closing package review for a mortgage lender or broker.
Design SharePoint Online site, list, library, and page provisioning specifications for insurance and financial services firms on Microsoft 365.
Design Exchange Online mail flow rules and shared mailbox configurations for insurance and financial services email routing and compliance.
Create a client proposal for a fixed-scope automation engagement with ROI projections, timeline, and investment summary. Use when converting a discovery call into a formal proposal document for an insurance, mortgage, or financial services prospect.
Generate milestone tracking configurations and progress report templates for fixed-scope engagements. Use when setting up project delivery tracking at engagement kickoff or when a client needs a status update format.
Design ETL transformation rules for field mapping, data cleansing, and format conversion to move data from source to destination systems with different data structures.
Build a phased data migration plan with cutover strategy, risk register, and go/no-go criteria for system transition engagements.
Review a system, workflow, or data model for GDPR and CCPA compliance. Use when assessing data collection, storage, processing, and deletion practices for insurance or financial services clients who handle EU or California resident data.
Design audit log specifications for regulated business processes. Use when a workflow requires a defensible audit trail for FINRA examinations, state insurance audits, SOX controls testing, or internal compliance reviews.
Design Power BI report and visual specifications for executive reporting on claims, loan pipeline, premium production, and financial services KPI tracking.
Advanced patterns for Claude Code Agent Teams — topology design, cross-team communication, worktree coordination, failure handling, and cost management
Advanced patterns for Claude Code Agent Teams — topology design, cross-team communication, worktree coordination, failure handling, and cost management
Agent-team topology kits — 5 production-ready team configurations with task decomposition, file ownership, worktree guidance, and quality-gate hooks
Agent-team topology kits — 5 production-ready team configurations with task decomposition, file ownership, worktree guidance, and quality-gate hooks
Design multi-step approval workflows with supervisor, manager, and executive levels. Use when the user needs to automate document approvals, contract sign-offs, or policy exceptions for insurance or mortgage operations.
Design AUS (Automated Underwriting System) integration workflow specifications for DU, LP, and GUS. Use when integrating a mortgage LOS with Fannie Mae Desktop Underwriter, Freddie Mac Loan Product Advisor, or USDA GUS.
Runtime behavior specs for the four autonomy profiles, the three autonomy agents (planner, verifier, reviewer), memory integration, context survival, and anti-patterns. Activate this skill to run the autonomy system — not just to read about it.
Design borrower self-service portal specifications for mortgage brokers and lenders. Use when specifying a borrower-facing portal for loan status tracking, document upload, communication, and closing scheduling.
# Channels Reference > Build MCP servers that push webhooks, alerts, and chat messages into a Claude Code session. > Requires Claude Code v2.1.80+ (permission relay requires v2.1.81+). > Research preview — requires claude.ai login; Console/API key auth not supported. ## What Is a Channel A channel is an MCP server that pushes events into a Claude Code session so Claude can react to things happening outside the terminal. Claude Code spawns it as a subprocess and communicates over stdio. **One
# Checkpointing > Track, rewind, and summarize Claude's edits and conversation to manage session state. > Built-in feature — no configuration required. ## Overview Claude Code automatically tracks file edits as you work, allowing you to quickly undo changes and rewind to previous states. This safety net lets you pursue ambitious, wide-scale tasks knowing you can always return to a prior code state. ## How Checkpoints Work ### Automatic Tracking - Every user prompt creates a new checkpoint -
Patterns for integrating Claude Code into CI/CD pipelines — GitHub Actions, GitLab CI, pre-commit hooks, automated PR reviews, headless mode, and cost control
Build claims intake, triage, assignment, and settlement automation workflows for insurance agencies. Use when automating first notice of loss handling, claims status tracking, or settlement authorization workflows.
Universal reference for Claude Code automation surface — hooks, skills, plugins, sub-agents, agent teams, MCP, scheduled tasks, channels, routines, headless/SDK, checkpointing, permissions. Invoke when designing automations that leverage Claude Code features or when user asks "how do I automate X with Claude Code".
Idempotent update of an existing Claude Code setup — re-fingerprint the repo, propagate updates to sub-repos, refresh docs/context, section-merge CLAUDE.md/README.md, fix configuration drift. Use this skill whenever the user runs /cc-sync, asks to "update the claude setup", "propagate to sub-repos", "fix drift", "resync", or reports that the .claude/ directory has gone stale.
Workflow packs for the 7 most common Claude Code tasks — codebase exploration, bug fixing, safe refactoring, TDD, repo review before merge, CLAUDE.md generation, and migration planning. Each pack has a start prompt, verification steps, subagent opportunities, failure modes, and completion checklist.
Audit a workflow or business process against insurance, mortgage, or financial services regulatory requirements. Use when a client workflow needs regulatory sign-off or when validating that a proposed automation meets compliance requirements before build.
# Claude Code Configuration Complete guide to all configuration files, settings, and directory structure. ## Directory Structure ``` project/ ├── .claude/ │ ├── CLAUDE.md # Project-level instructions (checked into git) │ ├── settings.json # Project-level settings (checked into git) │ ├── settings.local.json # Local overrides (gitignored) │ ├── rules/ # Path-scoped rule files │ ├── skills/ # Reusable workflow definitions │ ├── agents/
# Claude Code Configuration Complete guide to all configuration files, settings, and directory structure. ## Directory Structure ``` project/ ├── .claude/ │ ├── CLAUDE.md # Project-level instructions (checked into git) │ ├── settings.json # Project-level settings (checked into git) │ ├── settings.local.json # Local overrides (gitignored) │ ├── rules/ # Path-scoped rule files │ ├── skills/ # Reusable workflow definitions │ ├── agents/
--- name: context-budgeting description: Manage Claude Code's context window — token arithmetic, /compact strategy, anchor preservation, progressive loading, session analytics. Use this skill whenever a session gets long, context approaches limits, after /compact, when deciding what to load into CLAUDE.md vs leave in references, or when analyzing session cost/token usage. Triggers on: "context full", "compact", "too many tokens", "budget", "session analytics", "save tokens", "context window", "/
Advanced context window management — token arithmetic, anchor budget math, compact strategies, progressive loading, and large codebase partitioning
# Claude Code Cost Optimization Complete guide to managing costs, model routing, token usage, and caching. ## Cost Tracking ### /cost Command ``` /cost ``` Shows: - Input tokens consumed - Output tokens consumed - Cache read tokens (cheaper) - Cache write tokens - Total estimated cost (USD) ## Model Selection & Routing ### Available Models | Model | ID | Best For | Cost | |-------|-----|---------|------| | Opus 4.6 | `claude-opus-4-6` | Architecture, complex decisions | Highest | | Sonnet 4
Design embedded analytics integration specifications for embedding Power BI dashboards in SharePoint pages, Power Apps, Teams tabs, and custom web portals.
Patterns for integrating Claude Code into CI/CD pipelines — GitHub Actions, GitLab CI, pre-commit hooks, automated PR reviews, headless mode, and cost control
Profile source data quality, completeness, and anomalies before migration to identify cleansing requirements and assess fitness for migration.
Design data retention and deletion policies with regulatory basis for each data type. Use when a client needs to define how long different data categories are kept, when they are deleted, and what the regulatory or business justification is.
Deep project fingerprinting for tech stack detection, architecture analysis, and quality assessment
# Checkpointing > Track, rewind, and summarize Claude's edits and conversation to manage session state. > Built-in feature — no configuration required. ## Overview Claude Code automatically tracks file edits as you work, allowing you to quickly undo changes and rewind to previous states. This safety net lets you pursue ambitious, wide-scale tasks knowing you can always return to a prior code state. ## How Checkpoints Work ### Automatic Tracking - Every user prompt creates a new checkpoint -
Agent-team topology kits — 5 production-ready team configurations with task decomposition, file ownership, worktree guidance, and quality-gate hooks
Start working on a Jira issue with optimized tiered orchestration. Begins with intelligent question-gathering to ensure complete understanding before implementation.
# Channels Reference > Build MCP servers that push webhooks, alerts, and chat messages into a Claude Code session. > Requires Claude Code v2.1.80+ (permission relay requires v2.1.81+). > Research preview — requires claude.ai login; Console/API key auth not supported. ## What Is a Channel A channel is an MCP server that pushes events into a Claude Code session so Claude can react to things happening outside the terminal. Claude Code spawns it as a subprocess and communicates over stdio. **One
Create pull request linked to Jira issue. Use when the user wants to "create PR", "open pull request", "submit for review", or "jira pr".
Review code changes for Jira issue. Use when the user wants to "review code", "code review", "jira review", or "check implementation".
MUI core component patterns and best practices
AI-powered diagram generation using draw.io's built-in AI features and LLM integration
Advanced MUI component patterns — Autocomplete (async, virtualized, grouped, createFilterOptions), Stepper (non-linear, vertical, mobile), Popover, Popper, Portal, ClickAwayListener, and complex composition
Top 0.01% MUI patterns — sparkline grid cells, heatmap DataGrids, real-time WebSocket grids, AI assistant, save/restore grid state, bi-directional chart+grid, pivot tables, clipboard paste, progress cells
MUI transition components (Fade, Grow, Slide, Collapse, Zoom), custom transitions, TransitionGroup, and Framer Motion integration
Atlassian API integration for Jira and Confluence automation. Activate for Atlassian REST APIs, webhooks, and platform integration.
This skill should be used when the user asks to "create MongoDB model", "define Beanie document", "write MongoDB query", "create aggregation pipeline", "run database migration", "index MongoDB collection", or mentions Beanie, Motor, MongoDB documents, or async database operations. Provides MongoDB/Beanie ODM patterns for FastAPI.
Blazor component model including render modes, lifecycle, parameters, event handling, and component communication
Blazor forms, EditForm, input components, DataAnnotations, FluentValidation, and custom validation
Blazor rendering optimization, virtualization, lazy loading, caching, and memory management
Deploying .NET apps to Azure Container Apps, App Service, Docker, and Kubernetes with CI/CD
Resolve high-level intents into ordered plugin composition plans using greedy set cover for capability matching and Kahn's topological sort for dependency ordering. Activates when working with "compose", "plugin composition", "capability matching", "dependency resolution", or "intent specification".
Data-driven conditional formatting, live data binding, and dynamic diagram updates for draw.io
Confluence documentation including pages, spaces, templates, and Atlassian integration. Activate for wiki pages, documentation, knowledge bases, and team collaboration.
# example-skill Example skill for workflow-automator that demonstrates domain-specific knowledge integration. ## Activation Triggers This skill is activated when: - Working with workflow automation files - User mentions "workflow", "automation", or "process" in their request - Context requires process orchestration expertise - Task involves defining or modifying business workflows ### File Patterns This skill recognizes: - `*.workflow.json` - Workflow definition files - `*.process.yaml` - P
Modern C# 13/15 patterns, LINQ mastery, async/await, records, pattern matching, .NET 10/11 features, and .NET AI integration
Generate CSS, Tailwind, and styled-components code from design style selections
MUI X DataGrid configuration, server-side integration, and optimization
Computer science data structure visualization in draw.io — arrays, linked lists, trees, graphs, hash tables, heaps, stacks, queues
Analytical thinking patterns for comprehensive evaluation, code audits, security analysis, and performance reviews. Provides structured templates for thorough investigation with extended thinking support.
Apply and manage the AI-powered design system with 50+ curated styles
draw.io desktop app integration for Claude Code — OS detection, editor paths, CLI export, file watching, and iterative AI+human workflows
Comprehensive guide to all diagram types with selection criteria, notation rules, and draw.io implementation
Build Docker images with proper tagging, cache busting, and build tracking. Prevents stale image issues.
Entity Framework Core patterns for data access, migrations, relationships, performance, and best practices
This skill should be used when the user asks to "create background task", "add async job", "implement task queue", "schedule periodic task", "use Celery", "use ARQ", "process async", or mentions background processing, task queues, job scheduling, workers, or async jobs. Provides multiple task queue framework patterns.
This skill should be used when the user asks to "add caching", "implement Redis cache", "cache API response", "invalidate cache", "add cache layer", "optimize with caching", or mentions Redis, caching strategies, cache invalidation, or performance optimization. Provides Redis caching patterns for FastAPI.
This skill should be used when the user asks to "deploy FastAPI to Kubernetes", "create Dockerfile", "build Docker image", "write Helm chart", "configure K8s deployment", "add health checks", "scale FastAPI", or mentions Docker, Kubernetes, K8s, containers, Helm, or deployment. Provides containerization and orchestration patterns.
This skill should be used when the user asks to "create a FastAPI endpoint", "add async route", "implement dependency injection", "create middleware", "handle exceptions", "structure FastAPI project", or mentions FastAPI patterns, routers, or API design. Provides comprehensive FastAPI development patterns with async best practices.
This skill should be used when the user asks to "add WebSocket", "implement real-time", "create file upload", "add S3 upload", "send email", "implement notifications", "broadcast events", or mentions WebSockets, file storage, email service, push notifications, or real-time communication. Provides WebSocket, file upload, and notification patterns.
MUI form patterns with validation and library integration
Comprehensive guide for Harness Platform API authentication, rate limiting, error handling, and endpoint operations
Keycloak OIDC integration with Harness pipelines, EKS IRSA, service account authentication, and realm-as-code patterns
Safe Helm deployment with image verification, cache busting, and rollback safety. Prevents deploying stale images.
Expertise in API design, database integration, and service connectivity. Activates when working with "API", "database", "webhook", "service", "integrate", "connect", or system architecture.
Project fingerprinting, association rule mining (Apriori), and cosine-similarity plugin recommendations
Jira project management including issues, sprints, boards, and workflows. Activate for Jira tickets, sprint planning, backlog management, and Atlassian integration.
Create git branch linked to Jira issue. Use when the user wants to "create branch", "new branch for issue", "jira branch", or "feature branch".
draw.io MCP server configuration, tools reference, and integration patterns
Joy UI — MUI's alternative design system with CSS variables, modern aesthetics, and simpler API
Kanban methodology including boards, WIP limits, flow metrics, and continuous delivery. Activate for Kanban boards, workflow visualization, and lean project management.
Keycloak identity and access management including realms, clients, authentication flows, themes, and user federation. Activate for OAuth2, OIDC, SAML, SSO, identity providers, and authentication configuration.
Kubernetes deployment, management, and troubleshooting. Activate for k8s, kubectl, pods, deployments, services, ingress, namespaces, and container orchestration tasks.
LLM integration patterns for Claude, GPT, Gemini, and Ollama. Activate for AI API integration, prompt engineering, token management, extended thinking, and multi-model orchestration.
SignalR for real-time communication in Blazor apps including hubs, groups, streaming, and scaling
MUI version migration guides — v4→v5 and v5→v6 with codemods and patterns
Multi-tenant architecture patterns including org_id claim management, JWT token structure with organization context, database isolation strategies for MongoDB and PostgreSQL, theme switching per organization, tenant provisioning workflows, data isolation patterns, and cross-tenant security. Activate for multi-tenancy implementation, tenant isolation, and organization-scoped data access.
Network topology, infrastructure architecture, and software system mapping in draw.io with cloud, on-prem, and hybrid layouts
Next.js development including App Router, Server Components, API routes, and deployment. Activate for Next.js apps, SSR, SSG, and React Server Components.
Terraform infrastructure as code including modules, state management, and cloud provisioning. Activate for tf files, IaC, infrastructure provisioning, and cloud resource management.
MUI performance optimization — tree-shaking, bundle size, rendering, SSR
Project type detection matrix, template recommendations per project type, post-scaffolding checklist, Harness integration patterns, and testing recommendations
Visual quality critique checklist for draw.io diagrams — run before writing any .drawio file
React 18+ patterns with Vite bundler, TypeScript, hooks, component design, and state management. Activate for React apps, Vite configuration, TypeScript, frontend development, and modern React patterns.
Redis caching, pub/sub, and data structures. Activate for Redis operations, caching strategies, session management, and message queuing.
REST API design, implementation, and best practices. Activate for API endpoints, HTTP methods, status codes, authentication, and API documentation.
MUI slots and slotProps API for deep component customization — replacing internal elements, custom renderers, and composition patterns
Testing patterns including pytest, unittest, mocking, fixtures, and test-driven development with extended thinking integration. Activate for test writing, coverage analysis, TDD, hypothesis-driven development, and quality assurance tasks.
Testing MUI components with React Testing Library — theme mocking, portal components, DataGrid, DatePicker, and accessibility testing
MUI list virtualization with react-window, react-virtuoso, virtualized Autocomplete, and large dataset rendering patterns
MUI multi-theme and white-label systems — nested ThemeProvider, dynamic theme switching, tenant-specific branding, and theme composition
# Agentic Design Patterns > Based on "Agentic Design Patterns" by Antonio Gulli & Mauro Sauco (2025) > 21 patterns across 4 tiers for building production-grade AI agent systems ## Pattern Catalog ### Part 1: Foundational Patterns #### 1. Prompt Chaining (Pipeline) Decompose complex tasks into sequential sub-problems where each step's output feeds the next. **When to use**: Task too complex for single prompt, multiple processing stages, external tool integration between steps. **Implementat
Message Batches API for Claude with 50% cost savings on bulk processing. Activate for batch jobs, JSONL processing, bulk analysis, and cost optimization.
Database design, SQL queries, migrations, and optimization. Activate for PostgreSQL, MySQL, SQLite, schema design, queries, indexes, and data modeling.
Debugging techniques for Python, JavaScript, and distributed systems. Activate for troubleshooting, error analysis, log investigation, and performance debugging. Includes extended thinking integration for complex debugging scenarios.
Extended thinking (ultrathink) configuration for Claude API. Activate for complex reasoning tasks, deep analysis, multi-step problem solving, and tasks requiring careful deliberation. Enables Claude's internal reasoning with configurable thinking budgets.
Google Cloud Platform services including GKE, Cloud Run, Cloud Storage, BigQuery, and Pub/Sub. Activate for GCP infrastructure, Google Cloud deployment, and GCP integration.
GraphQL API development including schemas, resolvers, queries, mutations, and subscriptions. Activate for GraphQL servers, clients, and API design.
Sync local changes with Jira issue. Use when the user wants to "sync to jira", "update jira", "push progress", or "sync status".
MongoDB Atlas cloud database management including clusters, schemas, aggregation pipelines, and Prisma ORM integration. Activate for MongoDB queries, schema design, indexing, and Atlas administration.
# Stripe Payments Integration Stripe payments and subscription management skill for Lobbi member management system. Activates when working with payment processing, subscription management, or billing workflows. **Triggers:** stripe, payment, subscription, billing, invoice, checkout, webhook, customer, payment-method, card **Use this skill when:** - Implementing Stripe checkout flows - Managing subscriptions and billing cycles - Handling Stripe webhooks - Processing payments and refunds - Mana
Vector database operations for embeddings and semantic search. Activate for Pinecone, Weaviate, Chroma, pgvector, RAG, and similarity search.
ArgoCD ApplicationSets, progressive delivery, Harness GitX, and multi-cluster GitOps patterns
Detect and extract patterns from codebases for template generation
AWS EKS deployment patterns via Harness CD - Native Helm, Kubernetes manifests, and GitOps strategies with rolling, canary, and blue-green deployments
Local Kubernetes development with EKS parity using Kind, LocalStack for AWS services, and local Keycloak for authentication testing
# Agent Lifecycle Management Complete guide to managing sub-agent and teammate lifecycle in Claude Code — health checks, idle detection, cleanup, retention, and the mandatory audit loop. ## The Orchestration-First Principle Claude should **prefer to orchestrate** rather than do work directly. When a task has multiple components or would benefit from specialized review: 1. Break the task into work units 2. Assign each to the best-fit agent type 3. Run agents in parallel where possible 4. Audi
# Claude Agent SDK Complete guide to the Claude Agent SDK for building custom AI agents. ## Overview The Claude Agent SDK allows you to programmatically spawn and control Claude Code sessions from TypeScript/JavaScript or Python applications. ## Installation ### TypeScript/JavaScript ```bash npm install @anthropic-ai/claude-agent-sdk # or pnpm add @anthropic-ai/claude-agent-sdk ``` ### Python ```bash # Using uv (recommended) uv init && uv add claude-agent-sdk # Using pip python3 -m venv .
Production-ready channel server implementations — CI webhook receiver, mobile approval relay, Discord/Telegram bridge, and local fakechat dev profile. Copy-paste starter code with sender allowlists, permission relay, and security hardening.
Patterns for integrating Claude Code into CI/CD pipelines — GitHub Actions, GitLab CI, pre-commit hooks, automated PR reviews, headless mode, and cost control
# Claude Code CLI Reference Complete reference for the Claude Code command-line interface. ## Installation ### System Requirements - macOS 13.0+, Windows 10 1809+, Ubuntu 20.04+, Debian 10+, Alpine 3.19+ - 4GB+ RAM - Internet connection required - Shell: Bash, Zsh, PowerShell, CMD - Windows: Git for Windows required ### Methods ```bash # Native (Recommended) curl -fsSL https://claude.ai/install.sh | bash # Homebrew (macOS) brew install --cask claude-code # WinGet (Windows) winget install
Workflow packs for the 7 most common Claude Code tasks — codebase exploration, bug fixing, safe refactoring, TDD, repo review before merge, CLAUDE.md generation, and migration planning. Each pack has a start prompt, verification steps, subagent opportunities, failure modes, and completion checklist.
Computer use and GUI automation patterns — when to use GUI automation vs shell/MCP/browser tools, visual validation techniques, native app testing, and guardrails for visual regression workflows
# Claude Code Context Management Complete guide to managing context window, compression, and conversation flow. ## Context Window Overview Claude Code manages a conversation context window that accumulates messages, tool calls, and results throughout a session. ### Context Limits - The context window has a fixed token limit based on the model - Claude Code automatically warns when approaching limits - Auto-compact triggers when threshold is reached (configurable) ### Configuration ```json
# Claude Code Cost Optimization Complete guide to managing costs, model routing, token usage, and caching. ## Cost Tracking ### /cost Command ``` /cost ``` Shows: - Input tokens consumed - Output tokens consumed - Cache read tokens (cheaper) - Cache write tokens - Total estimated cost (USD) ## Model Selection & Routing ### Available Models | Model | ID | Best For | Cost | |-------|-----|---------|------| | Opus 4.6 | `claude-opus-4-6` | Architecture, complex decisions | Highest | | Sonnet 4
Domain knowledge for multi-agent council review protocols, orchestration patterns, scoring systems, and deliberation frameworks
# Claude Code Extended Thinking Complete guide to extended thinking modes and thinking budget configuration. ## Overview Extended thinking (also called "ultrathink") allows Claude to perform deeper reasoning before responding. This uses additional tokens for internal reasoning that improves quality on complex tasks. ## Thinking Modes ### Trigger Phrases (CLI) Use these phrases in your prompts to activate thinking levels: | Phrase | Thinking Tokens | Approx Cost | |--------|----------------
# Claude Code Git Integration Complete guide to Git workflows and version control within Claude Code. ## Git Awareness Claude Code automatically detects Git repositories and understands: - Current branch and status - Uncommitted changes (staged and unstaged) - Recent commit history - Remote tracking branches - Merge conflicts ## Commit Workflow ### Claude's Commit Protocol When asked to commit, Claude follows this exact workflow: 1. **Inspect state** (parallel): - `git status` — see unt
Hook policy engine with 8 installable packs for safety, verification, context recovery, and teammate quality gates
# Claude Code IDE Integrations Complete guide to using Claude Code with VS Code, JetBrains, and terminal editors. ## VS Code Extension ### Installation 1. Open VS Code Extensions (Ctrl+Shift+X / Cmd+Shift+X) 2. Search for "Claude Code" 3. Install the official Anthropic extension 4. Or: `code --install-extension anthropic.claude-code` ### Features - **Inline chat** — Ask Claude about selected code - **Terminal integration** — Claude Code runs in VS Code terminal - **File context** — Automatic
# Claude Code Memory & Instructions System Complete guide to CLAUDE.md, project instructions, auto-memory, and rules. ## CLAUDE.md — Project Instructions ### Purpose CLAUDE.md files contain natural-language instructions that Claude Code loads as system context. They tell Claude about your project's conventions, build commands, architecture, and preferences. ### Hierarchy (All Additive) ``` Enterprise/Managed CLAUDE.md (highest priority, cannot be overridden) └── User ~/.claude/CLAUDE.
Execution environment selection guide — helps choose between local CLI, Desktop, web, remote SSH, cloud tasks, and cowork sessions based on task requirements. Decision matrix with concrete examples.
# Scheduled Tasks > Use `/loop` and cron scheduling tools to run prompts repeatedly, poll for status, or set one-time reminders within a Claude Code session. > Requires Claude Code v2.1.72+. ## Overview Scheduled tasks let Claude re-run a prompt automatically on an interval. Use them to: - Poll a deployment status - Babysit a PR review cycle - Check on a long-running build - Set reminders during a session Tasks are **session-scoped**: they live in the current process and are gone when you ex
# Advanced Self-Healing & Lessons Learned Enhanced error capture, pattern detection, automated rotation, and rule promotion for the lessons-learned system. ## The Self-Healing Loop ``` Tool fails → PostToolUseFailure hook captures error ↓ Appends to .claude/rules/lessons-learned.md ↓ Claude fixes the issue in current session ↓ Claude updates entry: NEEDS_FIX → RESOLVED + Fix + Prevention ↓ Next session: lessons-learned.md loaded as rule ↓ Claude avoids repeating the mistak
Understanding and optimizing Claude Code session performance — token tracking, bottleneck identification, caching behavior, and cost estimation
# Claude Code Slash Commands Complete reference for all built-in and custom slash commands. ## Built-in Slash Commands ### Session Management | Command | Description | |---------|-------------| | `/clear` | Clear conversation and start fresh (same session) | | `/compact` | Compress conversation to reduce context usage | | `/compact [instructions]` | Compact with custom focus instructions | | `/resume` | Resume a previous session | | `/continue` | Continue current session | | `/status` | Curre
# Claude Code Teams & Collaboration Complete guide to team features, multi-user workflows, and organizational settings. ## Team Plans ### Overview Claude Code supports team/organizational plans that provide: - Shared billing and usage tracking - Managed settings and policies - Centralized API key management - Team member management - Usage analytics and reporting ### Organization Setup ```bash # Login with organization credentials claude auth login # Check organization status claude config
# Claude Code Testing Workflows Complete guide to testing patterns, TDD, and test execution within Claude Code. ## Test Execution ### Running Tests ```bash # Common test commands npm test pnpm test yarn test bun test pytest go test ./... cargo test # Single test file npm test -- path/to/test.ts pytest path/to/test.py # Pattern matching npm test -- --grep "authentication" pytest -k "test_auth" # Watch mode npm test -- --watch pytest --watch ``` ### Claude's Testing Protocol 1. **Before co
# Claude Code Tools Reference Complete reference for every built-in tool available in Claude Code. ## File Tools ### Read Read file contents from the filesystem. ``` Parameters: file_path: string (required) — Absolute path to file offset: number (optional) — Start line number limit: number (optional) — Number of lines to read pages: string (optional) — Page range for PDFs (e.g., "1-5") Capabilities: - Text files with line numbers (cat -n format) - Image files (PNG, JPG, etc.) — r
# Claude Code Troubleshooting & Debugger Complete guide to diagnosing, debugging, and fixing Claude Code setup and runtime issues. ## Quick Diagnostics ### /doctor Command ``` /doctor ``` Runs automated health checks: - API key validation - Network connectivity - CLI version check - MCP server status - Configuration validation - Node.js version check ### Verbose Mode ```bash claude --verbose ``` Shows detailed debug output including: - API calls and responses - MCP server communication - Too
Step-by-step tutorials and worked examples for common Claude Code workflows — setup, debugging, code review, agent teams, hooks, memory, optimization, and CI/CD
Master all templating formats - Handlebars, Cookiecutter, Copier, Maven, and Harness - with format selection matrix, generation workflows, and best practices
Knowledge for exporting marketplace items as Cowork-compatible plugin ZIPs for distribution via Claude Desktop private marketplaces
ASP.NET Core API development with minimal APIs, controllers, middleware, OpenAPI, and best practices
Testing Blazor apps with bUnit, xUnit, WebApplicationFactory, and integration testing patterns
Background tasks and worker services with IHostedService, BackgroundService, and .NET hosted service patterns
Multi-platform diagram embedding guide for GitHub, Confluence, Jira, Azure DevOps, Notion, Teams, and Harness
UI/UX wireframe and mockup generation in draw.io at lo-fi, mid-fi, and hi-fi fidelity levels
This skill should be used when the user asks to "add logging", "implement metrics", "add tracing", "configure Prometheus", "setup OpenTelemetry", "add health checks", "monitor API", or mentions observability, APM, monitoring, structured logging, distributed tracing, or Grafana. Provides comprehensive observability patterns.
This skill should be used when the user asks to "reason through", "think step by step", "analyze systematically", "debug with hypotheses", "root cause analysis", "chain of thought", "tree of thought", "documentation lookup", or needs structured reasoning frameworks with mandatory documentation retrieval before analysis.
Plugin Dev Studio workflow for hot-reload development, interactive testing, dependency visualization, and validation of Claude Code plugins. Covers the full plugin development lifecycle from scaffold to publish.
MUI Base (unstyled/headless) components and hooks — useButton, useInput, useMenu, useSlider for building custom UI
MUI X Date/Time Pickers setup, configuration, and form integration
MUI theming system — createTheme, palette, typography, dark mode, component overrides, TypeScript augmentation, and design tokens
MUI sx prop and styled() API for component styling
Expertise in automated testing, code review practices, and quality standards enforcement. Activates when working with "lint", "test", "review", "coverage", "quality", "standards", or test automation.
Prompt caching for Claude API to reduce latency by up to 85% and costs by up to 90%. Activate for cache_control, ephemeral caching, cache breakpoints, and performance optimization.
# Research Tool Routing Optimal routing of research tasks across Perplexity MCP, Firecrawl MCP, and Context7 MCP. Each tool has distinct strengths — use the right one for each job. ## Tool Strengths at a Glance | Tool | Best For | Cost | Speed | |------|----------|------|-------| | **Context7** | Library/framework docs, API reference | Free | Fast (cached <5ms) | | **Perplexity Ask** | Knowledge Q&A, current events, fact-checking | ~$0.02/query | Fast | | **Perplexity Research** | Deep invest
Advanced patterns for Claude Code Agent Teams — topology design, cross-team communication, worktree coordination, failure handling, and cost management
Tool use patterns for Claude including schema design, tool_choice modes, result handling, parallel execution, error recovery, and extended thinking integration.
MUI accessibility patterns, ARIA attributes, and WCAG compliance
Document citations and RAG (Retrieval-Augmented Generation) patterns for Claude. Activate for source attribution, document grounding, citation extraction, and contextual retrieval.
# Multi-Tenant Architecture Multi-tenant architecture skill for Lobbi member management system. Activates when working with tenant isolation, organization context, or row-level security patterns. **Triggers:** multi-tenant, tenant, org_id, organization, isolation, tenant-aware, row-level-security, rls, organization_id **Use this skill when:** - Implementing tenant-scoped database queries - Adding organization context to API endpoints - Enforcing tenant isolation in repositories - Working with
Domain-Driven Design and CQRS patterns for .NET microservices including aggregates, value objects, domain events, repositories, and application layer design
Complete draw.io XML generation reference including mxGraphModel structure, cell types, style properties, and validation rules
Flask API development including blueprints, extensions, and REST patterns. Activate for Flask apps, Python web APIs, and lightweight API development.
Security-hardened hook script implementations — ready-to-paste templates for security-guard, auto-format, inject-context, session-init, on-stop, and lessons-learned-capture
Authentication and authorization in Blazor with ASP.NET Core Identity, Entra ID, JWT, and policy-based auth
Vision and multimodal capabilities for Claude including image analysis, PDF processing, and document understanding. Activate for image input, base64 encoding, multiple images, and visual analysis.
.NET microservices patterns including service decomposition, communication, CQRS, saga, and resilience
MUI internationalization, RTL support, locale customization, and bidirectional text
Harness Code repository workflows, triggers, PR pipelines, branch protection, and GitOps integration for AWS EKS deployments
Identifies cutting-edge, innovative upgrade opportunities based on tech stack and industry trends
MUI server-side rendering with Next.js — App Router, Pages Router, RSC compatibility, Emotion cache, and Pigment CSS
Core analysis patterns, detection heuristics, and scoring algorithms for the upgrade intelligence system
Authentication and authorization including JWT, OAuth2, OIDC, sessions, RBAC, and security analysis. Activate for login, auth flows, security audits, threat modeling, access control, and identity management.
AWS cloud services including EC2, EKS, S3, Lambda, RDS, and IAM. Activate for AWS infrastructure, cloud deployment, and Amazon Web Services integration.
Multi-step reasoning patterns and frameworks for systematic problem solving. Activate for Chain-of-Thought, Tree-of-Thought, hypothesis-driven debugging, and structured analytical approaches that leverage extended thinking.
FastAPI development including async endpoints, Pydantic models, dependency injection, and OpenAPI documentation. Activate for FastAPI apps, async Python APIs, and modern Python web services.
Comprehensive research on a topic using multiple sources and approaches. Spawns parallel research threads.
Prepare a Jira task with enrichment and subtask creation. Use when the user wants to "prepare task", "enrich issue", "create subtasks", or "prepare for development".
Check status of current Jira work session. Use when the user asks "what's the status", "show progress", "current work", or "jira status".
Triage and analyze Jira issues. Use when the user wants to "triage issues", "analyze backlog", "assess tickets", or "jira triage".
Audit K8s deployments for stale images, wrong pull policies, and volume issues. Use when debugging Helm deploy or image caching problems.
React development including hooks, components, state management, and modern patterns. Activate for React components, JSX, hooks, context, and frontend development.
Scrape and extract documentation from a URL using Firecrawl. Use when you need to read external documentation.
# Member Management Member management system skill for Lobbi. Activates when working with member CRUD operations, enrollment flows, membership tiers, or member directory features. **Triggers:** member, membership, enrollment, directory, member-profile, member-status, tier, dues, roster **Use this skill when:** - Implementing member CRUD operations - Building enrollment and onboarding flows - Managing membership tiers and dues - Creating member directory/search features - Handling member statu
Server-Sent Events (SSE) streaming for Claude API with support for text, tool use, and extended thinking. Activate for real-time responses, stream handling, and progressive output.
Deep web research using Perplexity and Firecrawl MCP servers. Use when researching technologies, APIs, best practices, or current information.
Validate Cookiecutter templates, Terraform modules, and Harness pipelines
# Example Skill This is an example skill for the langgraph-architect plugin. ## Activation Triggers This skill is activated when: - Working with example files - User mentions "example" in their request ## Domain Knowledge ### Concepts - Example patterns - Best practices - Common use cases ### File Patterns This skill recognizes: - `*.example` - Example files - `example.config.json` - Configuration files ## Examples ### Creating an Example ```bash # Create example file touch example.tx
Helm chart development workflow including chart structure, values management, testing, linting, and publishing for EKS deployments with Keycloak integration
Runtime behavior specs for the four autonomy profiles, the three autonomy agents (planner, verifier, reviewer), memory integration, context survival, and anti-patterns. Activate this skill to run the autonomy system — not just to read about it.
Enterprise-grade security patterns for Claude Code — audit logging, compliance frameworks, secrets management, permission hardening, network security, and managed settings enforcement
# Claude Code Hooks System Complete reference for the hooks lifecycle system. ## Overview Hooks are user-defined shell commands that execute at specific points in the Claude Code lifecycle. They run synchronously and can modify Claude's behavior by returning structured JSON. ## Hook Types ### All Lifecycle Events | Event | When | Can Block? | |-------|------|-----------| | `SessionStart` | Session begins/resumes | No | | `UserPromptSubmit` | Before processing user prompt | Yes (exit 2) | |
LSP server detection, installation, and Claude Code integration — auto-invoke when setting up a new project, running /cc-setup, or configuring IDE tooling
# MCP Servers in Claude Code Complete guide to Model Context Protocol server configuration and usage. ## Overview MCP (Model Context Protocol) allows Claude Code to connect to external servers that provide additional tools, resources, and capabilities. Supports 300+ external tools and services. ## Transport Types | Transport | Description | Recommended | |-----------|-------------|-------------| | `http` | HTTP-based (streamable) | Yes (recommended) | | `sse` | Server-Sent Events | Deprecat
Project sync and configuration propagation — auto-invoke when running /cc-sync or updating Claude Code setup across repos
# Claude Code Permissions & Security Complete reference for the permission model and security features. ## Permission Modes Claude Code operates in one of several permission modes: ### Default Mode (`default`) - Prompts on first use of each tool type - User approves/denies each tool call - Safest mode for general use ### Accept Edits Mode (`acceptEdits`) - Auto-approves file edits (Read, Write, Edit) - Still asks for Bash commands and other tools - Good balance for code-focused work ### Pl
# Claude Code Settings Deep Dive Complete reference for every settings option, configuration key, and customization. ## Settings File Locations | Location | Scope | Git Tracked | |----------|-------|-------------| | Managed (system-level) | Organization | `/Library/...` (macOS), `/etc/claude-code/` (Linux), `C:\Program Files\...` (Win) | | `~/.claude/settings.json` | User (all projects) | N/A | | `.claude/settings.json` | Project (shared) | Yes | | `.claude/settings.local.json` | Project (per
Expert-level Harness template types, runtime inputs, expression language, pipeline patterns (CI/CD, GitOps, Canary, Blue-Green), versioning, and step configurations
JavaScript interop in Blazor for calling JS from .NET and .NET from JS
Multi-container .NET applications with Docker Compose, container orchestration, and development environments
.NET Aspire for cloud-native app orchestration, service discovery, telemetry, and component integrations
gRPC service development in .NET for high-performance inter-service communication
Master reference catalog of 190+ diagram types organized by category with selection guide, complexity ratings, stencil references, and XML examples
Index of draw.io XML templates by diagram type — reference when generating diagrams
FastAPI best practices, Pydantic models, SQLAlchemy ORM, async patterns, dependency injection, and JWT authentication. Activate for FastAPI apps, async Python APIs, API design, and modern Python web services.
UI component patterns with style-specific implementations and accessibility
Multi-tenant Keycloak authentication theming with realm-specific design systems
MERN stack patterns including React with Vite, Express middleware, MongoDB schemas, API Gateway architecture, session management, error handling, and testing strategies. Activate for MERN development, microservices architecture, and full-stack JavaScript applications.
Keycloak administration including realm management, client configuration, OAuth 2.0 setup, user management with custom attributes, role and group management, theme deployment, and token configuration. Activate for Keycloak Admin API operations, authentication setup, and identity provider configuration.
Federated registry protocol for multi-source plugin resolution with policy enforcement, lockfile management, and conflict detection across local, team, org, and public registries.
MUI X Charts — BarChart, LineChart, PieChart, ScatterChart, composition API, custom axes, tooltips, and responsive patterns
MUI CSS Variables mode (CssVarsProvider), Pigment CSS zero-runtime engine, and CSS custom properties theming
MUI ecosystem — FormEngine, react-jsonschema-form, Uniforms, schema-driven forms, Tailwind interop, Framer Motion, and third-party component libraries
MUI X Tree View — SimpleTreeView, RichTreeView, lazy loading, custom icons, multiselect, drag-and-drop, and virtualization
Expertise in deployment automation, container orchestration, and infrastructure as code. Activates when working with "deploy", "kubernetes", "docker", "terraform", "helm", "k8s", "container", or cloud infrastructure.
Expertise in CI/CD pipeline creation, process automation, and team workflow optimization. Activates when working with "automate", "pipeline", "workflow", "CI/CD", "process", or automation tools.
# Claude Code Configuration Complete guide to all configuration files, settings, and directory structure. ## Directory Structure ``` project/ ├── .claude/ │ ├── CLAUDE.md # Project-level instructions (checked into git) │ ├── settings.json # Project-level settings (checked into git) │ ├── settings.local.json # Local overrides (gitignored) │ ├── rules/ # Path-scoped rule files │ ├── skills/ # Reusable workflow definitions │ ├── agents/
Access 263+ design styles with AI-optimized prompt keywords for frontend development
Domain knowledge for the cowork marketplace seed catalog, including all 17 items mapped to 16 installed plugins with their agents, skills, and commands
This skill should be used when the user asks to "orchestrate jira", "work on issue", "complete jira ticket", "development workflow", "jira automation", "issue lifecycle", "work on story", "fix bug ticket", or needs guidance on coordinating development work through Jira with multi-agent orchestration patterns.
Scrum methodology including sprints, ceremonies, backlog management, and agile practices. Activate for sprint planning, standups, retrospectives, and agile workflows.
MUI layout components and responsive design patterns
Metadata-driven CRUD with MUI X DataGrid + FormEngine — entity metadata model, server-driven UI, column/form generation, shared validation, access control, wizard flows
.NET AI integration with Microsoft.Extensions.AI, Semantic Kernel, MCP servers, embeddings, vector search, and agent frameworks
Create smart commit linked to Jira issue. Use when the user wants to "commit", "smart commit", "jira commit", or "commit changes".
Git workflows including branching strategies, commits, merging, rebasing, and GitHub collaboration. Activate for git commands, version control, PRs, and repository management.
This skill should be used when the user asks to "triage issue", "classify ticket", "route jira", "analyze priority", "categorize issue", "determine complexity", "route to agents", or needs guidance on classifying, prioritizing, and routing Jira issues to appropriate agents and workflows.
# Channels User Guide > Push events into a running Claude Code session with channels. > Forward CI results, chat messages, monitoring alerts, and webhook events so Claude can react while you're away. > Requires Claude Code v2.1.80+. Research preview — requires claude.ai login. ## Overview A channel is an MCP server that pushes events into your running Claude Code session, so Claude can react to things that happen while you're not at the terminal. Channels can be two-way: Claude reads the even
# Context Anchoring System Preserve critical information across `/compact` events, session boundaries, and agent handoffs. Context anchoring ensures your most important rules, decisions, and state survive compression. ## What Survives Compaction ``` ┌─────────────────────────────────────────────────┐ │ ANCHORED (survives /compact) │ │ │ │ CLAUDE.md ← Full file, re-injected │ │ .claude/rules/* ← All matching ru
Supply chain security model for the marketplace plugin ecosystem
This skill should be used when the user asks to "add Keycloak authentication", "implement OIDC", "configure SSO", "validate JWT token", "add role-based access", "protect API endpoint", or mentions Keycloak, OAuth2, OpenID Connect, identity provider, or authentication in FastAPI. Provides Keycloak/OIDC integration patterns.
Gantt charts, Kanban boards, scheduling, and resource management libraries that integrate with MUI — SVAR, DHTMLX, Bryntum, Syncfusion, FullCalendar, dnd-kit, and architecture patterns
Research agent configurations for gathering data to build accurate, detailed diagrams
Enriches Jira tasks with comprehensive context, requirements analysis, and technical details through intelligent extraction, dependency mapping, and historical analysis
Harness MCP (Model Context Protocol) server integration for AI-powered CD operations, pipeline management, Git repositories, pull requests, code review comments, and bidirectional Jira synchronization
Harness CI (Continuous Integration) for container-native builds, test intelligence, caching, parallelization, and build infrastructure management. Activate for build pipelines, CI steps, test automation, artifact publishing, and build optimization.
This skill should be used when the user asks to "confluence page", "create documentation", "tech design", "write to confluence", "read from confluence", "link confluence", "create TDD", "write runbook", "meeting notes", "release notes", "architecture decision", or needs guidance on creating, managing, and organizing documentation in Confluence with integration to Jira workflows.
Clean Architecture and SOLID principles implementation including dependency injection, layer separation, domain-driven design, hexagonal architecture, and code quality patterns
This skill should be used when the user asks to "triage issue", "classify ticket", "route jira", "analyze priority", "categorize issue", "determine complexity", "route to agents", or needs guidance on classifying, prioritizing, and routing Jira issues to appropriate agents and workflows.
Comprehensive knowledge for creating, managing, and merging pull requests with Jira integration, following best practices for code review, deployment, and team collaboration
Harness CD (Continuous Delivery) for Kubernetes, Helm, Terraform, ECS, and serverless deployments with GitOps, approval gates, rollback strategies, and multi-environment promotion
Comprehensive code review knowledge including security, performance, accessibility, and quality standards across multiple languages and frameworks
This skill should be used when the user asks to "orchestrate jira", "work on issue", "complete jira ticket", "development workflow", "jira automation", "issue lifecycle", "work on story", "fix bug ticket", or needs guidance on coordinating development work through Jira with multi-agent orchestration patterns.
Harness Platform administration including delegates, RBAC, connectors, secrets, templates, policy as code (OPA), user management, audit logs, and governance. Activate for Harness setup, administration, access control, and platform configuration.