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.

When to Use

User wants to control how long or detailed a response is

User mentions tokens, budget, depth, or response length

User says "short version", "tldr", "brief", "al 25%", "exhaustive", etc.

Any time the user wants to choose depth/detail level upfront

**Do not trigger** when: user already set a level this session (maintain it silently), or the answer is trivially one line.


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

龙虾灵魂锻造炉 错误处理

错误处理

**完整降级策略**：见 [references/error-handling.md](references/error-handling.md)

核心原则：**降级，不中断**。

| 故障 | 降级行为 |
|------|---------|
| Python 不可用 | 跳过 gacha.py，从 10 类预设中随机选 |
| 生图 skill 未安装 | 输出提示词文本供手动使用 |
| 生图 skill 调用失败 | 重试 1 次，仍失败则输出提示词文本 |
| 任何未预期错误 | 记录错误，跳过该步骤，继续主流程 |

错误信息统一格式：


Design, implement, and refactor Ports & Adapters systems with clear domain boundaries, dependency inversion, and testable use-case orchestration across TypeScript, Java, Kotlin, and Go services.

Step 3: Implement the use case with pure orchestration

Use case class/function receives ports via constructor/arguments. It validates application-level invariants, coordinates domain rules, and returns plain data structures.


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

Pagination

For cursor-like pagination, include `id > :lastId` in JPQL with ordering.


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 2: Select & Install Skills
2b: Choose Skill Categories

2b: Choose Skill Categories

There are 7 selectable category groups below. The detailed confirmation lists that follow cover 45 skills across 8 categories, plus 1 standalone template. Use `AskUserQuestion` with `multiSelect: true`:


Use this skill to monitor a deployed URL for regressions after deploys, merges, or dependency upgrades.

Canary Watch — Post-Deploy Monitoring

When to Use

After deploying to production or staging

After merging a risky PR

When you want to verify a fix actually fixed it

Continuous monitoring during a launch window

After dependency upgrades


Spring Security best practices for authn/authz, validation, CSRF, secrets, headers, rate limiting, and dependency security in Java Spring Boot services.

Spring Boot Security Review
Password Encoding

Password Encoding

Always hash passwords with BCrypt or Argon2 — never store plaintext

Use `PasswordEncoder` bean, not manual hashing


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.

Dart/Flutter Patterns
7. Navigation with GoRouter

5. State Management: BLoC/Cubit

6. State Management: Riverpod

7. Navigation with GoRouter


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

API Design Patterns

Conventions and best practices for designing consistent, developer-friendly REST APIs.


Multi-source deep research using firecrawl and exa MCPs. Searches the web, synthesizes findings, and delivers cited reports with source attribution. Use when the user wants thorough research on any topic with evidence and citations.

Deep Research
Workflow
Step 2: Plan the Research

Step 2: Plan the Research

Break the topic into 3-5 research sub-questions. Example:

Topic: "Impact of AI on healthcare"

What are the main AI applications in healthcare today?

What clinical outcomes have been measured?

What are the regulatory challenges?

What companies are leading this space?

What's the market size and growth trajectory?


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

Modern Perl Development Patterns
When to Activate

When to Activate

Writing new Perl code or modules

Reviewing Perl code for idiom compliance

Refactoring legacy Perl to modern standards

Designing Perl module architecture

Migrating pre-5.36 code to modern Perl


Deployment workflows, CI/CD pipeline patterns, Docker containerization, health checks, rollback strategies, and production readiness checklists for web applications.

Deployment Patterns
Production Readiness Checklist
Application

Production Readiness Checklist

Before any production deployment:

Application

[ ] All tests pass (unit, integration, E2E)

[ ] No hardcoded secrets in code or config files

[ ] Error handling covers all edge cases

[ ] Logging is structured (JSON) and does not contain PII

[ ] Health check endpoint returns meaningful status


Troubleshooting

"Skills not being picked up by Claude Code"

Verify the skill directory contains a `SKILL.md` file (not just loose .md files)

For user-level: check `~/.claude/skills/<skill-name>/SKILL.md` exists

For project-level: check `.claude/skills/<skill-name>/SKILL.md` exists


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
Core Knowledge
Vendor Recovery

Vendor Recovery

Not all returns are the customer's fault. Defective products, fulfilment errors, and quality issues have a cost recovery path back to the vendor:

**Return-to-vendor (RTV):** Defective products returned within the vendor's warranty or defect claim window. Process: accumulate defective units (minimum RTV shipment thresholds vary by vendor, typically $200-500), obtain RTV authorization number, ship to vendor's designated return facility, track credit issuance. Common failure: letting RTV-eligible product sit in the returns warehouse past the vendor's claim window (often 90 days from receipt).

**Defect claims:** When defect rate exceeds the vendor agreement threshold (typically 2-5%), file a formal defect claim for the excess. Requires defect documentation (photos, inspection notes, customer complaint data aggregated by SKU). Vendors will challenge — your data quality determines your recovery.

**Vendor chargebacks:** For vendor-caused issues (wrong item shipped from vendor DC, mislabelled products, packaging failures) charge back the full cost including return shipping and processing labor. Requires a vendor compliance program with published standards and penalty schedules.

**Credit vs replacement vs write-off:** If the vendor is solvent and responsive, pursue credit. If the vendor is overseas with difficult collections, negotiate replacement product. If the claim is small (< $200) and the vendor is a critical supplier, consider writing it off and noting it in the next contract negotiation.


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.

Layout

break the grid when the composition benefits from it

use diagonals, offsets, and grouping intentionally

keep reading flow obvious even when the layout is unconventional


Baseline cross-project coding conventions for naming, readability, immutability, and code-quality review. Use detailed frontend or backend skills for framework-specific patterns.

Coding Standards & Best Practices
TypeScript/JavaScript Standards
Immutability Pattern (CRITICAL)

TypeScript/JavaScript Standards

Variable Naming

Function Naming

Immutability Pattern (CRITICAL)


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.

fal.ai Media Generation
Image Generation
Nano Banana Pro (High Fidelity)

Nano Banana Pro (High Fidelity)

Best for: production images, realism, typography, detailed prompts.


Build a fully automated AI-powered data collection agent for any public source — job boards, prices, news, GitHub, sports, anything. Scrapes on a schedule, enriches data with a free LLM (Gemini Flash), stores results in Notion/Sheets/Supabase, and learns from user feedback. Runs 100% free on GitHub Actions. Use when the user wants to monitor, collect, or track any public data automatically.

Data Scraper Agent
Workflow
Step 2: Design the Agent Architecture

Step 2: Design the Agent Architecture

Generate this directory structure for the user:


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.

Production Scheduling
Core Knowledge
Disruption Response

Disruption Response

**Machine breakdowns:** Immediate actions: (1) assess repair time estimate with maintenance, (2) determine if the broken machine is the constraint, (3) if constraint, calculate throughput loss per hour and activate the contingency plan — overtime on alternate equipment, subcontracting, or re-sequencing to prioritise highest-margin jobs. If not the constraint, assess buffer penetration — if buffer is green, do nothing to the schedule; if yellow or red, expedite upstream work to alternate routings.

**Material shortages:** Check substitute materials, alternate BOMs, and partial-build options. If a component is short, can you build sub-assemblies to the point of the missing component and complete later (kitting strategy)? Escalate to purchasing for expedited delivery. Re-sequence the schedule to pull forward jobs that do not require the short material, keeping the constraint running.

**Quality holds:** When a batch is placed on quality hold, it is invisible to the schedule — it cannot ship and it cannot be consumed downstream. Immediately re-run the schedule excluding held inventory. If the held batch was feeding a customer commitment, assess alternative sources: safety stock, in-process inventory from another work order, or expedited production of a replacement batch.

**Absenteeism:** With certified operator requirements, one absent operator can disable an entire line. Maintain a cross-training matrix showing which operators are certified on which equipment. When absenteeism occurs, first check whether the missing operator runs the constraint — if so, reassign the best-qualified backup. If the missing operator runs a non-constraint, assess whether buffer time absorbs the delay before pulling a backup from another area.

**Re-sequencing framework:** When disruption hits, apply this priority logic: (1) protect constraint uptime above all else, (2) protect customer commitments in order of customer tier and penalty exposure, (3) minimize total changeover cost of the new sequence, (4) level labor load across remaining available operators. Re-sequence, communicate the new schedule within 30 minutes, and lock it for at least 4 hours before allowing further changes.


Spring Boot Security Review
Authentication

Authentication

Prefer stateless JWT or opaque tokens with revocation list

