Scan your Claude Code configuration (.claude/ directory) for security vulnerabilities, misconfigurations, and injection risks using AgentShield. Checks CLAUDE.md, settings.json, MCP servers, hooks, and agent definitions.

When to Activate

Setting up a new Claude Code project

After modifying `.claude/settings.json`, `CLAUDE.md`, or MCP configs

Before committing configuration changes

When onboarding to a new repository with existing Claude Code configs

Periodic security hygiene checks


Research-before-coding workflow. Search for existing tools, libraries, and patterns before writing custom code. Invokes the researcher agent.

/search-first — Research Before You Code

How to Use

Quick Mode (inline)

Before writing a utility or adding functionality, mentally run through:

Does this already exist in the repo? → `rg` through relevant modules/tests first

Is this a common problem? → Search npm/PyPI

Is there an MCP for this? → Check `~/.claude/settings.json` and search

Is there a skill for this? → Check `~/.claude/skills/`

Is there a GitHub implementation/template? → Run GitHub code search for maintained OSS before writing net-new code


Idiomatic C# and .NET patterns, conventions, dependency injection, async/await, and best practices for building robust, maintainable .NET applications.

.NET Development Patterns
Options Pattern

Async/Await Patterns

Proper Async Usage

Parallel Async Operations

Options Pattern

Bind configuration sections to strongly-typed objects.


X/Twitter API integration for posting tweets, threads, reading timelines, search, and analytics. Covers OAuth auth patterns, rate limits, and platform-native content posting. Use when the user wants to interact with X programmatically.

Core Operations

Post a Tweet

Post a Thread

Read User Timeline

Search Tweets

Pull Recent Original Posts for Voice Modeling


Convene a four-voice council for ambiguous decisions, tradeoffs, and go/no-go calls. Use when multiple valid paths exist and you need structured disagreement before choosing.

Anti-Patterns

using council for code review

using council when the task is just implementation work

feeding the subagents the entire conversation transcript

hiding disagreement in the final verdict

persisting every decision as a note regardless of importance


Head-to-head comparison of coding agents (Claude Code, Aider, Codex, etc.) on custom tasks with pass rate, cost, time, and consistency metrics

2. Run Agents

Execute agents against your tasks:

Each run:

Creates a fresh git worktree from the specified commit

Hands the prompt to the agent

Runs the judge criteria

Records pass/fail, cost, and time


Use this skill to generate or audit design systems, check visual consistency, and review PRs that touch styling.

Design System — Generate & Audit Visual Systems

When to Use

Starting a new project that needs a design system

Auditing an existing codebase for visual consistency

Before a redesign — understand what you have

When the UI looks "off" but you can't pinpoint why

Reviewing PRs that touch styling


Transform Claude Code into a fully autonomous agent system with persistent memory, scheduled operations, computer use, and task queuing. Replaces standalone agent frameworks (Hermes, AutoGPT) by leveraging Claude Code's native crons, dispatch, MCP tools, and memory. Use when the user wants continuous autonomous operation, scheduled tasks, or a self-directing agent loop.

Autonomous Agent Harness
Setup Guide
Step 1: Configure MCP Servers

Setup Guide

Step 1: Configure MCP Servers

Ensure these are in `~/.claude.json`:


Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

Frontend Slides
Implementation Requirements
HTML / CSS

Implementation Requirements

HTML / CSS

Use inline CSS and JS unless the user explicitly wants a multi-file project.

Fonts may come from Google Fonts or Fontshare.

Prefer atmospheric backgrounds, strong type hierarchy, and a clear visual direction.

Use abstract shapes, gradients, grids, noise, and geometry rather than illustrations.


Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA standards. Use this skill to generate semantic ARIA for Web and accessibility traits for Web and Native platforms (iOS/Android).

Accessibility (WCAG 2.2)
How It Works
Step 1: Identify the Component Role

How It Works

Step 1: Identify the Component Role

Determine the functional purpose (e.g., Is this a button, a link, or a tab?). Use the most semantic native element available before resorting to custom roles.


Codified expertise for managing carrier portfolios, negotiating freight rates, tracking carrier performance, allocating freight, and maintaining strategic carrier relationships. Informed by transportation managers with 15+ years experience. Includes scorecarding frameworks, RFP processes, market intelligence, and compliance vetting. Use when managing carriers, negotiating rates, evaluating carrier performance, or building freight strategies.

Carrier Relationship Management
Decision Frameworks
Carrier Exit Criteria

Carrier Exit Criteria

Remove a carrier from your active routing guide when any of these thresholds are met, after documented corrective action has failed:

OTD below 85% for 60 consecutive days

Tender acceptance below 70% for 30 consecutive days with no communication

Claims ratio exceeds 2% of spend for 90 days

FMCSA authority revoked, insurance lapsed, or safety rating downgraded to Unsatisfactory

Invoice accuracy below 88% for 90 days after corrective notice

Discovery of double-brokering your freight

Evidence of financial distress: bond revocation, driver complaints on CarrierOK or Carrier411, unexplained service collapse


Hunt for exploitable, bounty-worthy security issues in repositories. Focuses on remotely reachable vulnerabilities that qualify for real reports instead of noisy local-only findings.

Security Bounty Hunter

Use this when the goal is practical vulnerability discovery for responsible disclosure or bounty submission, not a broad best-practices review.


Build monitoring dashboards that answer real operator questions for Grafana, SigNoz, and similar platforms. Use when turning metrics into a working dashboard instead of a vanity board.

Dashboard Builder
Workflow
2. Study the target platform schema

2. Study the target platform schema

Inspect existing dashboards first:

JSON structure

query language

variables

threshold styling

section layout


Open-source pipeline: fork, sanitize, and package private projects for safe public release. Chains 3 agents (forker, sanitizer, packager). Triggers: '/opensource', 'open source this', 'make this public', 'prepare for open source'.

Open-Source Pipeline Skill
Protocol
/opensource list

/opensource list

Show each project with pipeline progress (FORK_REPORT.md, SANITIZATION_REPORT.md, CLAUDE.md presence).


Cost optimization patterns for LLM API usage — model routing by task complexity, budget tracking, retry logic, and prompt caching.

Cost-Aware LLM Pipeline
When to Activate

When to Activate

Building applications that call LLM APIs (Claude, GPT, etc.)

Processing batches of items with varying complexity

Need to stay within a budget for API spend

Optimizing cost without sacrificing quality on complex tasks


Create CodeTour `.tour` files — persona-targeted, step-by-step walkthroughs with real file and line anchors. Use for onboarding tours, architecture walkthroughs, PR tours, RCA tours, and structured "explain how this works" requests.

Narrative Shape

Use this arc unless the task clearly needs something different:

orientation

module map

core execution path

edge case or gotcha

closing / next move

The tour should feel like a path, not an inventory.


Draft cold emails, warm intro blurbs, follow-ups, update emails, and investor communications for fundraising. Use when the user wants outreach to angels, VCs, strategic investors, or accelerators and needs concise, personalized, investor-facing messaging.

Post-Meeting Updates

Include:

the specific thing discussed

the answer or update promised

one new proof point if available

the next step


Trigger

Use this skill when:

Starting a new feature that likely has existing solutions

Adding a dependency or integration

The user asks "add X functionality" and you're about to write code

Before creating a new utility, helper, or abstraction


Protected Health Information (PHI) and Personally Identifiable Information (PII) compliance patterns for healthcare applications. Covers data classification, access control, audit trails, encryption, and common leak vectors.

Healthcare PHI/PII Compliance Patterns
How It Works
Data Classification

Data Classification

**PHI (Protected Health Information)** — any data that can identify a patient AND relates to their health: patient name, date of birth, address, phone, email, national ID numbers (SSN, Aadhaar, NHS number), medical record numbers, diagnoses, medications, lab results, imaging, insurance policy and claim details, appointment and admission records, or any combination of the above.

**PII (Non-patient-sensitive data)** in healthcare systems: clinician/staff personal details, doctor fee structures and payout amounts, employee salary and bank details, vendor payment information.


Capture architectural decisions made during Claude Code sessions as structured ADRs. Auto-detects decision moments, records context, alternatives considered, and rationale. Maintains an ADR log so future developers understand why the codebase is shaped the way it is.

Architecture Decision Records
ADR Format

ADR Format

Use the lightweight ADR format proposed by Michael Nygard, adapted for AI-assisted development:


JPA/Hibernate patterns for entity design, relationships, query optimization, transactions, auditing, indexing, pagination, and pooling in Spring Boot.

Repository Patterns

Use projections for lightweight queries:

Transactions

Annotate service methods with `@Transactional`

Use `@Transactional(readOnly = true)` for read paths to optimize

Choose propagation carefully; avoid long-running transactions


See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

VideoDB Skill
When to use
Live streams (RTSP) + monitoring

Live streams (RTSP) + monitoring

Connect **RTSP/live feeds**

Run **real-time visual and spoken understanding** and emit **events/alerts** for monitoring workflows


Create distinctive, production-grade frontend interfaces with high design quality. Use when the user asks to build web components, pages, or applications and the visual direction matters as much as the code quality.

Color

commit to a clear palette

one dominant field with selective accents usually works better than evenly weighted rainbow palettes

avoid cliché purple-gradient-on-white unless the product genuinely calls for it


Multi-agent orchestration using dmux (tmux pane manager for AI agents). Patterns for parallel agent workflows across Claude Code, Codex, OpenCode, and other harnesses. Use when running multiple agent sessions in parallel or coordinating multi-agent development workflows.

Troubleshooting

**Pane not responding:** Switch to the pane directly or inspect it with `tmux capture-pane -pt <session>:0.<pane-index>`.

**Merge conflicts:** Use git worktrees to isolate file changes per pane.

**High token usage:** Reduce number of parallel panes. Each pane is a full agent session.

**tmux not found:** Install with `brew install tmux` (macOS) or `apt install tmux` (Linux).


Laravel security best practices for authn/authz, validation, CSRF, mass assignment, file uploads, secrets, rate limiting, and secure deployment.

Laravel Security Best Practices
Rate Limiting

Rate Limiting

Apply `throttle` middleware on auth and write endpoints

Use stricter limits for login, password reset, and OTP


Suggests manual context compaction at logical intervals to preserve context through task phases rather than arbitrary auto-compaction.

How It Works

The `suggest-compact.js` script runs on PreToolUse (Edit/Write) and:

**Tracks tool calls** — Counts tool invocations in session

**Threshold detection** — Suggests at configurable threshold (default: 50 calls)

**Periodic reminders** — Reminds every 25 calls after threshold


Related Skills

`frontend-patterns`

`frontend-design`

`liquid-glass-design`

`swiftui-patterns`