Use `httpOnly`, `Secure`, `SameSite=Strict` cookies for sessions

Validate tokens with `OncePerRequestFilter` or resource server


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
Additional Resources

Additional Resources

Track carrier scorecards, exception trends, and routing-guide compliance in the same operating review so pricing and service decisions stay tied together.

Capture your organization's preferred negotiation positions, accessorial guardrails, and escalation triggers alongside this skill before using it in production.


JetBrains Exposed ORM patterns including DSL queries, DAO pattern, transactions, HikariCP connection pooling, Flyway migrations, and repository pattern.

Kotlin Exposed Patterns
Transactions
Transaction Isolation

Entity Definitions

DAO Operations

Transactions

Suspend Transaction Support

Transaction Isolation


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
14. Dependency Injection
Principles (apply to any DI approach):

14. Dependency Injection

Principles (apply to any DI approach):

[ ] Classes depend on abstractions (interfaces), not concrete implementations at layer boundaries

[ ] Dependencies provided externally via constructor, DI framework, or provider graph — not created internally

[ ] Registration distinguishes lifetime: singleton vs factory vs lazy singleton

[ ] Environment-specific bindings (dev/staging/prod) use configuration, not runtime `if` checks

[ ] No circular dependencies in the DI graph

[ ] Service locator calls (if used) are not scattered throughout business logic


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

Docker Patterns

Docker and Docker Compose best practices for containerized development.


Go testing patterns including table-driven tests, subtests, benchmarks, fuzzing, and test coverage. Follows TDD methodology with idiomatic Go practices.

Go Testing Patterns
Benchmarks
Benchmark with Different Sizes

Interface-Based Mocking

Benchmarks

Basic Benchmarks

Benchmark with Different Sizes


Scan skills to extract cross-cutting principles and distill them into rules — append, revise, or create new rule files

When to Use

Periodic rules maintenance (monthly or after installing new skills)

After a skill-stocktake reveals patterns that should be rules

When rules feel incomplete relative to the skills being used


Flutter/Dart Code Review Best Practices
6. Testing
Test types and expectations:

6. Testing

Test types and expectations:

[ ] **Unit tests**: Cover all business logic (state managers, repositories, utility functions)

[ ] **Widget tests**: Cover individual widget behavior, interactions, and visual output

[ ] **Integration tests**: Cover critical user flows end-to-end

[ ] **Golden tests**: Pixel-perfect comparisons for design-critical UI components


Reorganize the user's X and LinkedIn network with review-first pruning, add/follow recommendations, and channel-specific warm outreach drafted in the user's real voice. Use when the user wants to clean up following lists, grow toward current priorities, or rebalance a social graph around higher-signal relationships.

Safety Defaults

default is review-first, never blind auto-pruning

X: prune only accounts the user follows, never followers

LinkedIn: treat 1st-degree connection removal as manual-review-first

do not auto-send DMs, invites, or emails

emit a ranked action plan and drafts before any apply step


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)
How It Works
x402 Protocol

How It Works

x402 Protocol

x402 extends HTTP 402 (Payment Required) into a machine-negotiable flow. When a server returns `402`, the agent's payment tool automatically negotiates price, checks budget, signs a transaction, and retries — no human in the loop.


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.

What is dmux

dmux is a tmux-based orchestration tool that manages AI agent panes:

Press `n` to create a new pane with a prompt

Press `m` to merge pane output back to the main session

Supports: Claude Code, Codex, OpenCode, Cline, Gemini, Qwen

**Install:** Install dmux from its repository after reviewing the package. See [github.com/standardagents/dmux](https://github.com/standardagents/dmux)


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.

When to Activate

User wants to find leads or prospects in a specific industry

Building an outreach list for partnerships, sales, or fundraising

Researching who to reach out to and the best path to reach them

User says "find leads", "outreach list", "who should I reach out to", "warm intros"

Needs to score or rank a list of contacts by relevance

Wants to map mutual connections to find warm introduction paths


Production Scheduling
Decision Frameworks
Bottleneck Identification

Bottleneck Identification

**Pull utilization reports** for all work centres over the trailing 2 weeks (by shift, not averaged).

**Rank by utilization ratio** (load hours / available hours). The top work centre is the suspected constraint.

**Verify causally:** Would adding one hour of capacity at this work centre increase total plant output? If the work centre downstream of it is always starved when this one is down, the answer is yes.

**Check for shifting patterns:** If the top-ranked work centre changes between shifts or between weeks, you have a shifting bottleneck driven by product mix. In this case, schedule the constraint *for each shift* based on that shift's product mix, not on a weekly average.

**Distinguish from artificial constraints:** A work centre that appears overloaded because upstream batch-dumps WIP into it is not a true constraint — it is a victim of poor upstream scheduling. Fix the upstream release rate before adding capacity to the victim.


Audit the active repo, MCP servers, plugins, connectors, env surfaces, and harness setup, then recommend the highest-value ECC-native skills, hooks, agents, and operator workflows. Use when the user wants help setting up Claude Code or understanding what capabilities are actually available in their environment.

Workspace Surface Audit

Read-only audit skill for answering the question "what can this workspace and machine actually do right now, and what should we add or enable next?"

This is the ECC-native answer to setup-audit plugins. It does not modify files unless the user explicitly asks for follow-up implementation.


Carrier Relationship Management
Examples

Examples

**New carrier onboarding**: Regional LTL carrier applies for your freight. Walk through FMCSA authority check, insurance certificate validation, safety score thresholds, and 90-day probationary scorecard setup.

**Annual RFP**: Run a 200-lane TL RFP. Structure bid packages, analyze incumbent vs. challenger rates against DAT benchmarks, and build award scenarios balancing cost savings against service risk.

**Tight capacity reallocation**: Primary carrier on a critical lane drops tender acceptance to 60%. Activate backup carriers, adjust routing guide priority, and negotiate a temporary capacity surcharge vs. spot market exposure.


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.

Core Rules

Personalize every outbound message.

Keep the ask low-friction.

Use proof instead of adjectives.

Stay concise.

Never send copy that could go to any investor.


Perl testing patterns using Test2::V0, Test::More, prove runner, mocking, coverage with Devel::Cover, and TDD methodology.

Perl Testing Patterns
Common Pitfalls
Over-Mocking

Common Pitfalls

Forgetting `done_testing`

Missing `-l` Flag

Over-Mocking

Mock the *dependency*, not the code under test. If your test only verifies that a mock returns what you told it to, it tests nothing.


Connections Optimizer
Tool Requirements
Preferred

Tool Requirements

Preferred

`x-api` for X graph inspection and recent activity

`lead-intelligence` for target discovery and warm-path ranking

`social-graph-ranker` when the user wants bridge value scored independently of the broader lead workflow

Exa / deep research for person and company enrichment

`brand-voice` before drafting outbound


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

Plankton Code Quality Skill
Pairing with ECC
Avoiding Hook Conflicts

Avoiding Hook Conflicts

If running both ECC and Plankton hooks:

ECC's Prettier hook and Plankton's biome formatter may conflict on JS/TS files

Resolution: disable ECC's Prettier PostToolUse hook when using Plankton (Plankton's biome is more comprehensive)

Both can coexist on different file types (ECC handles what Plankton doesn't cover)


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

C++ Testing (Agent Skill)
Best Practices
DON'T

DON'T

Don't depend on real time or network in unit tests

Don't use sleeps as synchronization when a condition variable can be used

Don't over-mock simple value objects

Don't use brittle string matching for non-critical logs


ClickHouse database patterns, query optimization, analytics, and data engineering best practices for high-performance analytical workloads.

ClickHouse Analytics Patterns
Common Analytics Queries
Time Series Analysis

Query Performance

Table Statistics

Common Analytics Queries

Time Series Analysis


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)

Header Guard

Naming Conventions

Anti-Patterns

`using namespace std;` in a header at global scope (SF.7)

Headers that depend on inclusion order (SF.10, SF.11)

Hungarian notation like `strName`, `iCount` (NL.5)

ALL_CAPS for anything other than macros (NL.9)


Spring Security best practices for authn/authz, validation, CSRF, secrets, headers, rate limiting, and dependency security in Java Spring Boot services.

Spring Boot Security Review
Secrets Management

Secrets Management

No secrets in source; load from env or vault

Keep `application.yml` free of credentials; use placeholders

Rotate tokens and DB credentials regularly


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
Operations
Convert Documents

Operations

Convert Documents

Supported inputs: PDF, DOCX, XLSX, PPTX, DOC, XLS, PPT, PPS, PPSX, ODT, RTF, HTML, JPG, PNG, TIFF, HEIC, GIF, WebP, SVG, TGA, EPS.


Multi-agent adversarial verification with convergence loop. Two independent review agents must both pass before output ships.

Phase 4: Fix Until Nice (Convergence Loop)

Critical: each review round uses **fresh agents**. Reviewers must not carry memory from previous rounds, as prior context creates anchoring bias.


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
Common Use Cases

Common Use Cases

| Scenario | Recommended Approach |
|----------|---------------------|
| "What package for auth?" | Search "auth" with healthy filter |
| "Is spatie/package still maintained?" | Get details, check health score |
| "Need Laravel 12 packages" | Search with laravel_compatibility: "12" |
| "Find admin panel packages" | Search "admin panel", review results |
| "Check vendor reputation" | Search by vendor, check details |


Error Handling (E.*)

Key Rules

| Rule | Summary |
|------|---------|
| **E.1** | Develop an error-handling strategy early in a design |
| **E.2** | Throw an exception to signal that a function can't perform its assigned task |
| **E.6** | Use RAII to prevent leaks |
| **E.12** | Use `noexcept` when throwing is impossible or unacceptable |
| **E.14** | Use purpose-designed user-defined types as exceptions |
| **E.15** | Throw by value, catch by reference |
| **E.16** | Destructors, deallocation, and swap must never fail |
| **E.17** | Don't try to catch every exception in every function |


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

API Design Patterns
Pagination
Cursor-Based (Scalable)

Cursor-Based (Scalable)

**Pros:** Consistent performance regardless of position, stable with concurrent inserts
**Cons:** Cannot jump to arbitrary page, cursor is opaque


Pipeline Overview

Voice Before Outreach

Do not draft outbound from generic sales copy.

Run `brand-voice` first whenever the user's voice matters. Reuse its `VOICE PROFILE` instead of re-deriving style ad hoc inside this skill.

If live X access is available, pull recent original posts before drafting. If not, use supplied examples or the best repo/site material available.


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
Documentation Requirements

Documentation Requirements

**Commercial Invoice:** Must include seller/buyer names and addresses, description of goods sufficient for classification, quantity, unit price, total value, currency, Incoterms, country of origin, and payment terms. US CBP requires the invoice conform to 19 CFR § 141.86. Undervaluation triggers penalties per 19 USC § 1592.

**Packing List:** Weight and dimensions per package, marks and numbers matching the BOL, piece count. Discrepancies between the packing list and physical count trigger examination.

**Certificate of Origin:** Varies by FTA. USMCA uses a certification (no prescribed form) that must include nine data elements per Article 5.2. EUR.1 movement certificates for EU preferential trade. Form A for GSP claims. UK uses "origin declarations" on invoices for UK-EU TCA claims.

**Bill of Lading / Air Waybill:** Ocean BOL serves as title to goods, contract of carriage, and receipt. Air waybill is non-negotiable. Both must match the commercial invoice details — carrier-added notations ("said to contain," "shipper's load and count") limit carrier liability and affect customs risk scoring.

**ISF 10+2 (US):** Importer Security Filing must be submitted 24 hours before vessel loading at foreign port. Ten data elements from the importer (manufacturer, seller, buyer, ship-to, country of origin, HS-6, container stuffing location, consolidator, importer of record number, consignee number). Two from the carrier. Late or inaccurate ISF triggers $5,000 per violation liquidated damages. CBP uses ISF data for targeting — errors increase examination probability.

**Entry Summary (CBP 7501):** Filed within 10 business days of entry. Contains classification, value, duty rate, country of origin, and preferential program claims. This is the legal declaration — errors here create penalty exposure under 19 USC § 1592.


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
5. Performance
Other:

Other:

[ ] `Opacity` widget avoided in animations — use `AnimatedOpacity` or `FadeTransition`

[ ] Clipping avoided in animations — pre-clip images

[ ] `operator ==` not overridden on widgets — use `const` constructors instead

[ ] Intrinsic dimension widgets (`IntrinsicHeight`, `IntrinsicWidth`) used sparingly (extra layout pass)


Workspace Surface Audit
Audit Process
Phase 3: Turn Gaps Into ECC Decisions

Phase 3: Turn Gaps Into ECC Decisions

For every real gap, recommend the correct ECC-native shape:

| Gap Type | Preferred ECC Shape |
|----------|---------------------|
| Repeatable operator workflow | Skill |
| Automatic enforcement or side-effect | Hook |
| Specialized delegated role | Agent |
| External tool bridge | MCP server or connector |
| Install/bootstrap guidance | Setup or audit skill |

Default to user-facing skills that orchestrate existing tools when the need is operational rather than infrastructural.


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

Go Development Patterns
Memory and Performance
Preallocate Slices When Size is Known

Embedding for Composition

Memory and Performance

Preallocate Slices When Size is Known


Use this skill to prevent destructive operations when working on production systems or running agents autonomously.

Safety Guard — Prevent Destructive Operations

Mode 2: Freeze Mode

Locks file edits to a specific directory tree:

Any Write/Edit outside `src/components/` is blocked with an explanation. Useful when you want an agent to focus on one area without touching unrelated code.


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.

Outputs

Produce these artifacts in order:

DAILY inventory

LIBRARY inventory

install plan

verification report

optional `skill-library` router if the project wants one


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 2: Select the Best Match

Step 2: Select the Best Match

From the resolution results, choose one result using:

**Name match**: Prefer exact or closest match to what the user asked for.

**Benchmark score**: Higher scores indicate better documentation quality (100 is highest).

**Source reputation**: Prefer High or Medium reputation when available.

**Version**: If the user specified a version (e.g. "React 19", "Next.js 15"), prefer a version-specific library ID if listed (e.g. `/org/project/v1.2.0`).


Evidence-first mailbox triage, drafting, send verification, and sent-mail-safe follow-up workflow for ECC. Use when the user wants to organize email, draft or send through the real mail surface, or prove what landed in Sent.

Email Ops
Workflow
3. Draft, then verify

3. Draft, then verify

For draft-only work:

produce the final copy

state sender, recipient, subject, and purpose

For live-send work:

verify the exact final body first

send through the chosen mail surface

confirm the message landed in Sent or the equivalent sent-copy store


Flutter/Dart Code Review Best Practices
6. Testing
Coverage targets:

Coverage targets:

[ ] Aim for 80%+ line coverage on business logic

[ ] All state transitions have corresponding tests (loading → success, loading → error, retry, etc.)

[ ] Edge cases tested: empty states, error states, loading states, boundary values


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.

Anti-Patterns

generic startup gradients with no visual identity

system-font decks unless intentionally editorial

long bullet walls

code blocks that need scrolling

fixed-height content boxes that break on short screens

invalid negated CSS functions like `-clamp(...)`


Use this skill to validate the "why" before building, run product diagnostics, and pressure-test product direction before the request becomes an implementation contract.

Product Lens — Think Before You Build
Integration

Integration

Pair with:

`/browser-qa` to verify the user journey audit findings

`/design-system audit` for visual polish assessment

`/canary-watch` for post-launch monitoring

`product-capability` when the product brief needs to become an implementation-ready capability plan


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

**The most sophisticated pattern.** An RFC-driven, multi-agent pipeline that decomposes a spec into a dependency DAG, runs each unit through a tiered quality pipeline, and lands them via an agent-driven merge queue. Created by enitrat (credit: @enitrat).


How It Works

Classify products using GRI rules and chapter/heading/subheading analysis

Determine applicable duty rates, preferential programs (FTZs, drawback, FTAs), and trade remedies

Screen all transaction parties against consolidated denied-party lists before shipment

Prepare and validate entry documentation per jurisdiction requirements

Monitor regulatory changes (tariff modifications, new sanctions, trade agreement updates)

Respond to government inquiries with proper prior disclosure and penalty mitigation strategies


Customs & Trade Compliance
Core Knowledge
Restricted Party Screening

Restricted Party Screening

**Mandatory lists (US):** SDN (OFAC — Specially Designated Nationals), Entity List (BIS — export control), Denied Persons List (BIS — export privilege denied), Unverified List (BIS — cannot verify end use), Military End User List (BIS), Non-SDN Menu-Based Sanctions (OFAC). Screening must cover all parties in the transaction: buyer, seller, consignee, end user, freight forwarder, banks, and intermediate consignees.

**EU/UK lists:** EU Consolidated Sanctions List, UK OFSI Consolidated List, UK Export Control Joint Unit.