Turn a one-line objective into a step-by-step construction plan for multi-session, multi-agent engineering projects. Each step has a self-contained context brief so a fresh agent can execute it cold. Includes adversarial review gate, dependency graph, parallel step detection, anti-pattern catalog, and plan mutation protocol. TRIGGER when: user requests a plan, blueprint, or roadmap for a complex multi-PR task, or describes work that needs multiple sessions. DO NOT TRIGGER when: task is completable in a single PR or fewer than 3 tool calls, or user says "just do it".

Blueprint — Construction Plan Generator
Installation
Vendored standalone install

Vendored standalone install

If you are vendoring only this skill outside the full ECC install, copy the reviewed file from the ECC repository into `~/.claude/skills/blueprint/SKILL.md`. Vendored copies do not have a git remote, so update them by re-copying the file from a reviewed ECC commit rather than running `git pull`.


Multi-platform content distribution across X, LinkedIn, Threads, and Bluesky. Adapts content per platform using content-engine patterns. Never posts identical content cross-platform. Use when the user wants to distribute content across social platforms.

Crosspost
Workflow
Step 1: Start with the Primary Version

Workflow

Step 1: Start with the Primary Version

Pick the strongest source version first:

the original X post

the original article

the launch note

the thread

the memo or changelog

Use `content-engine` first if the source still needs voice shaping.


Codified expertise for demand forecasting, safety stock optimization, replenishment planning, and promotional lift estimation at multi-location retailers. Informed by demand planners with 15+ years experience managing hundreds of SKUs. Includes forecasting method selection, ABC/XYZ analysis, seasonal transition management, and vendor negotiation frameworks. Use when forecasting demand, setting safety stock, planning replenishment, managing promotions, or optimizing inventory levels.

When to Use

Generating or reviewing demand forecasts for existing or new SKUs

Setting safety stock levels based on demand variability and service level targets

Planning replenishment for seasonal transitions, promotions, or new product launches

Evaluating forecast accuracy and adjusting models or overrides

Making buy decisions under supplier MOQ constraints or lead time changes


AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

Video Editing
Layer 2: Organization (Claude / Codex)

Layer 2: Organization (Claude / Codex)

Use Claude Code or Codex to:

**Transcribe and label**: generate transcript, identify topics and themes

**Plan structure**: decide what stays, what gets cut, what order works

**Identify dead sections**: find pauses, tangents, repeated takes

**Generate edit decision list**: timestamps for cuts, segments to keep

**Scaffold FFmpeg and Remotion code**: generate the commands and compositions

This layer is about structure, not final creative taste.


Neural search via Exa MCP for web, code, and company research. Use when the user needs web search, code examples, company intel, people lookup, or AI-powered deep research with Exa's neural search engine.

MCP Requirement

Exa MCP server must be configured. Add to `~/.claude.json`:

Get an API key at [exa.ai](https://exa.ai).
This repo's current Exa setup documents the tool surface exposed here: `web_search_exa` and `get_code_context_exa`.
If your Exa server exposes additional tools, verify their exact names before depending on them in docs or prompts.


Cache expensive file processing results using SHA-256 content hashes — path-independent, auto-invalidating, with service layer separation.

Content-Hash File Cache Pattern

Cache expensive file processing results (PDF parsing, text extraction, image analysis) using SHA-256 content hashes as cache keys. Unlike path-based caching, this approach survives file moves/renames and auto-invalidates when content changes.


Verification loop for Laravel projects: env checks, linting, static analysis, tests with coverage, security scans, and deployment readiness.

Laravel Verification Loop
Phase 5: Database and Migrations

Phase 4: Security and Dependency Checks

Phase 5: Database and Migrations

Review destructive migrations carefully

Ensure migration filenames follow `Y_m_d_His_*` (e.g., `2025_03_14_154210_create_orders_table.php`) and describe the change clearly

Ensure rollbacks are possible

Verify `down()` methods and avoid irreversible data loss without explicit backups


Operate execution flow across GitHub and Linear by triaging issues and pull requests, linking active work, and keeping GitHub public-facing while Linear remains the internal execution layer. Use when the user wants backlog control, PR triage, or GitHub-to-Linear coordination.

Project Flow Ops
Core Workflow
3. Decide whether Linear is warranted

3. Decide whether Linear is warranted

Create or update Linear only if:

execution is actively planned

multiple repos or workstreams are involved

the work needs internal ownership or sequencing

the issue is part of a larger program lane

Do not mirror everything mechanically.


Patterns and architectures for autonomous Claude Code loops — from simple sequential pipelines to RFC-driven multi-agent DAG systems.

Autonomous Loops Skill
5. The De-Sloppify Pattern
The Problem

The Problem

When you ask an LLM to implement with TDD, it takes "write tests" too literally:

Tests that verify TypeScript's type system works (testing `typeof x === 'string'`)

Overly defensive runtime checks for things the type system already guarantees

Tests for framework behavior rather than business logic

Excessive error handling that obscures the actual code


REST API design patterns including resource naming, status codes, pagination, filtering, error responses, versioning, and rate limiting for production APIs.

API Design Patterns
Versioning
URL Path Versioning (Recommended)

Versioning

URL Path Versioning (Recommended)

**Pros:** Explicit, easy to route, cacheable
**Cons:** URL changes between versions


Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

6. Validate

Check the finished deck at these sizes:

1920x1080

1280x720

768x1024

375x667

667x375

If browser automation is available, use it to verify no slide overflows and that keyboard navigation works.


VideoDB Skill
How it works
1. Install SDK

Setup

When the user asks to "setup videodb" or similar:

1. Install SDK

If `videodb[capture]` fails on Linux, install without the capture extra:


Write-time code quality enforcement using Plankton — auto-formatting, linting, and Claude-powered fixes on every file edit via hooks.

Plankton Code Quality Skill
How It Works
Package Manager Enforcement

Package Manager Enforcement

A PreToolUse hook on Bash blocks legacy package managers:

`pip`, `pip3`, `poetry`, `pipenv` → Blocked (use `uv`)

`npm`, `yarn`, `pnpm` → Blocked (use `bun`)

Allowed exceptions: `npm audit`, `npm view`, `npm publish`


AI-native lead intelligence and outreach pipeline. Replaces Apollo, Clay, and ZoomInfo with agent-powered signal scoring, mutual ranking, warm path discovery, source-derived voice modeling, and channel-specific outreach across email, LinkedIn, and X. Use when the user wants to find, qualify, and reach high-value contacts.

Lead Intelligence
Stage 4: Enrichment
Enrichment Sources

Enrichment Sources

Exa: company data, news, blog posts

X API: recent tweets, bio, followers

GitHub: open source contributions (for developer-centric leads)

LinkedIn (via browser-use): full profile, experience, education


Codified expertise for electricity and gas procurement, tariff optimization, demand charge management, renewable PPA evaluation, and multi-facility energy cost management. Informed by energy procurement managers with 15+ years experience at large commercial and industrial consumers. Includes market structure analysis, hedging strategies, load profiling, and sustainability reporting frameworks. Use when procuring energy, optimizing tariffs, managing demand charges, evaluating PPAs, or developing energy strategies.

Energy Procurement
Core Knowledge
Load Profiling

Load Profiling

Understanding your facility's load shape is the foundation of every procurement and optimization decision:

**Base vs. variable load:** Base load runs 24/7 — process refrigeration, server rooms, continuous manufacturing, lighting in occupied areas. Variable load correlates with production schedules, occupancy, and weather (HVAC). A facility with a 0.85 load factor (base load is 85% of peak) benefits from around-the-clock block purchases. A facility with a 0.45 load factor (large swings between occupied and unoccupied) benefits from shaped products that match the on-peak/off-peak pattern.

**Load factor:** Average demand divided by peak demand. Load factor = (Total kWh) / (Peak kW × Hours in period). A high load factor (>0.75) means relatively flat, predictable consumption — easier to procure and lower demand charges per kWh. A low load factor (<0.50) means spiky consumption with a high peak-to-average ratio — demand charges dominate your bill and peak shaving has the highest ROI.

**Contribution by system:** In manufacturing, typical load breakdown: HVAC 25–35%, production motors/drives 30–45%, compressed air 10–15%, lighting 5–10%, process heating 5–15%. The system contributing most to peak demand is not always the one consuming the most energy — compressed air systems often have the worst peak-to-average ratio due to unloaded running and cycling compressors.


Use when auditing Claude skills and commands for quality. Supports Quick Scan (changed skills only) and Full Stocktake modes with sequential subagent batch evaluation.

skill-stocktake
Full Stocktake Flow
Phase 4 — Consolidation

Phase 4 — Consolidation

**Retire / Merge**: present detailed justification per file before confirming with user:

What specific problem was found (overlap, staleness, broken references, etc.)

What alternative covers the same functionality (for Retire: which existing skill/rule; for Merge: the target file and what content to integrate)

Impact of removal (any dependent skills, MEMORY.md references, or workflows affected)

**Improve**: present specific improvement suggestions with rationale:

What to change and why (e.g., "trim 430→200 lines because sections X/Y duplicate python-patterns")

User decides whether to act

**Update**: present updated content with sources checked

Check MEMORY.md line count; propose compression if >100 lines


Discover and evaluate Laravel packages via LaraPlugins.io MCP. Use when the user wants to find plugins, check package health, or assess Laravel/PHP compatibility.

Laravel Plugin Discovery
Response Interpretation
Package Details

Package Details

The detailed response includes:

**Health Score**: Numeric or band indicator

**Last Activity**: When the package was last updated

**Laravel Support**: Version compatibility matrix

**PHP Support**: PHP version compatibility

**Risk Score**: Vendor trust indicators

**Version History**: Recent release timeline


Ktor server patterns including routing DSL, plugins, authentication, Koin DI, kotlinx.serialization, WebSockets, and testApplication testing.

Ktor Server Patterns
Koin Dependency Injection
Koin for Testing

Koin Dependency Injection

Module Definition

Using Koin in Routes

Koin for Testing


Formal evaluation framework for Claude Code sessions implementing eval-driven development (EDD) principles

Eval Harness Skill
Eval Types
Capability Evals

Eval Types

Capability Evals

Test if Claude can do something it couldn't before:


Structured self-debugging workflow for AI agent failures using capture, diagnosis, contained recovery, and introspection reports.

Agent Introspection Debugging
Output Standard

Output Standard

When this skill is active, do not end with “I fixed it” alone.

Always provide:

the failure pattern

the root-cause hypothesis

the recovery action

the evidence that the situation is now better or still blocked


Codified expertise for quality control, non-conformance investigation, root cause analysis, corrective action, and supplier quality management in regulated manufacturing. Informed by quality engineers with 15+ years experience across FDA, IATF 16949, and AS9100 environments. Includes NCR lifecycle management, CAPA systems, SPC interpretation, and audit methodology. Use when investigating non-conformances, performing root cause analysis, managing CAPAs, interpreting SPC data, or handling supplier quality issues.

Quality & Non-Conformance Management
How It Works

How It Works

Detect the non-conformance through inspection, SPC alert, or customer complaint

Contain affected material immediately (quarantine, production hold, shipment stop)

Classify severity (critical, major, minor) based on safety impact and regulatory requirements

Investigate root cause using structured methodology appropriate to complexity

Determine disposition based on engineering evaluation, regulatory constraints, and economics

Implement corrective action, verify effectiveness, and close the CAPA with evidence


Library-agnostic Flutter/Dart code review checklist covering widget best practices, state management patterns (BLoC, Riverpod, Provider, GetX, MobX, Signals), Dart idioms, performance, accessibility, security, and clean architecture.

Flutter/Dart Code Review Best Practices
8. Platform-Specific Concerns
Responsive design:

Responsive design:

[ ] `LayoutBuilder` or `MediaQuery` used for responsive layouts

[ ] Breakpoints defined consistently (phone, tablet, desktop)

[ ] Text doesn't overflow on small screens — use `Flexible`, `Expanded`, `FittedBox`

[ ] Landscape orientation tested or explicitly locked

[ ] Web-specific: mouse/keyboard interactions supported, hover states present


Capture architectural decisions made during Claude Code sessions as structured ADRs. Auto-detects decision moments, records context, alternatives considered, and rationale. Maintains an ADR log so future developers understand why the codebase is shaped the way it is.

Architecture Decision Records
Decision Detection Signals

ADR Directory Structure

ADR Index Format

Decision Detection Signals

Watch for these patterns in conversation that indicate an architectural decision:

**Explicit signals**

"Let's go with X"

"We should use X instead of Y"

"The trade-off is worth it because..."

"Record this as an ADR"

**Implicit signals** (suggest recording an ADR — do not auto-create without user confirmation)

Comparing two frameworks or libraries and reaching a conclusion

Making a database schema design choice with stated rationale

Choosing between architectural patterns (monolith vs microservices, REST vs GraphQL)

Deciding on authentication/authorization strategy

Selecting deployment infrastructure after evaluating alternatives


Codified expertise for production scheduling, job sequencing, line balancing, changeover optimization, and bottleneck resolution in discrete and batch manufacturing. Informed by production schedulers with 15+ years experience. Includes TOC/drum-buffer-rope, SMED, OEE analysis, disruption response frameworks, and ERP/MES interaction patterns. Use when scheduling production, resolving bottlenecks, optimizing changeovers, responding to disruptions, or balancing manufacturing lines.

How It Works

Identify the system constraint (bottleneck) using OEE data and capacity utilization

Classify demand by priority: past-due, constraint-feeding, and remaining jobs

Sequence jobs using dispatching rules (EDD, SPT, or setup-aware EDD) appropriate to the product mix

Optimize changeover sequences using the setup matrix and nearest-neighbor heuristic with 2-opt improvement

Lock a stabilization window (typically 24–48 hours) to prevent schedule churn on committed jobs

Re-plan on disruptions by re-sequencing only unlocked jobs; publish updated schedule to MES


HIPAA-specific entrypoint for healthcare privacy and security work. Use when a task is explicitly framed around HIPAA, PHI handling, covered entities, BAAs, breach posture, or US healthcare compliance requirements.

When to Use

The request explicitly mentions HIPAA, PHI, covered entities, business associates, or BAAs

Building or reviewing US healthcare software that stores, processes, exports, or transmits PHI

Assessing whether logging, analytics, LLM prompts, storage, or support workflows create HIPAA exposure

Designing patient-facing or clinician-facing systems where minimum necessary access and auditability matter


Modern Perl 5.36+ idioms, best practices, and conventions for building robust, maintainable Perl applications.

Modern Perl Development Patterns
Anti-Patterns

Anti-Patterns

**Remember**: Modern Perl is clean, readable, and safe. Let `use v5.36` handle the boilerplate, use Moo for objects, and prefer CPAN's battle-tested modules over hand-rolled solutions.


Operate notifications as one ECC-native workflow across GitHub, Linear, desktop alerts, hooks, and connected communication surfaces. Use when the real problem is alert routing, deduplication, escalation, or inbox collapse.

Unified Notifications Ops
Workflow
2. Decide what deserves interruption

2. Decide what deserves interruption

For each event family, answer:

who needs to know?

how fast do they need to know?

should this interrupt, batch, or just log?

Use these defaults:

interrupt for release, CI, security, and owner-blocking events

digest for medium-signal updates

log-only for telemetry and low-signal lifecycle markers


Unified media generation via fal.ai MCP — image, video, and audio. Covers text-to-image (Nano Banana), text/image-to-video (Seedance, Kling, Veo 3), text-to-speech (CSM-1B), and video-to-audio (ThinkSound). Use when the user wants to generate images, videos, or audio with AI.

MCP Tools

The fal.ai MCP provides these tools:

`search` — Find available models by keyword

`find` — Get model details and parameters

`generate` — Run a model with parameters

`result` — Check async generation status

`status` — Check job status

`cancel` — Cancel a running job

`estimate_cost` — Estimate generation cost

`models` — List popular models

`upload` — Upload files for use as inputs


为 OpenClaw AI Agent 锻造完整的龙虾灵魂方案。根据用户偏好或随机抽卡，
输出身份定位、灵魂描述(SOUL.md)、角色化底线规则、名字和头像生图提示词。
如当前环境提供已审核的生图 skill，可自动生成统一风格头像图片。
当用户需要创建、设计或定制 OpenClaw 龙虾灵魂时使用。
不适用于：微调已有 SOUL.md、非 OpenClaw 平台的角色设计、纯工具型无性格 Agent。
触发词：龙虾灵魂、虾魂、OpenClaw 灵魂、养虾灵魂、龙虾角色、龙虾定位、
龙虾剧本杀角色、龙虾游戏角色、龙虾 NPC、龙虾性格、龙虾背景故事、
lobster soul、lobster character、抽卡、随机龙虾、龙虾 SOUL、gacha。

龙虾灵魂锻造炉
Step 5：生成头像

Step 5：生成头像

**风格基底、变量、提示词模板**：见 [references/avatar-style.md](references/avatar-style.md)


Build an evidence-backed ECC install plan for a specific repo by sorting skills, commands, rules, hooks, and extras into DAILY vs LIBRARY buckets using parallel repo-aware review passes. Use when ECC should be trimmed to what a project actually needs instead of loading the full bundle.

When to Use

A project only needs a subset of ECC and full installs are too noisy

The repo stack is clear, but nobody wants to hand-curate skills one by one

A team wants a repeatable install decision backed by grep evidence instead of opinion

You need to separate always-loaded daily workflow surfaces from searchable library/reference surfaces

A repo has drifted into the wrong language, rule, or hook set and needs cleanup


Use this skill to measure performance baselines, detect regressions before/after PRs, and compare stack alternatives.

Benchmark — Performance Baseline & Regression Detection

Mode 4: Before/After Comparison

Run before and after a change to measure impact:

Output:


Create and update pitch decks, one-pagers, investor memos, accelerator applications, financial models, and fundraising materials. Use when the user needs investor-facing documents, projections, use-of-funds tables, milestone plans, or materials that must stay internally consistent across multiple fundraising assets.

Investor Materials
Asset Guidance
Financial Model

Financial Model

Include:

explicit assumptions

bear / base / bull cases when useful

clean layer-by-layer revenue logic

milestone-linked spending

sensitivity analysis where the decision hinges on assumptions


REST API design patterns including resource naming, status codes, pagination, filtering, error responses, versioning, and rate limiting for production APIs.

API Design Patterns
HTTP Methods and Status Codes
Method Semantics

Resource Design

URL Structure

Naming Rules

HTTP Methods and Status Codes

Method Semantics

| Method | Idempotent | Safe | Use For |
|--------|-----------|------|---------|
| GET | Yes | Yes | Retrieve resources |
| POST | No | No | Create resources, trigger actions |
| PUT | Yes | No | Full replacement of a resource |
| PATCH | No* | No | Partial update of a resource |
| DELETE | Yes | No | Remove a resource |

*PATCH can be made idempotent with proper implementation


Use only when writing/updating/fixing C++ tests, configuring GoogleTest/CTest, diagnosing failing or flaky tests, or adding coverage/sanitizers.

TDD Workflow

Follow the RED → GREEN → REFACTOR loop:

**RED**: write a failing test that captures the new behavior

**GREEN**: implement the smallest change to pass

**REFACTOR**: clean up while tests stay green


Test-driven development for Spring Boot using JUnit 5, Mockito, MockMvc, Testcontainers, and JaCoCo. Use when adding features, fixing bugs, or refactoring.

Coverage (JaCoCo)

Maven snippet:

Assertions

Prefer AssertJ (`assertThat`) for readability

For JSON responses, use `jsonPath`

For exceptions: `assertThatThrownBy(...)`


Cost optimization patterns for LLM API usage — model routing by task complexity, budget tracking, retry logic, and prompt caching.

Cost-Aware LLM Pipeline
Pricing Reference (2025-2026)


Git workflow patterns including branching strategies, commit conventions, merge vs rebase, conflict resolution, and collaborative development best practices for teams of all sizes.

Git Workflow Patterns
Common Workflows
Updating a PR with New Changes

Useful Aliases

Gitignore Patterns

Common Workflows

Starting a New Feature

Updating a PR with New Changes


Fact-forcing gate that blocks Edit/Write/Bash (including MultiEdit) and demands concrete investigation (importers, data schemas, user instruction) before allowing the action. Measurably improves output quality by +2.25 points vs ungated agents.

GateGuard — Fact-Forcing Pre-Action Gate

A PreToolUse hook that forces Claude to investigate before editing. Instead of self-evaluation ("are you sure?"), it demands concrete facts. The act of investigation creates awareness that self-evaluation never did.


Use when auditing Claude skills and commands for quality. Supports Quick Scan (changed skills only) and Full Stocktake modes with sequential subagent batch evaluation.

Quick Scan Flow

Re-evaluate only skills that have changed since the last run (5–10 min).

Read `~/.claude/skills/skill-stocktake/results.json`

Run: `bash ~/.claude/skills/skill-stocktake/scripts/quick-diff.sh \
      ~/.claude/skills/skill-stocktake/results.json`
(Project dir is auto-detected from `$PWD/.claude/skills`; pass it explicitly only if needed)

If output is `[]`: report "No changes since last run." and stop

Re-evaluate only those changed files using the same Phase 2 criteria

Carry forward unchanged skills from previous results

Output only the diff

Run: `bash ~/.claude/skills/skill-stocktake/scripts/save-results.sh \
      ~/.claude/skills/skill-stocktake/results.json <<< "$EVAL_RESULTS"`


Codified expertise for quality control, non-conformance investigation, root cause analysis, corrective action, and supplier quality management in regulated manufacturing. Informed by quality engineers with 15+ years experience across FDA, IATF 16949, and AS9100 environments. Includes NCR lifecycle management, CAPA systems, SPC interpretation, and audit methodology. Use when investigating non-conformances, performing root cause analysis, managing CAPAs, interpreting SPC data, or handling supplier quality issues.

Quality & Non-Conformance Management
Decision Frameworks
Inspection Level Adjustment

Inspection Level Adjustment

| Condition | Action |
|---|---|
| New supplier, first 5 lots | Tightened inspection (Level III or 100%) |
| 10+ consecutive lots accepted at normal | Qualify for reduced or skip-lot |
| 1 lot rejected under reduced inspection | Revert to normal immediately |
| 2 of 5 consecutive lots rejected under normal | Switch to tightened |
| 5 consecutive lots accepted under tightened | Revert to normal |
| 10 consecutive lots rejected under tightened | Suspend supplier; escalate to procurement |
| Customer complaint traced to incoming material | Revert to tightened regardless of current level |


Evidence-first repo execution workflow for ECC. Use when the user wants a command run, a repo checked, a CI failure debugged, or a narrow fix pushed with exact proof of what was executed and verified.

Terminal Ops
Workflow
3. Keep the fix narrow

3. Keep the fix narrow

Solve one dominant failure at a time:

use the smallest useful proving command first

only escalate to a bigger build/test pass after the local failure is addressed

if a command keeps failing with the same signature, stop broad retries and narrow scope


Spring Boot architecture patterns, REST API design, layered services, data access, caching, async processing, and logging. Use for Java Spring Boot backend work.

Spring Boot Development Patterns
Background Jobs

Background Jobs

Use Spring’s `@Scheduled` or integrate with queues (e.g., Kafka, SQS, RabbitMQ). Keep handlers idempotent and observable.


Cross-stack source code asset audit — classifies every file, detects embedded third-party libraries, and delivers actionable four-level verdicts per module with interactive HTML reports.

How It Works

**Classify the repo surface**: enumerate files, then tag each as project code, embedded third-party code, or build artifact.

**Detect embedded libraries**: inspect directory names, headers, license files, and version markers to identify bundled dependencies and likely versions.

**Score each module**: group files by module or subsystem, then assign one of the four verdicts based on ownership, duplication, and maintenance cost.

**Highlight structural risks**: call out dead-weight artifacts, duplicated wrappers, outdated vendored code, and modules that should be extracted, rebuilt, or deprecated.

**Produce the report**: return a concise summary plus the interactive HTML output with per-module drill-down so the audit can be reviewed asynchronously.


Convene a four-voice council for ambiguous decisions, tradeoffs, and go/no-go calls. Use when multiple valid paths exist and you need structured disagreement before choosing.

When NOT to Use

| Instead of council | Use |
| --- | --- |
| Verifying whether output is correct | `santa-method` |
| Breaking a feature into implementation steps | `planner` |
| Designing system architecture | `architect` |
| Reviewing code for bugs or security | `code-reviewer` or `santa-method` |
| Straight factual questions | just answer directly |
| Obvious execution tasks | just do the task |


Build MCP servers with Node/TypeScript SDK — tools, resources, prompts, Zod validation, stdio vs Streamable HTTP. Use Context7 or official MCP docs for latest API.

MCP Server Patterns
How It Works
Remote (Streamable HTTP)

Remote (Streamable HTTP)

For Cursor, cloud, or other remote clients, use **Streamable HTTP** (single MCP HTTP endpoint per current spec). Support legacy HTTP/SSE only when backward compatibility is required.


Interactive installer for Everything Claude Code — guides users through selecting and installing skills and rules to user-level or project-level directories, verifies paths, and optionally optimizes installed files.

Configure Everything Claude Code (ECC)
Step 1: Choose Installation Level

Step 1: Choose Installation Level

Use `AskUserQuestion` to ask the user where to install:

Store the choice as `INSTALL_LEVEL`. Set the target directory:

User-level: `TARGET=~/.claude`

Project-level: `TARGET=.claude` (relative to current project root)

Both: `TARGET_USER=~/.claude`, `TARGET_PROJECT=.claude`

Create the target directories if they don't exist:


Swift 6.2 Approachable Concurrency — single-threaded by default, @concurrent for explicit background offloading, isolated conformances for main actor types.

Swift 6.2 Approachable Concurrency
When to Activate

When to Activate

Migrating Swift 5.x or 6.0/6.1 projects to Swift 6.2

Resolving data-race safety compiler errors

Designing MainActor-based app architecture

Offloading CPU-intensive work to background threads

Implementing protocol conformances on MainActor-isolated types

Enabling Approachable Concurrency build settings in Xcode 26


Docker and Docker Compose patterns for local development, container security, networking, volume strategies, and multi-service orchestration.

Container Security

Dockerfile Hardening

Compose Security

Secret Management

.dockerignore


Formal evaluation framework for Claude Code sessions implementing eval-driven development (EDD) principles

Example: Adding Authentication

Product Evals (v1.8)

Use product evals when behavior quality cannot be captured by unit tests alone.


Idiomatic Go patterns, best practices, and conventions for building robust, efficient, and maintainable Go applications.

Go Development Patterns
Core Principles
3. Accept Interfaces, Return Structs

3. Accept Interfaces, Return Structs

Functions should accept interface parameters and return concrete types.


Python testing strategies using pytest, TDD methodology, fixtures, mocking, parametrization, and coverage requirements.

Python Testing Patterns
Core Testing Philosophy
Test-Driven Development (TDD)

Core Testing Philosophy

Test-Driven Development (TDD)

Always follow the TDD cycle:

**RED**: Write a failing test for the desired behavior

**GREEN**: Write minimal code to make the test pass

**REFACTOR**: Improve code while keeping tests green


PyTorch deep learning patterns and best practices for building robust, efficient, and reproducible training pipelines, model architectures, and data loading.

PyTorch Development Patterns
When to Activate

When to Activate

Writing new PyTorch models or training scripts

Reviewing deep learning code

Debugging training loops or data pipelines

Optimizing GPU memory usage or training speed

Setting up reproducible experiments


Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing.

Eval-First Loop

Define capability eval and regression eval.

Run baseline and capture failure signatures.

Execute implementation.

Re-run evals and compare deltas.


Eval Storage

Store evals in project:

Best Practices

**Define evals BEFORE coding** - Forces clear thinking about success criteria

**Run evals frequently** - Catch regressions early

**Track pass@k over time** - Monitor reliability trends

**Use code graders when possible** - Deterministic > probabilistic

**Human review for security** - Never fully automate security checks

**Keep evals fast** - Slow evals don't get run

**Version evals with code** - Evals are first-class artifacts


Codified expertise for demand forecasting, safety stock optimization, replenishment planning, and promotional lift estimation at multi-location retailers. Informed by demand planners with 15+ years experience managing hundreds of SKUs. Includes forecasting method selection, ABC/XYZ analysis, seasonal transition management, and vendor negotiation frameworks. Use when forecasting demand, setting safety stock, planning replenishment, managing promotions, or optimizing inventory levels.

Decision Frameworks

Forecast Method Selection by Demand Pattern

| Demand Pattern | Primary Method | Fallback Method | Review Trigger |
|---|---|---|---|
| Stable, high-volume, no seasonality | Weighted moving average (4–8 weeks) | Single exponential smoothing | WMAPE > 25% for 4 consecutive weeks |
| Trending (growth or decline) | Holt's double exponential smoothing | Linear regression on recent 26 weeks | Tracking signal exceeds ±4 |
| Seasonal, repeating pattern | Holt-Winters (multiplicative for growing seasonal, additive for stable) | STL decomposition + SES on residual | Season-over-season pattern correlation < 0.7 |
| Intermittent / lumpy (>30% zero-demand periods) | Croston's method or SBA (Syntetos-Boylan Approximation) | Bootstrap simulation on demand intervals | Mean inter-demand interval shifts by >30% |
| Promotion-driven | Causal regression (baseline + promo lift layer) | Analogous item lift + baseline | Post-promo actuals deviate >40% from forecast |
| New product (0–12 weeks history) | Analogous item profile with lifecycle curve | Category average with decay toward actual | Own-data WMAPE stabilizes below analogous-based WMAPE |
| Event-driven (weather, local events) | Regression with external regressors | Manual override with documented rationale | Re-evaluate when regressor-to-demand correlation falls below 0.6 or event-period forecast error rises >30% for 2 comparable events |


Codified expertise for returns authorization, receipt and inspection, disposition decisions, refund processing, fraud detection, and warranty claims management. Informed by returns operations managers with 15+ years experience. Includes grading frameworks, disposition economics, fraud pattern recognition, and vendor recovery processes. Use when handling product returns, reverse logistics, refund decisions, return fraud detection, or warranty claims.

Examples

**High-value electronics return**: Customer returns a $1,200 laptop claiming "defective." Inspection reveals cosmetic damage inconsistent with defect claim. Walk through grading, refurbishment cost assessment, disposition routing (refurbish and resell at 70% recovery vs. vendor RTV at 85%), and fraud flag evaluation.

**Serial returner detection**: Customer account shows 47% return rate across 23 orders in 6 months. Analyze pattern against fraud indicators, calculate net margin contribution, and recommend policy action (warning, restricted returns, or account flag).

**Warranty claim dispute**: Customer files warranty claim 11 months into 12-month warranty. Product shows signs of misuse. Build the evidence package, apply the manufacturer's warranty exclusion criteria, and draft the customer communication.


Examples

On a 50,000-file C++ monorepo:

Found FFmpeg 2.x (2015 vintage) still in production

Discovered the same SDK wrapper duplicated 3 times

Identified 636 MB of committed Debug/ipch/obj build artifacts

Classified: 3 MB project code vs 596 MB third-party


Pythonic idioms, PEP 8 standards, type hints, and best practices for building robust, efficient, and maintainable Python applications.

Python Development Patterns

Idiomatic Python patterns and best practices for building robust, efficient, and maintainable applications.


Pattern for progressively refining context retrieval to solve the subagent context problem

Iterative Retrieval Pattern
When to Activate

When to Activate

Spawning subagents that need codebase context they cannot predict upfront

Building multi-agent workflows where context is progressively refined

Encountering "context too large" or "missing context" failures in agent tasks

Designing RAG-like retrieval pipelines for code exploration

Optimizing token usage in agent orchestration


Create and update pitch decks, one-pagers, investor memos, accelerator applications, financial models, and fundraising materials. Use when the user needs investor-facing documents, projections, use-of-funds tables, milestone plans, or materials that must stay internally consistent across multiple fundraising assets.

Investor Materials

Build investor-facing materials that are consistent, credible, and easy to defend.


Regression testing strategies for AI-assisted development. Sandbox-mode API testing without database dependencies, automated bug-check workflows, and patterns to catch AI blind spots where the same model writes and reviews code.

AI Regression Testing
Common AI Regression Patterns
Pattern 3: Error State Leakage

Pattern 3: Error State Leakage

**Frequency**: Moderate — when adding error handling to existing components


Laravel architecture patterns, routing/controllers, Eloquent ORM, service layers, queues, events, caching, and API resources for production apps.

Laravel Development Patterns
Examples
Migrations

Query Scopes for Reusable Filters

Transactions for Multi-Step Updates

Migrations


Evidence-first ECC Tools burn and billing audit workflow. Use when investigating runaway PR creation, quota bypass, premium-model leakage, duplicate jobs, or GitHub App cost spikes in the ECC Tools repo.

ECC Tools Cost Audit
Workflow
3. Trace the worker and side effects

3. Trace the worker and side effects

inspect the queue consumer or scheduled worker that handles analysis

confirm whether a queued analysis always ends in:

PR creation

branch creation

file updates

premium model calls

usage increments

if analysis can spend tokens and then fail before output is persisted, classify it as burn-with-broken-output


Security checklist for Solidity AMM contracts, liquidity pools, and swap flows. Covers reentrancy, CEI ordering, donation or inflation attacks, oracle manipulation, slippage, admin controls, and integer math.

Security Checklist

Reentrancy-exposed entrypoints use `nonReentrant`

CEI ordering is respected

Share math does not depend on raw `balanceOf(address(this))`

ERC-20 transfers use `SafeERC20`

Deposits measure actual tokens received

Oracle reads use TWAP or another manipulation-resistant source

Swaps require `amountOutMin` and `deadline`

Overflow-sensitive reserve math uses safe primitives like `mulDiv`

Admin functions are access-controlled

Emergency pause exists and is tested

Static analysis and fuzzing are run before production


Create platform-native content systems for X, LinkedIn, TikTok, YouTube, newsletters, and repurposed multi-platform campaigns. Use when the user wants social posts, threads, scripts, content calendars, or one source asset adapted cleanly across platforms.

Quality Gate

Before delivering:

every draft sounds like the intended author, not the platform stereotype

every draft contains a real claim, proof point, or concrete observation

no generic hype language remains

no fake engagement bait remains

no duplicated copy across platforms unless requested

any CTA is earned and user-approved


Use when auditing Claude skills and commands for quality. Supports Quick Scan (changed skills only) and Full Stocktake modes with sequential subagent batch evaluation.

skill-stocktake

Slash command (`/skill-stocktake`) that audits all Claude skills and commands using a quality checklist + AI holistic judgment. Supports two modes: Quick Scan for recently changed skills, and Full Stocktake for a complete review.


Offers the user an informed choice about how much response depth to consume before answering. Use this skill when the user explicitly wants to control response length, depth, or token budget. TRIGGER when: "token budget", "token count", "token usage", "token limit", "response length", "answer depth", "short version", "brief answer", "detailed answer", "exhaustive answer", "respuesta corta vs larga", "cuántos tokens", "ahorrar tokens", "responde al 50%", "dame la versión corta", "quiero controlar cuánto usas", or clear variants where the user is explicitly asking to control answer size or depth. DO NOT TRIGGER when: user has already specified a level in the current session (maintain it), the request is clearly a one-word answer, or "token" refers to auth/session/payment tokens rather than response size.

Token Budget Advisor (TBA)
How It Works
Step 1 — Estimate input tokens

How It Works

Step 1 — Estimate input tokens

Use the repository's canonical context-budget heuristics to estimate the prompt's token count mentally.

Use the same calibration guidance as [context-budget](../context-budget/SKILL.md):

prose: `words × 1.3`

code-heavy or mixed/code blocks: `chars / 4`

For mixed content, use the dominant content type and keep the estimate heuristic.


Cross-stack source code asset audit — classifies every file, detects embedded third-party libraries, and delivers actionable four-level verdicts per module with interactive HTML reports.

Installation

Review the source before installing any agent skill.

Core Capabilities

| Capability | Description |
|---|---|
| **Cross-stack scanning** | C/C++, Java/Android, iOS (OC/Swift), Web (TS/JS/Vue) in one pass |
| **File classification** | Every file tagged as project code, third-party, or build artifact |
| **Library detection** | 50+ known libraries (FFmpeg, Boost, OpenSSL…) with version extraction |
| **Four-level verdicts** | Core Asset / Extract & Merge / Rebuild / Deprecate |
| **HTML reports** | Interactive dark-theme pages with drill-down navigation |
| **Monorepo support** | Hierarchical scanning with summary + sub-project reports |


Thread-safe data persistence in Swift using actors — in-memory cache with file-backed storage, eliminating data races by design.

Swift Actors for Thread-Safe Persistence

Best Practices

**Use `Sendable` types** for all data crossing actor boundaries

**Keep the actor's public API minimal** — only expose domain operations, not persistence details

**Use `.atomic` writes** to prevent data corruption if the app crashes mid-write

**Load synchronously in `init`** — async initializers add complexity with minimal benefit for local files

**Combine with `@Observable`** ViewModels for reactive UI updates


Scope

The command targets the following paths **relative to the directory where it is invoked**:

| Path | Description |
|------|-------------|
| `~/.claude/skills/` | Global skills (all projects) |
| `{cwd}/.claude/skills/` | Project-level skills (if the directory exists) |

**At the start of Phase 1, the command explicitly lists which paths were found and scanned.**


Security patterns for autonomous trading agents with wallet or transaction authority. Covers prompt injection, spend limits, pre-send simulation, circuit breakers, MEV protection, and key handling.

How It Works

Layer the defenses. No single check is enough. Treat prompt hygiene, spend policy, simulation, execution limits, and wallet isolation as independent controls.


Production-ready Dart and Flutter patterns covering null safety, immutable state, async composition, widget architecture, popular state management frameworks (BLoC, Riverpod, Provider), GoRouter navigation, Dio networking, Freezed code generation, and clean architecture.

How It Works

This skill provides copy-paste-ready Dart/Flutter code patterns organized by concern:

**Null safety** — avoid `!`, prefer `?.`/`??`/pattern matching

**Immutable state** — sealed classes, `freezed`, `copyWith`

**Async composition** — concurrent `Future.wait`, safe `BuildContext` after `await`

**Widget architecture** — extract to classes (not methods), `const` propagation, scoped rebuilds

**State management** — BLoC/Cubit events, Riverpod notifiers and derived providers

**Navigation** — GoRouter with reactive auth guards via `refreshListenable`

**Networking** — Dio with interceptors, token refresh with one-time retry guard

**Error handling** — global capture, `ErrorWidget.builder`, crashlytics wiring

**Testing** — unit (BLoC test), widget (ProviderScope overrides), fakes over mocks


Codified expertise for customs documentation, tariff classification, duty optimization, restricted party screening, and regulatory compliance across multiple jurisdictions. Informed by trade compliance specialists with 15+ years experience. Includes HS classification logic, Incoterms application, FTA utilization, and penalty mitigation. Use when handling customs clearance, tariff classification, trade compliance, import/export documentation, or duty optimization.

Customs & Trade Compliance
Core Knowledge
HS Tariff Classification

Core Knowledge

HS Tariff Classification

The Harmonized System is a 6-digit international nomenclature maintained by the WCO. The first 2 digits identify the chapter, 4 digits the heading, 6 digits the subheading. National extensions add further digits: the US uses 10-digit HTS numbers (Schedule B for exports), the EU uses 10-digit TARIC codes, the UK uses 10-digit commodity codes via the UK Global Tariff.

Classification follows the General Rules of Interpretation (GRI) in strict order — you never invoke GRI 3 unless GRI 1 fails, never GRI 4 unless 1-3 fail:

**GRI 1:** Classification is determined by the terms of the headings and Section/Chapter notes. This resolves ~90% of classifications. Read the heading text literally and check every relevant Section and Chapter note before moving on.

**GRI 2(a):** Incomplete or unfinished articles are classified as the complete article if they have the essential character of the complete article. A car body without the engine is still classified as a motor vehicle.

**GRI 2(b):** Mixtures and combinations of materials. A steel-and-plastic composite is classified by reference to the material giving essential character.

**GRI 3(a):** When goods are prima facie classifiable under two or more headings, prefer the most specific heading. "Surgical gloves of rubber" is more specific than "articles of rubber."

**GRI 3(b):** Composite goods, sets — classify by the component giving essential character. A gift set with a $40 perfume and a $5 pouch classifies as perfume.

**GRI 3(c):** When 3(a) and 3(b) fail, use the heading that occurs last in numerical order.

**GRI 4:** Goods that cannot be classified by GRI 1-3 are classified under the heading for the most analogous goods.

**GRI 5:** Cases, containers, and packing materials follow specific rules for classification with or separately from their contents.

**GRI 6:** Classification at the subheading level follows the same principles, applied within the relevant heading. Subheading notes take precedence at this level.

**Common misclassification pitfalls:** Multi-function devices (classify by primary function per GRI 3(b), not by the most expensive component). Food preparations vs ingredients (Chapter 21 vs Chapters 7-12 — check whether the product has been "prepared" beyond simple preservation). Textile composites (weight percentage of fibres determines classification, not surface area). Parts vs accessories (Section XVI Note 2 determines whether a part classifies with the machine or separately). Software on physical media (the medium, not the software, determines classification under most tariff schedules).


Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA standards. Use this skill to generate semantic ARIA for Web and accessibility traits for Web and Native platforms (iOS/Android).

Accessibility (WCAG 2.2)
Cross-Platform Mapping

Accessibility Architecture Diagram

Cross-Platform Mapping

| Feature            | Web (HTML/ARIA)          | iOS (SwiftUI)                        | Android (Compose)                                           |
| :----------------- | :----------------------- | :----------------------------------- | :---------------------------------------------------------- |
| **Primary Label**  | `aria-label` / `<label>` | `.accessibilityLabel()`              | `contentDescription`                                        |
| **Secondary Hint** | `aria-describedby`       | `.accessibilityHint()`               | `Modifier.semantics { stateDescription = ... }`             |
| **Action Role**    | `role="button"`          | `.accessibilityAddTraits(.isButton)` | `Modifier.semantics { role = Role.Button }`                 |
| **Live Updates**   | `aria-live="polite"`     | `.accessibilityLiveRegion(.polite)`  | `Modifier.semantics { liveRegion = LiveRegionMode.Polite }` |


Add x402 payment execution to AI agents — per-task budgets, spending controls, and non-custodial wallets via MCP tools. Use when agents need to pay for APIs, services, or other agents.

Agent Payment Execution (x402)
MCP Integration

MCP Integration

The payment layer exposes standard MCP tools that slot into any Claude Code or agent harness setup.

**Security note**: Always pin the package version. This tool manages private keys — unpinned `npx` installs introduce supply-chain risk.


Python testing strategies using pytest, TDD methodology, fixtures, mocking, parametrization, and coverage requirements.

Testing Class Methods

pytest Configuration

pytest.ini

pyproject.toml

Running Tests


Use up-to-date library and framework docs via Context7 MCP instead of training data. Activates for setup questions, API references, code examples, or when the user names a framework (e.g. React, Next.js, Prisma).

Documentation Lookup (Context7)
How it works
Step 3: Fetch the Documentation

Step 3: Fetch the Documentation

Call the **query-docs** MCP tool with:

**libraryId**: The selected Context7 library ID from Step 2 (e.g. `/vercel/next.js`).

**query**: The user's specific question or task. Be specific to get relevant snippets.

Limit: do not call query-docs (or resolve-library-id) more than 3 times per question. If the answer is unclear after 3 calls, state the uncertainty and use the best information you have rather than guessing.


Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates.

Agent Harness Construction
Anti-Patterns

Anti-Patterns

Too many tools with overlapping semantics.

Opaque tool output with no recovery hints.

Error-only output without next steps.

Context overloading with irrelevant references.


Next.js 16+ and Turbopack — incremental bundling, FS caching, dev speed, and when to use Turbopack vs webpack.

When to Use

**Turbopack (default dev)**: Use for day-to-day development. Faster cold start and HMR, especially in large apps.

**Webpack (legacy dev)**: Use only if you hit a Turbopack bug or rely on a webpack-only plugin in dev. Disable with `--webpack` (or `--no-turbopack` depending on your Next.js version; check the docs for your release).

**Production**: Production build behavior (`next build`) may use Turbopack or webpack depending on Next.js version; check the official Next.js docs for your version.

Use when: developing or debugging Next.js 16+ apps, diagnosing slow dev startup or HMR, or optimizing production bundles.


Regression testing strategies for AI-assisted development. Sandbox-mode API testing without database dependencies, automated bug-check workflows, and patterns to catch AI blind spots where the same model writes and reviews code.

The Core Problem

When an AI writes code and then reviews its own work, it carries the same assumptions into both steps. This creates a predictable failure pattern:

**Real-world example** (observed in production):

The pattern: **sandbox/production path inconsistency** is the #1 AI-introduced regression.


Patterns and architectures for autonomous Claude Code loops — from simple sequential pipelines to RFC-driven multi-agent DAG systems.

6. Ralphinho / RFC-Driven DAG Orchestration

Architecture Overview

RFC Decomposition

AI reads the RFC and produces work units:

**Decomposition Rules:**

Prefer fewer, cohesive units (minimize merge risk)

Minimize cross-unit file overlap (avoid conflicts)

Keep tests WITH implementation (never separate "implement X" + "test X")

Dependencies only where real code dependency exists

The dependency DAG determines execution order:


Idiomatic Kotlin patterns, best practices, and conventions for building robust, efficient, and maintainable Kotlin applications with coroutines, null safety, and DSL builders.

Kotlin Development Patterns
Core Principles
1. Null Safety

Core Principles

1. Null Safety

Kotlin's type system distinguishes nullable and non-nullable types. Leverage it fully.


Audit, plan, and implement SEO improvements across technical SEO, on-page optimization, structured data, Core Web Vitals, and content strategy. Use when the user wants better search visibility, SEO remediation, schema markup, sitemap/robots work, or keyword mapping.

Anti-Patterns

| Anti-pattern | Fix |
| --- | --- |
| keyword stuffing | write for users first |
| thin near-duplicate pages | consolidate or differentiate them |
| schema for content that is not actually present | match schema to reality |
| content advice without checking the actual page | read the real page first |
| generic “improve SEO” outputs | tie every recommendation to a page or asset |


Operate across Google Drive, Docs, Sheets, and Slides as one workflow surface for plans, trackers, decks, and shared documents. Use when the user needs to find, summarize, edit, migrate, or clean up Google Workspace assets without dropping to raw tool calls.

Google Workspace Ops
Workflow
4. Keep the working system clean

4. Keep the working system clean

When the file is part of a larger workflow, also surface:

duplicate trackers

outdated decks

stale docs vs canonical docs

whether the asset should be archived, merged, or renamed


Instinct-based learning system that observes sessions via hooks, creates atomic instincts with confidence scoring, and evolves them into skills/commands/agents. v2.1 adds project-scoped instincts to prevent cross-project contamination.

Continuous Learning v2.1 - Instinct
Backward Compatibility

Backward Compatibility

v2.1 is fully compatible with v2.0 and v1:

Existing global instincts in `~/.claude/homunculus/instincts/` still work as global instincts

Existing `~/.claude/skills/learned/` skills from v1 still work

Stop hook still runs (but now also feeds into v2)

Gradual migration: run both in parallel


Protocol-based dependency injection for testable Swift code — mock file system, network, and external APIs using focused protocols and Swift Testing.

Swift Protocol-Based Dependency Injection for Testing

Core Pattern

1. Define Small, Focused Protocols

Each protocol handles exactly one external concern.


Codified expertise for returns authorization, receipt and inspection, disposition decisions, refund processing, fraud detection, and warranty claims management. Informed by returns operations managers with 15+ years experience. Includes grading frameworks, disposition economics, fraud pattern recognition, and vendor recovery processes. Use when handling product returns, reverse logistics, refund decisions, return fraud detection, or warranty claims.

Returns & Reverse Logistics
Escalation Protocols
Escalation Chain

Escalation Chain

Level 1 (Returns Associate) → Level 2 (Team Lead, 2 hours) → Level 3 (Returns Manager, 8 hours) → Level 4 (Director of Operations, 24 hours) → Level 5 (VP, 48+ hours or any single-item return > $25K)


Nuxt 4 app patterns for hydration safety, performance, route rules, lazy loading, and SSR-safe data fetching with useFetch and useAsyncData.

Data Fetching

Prefer `await useFetch()` for SSR-safe API reads in pages and components. It forwards server-fetched data into the Nuxt payload and avoids a second fetch on hydration.

Use `useAsyncData()` when the fetcher is not a simple `$fetch()` call, when you need a custom key, or when you are composing multiple async sources.

Give `useAsyncData()` a stable key for cache reuse and predictable refresh behavior.

Keep `useAsyncData()` handlers side-effect free. They can run during SSR and hydration.

Use `$fetch()` for user-triggered writes or client-only actions, not top-level page data that should be hydrated from SSR.

Use `lazy: true`, `useLazyFetch()`, or `useLazyAsyncData()` for non-critical data that should not block navigation. Handle `status === 'pending'` in the UI.

Use `server: false` only for data that is not needed for SEO or the first paint.

Trim payload size with `pick` and prefer shallower payloads when deep reactivity is unnecessary.


Python Testing Patterns
Testing Exceptions
Testing Expected Exceptions

Async Fixture

Mocking Async Functions

Testing Exceptions

Testing Expected Exceptions


Evidence-first revenue, pricing, refunds, team-billing, and billing-model truth workflow for ECC. Use when the user wants a sales snapshot, pricing comparison, duplicate-charge diagnosis, or code-backed billing reality instead of generic payments advice.

2. Separate customer incidents from product truth

If the question is customer-specific, classify first:

duplicate checkout

real team intent

broken self-serve controls

unmet product value

failed payment or incomplete setup

Then separate that from the broader product question:

does team billing really exist?

are seats actually counted?

does checkout quantity change entitlement?

does the site overstate current behavior?


Create and update pitch decks, one-pagers, investor memos, accelerator applications, financial models, and fundraising materials. Use when the user needs investor-facing documents, projections, use-of-funds tables, milestone plans, or materials that must stay internally consistent across multiple fundraising assets.

When to Activate

creating or revising a pitch deck

writing an investor memo or one-pager

building a financial model, milestone plan, or use-of-funds table

answering accelerator or incubator application questions

aligning multiple fundraising docs around one source of truth


Codified expertise for handling freight exceptions, shipment delays, damages, losses, and carrier disputes. Informed by logistics professionals with 15+ years operational experience. Includes escalation protocols, carrier-specific behaviors, claims procedures, and judgment frameworks. Use when handling shipping exceptions, freight claims, delivery issues, or carrier disputes.

Logistics Exception Management
Core Knowledge
Fraud and Red Flags

Fraud and Red Flags

**Staged damages:** Damage patterns inconsistent with transit mode. Multiple claims from same consignee location.

**Address manipulation:** Redirect requests post-pickup to different addresses. Common in high-value electronics.

**Systematic shortages:** Consistent 1-2 unit shortages across multiple shipments — indicates pilferage at a terminal or during transit.

**Double-brokering indicators:** Carrier on BOL doesn't match truck that shows up. Driver can't name their dispatcher. Insurance certificate is from a different entity.


Anthropic Claude API patterns for Python and TypeScript. Covers Messages API, streaming, tool use, vision, extended thinking, batches, prompt caching, and Claude Agent SDK. Use when building applications with the Claude API or Anthropic SDKs.

Error Handling

Environment Setup

Never hardcode API keys. Always use environment variables.


Interactive agent picker for composing and dispatching parallel teams

When to Use

You have multiple agent personas (markdown files) and want to pick which ones to use for a task

You want to compose an ad-hoc team from different domains (e.g., Security + SEO + Architecture)

You want to browse what agents are available before deciding


Process, convert, OCR, extract, redact, sign, and fill documents using the Nutrient DWS API. Works with PDFs, DOCX, XLSX, PPTX, HTML, and images.

Nutrient Document Processing
MCP Server (Alternative)

Add Watermarks

Digital Signatures

Fill PDF Forms

MCP Server (Alternative)

For native tool integration, use the MCP server instead of curl:


Django testing strategies with pytest-django, TDD methodology, factory_boy, mocking, coverage, and testing Django REST Framework APIs.

Django Testing with TDD
When to Activate

When to Activate

Writing new Django applications

Implementing Django REST Framework APIs

Testing Django models, views, and serializers

Setting up testing infrastructure for Django projects


Kotlin testing patterns with Kotest, MockK, coroutine testing, property-based testing, and Kover coverage. Follows TDD methodology with idiomatic Kotlin practices.

Kotlin Testing Patterns
Examples
Integration with CI/CD

Integration with CI/CD

**Remember**: Tests are documentation. They show how your Kotlin code is meant to be used. Use Kotest's expressive matchers to make tests readable and MockK for clean mocking of dependencies.


Codified expertise for demand forecasting, safety stock optimization, replenishment planning, and promotional lift estimation at multi-location retailers. Informed by demand planners with 15+ years experience managing hundreds of SKUs. Includes forecasting method selection, ABC/XYZ analysis, seasonal transition management, and vendor negotiation frameworks. Use when forecasting demand, setting safety stock, planning replenishment, managing promotions, or optimizing inventory levels.

Inventory Demand Planning
Key Edge Cases

Key Edge Cases

Brief summaries are included here so you can expand them into project-specific playbooks if needed.

**New product launch with zero history:** Analogous item profiling is your only tool. Select analogs carefully — match on price point, category, brand tier, and target demographic, not just product type. Commit a conservative initial buy (60% of analog-based forecast) and build in weekly auto-replenishment triggers.

**Viral social media spike:** Demand jumps 500–2,000% with no warning. Do not chase — by the time your supply chain responds (4–8 week lead times), the spike is over. Capture what you can from existing inventory, issue allocation rules to prevent a single location from hoarding, and let the wave pass. Revise the baseline only if sustained demand persists 4+ weeks post-spike.

**Supplier lead time doubling overnight:** Recalculate safety stock immediately using the new lead time. If SS doubles, you likely cannot fill the gap from current inventory. Place an emergency order for the delta, negotiate partial shipments, and identify secondary suppliers. Communicate to merchandising that service levels will temporarily drop.

**Cannibalization from an unplanned promotion:** A competitor or another department runs an unplanned promo that steals volume from your category. Your forecast will over-project. Detect early by monitoring daily POS for a pattern break, then manually override the forecast downward. Defer incoming orders if possible.

**Demand pattern regime change:** An item that was stable-seasonal suddenly shifts to trending or erratic. Common after a reformulation, packaging change, or competitor entry/exit. The old model will fail silently. Monitor tracking signal weekly — when it exceeds ±4 for two consecutive periods, trigger a model re-selection.

**Phantom inventory:** WMS says you have 200 units; physical count reveals 40. Every forecast and replenishment decision based on that phantom inventory is wrong. Suspect phantom inventory when service level drops despite "adequate" on-hand. Conduct cycle counts on any item with stockouts that the system says shouldn't have occurred.

**Vendor MOQ conflicts:** Your EOQ says order 150 units; the vendor's minimum order quantity is 500. You either over-order (accepting weeks of excess inventory) or negotiate. Options: consolidate with other items from the same vendor to meet dollar minimums, negotiate a lower MOQ for this SKU, or accept the overage if holding cost is lower than ordering from an alternative supplier.

**Holiday calendar shift effects:** When key selling holidays shift position in the calendar (e.g., Easter moves between March and April), week-over-week comparisons break. Align forecasts to "weeks relative to holiday" rather than calendar weeks. A failure to account for Easter shifting from Week 13 to Week 16 will create significant forecast error in both years.


Write articles, guides, blog posts, tutorials, newsletter issues, and other long-form content in a distinctive voice derived from supplied examples or brand guidance. Use when the user wants polished written content longer than a paragraph, especially when voice consistency, structure, and credibility matter.

Article Writing
Structure Guidance
Essays / Opinion

Essays / Opinion

start with tension, contradiction, or a specific observation

keep one argument thread per section

make opinions answer to evidence


Visualize whether skills, rules, and agent definitions are actually followed — auto-generates scenarios at 3 prompt strictness levels, runs agents, classifies behavioral sequences, and reports compliance rates with full tool call timelines

skill-comply: Automated Compliance Measurement

Usage

Key Concept: Prompt Independence

Measures whether a skill/rule is followed even when the prompt doesn't explicitly support it.


Kotlin Coroutines and Flow patterns for Android and KMP — structured concurrency, Flow operators, StateFlow, error handling, and testing.

Kotlin Coroutines & Flows
Anti-Patterns to Avoid

Faking Flows

Anti-Patterns to Avoid

Using `GlobalScope` — leaks coroutines, no structured cancellation

Collecting Flows in `init {}` without a scope — use `viewModelScope.launch`

Using `MutableStateFlow` with mutable collections — always use immutable copies: `_state.update { it.copy(list = it.list + newItem) }`

Catching `CancellationException` — let it propagate for proper cancellation

Using `flowOn(Dispatchers.Main)` to collect — collection dispatcher is the caller's dispatcher

Creating `Flow` in `@Composable` without `remember` — recreates the flow every recomposition


Modern Perl 5.36+ idioms, best practices, and conventions for building robust, maintainable Perl applications.

Modern Perl Development Patterns
Core Principles
1. Use `v5.36` Pragma

Core Principles

1. Use `v5.36` Pragma

A single `use v5.36` replaces the old boilerplate and enables strict, warnings, and subroutine signatures.


Analyze an unfamiliar codebase and generate a structured onboarding guide with architecture map, key entry points, conventions, and a starter CLAUDE.md. Use when joining a new project or setting up Claude Code for the first time in a repo.

Codebase Onboarding
Examples
Example 1: First time in a new repo

Examples

Example 1: First time in a new repo

**User**: "Onboard me to this codebase"
**Action**: Run full 4-phase workflow → produce Onboarding Guide + Starter CLAUDE.md
**Output**: Onboarding Guide printed directly to the conversation, plus a `CLAUDE.md` written to the project root


Offers the user an informed choice about how much response depth to consume before answering. Use this skill when the user explicitly wants to control response length, depth, or token budget. TRIGGER when: "token budget", "token count", "token usage", "token limit", "response length", "answer depth", "short version", "brief answer", "detailed answer", "exhaustive answer", "respuesta corta vs larga", "cuántos tokens", "ahorrar tokens", "responde al 50%", "dame la versión corta", "quiero controlar cuánto usas", or clear variants where the user is explicitly asking to control answer size or depth. DO NOT TRIGGER when: user has already specified a level in the current session (maintain it), the request is clearly a one-word answer, or "token" refers to auth/session/payment tokens rather than response size.

Token Budget Advisor (TBA)
Shortcuts — skip the question

Shortcuts — skip the question

If the user already signals a level, respond at that level immediately without asking:

| What they say                                      | Level |
|----------------------------------------------------|-------|
| "1" / "25% depth" / "short version" / "brief answer" / "tldr"  | 25%   |
| "2" / "50% depth" / "moderate depth" / "balanced answer"        | 50%   |
| "3" / "75% depth" / "detailed answer" / "thorough answer"       | 75%   |
| "4" / "100% depth" / "exhaustive answer" / "full deep dive"     | 100%  |

If the user set a level earlier in the session, **maintain it silently** for subsequent responses unless they change it.


Record polished UI demo videos using Playwright. Use when the user asks to create a demo, walkthrough, screen recording, or tutorial video of a web application. Produces WebM videos with visible cursor, natural pacing, and professional feel.

UI Demo Video Recorder

Record polished demo videos of web applications using Playwright's video recording with an injected cursor overlay, natural pacing, and storytelling flow.


PostgreSQL database patterns for query optimization, schema design, indexing, and security. Based on Supabase best practices.

When to Activate

Writing SQL queries or migrations

Designing database schemas

Troubleshooting slow queries

Implementing Row Level Security

Setting up connection pooling


X/Twitter API integration for posting tweets, threads, reading timelines, search, and analytics. Covers OAuth auth patterns, rate limits, and platform-native content posting. Use when the user wants to interact with X programmatically.

X API
Authentication
OAuth 2.0 Bearer Token (App-Only)

Authentication

OAuth 2.0 Bearer Token (App-Only)

Best for: read-heavy operations, search, public data.


Database migration best practices for schema changes, data migrations, rollbacks, and zero-downtime deployments across PostgreSQL, MySQL, and common ORMs (Prisma, Drizzle, Kysely, Django, TypeORM, golang-migrate).

Database Migration Patterns
Django (Python)
SeparateDatabaseAndState

Data Migration

SeparateDatabaseAndState

Remove a column from the Django model without dropping it from the database immediately:


Codified expertise for electricity and gas procurement, tariff optimization, demand charge management, renewable PPA evaluation, and multi-facility energy cost management. Informed by energy procurement managers with 15+ years experience at large commercial and industrial consumers. Includes market structure analysis, hedging strategies, load profiling, and sustainability reporting frameworks. Use when procuring energy, optimizing tariffs, managing demand charges, evaluating PPAs, or developing energy strategies.

Energy Procurement
Decision Frameworks
Market Timing

Market Timing

Never try to "call the bottom" on energy markets. Instead:

Monitor the forward curve relative to the 5-year historical range. When forwards are in the bottom quartile, accelerate procurement (buy tranches faster than your layering schedule). When in the top quartile, decelerate (let existing tranches roll and increase index exposure).

Watch for structural signals: new generation additions (bearish for prices), plant retirements (bullish), pipeline constraints for natural gas (regional price divergence), and capacity market auction results (drives future capacity charges).

Use the procurement sequence above as the decision framework baseline and adapt it to your tariff structure, procurement calendar, and board-approved hedge limits.


iOS 26 Liquid Glass design system — dynamic glass material with blur, reflection, and interactive morphing for SwiftUI, UIKit, and WidgetKit.

Liquid Glass Design System (iOS 26)
Core Pattern — WidgetKit
Rendering Mode Detection

Scroll Edge Effects

Toolbar Glass Integration

Core Pattern — WidgetKit

Rendering Mode Detection


Core Knowledge

Pricing Structures and Utility Bill Anatomy

Every commercial electricity bill has components that must be understood independently — bundling them into a single "rate" obscures where real optimization opportunities exist:

**Energy charges:** The per-kWh cost for electricity consumed. Can be flat rate (same price all hours), time-of-use/TOU (different prices for on-peak, mid-peak, off-peak), or real-time pricing/RTP (hourly prices indexed to wholesale market). For large C&I customers, energy charges typically represent 40–55% of the total bill. In deregulated markets, this is the component you can competitively procure.

**Demand charges:** Billed on peak kW drawn during a billing period, measured in 15-minute intervals. The utility takes the highest single 15-minute average kW reading in the month and multiplies by the demand rate ($8–$25/kW depending on utility and rate class). Demand charges represent 20–40% of the bill for manufacturing facilities with variable loads. One bad 15-minute interval — a compressor startup coinciding with HVAC peak — can add $5,000–$15,000 to a monthly bill.

**Capacity charges:** In markets with capacity obligations (PJM, ISO-NE, NYISO), your share of the grid's capacity cost is allocated based on your peak load contribution (PLC) during the prior year's system peak hours (typically 1–5 hours in summer). PLC is measured at your meter during the system coincident peak. Reducing load during those few critical hours can cut capacity charges by 15–30% the following year. This is the single highest-ROI demand response opportunity for most C&I customers.

**Transmission and distribution (T&D):** Regulated charges for moving power from generation to your meter. Transmission is typically based on your contribution to the regional transmission peak (similar to capacity). Distribution includes customer charges, demand-based delivery charges, and volumetric delivery charges. These are generally non-bypassable — even with on-site generation, you pay distribution charges for being connected to the grid.

**Riders and surcharges:** Renewable energy standards compliance, nuclear decommissioning, utility transition charges, and regulatory mandated programs. These change through rate cases. A utility rate case filing can add $0.005–$0.015/kWh to your delivered cost — track open proceedings at your state PUC.


C++ coding standards based on the C++ Core Guidelines (isocpp.github.io). Use when writing, reviewing, or refactoring C++ code to enforce modern, safe, and idiomatic practices.

C++ Coding Standards (C++ Core Guidelines)

Classes & Class Hierarchies (C.*)

Key Rules

| Rule | Summary |
|------|---------|
| **C.2** | Use `class` if invariant exists; `struct` if data members vary independently |
| **C.9** | Minimize exposure of members |
| **C.20** | If you can avoid defining default operations, do (Rule of Zero) |
| **C.21** | If you define or `=delete` any copy/move/destructor, handle them all (Rule of Five) |
| **C.35** | Base class destructor: public virtual or protected non-virtual |
| **C.41** | A constructor should create a fully initialized object |
| **C.46** | Declare single-argument constructors `explicit` |
| **C.67** | A polymorphic class should suppress public copy/move |
| **C.128** | Virtual functions: specify exactly one of `virtual`, `override`, or `final` |


EMR/EHR development patterns for healthcare applications. Clinical safety, encounter workflows, prescription generation, clinical decision support integration, and accessibility-first UI for medical data entry.

Healthcare EMR Development Patterns
How It Works
Anti-Patterns

Anti-Patterns

Storing clinical data in browser localStorage

Silent failures in drug interaction checking

Dismissable toasts for critical clinical alerts

Tab-based encounter UIs that fragment the clinical workflow

Allowing edits to signed/locked encounters

Displaying clinical data without audit trail

Using `any` type for clinical data structures


When to Use

Running an RFP for electricity or natural gas supply across multiple facilities

Analyzing tariff structures and rate schedule optimization opportunities

Evaluating demand charge mitigation strategies (load shifting, battery storage, power factor correction)

Assessing PPA (Power Purchase Agreement) offers for on-site or virtual renewable energy

Building annual energy budgets and hedge position strategies

Responding to market volatility events (polar vortex, heat wave, regulatory changes)


Use this skill to measure performance baselines, detect regressions before/after PRs, and compare stack alternatives.

Benchmark — Performance Baseline & Regression Detection

Mode 2: API Performance

Benchmarks API endpoints:

Mode 3: Build Performance

Measures development feedback loop:


Pythonic idioms, PEP 8 standards, type hints, and best practices for building robust, efficient, and maintainable Python applications.

Python Development Patterns
Context Managers
Resource Management

Exception Chaining

Custom Exception Hierarchy

Context Managers

Resource Management


Fact-forcing gate that blocks Edit/Write/Bash (including MultiEdit) and demands concrete investigation (importers, data schemas, user instruction) before allowing the action. Measurably improves output quality by +2.25 points vs ungated agents.

GateGuard — Fact-Forcing Pre-Action Gate

Evidence

Two independent A/B tests, identical agents, same task:

| Task | Gated | Ungated | Gap |
| --- | --- | --- | --- |
| Analytics module | 8.0/10 | 6.5/10 | +1.5 |
| Webhook validator | 10.0/10 | 7.0/10 | +3.0 |
| **Average** | **9.0** | **6.75** | **+2.25** |

Both agents produce code that runs and passes tests. The difference is design depth.


Protected Health Information (PHI) and Personally Identifiable Information (PII) compliance patterns for healthcare applications. Covers data classification, access control, audit trails, encryption, and common leak vectors.

Healthcare PHI/PII Compliance Patterns
How It Works
Deployment Checklist

Database Schema Tagging

Mark PHI/PII columns at the schema level:

Deployment Checklist

Before every deployment:

No PHI in error messages or stack traces

No PHI in console.log/console.error

No PHI in URL parameters

No PHI in browser storage

No service_role key in client code

RLS enabled on all PHI/PII tables

Audit trail for all data modifications

Session timeout configured

API authentication on all PHI endpoints

Cross-facility data isolation verified


Bun as runtime, package manager, bundler, and test runner. When to choose Bun vs Node, migration notes, and Vercel support.

When to Use

**Prefer Bun** for: new JS/TS projects, scripts where install/run speed matters, Vercel deployments with Bun runtime, and when you want a single toolchain (run + install + test + build).

**Prefer Node** for: maximum ecosystem compatibility, legacy tooling that assumes Node, or when a dependency has known Bun issues.

Use when: adopting Bun, migrating from Node, writing or debugging Bun scripts/tests, or configuring Bun on Vercel or other platforms.


Create CodeTour `.tour` files — persona-targeted, step-by-step walkthroughs with real file and line anchors. Use for onboarding tours, architecture walkthroughs, PR tours, RCA tours, and structured "explain how this works" requests.

Best Practices

keep step count proportional to repo size and persona depth

use directory steps for orientation, file steps for substance

for PR tours, cover changed files first

for monorepos, scope to the relevant packages instead of touring everything

close with what the reader can now do, not a recap


Draft cold emails, warm intro blurbs, follow-ups, update emails, and investor communications for fundraising. Use when the user wants outreach to angels, VCs, strategic investors, or accelerators and needs concise, personalized, investor-facing messaging.

Quality Gate

Before delivering:

the message is genuinely personalized

the ask is explicit

the proof point is concrete

filler praise and softener language are gone

word count stays tight


Use up-to-date library and framework docs via Context7 MCP instead of training data. Activates for setup questions, API references, code examples, or when the user names a framework (e.g. React, Next.js, Prisma).

Documentation Lookup (Context7)
How it works
Step 1: Resolve the Library ID

How it works

Step 1: Resolve the Library ID

Call the **resolve-library-id** MCP tool with:

**libraryName**: The library or product name taken from the user's question (e.g. `Next.js`, `Prisma`, `Supabase`).

**query**: The user's full question. This improves relevance ranking of results.

You must obtain a Context7-compatible library ID (format `/org/project` or `/org/project/version`) before querying docs. Do not call query-docs without a valid library ID from this step.


Interactive installer for Everything Claude Code — guides users through selecting and installing skills and rules to user-level or project-level directories, verifies paths, and optionally optimizes installed files.

Configure Everything Claude Code (ECC)
Step 4: Post-Installation Verification

Step 4: Post-Installation Verification

After installation, perform these automated checks:


Create distinctive, production-grade frontend interfaces with high design quality. Use when the user asks to build web components, pages, or applications and the visual direction matters as much as the code quality.

Frontend Design
Design Workflow
2. Build the visual system

2. Build the visual system

Define:

type hierarchy

color variables

spacing rhythm

layout logic

motion rules

surface / border / shadow treatment

Use CSS variables or the project's token system so the interface stays coherent as it grows.


Liquid Glass Design System (iOS 26)

Patterns for implementing Apple's Liquid Glass — a dynamic material that blurs content behind it, reflects color and light from surrounding content, and reacts to touch and pointer interactions. Covers SwiftUI, UIKit, and WidgetKit integration.


Build MCP servers with Node/TypeScript SDK — tools, resources, prompts, Zod validation, stdio vs Streamable HTTP. Use Context7 or official MCP docs for latest API.

MCP Server Patterns
How It Works
Connecting with stdio

Connecting with stdio

For local clients, create a stdio transport and pass it to your server’s connect method. The exact API varies by SDK version (e.g. constructor vs factory). See the official MCP documentation or query Context7 for "MCP stdio server" for the current pattern.

Keep server logic (tools + resources) independent of transport so you can plug in stdio or HTTP in the entrypoint.


Codified expertise for customs documentation, tariff classification, duty optimization, restricted party screening, and regulatory compliance across multiple jurisdictions. Informed by trade compliance specialists with 15+ years experience. Includes HS classification logic, Incoterms application, FTA utilization, and penalty mitigation. Use when handling customs clearance, tariff classification, trade compliance, import/export documentation, or duty optimization.

Customs & Trade Compliance
Additional Resources

Additional Resources

Pair this skill with an internal HS classification log, broker escalation matrix, and a list of jurisdictions where your team has non-resident importer or FTZ coverage.

Record the valuation assumptions your organization uses for U.S., EU, and APAC lanes so duty calculations stay consistent across teams.


This skill should be used when the user asks to create a hookify rule, write a hook rule, configure hookify, add a hookify rule, or needs guidance on hookify rule syntax and patterns.

Writing Hookify Rules
Event Type Guide
file Events

file Events

Match Edit/Write/MultiEdit operations:

Debug code: `console\.log\(`, `debugger`

Security risks: `eval\(`, `innerHTML\s*=`

Sensitive files: `\.env$`, `credentials`, `\.pem$`


Cache expensive file processing results using SHA-256 content hashes — path-independent, auto-invalidating, with service layer separation.

Content-Hash File Cache Pattern
Core Pattern
4. Service Layer Wrapper (SRP)

4. Service Layer Wrapper (SRP)

Keep the processing function pure. Add caching as a separate service layer.


Security checklist for Solidity AMM contracts, liquidity pools, and swap flows. Covers reentrancy, CEI ordering, donation or inflation attacks, oracle manipulation, slippage, admin controls, and integer math.

When to Use

Writing or auditing a Solidity AMM or liquidity-pool contract

Implementing swap, deposit, withdraw, mint, or burn flows that hold token balances

Reviewing any contract that uses `token.balanceOf(address(this))` in share or reserve math

Adding fee setters, pausers, oracle updates, or other admin functions to a DeFi protocol


Process, convert, OCR, extract, redact, sign, and fill documents using the Nutrient DWS API. Works with PDFs, DOCX, XLSX, PPTX, HTML, and images.

Nutrient Document Processing

**Note:** This skill integrates with the Nutrient commercial API. Review their terms before use.

Process documents with the [Nutrient DWS Processor API](https://www.nutrient.io/api/). Convert formats, extract text and tables, OCR scanned documents, redact PII, add watermarks, digitally sign, and fill PDF forms.


Transform Claude Code into a fully autonomous agent system with persistent memory, scheduled operations, computer use, and task queuing. Replaces standalone agent frameworks (Hermes, AutoGPT) by leveraging Claude Code's native crons, dispatch, MCP tools, and memory. Use when the user wants continuous autonomous operation, scheduled tasks, or a self-directing agent loop.

Constraints

Cron tasks run in isolated sessions — they don't share context with interactive sessions unless through memory.

Computer use requires explicit permission grants. Don't assume access.

Remote dispatch may have rate limits. Design crons with appropriate intervals.

Memory files should be kept concise. Archive old data rather than letting files grow unbounded.

Always verify that scheduled tasks completed successfully. Add error handling to cron prompts.


Library-agnostic Flutter/Dart code review checklist covering widget best practices, state management patterns (BLoC, Riverpod, Provider, GetX, MobX, Signals), Dart idioms, performance, accessibility, security, and clean architecture.

Flutter/Dart Code Review Best Practices
7. Accessibility
Visual accessibility:

Visual accessibility:

[ ] Contrast ratio >= 4.5:1 for text against background

[ ] Tappable targets are at least 48x48 pixels

[ ] Color is not the sole indicator of state (use icons/text alongside)

[ ] Text scales with system font size settings