**Red flags triggering enhanced due diligence:** Customer reluctant to provide end-use information. Unusual routing (high-value goods through free ports). Customer willing to pay cash for expensive items. Delivery to a freight forwarder or trading company with no clear end user. Product capabilities exceed the stated application. Customer has no business background in the product type. Order patterns inconsistent with customer's business.

**False positive management:** ~95% of screening hits are false positives. Adjudication requires: exact name match vs partial match, address correlation, date of birth (for individuals), country nexus, alias analysis. Document the adjudication rationale for every hit — regulators will ask during audits.


Related ECC Skills

`frontend-patterns` for component and interaction patterns around the deck

`liquid-glass-design` when a presentation intentionally borrows Apple glass aesthetics

`e2e-testing` if you need automated browser verification for the final deck


Translate PRD intent, roadmap asks, or product discussions into an implementation-ready capability plan that exposes constraints, invariants, interfaces, and unresolved decisions before multi-service work starts. Use when the user needs an ECC-native PRD-to-SRS lane instead of vague planning prose.

Product Capability
Core Workflow
2. Resolve capability constraints

2. Resolve capability constraints

Extract the constraints that must hold before implementation:

business rules

scope boundaries

invariants

trust boundaries

data ownership

lifecycle transitions

rollout / migration requirements

failure and recovery expectations

These are the things that often live only in senior-engineer memory.


C# and .NET testing patterns with xUnit, FluentAssertions, mocking, integration tests, and test organization best practices.

C# Testing Patterns
Test Framework Stack

Test Framework Stack

| Tool | Purpose |
|---|---|
| **xUnit** | Test framework (preferred for .NET) |
| **FluentAssertions** | Readable assertion syntax |
| **NSubstitute** or **Moq** | Mocking dependencies |
| **Testcontainers** | Real infrastructure in integration tests |
| **WebApplicationFactory** | ASP.NET Core integration tests |
| **Bogus** | Realistic test data generation |


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
Escalation Protocols
Escalation Chain

Escalation Chain

Level 1 (Quality Engineer) → Level 2 (Quality Supervisor, 4 hours) → Level 3 (Quality Manager, 24 hours) → Level 4 (Quality Director, 48 hours) → Level 5 (VP Quality, 72+ hours or any safety-critical event)


Decision framework for choosing between regex and LLM when parsing structured text — start with regex, add LLM only for low-confidence edge cases.

Regex vs LLM for Structured Text Parsing

2. Confidence Scoring

Flag items that may need LLM review:

3. LLM Validator (Edge Cases Only)


Idiomatic Rust patterns, ownership, error handling, traits, concurrency, and best practices for building safe, performant applications.

Rust Development Patterns
Core Principles
1. Ownership and Borrowing

Core Principles

1. Ownership and Borrowing

Rust's ownership system prevents data races and memory bugs at compile time.


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

How It Works

**Identify target code** — Find the function, class, or module to test

**Write a Kotest spec** — Choose a spec style (StringSpec, FunSpec, BehaviorSpec) matching the test scope

**Mock dependencies** — Use MockK to isolate the unit under test

**Run tests (RED)** — Verify the test fails with the expected error

**Implement code (GREEN)** — Write minimal code to pass the test

**Refactor** — Improve the implementation while keeping tests green

**Check coverage** — Run `./gradlew koverHtmlReport` and verify 80%+ coverage


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
Filtering Best Practices
By Laravel Version

By Laravel Version

| Version | Notes |
|---------|-------|
| `13` | Latest Laravel |
| `12` | Current stable |
| `11` | Still widely used |
| `10` | Legacy but common |
| `5`-`9` | Deprecated |

**Recommendation**: Match the target project's Laravel version.


Spring Security best practices for authn/authz, validation, CSRF, secrets, headers, rate limiting, and dependency security in Java Spring Boot services.

Spring Boot Security Review
File Uploads

File Uploads

Validate size, content type, and extension

Store outside web root; scan if required


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.

HIPAA Compliance

Use this as the HIPAA-specific entrypoint when a task is clearly about US healthcare compliance. This skill intentionally stays thin and canonical:

`healthcare-phi-compliance` remains the primary implementation skill for PHI/PII handling, data classification, audit logging, encryption, and leak prevention.

`healthcare-reviewer` remains the specialized reviewer when code, architecture, or product behavior needs a healthcare-aware second pass.

`security-review` still applies for general auth, input-handling, secrets, API, and deployment hardening.


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

Kotlin Coroutines & Flows
Structured Concurrency
Scope Hierarchy

Structured Concurrency

Scope Hierarchy

Always use structured concurrency — never `GlobalScope`:


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 4: Ensure Understandable Logic

Step 4: Ensure Understandable Logic

Use consistent navigation patterns.

Provide descriptive error messages and suggestions for correction (SC 3.3.3).

Implement "Redundant Entry" (SC 3.3.7) to prevent asking for the same data twice.


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

PyTorch Development Patterns
Model Architecture Patterns
Proper Weight Initialization

Model Architecture Patterns

Clean nn.Module Structure

Proper Weight Initialization


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

Iterative Retrieval Pattern

Solves the "context problem" in multi-agent workflows where subagents don't know what context they need until they start working.


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.

Persistence Rule

Do **not** write ad-hoc notes to `~/.claude/notes` or other shadow paths from this skill.

If the council materially changes the recommendation:

use `knowledge-ops` to store the lesson in the right durable location

or use `/save-session` if the outcome belongs in session memory

or update the relevant GitHub / Linear issue directly if the decision changes active execution truth

Only persist a decision when it changes something real.


Clinical Decision Support System (CDSS) development patterns. Drug interaction checking, dose validation, clinical scoring (NEWS2, qSOFA), alert severity classification, and integration into EMR workflows.

Healthcare CDSS Development Patterns

Patterns for building Clinical Decision Support Systems that integrate into EMR workflows. CDSS modules are patient safety critical — zero tolerance for false negatives.


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
Examples
Screen Recording (Desktop Capture)

Screen Recording (Desktop Capture)

Use `ws_listener.py` to capture WebSocket events during recording sessions. Desktop capture supports **macOS** only.

Quick Start

Quick Start

**Choose state dir**: `STATE_DIR="${VIDEODB_EVENTS_DIR:-$HOME/.local/state/videodb}"`

**Start listener**: `VIDEODB_EVENTS_DIR="$STATE_DIR" python scripts/ws_listener.py --clear "$STATE_DIR" &`

**Get WebSocket ID**: `cat "$STATE_DIR/videodb_ws_id"`

**Run capture code** (see reference/capture.md for the full workflow)

**Events written to**: `$STATE_DIR/videodb_events.jsonl`

Use `--clear` whenever you start a fresh capture run so stale transcript and visual events do not leak into the new session.

Query Events

Query Events


Audit the active repo, MCP servers, plugins, connectors, env surfaces, and harness setup, then recommend the highest-value ECC-native skills, hooks, agents, and operator workflows. Use when the user wants help setting up Claude Code or understanding what capabilities are actually available in their environment.

Workspace Surface Audit
Non-Negotiable Rules

Non-Negotiable Rules

Never print secret values. Surface only provider names, capability names, file paths, and whether a key or config exists.

Prefer ECC-native workflows over generic "install another plugin" advice when ECC can reasonably own the surface.

Treat external plugins as benchmarks and inspiration, not authoritative product boundaries.

Separate three things clearly:

already available now

available but not wrapped well in ECC

not available and would require a new integration


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

Laravel Development Patterns
Examples
Global Scopes and Soft Deletes

Eager Loading to Avoid N+1

Query Objects for Complex Filters

Global Scopes and Soft Deletes

Use global scopes for default filtering and `SoftDeletes` for recoverable records.
Use either a global scope or a named scope for the same filter, not both, unless you intend layered behavior.


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

Agent Harness Construction
Observation Design

Observation Design

Every tool response should include:

`status`: success|warning|error

`summary`: one-line result

`next_actions`: actionable follow-ups

`artifacts`: file paths / IDs


Output Format

Return five sections in this order:

**Current surface**

what is already usable right now

**Parity**

where ECC already matches or exceeds the benchmark

**Primitive-only gaps**

tools exist, but ECC lacks a clean operator skill

**Missing integrations**

capability not available yet

**Top 3-5 next moves**

concrete ECC-native additions, ordered by impact


Evidence-first automation inventory and overlap audit workflow for ECC. Use when the user wants to know which jobs, hooks, connectors, MCP servers, or wrappers are live, broken, redundant, or missing before fixing anything.

Guardrails

start read-only unless the user explicitly asked for fixes

separate:

configured

authenticated

recently verified

stale or broken

missing entirely

do not claim a tool is live just because a skill or config references it

do not merge or delete overlapping surfaces until the evidence table exists


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.

Layer 5: Generated Assets (ElevenLabs / fal.ai)

Generated visuals with fal.ai

Use for insert shots, thumbnails, or b-roll that doesn't exist:


JetBrains Exposed ORM patterns including DSL queries, DAO pattern, transactions, HikariCP connection pooling, Flyway migrations, and repository pattern.

Kotlin Exposed Patterns
Table Definitions
Composite Tables

Flyway Migrations

Migration Files

Table Definitions

DSL Style Tables

Composite Tables


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
3. Widget Best Practices
Build method complexity:

Build method complexity:

[ ] No network calls, file I/O, or heavy computation in `build()`

[ ] No `Future.then()` or `async` work in `build()`

[ ] No subscription creation (`.listen()`) in `build()`

[ ] `setState()` localized to smallest possible subtree


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

Laravel Verification Loop
Phase 2: Linting and Static Analysis

Phase 1.5: Composer and Autoload

Phase 2: Linting and Static Analysis

If your project uses Psalm instead of PHPStan:


Workspace Surface Audit
Recommendation Rules

Recommendation Rules

Recommend at most 1-2 highest-value ideas per category.

Favor skills with obvious user intent and business value:

setup audit

billing/customer ops

issue/program ops

Google Workspace ops

deployment/ops control

If a connector is company-specific, recommend it only when it is genuinely available or clearly useful to the user's workflow.

If ECC already has a strong primitive, propose a wrapper skill instead of inventing a brand-new subsystem.


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
Performance Indicators

Performance Indicators

Track these metrics weekly and trend monthly:

| Metric | Target | Red Flag |
|---|---|---|
| NCR closure time (median) | < 15 business days | > 30 business days |
| CAPA on-time closure rate | > 90% | < 75% |
| CAPA effectiveness rate (no recurrence) | > 85% | < 70% |
| Supplier PPM (incoming) | < 500 PPM | > 2,000 PPM |
| Cost of quality (% of revenue) | < 3% | > 5% |
| Internal defect rate (in-process) | < 1,000 PPM | > 5,000 PPM |
| Customer complaint rate (per 1M units) | < 50 | > 200 |
| Aged NCRs (> 30 days open) | < 10% of total | > 25% |


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)

Guidelines

Anti-Patterns

Optimizing without profiling data (Per.1, Per.6)

Choosing "clever" low-level code over clear abstractions (Per.4, Per.5)

Ignoring data layout and cache behavior (Per.19)


SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

SwiftUI Patterns

Modern SwiftUI patterns for building declarative, performant user interfaces on Apple platforms. Covers the Observation framework, view composition, type-safe navigation, and performance optimization.


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

Notes

Evaluation is blind: the same checklist applies to all skills regardless of origin (ECC, self-authored, auto-extracted)

Archive / delete operations always require explicit user confirmation

No verdict branching by skill origin


Conduct market research, competitive analysis, investor due diligence, and industry intelligence with source attribution and decision-oriented summaries. Use when the user wants market sizing, competitor comparisons, fund research, technology scans, or research that informs business decisions.

Market Research
Common Research Modes
Market Sizing

Market Sizing

Use:

top-down estimates from reports or public datasets

bottom-up sanity checks from realistic customer acquisition assumptions

explicit assumptions for every leap in logic


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
Strong Defaults
Typography

Strong Defaults

Typography

pick fonts with character

pair a distinctive display face with a readable body face when appropriate

avoid generic defaults when the page is design-led


Django security best practices, authentication, authorization, CSRF protection, SQL injection prevention, XSS prevention, and secure deployment configurations.

Django Security Best Practices
CSRF Protection
Exempting Views (Use Carefully)

HTTP Headers

CSRF Protection

Default CSRF Protection

Exempting Views (Use Carefully)


Trace every user-facing button/touchpoint through its full state change sequence to find bugs where functions individually work but cancel each other out, produce wrong final state, or leave the UI in an inconsistent state. Use when: systematic debugging found no bugs but users report broken buttons, or after any major refactor touching shared state stores.

/click-path-audit — Behavioural Flow Audit

Recommended agent split for full app:

Agent 1 MUST complete first. Its output is input for all other agents.


Analyze raw prompts, identify intent and gaps, match ECC components (skills/commands/agents/hooks), and output a ready-to-paste optimized prompt. Advisory role only — never executes the task itself. TRIGGER when: user says "optimize prompt", "improve my prompt", "how to write a prompt for", "help me prompt", "rewrite this prompt", or explicitly asks to enhance prompt quality. Also triggers on Chinese equivalents: "优化prompt", "改进prompt", "怎么写prompt", "帮我优化这个指令". DO NOT TRIGGER when: user wants the task executed directly, or says "just do it" / "直接做". DO NOT TRIGGER when user says "优化代码", "优化性能", "optimize performance", "optimize this code" — those are refactoring/performance tasks, not prompt optimization.

Prompt Optimizer
Output Format
Section 5: Enhancement Rationale

Section 5: Enhancement Rationale

| Enhancement | Reason |
|-------------|--------|
| (what was added) | (why it matters) |


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 2: SELECT Clause Omission

Pattern 2: SELECT Clause Omission

**Frequency**: Common with Supabase/Prisma when adding new columns


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.

Scope Guardrails

work in the sibling `ECC-Tools` repo, not in `everything-claude-code`

start read-only unless the user clearly asked for a fix

do not mutate unrelated billing, checkout, or UI flows while tracing analysis burn

treat app-generated branches and app-generated PRs as red-flag recursion paths until proved otherwise

separate three things explicitly:

repo-side burn root cause

customer-facing billing impact

product or entitlement gaps that need backlog follow-up


Multi-source deep research using firecrawl and exa MCPs. Searches the web, synthesizes findings, and delivers cited reports with source attribution. Use when the user wants thorough research on any topic with evidence and citations.


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.

Transcode video (resolution / quality change)

Reframe aspect ratio (for social platforms)

**Warning:** `reframe()` is a slow server-side operation. For long videos it can take
several minutes and may time out. Best practices:

Always limit to a short segment using `start`/`end` when possible

For full-length videos, use `callback_url` for async processing

Trim the video on a `Timeline` first, then reframe the shorter result


VideoDB Skill
When to use
Timeline editing + generation

Timeline editing + generation

Subtitles: **generate**, **translate**, **burn-in**

Overlays: **text/image/branding**, motion captions

Audio: **background music**, **voiceover**, **dubbing**

Programmatic composition and exports via **timeline operations**


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
Configuration

Configuration

Edit `config.json` to control the background observer:

| Key | Default | Description |
|-----|---------|-------------|
| `observer.enabled` | `false` | Enable the background observer agent |
| `observer.run_interval_minutes` | `5` | How often the observer analyzes observations |
| `observer.min_observations_to_analyze` | `20` | Minimum observations before analysis runs |

Other behavior (observation capture, instinct thresholds, project scoping, promotion criteria) is configured via code defaults in `instinct-cli.py` and `observe.sh`.


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

Anti-Patterns to Avoid

Creating a single large protocol that covers all external access

Mocking internal types that have no external dependencies

Using `#if DEBUG` conditionals instead of proper dependency injection

Forgetting `Sendable` conformance when used with actors

Over-engineering: if a type has no external dependencies, it doesn't need a protocol


ClickHouse database patterns, query optimization, analytics, and data engineering best practices for high-performance analytical workloads.

ClickHouse Analytics Patterns
Best Practices
5. Monitoring

5. Monitoring

Track query performance

Monitor disk usage

Check merge operations

Review slow query log

**Remember**: ClickHouse excels at analytical workloads. Design tables for your query patterns, batch inserts, and leverage materialized views for real-time aggregations.


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
Preferred Surface

Preferred Surface

Start from what already exists:

GitHub issues, PRs, reviews, comments, and CI

Linear issue/project movement

local hook events and session lifecycle signals

desktop notification primitives

connected email/chat surfaces when they actually exist

Prefer ECC-native orchestration over telling the user to adopt a separate notification product.


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.

Git Worktree Integration

For tasks that touch overlapping files:

Complementary Tools

| Tool | What It Does | When to Use |
|------|-------------|-------------|
| **dmux** | tmux pane management for agents | Parallel agent sessions |
| **Superset** | Terminal IDE for 10+ parallel agents | Large-scale orchestration |
| **Claude Code Task tool** | In-process subagent spawning | Programmatic parallelism within a session |
| **Codex multi-agent** | Built-in agent roles | Codex-specific parallel work |


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
Rate Limiting (Filter + Bucket4j)

Middleware / Filters

Pagination and Sorting

Error-Resilient External Calls

Rate Limiting (Filter + Bucket4j)

**Security Note**: The `X-Forwarded-For` header is untrusted by default because clients can spoof it.
Only use forwarded headers when:

Your app is behind a trusted reverse proxy (nginx, AWS ALB, etc.)

You have registered `ForwardedHeaderFilter` as a bean

You have configured `server.forward-headers-strategy=NATIVE` or `FRAMEWORK` in application properties

Your proxy is configured to overwrite (not append to) the `X-Forwarded-For` header

When `ForwardedHeaderFilter` is properly configured, `request.getRemoteAddr()` will automatically
return the correct client IP from the forwarded headers. Without this configuration, use
`request.getRemoteAddr()` directly—it returns the immediate connection IP, which is the only
trustworthy value.


Evidence-first mailbox triage, drafting, send verification, and sent-mail-safe follow-up workflow for ECC. Use when the user wants to organize email, draft or send through the real mail surface, or prove what landed in Sent.

Email Ops
Workflow
4. Report exact state

4. Report exact state

Use exact status words:

drafted

approval-pending

sent

blocked

awaiting verification

If the send surface is blocked, preserve the draft and report the exact blocker instead of improvising a second transport without saying so.


GitHub repository operations, automation, and management. Issue triage, PR management, CI/CD operations, release management, and security monitoring using the gh CLI. Use when the user wants to manage GitHub issues, PRs, CI status, releases, contributors, stale items, or any GitHub operational task beyond simple git commands.

Quality Gate

Before completing any GitHub operations task:

all issues triaged have appropriate labels

no PRs older than 7 days without a review or comment

CI failures have been investigated (not just re-run)

releases include accurate changelogs

security alerts are acknowledged and tracked


VideoDB Skill
When to use
Video ingest + stream

Video ingest + stream

Ingest a **file or URL** and return a **playable web stream link**

Transcode/normalize: **codec, bitrate, fps, resolution, aspect ratio**


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
Key Design Decisions

Key Design Decisions

| Decision | Rationale |
|----------|-----------|
| Single-threaded by default | Most natural code is data-race free; concurrency is opt-in |
| Async stays on calling actor | Eliminates implicit offloading that caused data-race errors |
| Isolated conformances | MainActor types can conform to protocols without unsafe workarounds |
| `@concurrent` explicit opt-in | Background execution is a deliberate performance choice, not accidental |
| MainActor default inference | Reduces boilerplate `@MainActor` annotations for app targets |
| Opt-in adoption | Non-breaking migration path — enable features incrementally |


Multi-agent adversarial verification with convergence loop. Two independent review agents must both pass before output ships.

Santa Method
Integration with Other Skills

Integration with Other Skills

| Skill | Relationship |
|-------|-------------|
| Verification Loop | Use for deterministic checks (build, lint, test). Santa for semantic checks (accuracy, hallucinations). Run verification-loop first, Santa second. |
| Eval Harness | Santa Method results feed eval metrics. Track pass@k across Santa runs to measure generator quality over time. |
| Continuous Learning v2 | Santa findings become instincts. Repeated failures on the same criterion → learned behavior to avoid the pattern. |
| Strategic Compact | Run Santa BEFORE compacting. Don't lose review context mid-verification. |


Interactive agent picker for composing and dispatching parallel teams


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
4. State Management (Library-Agnostic)
Subscriptions & disposal:

Subscriptions & disposal:

[ ] All manual subscriptions (`.listen()`) are cancelled in `dispose()` / `close()`

[ ] Stream controllers are closed when no longer needed

[ ] Timers are cancelled in disposal lifecycle

[ ] Framework-managed lifecycle is preferred over manual subscription (declarative builders over `.listen()`)

[ ] `mounted` check before `setState` in async callbacks

[ ] `BuildContext` not used after `await` without checking `context.mounted` (Flutter 3.7+) — stale context causes crashes

[ ] No navigation, dialogs, or scaffold messages after async gaps without verifying the widget is still mounted

[ ] `BuildContext` never stored in singletons, state managers, or static fields


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
Audit Trail

Access Control: Row-Level Security

Audit Trail

Every PHI access or modification must be logged:


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
Core Knowledge
Inspection and Grading

Inspection and Grading

Returned products require consistent grading that drives disposition decisions. Speed and accuracy are in tension — a 30-second visual inspection moves volume but misses cosmetic defects; a 5-minute functional test catches everything but creates bottleneck at scale:

**Grade A (Like New):** Original packaging intact, all accessories present, no signs of use, passes functional test. Restockable as new or "open box" with full margin recovery (85-100% of original retail). Target inspection time: 45-90 seconds.

**Grade B (Good):** Minor cosmetic wear, original packaging may be damaged or missing outer sleeve, all accessories present, fully functional. Restockable as "open box" or "renewed" at 60-80% of retail. May need repackaging ($2-5 per unit). Target inspection time: 90-180 seconds.

**Grade C (Fair):** Visible wear, scratches, or minor damage. Missing accessories that cost <10% of unit value. Functional but cosmetically impaired. Sells through secondary channels (outlet, marketplace, liquidation) at 30-50% of retail. Refurbishment possible if cost < 20% of recovered value.

**Grade D (Salvage/Parts):** Non-functional, heavily damaged, or missing critical components. Salvageable for parts or materials recovery at 5-15% of retail. If parts recovery isn't viable, route to recycling or destruction.

Grading standards vary by category. Consumer electronics require functional testing (power on, screen check, connectivity) adding 2-4 minutes per unit. Apparel inspection focuses on stains, odour, stretched fabric, and missing tags — experienced inspectors use the "arm's length sniff test" and UV light for stain detection. Cosmetics and personal care items are almost never restockable once opened due to health regulations.


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.

Output Format

Return the result in this order:


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
1. Define the operating questions

Workflow

1. Define the operating questions

Organize around:

health / availability

latency / performance

throughput / volume

saturation / resources

service-specific risk


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.

The Pipeline

Each layer has a specific job. Do not skip layers. Do not try to make one tool do everything.


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)

Cross-Cutting Principles

These themes recur across the entire guidelines and form the foundation:

**RAII everywhere** (P.8, R.1, E.6, CP.20): Bind resource lifetime to object lifetime

**Immutability by default** (P.10, Con.1-5, ES.25): Start with `const`/`constexpr`; mutability is the exception

**Type safety** (P.4, I.4, ES.46-49, Enum.3): Use the type system to prevent errors at compile time

**Express intent** (P.3, F.1, NL.1-2, T.10): Names, types, and concepts should communicate purpose

**Minimize complexity** (F.2-3, ES.5, Per.4-5): Simple code is correct code

**Value semantics over pointer semantics** (C.10, R.3-5, F.20, CP.31): Prefer returning by value and scoped objects


Clean Architecture patterns for Android and Kotlin Multiplatform projects — module structure, dependency rules, UseCases, Repositories, and data layer patterns.

References

See skill: `compose-multiplatform-patterns` for UI patterns.
See skill: `kotlin-coroutines-flows` for async patterns.


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
Core Components
4. Computer Use

4. Computer Use

Leverage Claude's computer-use MCP for physical world interaction.

**Capabilities:**

Browser automation (navigate, click, fill forms, screenshot)

Desktop control (open apps, type, mouse control)

File system operations beyond CLI

**Use cases within the harness:**

Automated testing of web UIs

Form filling and data entry

Screenshot-based monitoring

Multi-app workflows


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.

Operating Model

**GitHub** is the public and community truth

**Linear** is the internal execution truth for active scheduled work

Not every GitHub issue needs a Linear issue

Create or update Linear only when the work is:

active

delegated

scheduled

cross-functional

important enough to track internally


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.

Python SDK

Installation

Basic Message

Streaming

System Prompt

TypeScript SDK


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
When to Consolidate vs. Diversify

When to Consolidate vs. Diversify

**Consolidate (reduce carrier count) when:** You have more than 3 carriers on a lane with <5 loads/week (each carrier gets too little volume to care). Your carrier management resources are stretched. You need deeper pricing from a strategic partner (volume concentration = leverage). The market is loose and carriers are competing for your freight.

**Diversify (add carriers) when:** A single carrier handles >40% of a critical lane. Tender rejections are rising above 15% on a lane. You're entering peak season and need surge capacity. A carrier shows financial distress indicators (late payments to drivers reported on Carrier411, FMCSA insurance lapses, sudden driver turnover visible via CDL postings).


Patterns for continuous autonomous agent loops with quality gates, evals, and recovery controls.

Loop Selection Flow

Combined Pattern

Recommended production stack:

RFC decomposition (`ralphinho-rfc-pipeline`)

quality gates (`plankton-code-quality` + `/quality-gate`)

eval loop (`eval-harness`)

session persistence (`nanoclaw-repl`)


Operate customer billing workflows such as subscriptions, refunds, churn triage, billing-portal recovery, and plan analysis using connected billing tools like Stripe. Use when the user needs to help a customer, inspect subscription state, or manage revenue-impacting billing operations.

Customer Billing Ops
Workflow
4. Check operator-side product gaps

4. Check operator-side product gaps

If the customer pain comes from a missing operator surface, call it out explicitly. Common examples:

no billing portal

no usage/rate-limit visibility

no plan/seat explanation

no cancellation flow

no duplicate-subscription guard

Treat those as ECC or website follow-up items, not just support incidents.


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

PostgreSQL Patterns
Quick Reference
Index Cheat Sheet

Quick Reference

Index Cheat Sheet

| Query Pattern | Index Type | Example |
|--------------|------------|---------|
| `WHERE col = value` | B-tree (default) | `CREATE INDEX idx ON t (col)` |
| `WHERE col > value` | B-tree | `CREATE INDEX idx ON t (col)` |
| `WHERE a = x AND b > y` | Composite | `CREATE INDEX idx ON t (a, b)` |
| `WHERE jsonb @> '{}'` | GIN | `CREATE INDEX idx ON t USING gin (col)` |
| `WHERE tsv @@ query` | GIN | `CREATE INDEX idx ON t USING gin (col)` |
| Time-series ranges | BRIN | `CREATE INDEX idx ON t USING brin (col)` |


Use this skill when writing new features, fixing bugs, or refactoring code. Enforces test-driven development with 80%+ coverage including unit, integration, and E2E tests.

Test-Driven Development Workflow
TDD Workflow Steps
Step 4: Implement Code

Step 4: Implement Code

Write minimal code to make tests pass:

If the repository is under Git, stage the minimal fix now but defer the checkpoint commit until GREEN is validated in Step 5.


SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

SwiftUI Patterns
View Composition
Extract Subviews to Limit Invalidation

View Composition

Extract Subviews to Limit Invalidation

Break views into small, focused structs. When state changes, only the subview reading that state re-renders:


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.

Hard Bans

Delete and rewrite any of these:

"I'd love to connect"

"excited to share"

generic thesis praise without a real tie-in

vague founder adjectives

begging language

soft closing questions when a direct ask is clearer


Conduct market research, competitive analysis, investor due diligence, and industry intelligence with source attribution and decision-oriented summaries. Use when the user wants market sizing, competitor comparisons, fund research, technology scans, or research that informs business decisions.

Market Research
Common Research Modes
Competitive Analysis

Competitive Analysis

Collect:

product reality, not marketing copy

funding and investor history if public

traction metrics if public

distribution and pricing clues

strengths, weaknesses, and positioning gaps


Build reusable Manim explainers for technical concepts, graphs, system diagrams, and product walkthroughs, then hand off to the wider ECC video stack if needed. Use when the user wants a clean animated explainer rather than a generic talking-head script.

Workflow

Define the core visual thesis in one sentence.

Break the concept into 3 to 6 scenes.

Decide what each scene proves.

Write the scene outline before writing Manim code.

Render the smallest working version first.

Tighten typography, spacing, color, and pacing after the render works.

Hand off to the wider video stack only if it adds value.


NestJS architecture patterns for modules, controllers, providers, DTO validation, guards, interceptors, config, and production-grade TypeScript backends.

NestJS Development Patterns
DTOs and Validation

DTOs and Validation

Validate every request DTO with `class-validator`.

Use dedicated response DTOs or serializers instead of returning ORM entities directly.

Avoid leaking internal fields such as password hashes, tokens, or audit columns.


Baseline cross-project coding conventions for naming, readability, immutability, and code-quality review. Use detailed frontend or backend skills for framework-specific patterns.

Coding Standards & Best Practices
Code Quality Principles
4. YAGNI (You Aren't Gonna Need It)

4. YAGNI (You Aren't Gonna Need It)

Don't build features before they're needed

Avoid speculative generality

Add complexity only when required

Start simple, refactor when needed


Verification loop for Spring Boot projects: build, static analysis, tests with coverage, security scans, and diff review before release or PR.

Spring Boot Verification Loop
When to Activate

When to Activate

Before opening a pull request for a Spring Boot service

After major refactoring or dependency upgrades

Pre-deployment verification for staging or production

Running full build → lint → test → security scan pipeline

Validating test coverage meets thresholds


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.

Deliverables

When asked for a campaign, return:

a short voice profile if voice matching matters

the core angle

platform-native drafts

posting order only if it helps execution

gaps that must be filled before publishing


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.

Handoffs

If the next step is interactive installation or repair, hand off to:

`configure-ecc`

If the next step is overlap cleanup or catalog review, hand off to:

`skill-stocktake`

If the next step is broader context trimming, hand off to:

`strategic-compact`


Evidence-first automation inventory and overlap audit workflow for ECC. Use when the user wants to know which jobs, hooks, connectors, MCP servers, or wrappers are live, broken, redundant, or missing before fixing anything.

Output Format

Pitfalls

do not answer from memory when the live inventory can be read

do not treat "present in config" as "working"

do not fix lower-value redundancy before naming the broken high-signal path

do not widen the task into a repo rewrite if the user asked for inventory first


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

Laravel Development Patterns
Examples
Routing and Controllers

Routing and Controllers

Prefer route-model binding and resource controllers for clarity.


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.

When to Use

user asks for Stripe sales, refunds, MRR, or recent customer activity

user asks whether team billing, per-seat billing, or quota stacking is real in code

user wants competitor pricing comparisons or pricing-model benchmarks

the question mixes revenue facts with product implementation truth


Spring Security best practices for authn/authz, validation, CSRF, secrets, headers, rate limiting, and dependency security in Java Spring Boot services.

Spring Boot Security Review
SQL Injection Prevention

SQL Injection Prevention

Use Spring Data repositories or parameterized queries

For native queries, use `:param` bindings; never concatenate strings


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.

Core Tools

web_search_exa

General web search for current information, news, or facts.

**Parameters:**

| Param | Type | Default | Notes |
|-------|------|---------|-------|
| `query` | string | required | Search query |
| `numResults` | number | 8 | Number of results |
| `type` | string | `auto` | Search mode |
| `livecrawl` | string | `fallback` | Prefer live crawling when needed |
| `category` | string | none | Optional focus such as `company` or `research paper` |


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.

Dart/Flutter Patterns
3. Async Composition
BuildContext After Await

3. Async Composition

Structured Concurrency with Future.wait

Stream Patterns

BuildContext After Await


Knowledge base management, ingestion, sync, and retrieval across multiple storage layers (local files, MCP memory, vector stores, Git repos). Use when the user wants to save, organize, sync, deduplicate, or search across their knowledge systems.

Knowledge Operations
Ingestion Workflow
1. Classify

Ingestion Workflow

When new knowledge needs to be captured:

1. Classify

What type of knowledge is it?

Business decision -> memory file (project type) + MCP memory

Active roadmap / release / implementation state -> GitHub + Linear first

Personal preference -> memory file (user/feedback type)

Reference info -> memory file (reference type) + MCP memory

Large document -> external data store + summary in memory

Conversation/session -> knowledge base repo + short summary in memory


Use this skill when adding authentication, handling user input, working with secrets, creating API endpoints, or implementing payment/sensitive features. Provides comprehensive security checklist and patterns.

Security Review Skill
Security Checklist
10. Dependency Security

10. Dependency Security

Regular Updates

Regular Updates

Lock Files

Lock Files

Verification Steps

Verification Steps

[ ] Dependencies up to date

[ ] No known vulnerabilities (npm audit clean)

[ ] Lock files committed

[ ] Dependabot enabled on GitHub

[ ] Regular security updates


SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

SwiftUI Patterns
Performance
Stable Identifiers

Stable Identifiers

Always use stable, unique IDs in `ForEach` — avoid using array indices:


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

Plankton Code Quality Skill
Setup
Language-Specific Dependencies

Language-Specific Dependencies

| Language | Required | Optional |
|----------|----------|----------|
| Python | `ruff`, `uv` | `ty` (types), `vulture` (dead code), `bandit` (security) |
| TypeScript/JS | `biome` | `oxlint`, `semgrep`, `knip` (dead exports) |
| Shell | `shellcheck`, `shfmt` | — |
| YAML | `yamllint` | — |
| Markdown | `markdownlint-cli2` | — |
| Dockerfile | `hadolint` (>= 2.12.0) | — |
| TOML | `taplo` | — |
| JSON | `jaq` | — |


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

Autonomous Loops Skill
3. Infinite Agentic Loop
The Pattern

Architecture: Two-Prompt System

The Pattern

**Spec Analysis** — Orchestrator reads a specification file (Markdown) defining what to generate

**Directory Recon** — Scans existing output to find the highest iteration number

**Parallel Deployment** — Launches N sub-agents, each with:

The full spec

A unique creative direction

A specific iteration number (no conflicts)

A snapshot of existing iterations (for uniqueness)

**Wave Management** — For infinite mode, deploys waves of 3-5 agents until context is exhausted


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
Phase 2: Rehearse
When rehearsal fails

When rehearsal fails

Read the visible-element dump.

Find the correct selector.

Update the script.

Re-run rehearsal.

Only proceed when every selector passes.


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
Additional Resources

Additional Resources

Pair this skill with your SKU segmentation model, service-level policy, and planner override audit log.

Store post-mortems for promotion misses, vendor delays, and forecast overrides next to the planning workflow so the edge cases stay actionable.


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
Kysely (TypeScript/Node.js)

Drizzle (TypeScript/Node.js)

Workflow

Schema Example

Kysely (TypeScript/Node.js)


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
10. Package/Dependency Review
Monorepo-specific (melos/workspace):

Monorepo-specific (melos/workspace):

[ ] Internal packages import only from public API — no `package:other/src/internal.dart` (breaks Dart package encapsulation)

[ ] Internal package dependencies use workspace resolution, not hardcoded `path: ../../` relative strings

[ ] All sub-packages share or inherit root `analysis_options.yaml`


Django security best practices, authentication, authorization, CSRF protection, SQL injection prevention, XSS prevention, and secure deployment configurations.

Django Security Best Practices

Comprehensive security guidelines for Django applications to protect against common vulnerabilities.


Comprehensive Perl security covering taint mode, input validation, safe process execution, DBI parameterized queries, web security (XSS/SQLi/CSRF), and perlcritic security policies.

Taint Mode

Perl's taint mode (`-T`) tracks data from external sources and prevents it from being used in unsafe operations without explicit validation.


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
Decision Frameworks
Screening Hit Assessment

Screening Hit Assessment

When a restricted party screening tool returns a match, do not block the transaction automatically or clear it without investigation. Follow this protocol:

**Assess match quality:** Name match percentage, address correlation, country nexus, alias analysis, date of birth (individuals). Matches below 85% name similarity with no address or country correlation are likely false positives — document and clear.

**Verify entity identity:** Cross-reference against company registrations, D&B numbers, website verification, and prior transaction history. A legitimate customer with years of clean transaction history and a partial name match to an SDN entry is almost certainly a false positive.

**Check list specifics:** SDN hits require OFAC licence to proceed. Entity List hits require BIS licence with a presumption of denial. Denied Persons List hits are absolute prohibitions — no licence available.

**Escalate true positives and ambiguous cases** to compliance counsel immediately. Never proceed with a transaction while a screening hit is unresolved.

**Document everything.** Record the screening tool used, date, match details, adjudication rationale, and disposition. Retain for 5 years minimum.


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.

Output Format

Return:

the primary platform version

adapted variants for each requested platform

a short note on what changed and why

any publishing constraint the user still needs to resolve


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
Renewable Energy Procurement

Renewable Energy Procurement

**Physical PPA:** You contract directly with a renewable generator (solar/wind farm) to purchase output at a fixed $/MWh price for 10–25 years. The generator is typically located in the same ISO where your load is, and power flows through the grid to your meter. You receive both the energy and the associated RECs. Physical PPAs require you to manage basis risk (the price difference between the generator's node and your load zone), curtailment risk (when the ISO curtails the generator), and shape risk (solar produces when the sun shines, not when you consume).

**Virtual (financial) PPA (VPPA):** A contract-for-differences. You agree on a fixed strike price (e.g., $35/MWh). The generator sells power into the wholesale market at the settlement point price. If the market price is $45/MWh, the generator pays you $10/MWh. If the market price is $25/MWh, you pay the generator $10/MWh. You receive RECs to claim renewable attributes. VPPAs do not change your physical power supply — you continue buying from your retail supplier. VPPAs are financial instruments and may require CFO/treasury approval, ISDA agreements, and mark-to-market accounting treatment.

**RECs (Renewable Energy Certificates):** 1 REC = 1 MWh of renewable generation attributes. Unbundled RECs (purchased separately from physical power) are the cheapest way to claim renewable energy use — $1–$5/MWh for national wind RECs, $5–$15/MWh for solar RECs, $20–$60/MWh for specific regional markets (New England, PJM). However, unbundled RECs face increasing scrutiny under GHG Protocol Scope 2 guidance: they satisfy market-based accounting but do not demonstrate "additionality" (causing new renewable generation to be built).

**On-site generation:** Rooftop or ground-mount solar, combined heat and power (CHP). On-site solar PPA pricing: $0.04–$0.08/kWh depending on location, system size, and ITC eligibility. On-site generation reduces T&D exposure and can lower capacity tags. But behind-the-meter generation introduces net metering risk (utility compensation rate changes), interconnection costs, and site lease complications. Evaluate on-site vs. off-site based on total economic value, not just energy cost.


Customs & Trade Compliance
Core Knowledge
Regional Specialties

Regional Specialties

**US CBP:** Centers of Excellence and Expertise (CEEs) specialise by industry. Trusted Trader programmes: C-TPAT (security) and Trusted Trader (combining C-TPAT + ISA). ACE is the single window for all import/export data. Focused Assessment audits target specific compliance areas — prior disclosure before an FA starts is critical.

**EU Customs Union:** Common External Tariff (CET) applies uniformly. Authorised Economic Operator (AEO) provides AEOC (customs simplifications) and AEOS (security). Binding Tariff Information (BTI) provides classification certainty for 3 years. Union Customs Code (UCC) governs since 2016.

**UK post-Brexit:** UK Global Tariff replaced the CET. Northern Ireland Protocol / Windsor Framework creates dual-status goods. UK Customs Declaration Service (CDS) replaced CHIEF. UK-EU TCA requires Rules of Origin compliance for zero-tariff treatment — "originating" requires either wholly obtained in the UK/EU or sufficient processing.

**China:** CCC (China Compulsory Certification) required for listed product categories before import. China uses 13-digit HS codes. Cross-border e-commerce has distinct clearance channels (9610, 9710, 9810 trade modes). Recent Unreliable Entity List creates new screening obligations.


Use this skill to automate visual testing and UI interaction verification using browser automation after deploying features.

Browser QA — Automated Visual Testing & Interaction

Output Format

Integration

Works with any browser MCP:

`mChild__claude-in-chrome__*` tools (preferred — uses your actual Chrome)

Playwright via `mcp__browserbase__*`

Direct Puppeteer scripts

Pair with `/canary-watch` for post-deploy monitoring.


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 3: Deterministic Cuts (FFmpeg)
Normalize audio levels

Create proxy for faster editing

Extract audio for transcription

Normalize audio levels


Django architecture patterns, REST API design with DRF, ORM best practices, caching, signals, middleware, and production-grade Django apps.

Django Development Patterns
Quick Reference

N+1 Query Prevention

Database Indexing

Bulk Operations

Quick Reference

| Pattern | Description |
|---------|-------------|
| Split settings | Separate dev/prod/test settings |
| Custom QuerySet | Reusable query methods |
| Service Layer | Business logic separation |
| ViewSet | REST API endpoints |
| Serializer validation | Request/response transformation |
| select_related | Foreign key optimization |
| prefetch_related | Many-to-many optimization |
| Cache first | Cache expensive operations |
| Signals | Event-driven actions |
| Middleware | Request/response processing |

Remember: Django provides many shortcuts, but for production applications, structure and organization matter more than concise code. Build for maintainability.