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
Escalation Protocols
Automatic Escalation Triggers

Escalation Protocols

Automatic Escalation Triggers

| Trigger | Action | Timeline |
|---|---|---|
| Constraint work centre down > 30 minutes unplanned | Alert production manager + maintenance manager | Immediate |
| Plan adherence drops below 80% for a shift | Root cause analysis with shift supervisor | Within 4 hours |
| Customer order projected to miss committed ship date | Notify sales and customer service with revised ETA | Within 2 hours of detection |
| Overtime requirement exceeds weekly budget by > 20% | Escalate to plant manager with cost-benefit analysis | Within 1 business day |
| OEE at constraint drops below 65% for 3 consecutive shifts | Trigger focused improvement event (maintenance + engineering + scheduling) | Within 1 week |
| Quality yield at constraint drops below 93% | Joint review with quality engineering | Within 24 hours |
| MRP-generated load exceeds finite capacity by > 15% for the upcoming week | Capacity meeting with planning and production management | 2 days before the overloaded week |


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

pass^k

"All k trials succeed"

Higher bar for reliability

pass^3: 3 consecutive successes

Use for critical paths


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

Laravel Security Best Practices
XSS Prevention

XSS Prevention

Blade escapes output by default (`{{ }}`)

Use `{!! !!}` only for trusted, sanitized HTML

Sanitize rich text with a dedicated library


GAN-inspired Generator-Evaluator agent harness for building high-quality applications autonomously. Based on Anthropic's March 2026 harness design paper.

GAN-Style Harness Skill
The Three Agents
2. Generator Agent

2. Generator Agent

**Role:** Developer — implements features according to the spec.

**Key behaviors:**

Works in structured sprints (or continuous mode with newer models)

Negotiates a "sprint contract" with the Evaluator before writing code

Uses full-stack tooling: React, FastAPI/Express, databases, CSS

Manages git for version control between iterations

Reads Evaluator feedback and incorporates it in next iteration

**Model:** Opus 4.6 (needs strong coding capability)


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

Deployment Patterns
Deployment Strategies
Blue-Green Deployment

Blue-Green Deployment

Run two identical environments. Switch traffic atomically.

**Pros:** Instant rollback (switch back to blue), clean cutover
**Cons:** Requires 2x infrastructure during deployment
**Use when:** Critical services, zero-tolerance for issues


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
Disposition Decision Trees

Disposition Decision Trees

Disposition is where returns either recover value or destroy margin. The routing decision is economics-driven:

**Restock as new:** Only Grade A with complete packaging. Product must pass any required functional/safety testing. Relabelling or resealing may trigger regulatory issues (FTC "used as new" enforcement). Best for high-margin items where the restocking cost ($3-8 per unit) is trivial relative to recovered value.

**Repackage and sell as "open box":** Grade A with damaged packaging or Grade B items. Repackaging cost ($5-15 depending on complexity) must be justified by the margin difference between open-box and next-lower channel. Electronics and small appliances are the sweet spot.

**Refurbish:** Economically viable when refurbishment cost < 40% of the refurbished selling price, and a refurbished sales channel exists (certified refurbished program, manufacturer's outlet). Common for premium electronics, power tools, and small appliances. Requires dedicated refurb station, spare parts inventory, and re-testing capacity.

**Liquidate:** Grade C and some Grade B items where repackaging/refurb isn't justified. Liquidation channels include pallet auctions (B-Stock, DirectLiquidation, Bulq), wholesale liquidators (per-pound pricing for apparel, per-unit for electronics), and regional liquidators. Recovery rates: 5-20% of retail. Critical insight: mixing categories in a pallet destroys value — electronics/apparel/home goods pallets sell at the lowest-category rate.

**Donate:** Tax-deductible at fair market value (FMV). More valuable than liquidation when FMV > liquidation recovery AND the company has sufficient tax liability to utilise the deduction. Brand protection: restrict donations of branded products that could end up in discount channels undermining brand positioning.

**Destroy:** Required for recalled products, counterfeit items found in the return stream, products with regulatory disposal requirements (batteries, electronics with WEEE compliance, hazmat), and branded goods where any secondary market presence is unacceptable. Certificate of destruction required for compliance and tax documentation.


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

Kotest Matchers

Core Matchers

Core Matchers

Custom Matchers

Custom Matchers

MockK

Basic Mocking

Basic Mocking

Coroutine Mocking

Coroutine Mocking

Argument Capture

Argument Capture

Spy and Partial Mocking

Spy and Partial Mocking


When NOT to Use

Quick single-file fixes (use standard `claude -p`)

Tasks with tight budget constraints (<$10)

Simple refactoring (use de-sloppify pattern instead)

Tasks that are already well-specified with tests (use TDD workflow)


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.

dmux Workflows

Orchestrate parallel AI agent sessions using dmux, a tmux pane manager for agent harnesses.


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
Examples
Example: Find Authentication Packages

Examples

Example: Find Authentication Packages

Returns packages matching "authentication" with healthy status:

spatie/laravel-permission

laravel/breeze

laravel/passport

etc.


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

Setup

Get a free API key at **[nutrient.io](https://dashboard.nutrient.io/sign_up/?product=processor)**

All requests go to `https://api.nutrient.io/build` as multipart POST with an `instructions` JSON field.


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

Anti-Patterns to Avoid

Sending all text to an LLM when regex handles 95%+ of cases (expensive and slow)

Using regex for free-form, highly variable text (LLM is better here)

Skipping confidence scoring and hoping regex "just works"

Mutating parsed objects during cleaning/validation steps

Not testing edge cases (malformed input, missing fields, encoding issues)


Operate long-lived agent workloads with observability, security boundaries, and lifecycle management.

Incident Pattern

When failure spikes:

freeze new rollout

capture representative traces

isolate failing route

patch with smallest safe change

run regression + security checks

resume gradually


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

Python Testing Patterns
Mocking and Patching
Mocking Context Managers

Mocking Functions

Mocking Return Values

Mocking Exceptions

Mocking Context Managers


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

Crosspost
Workflow
Step 2: Capture the Voice Fingerprint

Step 2: Capture the Voice Fingerprint

Run `brand-voice` first if the source voice is not already captured in the current session.

Reuse the resulting `VOICE PROFILE` directly.
Do not build a second ad hoc voice checklist here unless the user explicitly wants a fresh override for this campaign.


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

Phase 2: Check It Twice (Independent Dual Review)

Spawn two review agents in parallel. Critical invariants:

**Context isolation** — neither reviewer sees the other's assessment

**Identical rubric** — both receive the same evaluation criteria

**Same inputs** — both receive the original spec AND the generated output

**Structured output** — each returns a typed verdict, not prose


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.

Core Principle

Pick a direction and commit to it.

Safe-average UI is usually worse than a strong, coherent aesthetic with a few bold choices.


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

Iterative Retrieval Pattern
Practical Examples
Example 2: Feature Implementation

Practical Examples

Example 1: Bug Fix Context

Example 2: Feature Implementation


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.

Pitfalls

do not begin with broad repo wandering; settle webhook -> queue -> worker first

do not mix customer billing inference with code-backed product truth

do not fix lower-value quality issues before the highest-burn path is contained

do not claim burn is fixed until the narrow proving step was rerun

do not push or deploy unless the user asked

do not touch unrelated repo-local changes if they are already in progress


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
Core Knowledge
Regulatory Frameworks

Regulatory Frameworks

**FDA 21 CFR 820 (QSR):** Covers medical device quality systems. Key sections: 820.90 (nonconforming product), 820.100 (CAPA), 820.198 (complaint handling), 820.250 (statistical techniques). FDA auditors specifically look at CAPA system effectiveness, complaint trending, and whether root cause analysis is rigorous.

**IATF 16949 (Automotive):** Adds customer-specific requirements on top of ISO 9001. Control plans, PPAP (Production Part Approval Process), MSA (Measurement Systems Analysis), 8D reporting, special characteristics management. Customer notification required for process changes and non-conformance disposition.

**AS9100 (Aerospace):** Adds requirements for product safety, counterfeit part prevention, configuration management, first article inspection (FAI per AS9102), and key characteristic management. Customer approval required for use-as-is dispositions. OASIS database for supplier management.

**ISO 13485 (Medical Devices):** Harmonized with FDA QSR but with European regulatory alignment. Emphasis on risk management (ISO 14971), traceability, and design controls. Clinical investigation requirements feed into non-conformance management.

**Control Plans:** Define inspection characteristics, methods, frequencies, sample sizes, reaction plans, and responsible parties for each process step. Required by IATF 16949 and good practice universally. Must be a living document updated when processes change.


When to Activate

Parsing structured text with repeating patterns (questions, forms, tables)

Deciding between regex and LLM for text extraction

Building hybrid pipelines that combine both approaches

Optimizing cost/accuracy tradeoffs in text processing


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

When to Use

First time opening a project with Claude Code

Joining a new team or repository

User asks "help me understand this codebase"

User asks to generate a CLAUDE.md for a project

User says "onboard me" or "walk me through this repo"


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

Agent Payment Execution (x402)
MCP Integration
Available Tools (agent-callable)

Available Tools (agent-callable)

| Tool | Purpose |
|------|---------|
| `get_balance` | Check agent wallet balance |
| `send_payment` | Send payment to address or ENS |
| `check_spending` | Query remaining budget |
| `list_transactions` | Audit trail of all payments |

**Note**: Spending policy is set by the **orchestrator** before delegating to the agent — not by the agent itself. This prevents agents from escalating their own spending limits. Configure policy via `set_policy` in your orchestration layer or pre-task hook, never as an agent-callable tool.


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

Python Development Patterns
Data Classes and Named Tuples
Data Classes

Generator Expressions

Generator Functions

Data Classes and Named Tuples

Data Classes


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.

8. HTTP with Dio

9. Error Handling Architecture

10. Testing Quick Reference

References

[Effective Dart: Design](https://dart.dev/effective-dart/design)

[Flutter Performance Best Practices](https://docs.flutter.dev/perf/best-practices)

[Riverpod Documentation](https://riverpod.dev/)

[BLoC Library](https://bloclibrary.dev/)

[GoRouter](https://pub.dev/packages/go_router)

[Freezed](https://pub.dev/packages/freezed)

Skill: `flutter-dart-code-review` — comprehensive review checklist

Rules: `rules/dart/` — coding style, patterns, security, testing, hooks


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.

Step 5: Synthesize and Write Report

Structure the report:

Step 6: Deliver

**Short topics**: Post the full report in chat

**Long reports**: Post the executive summary + key takeaways, save full report to a file


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

Pattern-Based

Model-Based (LLM-as-judge)

Best Practices

**Start with 3-5 tasks** that represent your real workload, not toy examples

**Run at least 3 trials** per agent to capture variance — agents are non-deterministic

**Pin the commit** in your task YAML so results are reproducible across days/weeks

**Include at least one deterministic judge** (tests, build) per task — LLM judges add noise

**Track cost alongside pass rate** — a 95% agent at 10x the cost may not be the right choice

**Version your task definitions** — they are test fixtures, treat them as code


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

Unified Notifications Ops
Workflow
4. Design the ECC-native workflow

4. Design the ECC-native workflow

For each real notification need, define:

**source**

**gate**

**shape**: immediate alert, digest, queue, or dashboard-only

**channel**

**action**

If ECC already has the primitive, prefer:

a skill for operator triage

a hook for automatic emission/enforcement

an agent for delegated classification

an MCP/connector only when a real bridge is missing


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
Core Knowledge
Safety Stock Calculation

Safety Stock Calculation

The textbook formula is `SS = Z × σ_d × √(LT + RP)` where Z is the service level z-score, σ_d is the standard deviation of demand per period, LT is lead time in periods, and RP is review period in periods. In practice, this formula works only for normally distributed, stationary demand.

**Service Level Targets:** 95% service level (Z=1.65) is standard for A-items. 99% (Z=2.33) for critical/A+ items where stockout cost dwarfs holding cost. 90% (Z=1.28) is acceptable for C-items. Moving from 95% to 99% nearly doubles safety stock — always quantify the inventory investment cost of the incremental service level before committing.

**Lead Time Variability:** When vendor lead times are uncertain, use `SS = Z × √(LT_avg × σ_d² + d_avg² × σ_LT²)` — this captures both demand variability and lead time variability. Vendors with coefficient of variation (CV) on lead time > 0.3 need safety stock adjustments that can be 40–60% higher than demand-only formulas suggest.

**Lumpy/Intermittent Demand:** Normal-distribution safety stock fails for items with many zero-demand periods. Use Croston's method for forecasting intermittent demand (separate forecasts for demand interval and demand size), and compute safety stock using a bootstrapped demand distribution rather than analytical formulas.

**New Products:** No demand history means no σ_d. Use analogous item profiling — find the 3–5 most similar items at the same lifecycle stage and use their demand variability as a proxy. Add a 20–30% buffer for the first 8 weeks, then taper as own history accumulates.


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.

Council
Workflow
3. Form the Architect position first

3. Form the Architect position first

Before reading other voices, write down:

your initial position

the three strongest reasons for it

the main risk in your preferred path

Do this first so the synthesis does not simply mirror the external voices.


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
9. Security
Network security:

Network security:

[ ] HTTPS enforced for all API calls

[ ] Certificate pinning considered for high-security apps

[ ] Authentication tokens refreshed and expired properly

[ ] No sensitive data logged or printed


Compose Multiplatform and Jetpack Compose patterns for KMP projects — state management, navigation, theming, performance, and platform-specific UI.

Compose Multiplatform Patterns
Performance
Avoid Allocations in Recomposition

Use `key()` and Lazy Lists Correctly

Defer Reads with `derivedStateOf`

Avoid Allocations in Recomposition


Interactive agent picker for composing and dispatching parallel teams

Configuration

Agents are discovered via two methods, merged and deduplicated by agent name:

**`claude agents` command** (primary) — run `claude agents` to get all agents known to the CLI, including user agents, plugin agents (e.g. `everything-claude-code:architect`), and built-in agents. This automatically covers ECC marketplace installs without any path configuration.

**File glob** (fallback, for reading agent content) — agent markdown files are read from:

`./agents/**/*.md` + `./agents/*.md` — project-local agents

`~/.claude/agents/**/*.md` + `~/.claude/agents/*.md` — global user agents

Earlier sources take precedence when names collide: user agents > plugin agents > built-in agents. A custom path can be used instead if the user specifies one.


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
Scene Detection and Auto-Cut
Highlight extraction

Silence detection for auto-cut

Highlight extraction

Use Claude to analyze transcript + scene timestamps:


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

/search-first — Research Before You Code

Content & Publishing

Markdown processing → `remark`, `unified`, `markdown-it`

Image optimization → `sharp`, `imagemin`


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

Core Pattern — UIKit

Basic UIGlassEffect

UIGlassContainerEffect for Multiple Elements


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

Links

[API Playground](https://dashboard.nutrient.io/processor-api/playground/)

[Full API Docs](https://www.nutrient.io/guides/dws-processor/)

[npm MCP Server](https://www.npmjs.com/package/@nutrient-sdk/dws-mcp-server)


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

How It Works

Start with taint-aware input boundaries, then move outward: validate and untaint inputs, keep filesystem and process execution constrained, and use parameterized DBI queries everywhere. The examples below show the safe defaults this skill expects you to apply before shipping Perl code that touches user input, the shell, or the network.


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

When to Use

Any application calling Claude, OpenAI, or similar LLM APIs

Batch processing pipelines where cost adds up quickly

Multi-model architectures that need intelligent routing

Production systems that need budget guardrails


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
Warranty Management

Warranty Management

Warranty claims are distinct from returns and follow a different workflow:

**Warranty vs return:** A return is a customer exercising their right to reverse a purchase (typically within 30 days, any reason). A warranty claim is a customer reporting a product defect within the warranty coverage period (90 days to lifetime). Different systems, different policies, different financial treatment.

**Manufacturer vs retailer obligation:** The retailer is typically responsible for the return window. The manufacturer is responsible for the warranty period. Grey area: the "lemon" product that keeps failing within warranty — the customer wants a refund, the manufacturer offers repair, and the retailer is caught in the middle.

**Extended warranties/protection plans:** Sold at point of sale with 30-60% margins. Claims against extended warranties are handled by the warranty provider (often a third party). Retailer's role is facilitating the claim, not processing it. Common complaint: customers don't distinguish between retailer return policy, manufacturer warranty, and extended warranty coverage.


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.

3. Define the implementation-facing contract

Produce an SRS-style capability plan with:

capability summary

explicit non-goals

actors and surfaces

required states and transitions

interfaces / inputs / outputs

data model implications

security / billing / policy constraints

observability and operator requirements

open questions blocking implementation


With iterative-retrieval skill

Combine for progressive discovery:

Cycle 1: Broad search (npm, PyPI, MCP)

Cycle 2: Evaluate top candidates in detail

Cycle 3: Test compatibility with project constraints


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 3: Record
Recording Principles

Recording Principles

1. Storytelling Flow

1. Storytelling Flow

Plan the video as a story. Follow user-specified order, or use this default:

**Entry**: Login or navigate to the starting point

**Context**: Pan the surroundings so viewers orient themselves

**Action**: Perform the main workflow steps

**Variation**: Show a secondary feature such as settings, theme, or localization

**Result**: Show the outcome, confirmation, or new state

2. Pacing

2. Pacing

After login: `4s`

After navigation: `3s`

After clicking a button: `2s`

Between major steps: `1.5-2s`

After the final action: `3s`

Typing delay: `25-40ms` per character

3. Cursor Overlay

3. Cursor Overlay

Inject an SVG arrow cursor that follows mouse movements:

Call `injectCursor(page)` after every page navigation because the overlay is destroyed on navigate.

4. Mouse Movement

4. Mouse Movement

Never teleport the cursor. Move to the target before clicking:

Every call should include a descriptive `label` for debugging.

5. Typing

5. Typing

Type visibly, not instant-fill:

6. Scrolling

6. Scrolling

Use smooth scroll instead of jumps:

7. Dashboard Panning

7. Dashboard Panning

When showing a dashboard or overview page, move the cursor across key elements:

8. Subtitles

8. Subtitles

Inject a subtitle bar at the bottom of the viewport:

Call `injectSubtitleBar(page)` alongside `injectCursor(page)` after every navigation.

Usage pattern:

Guidelines:

Keep subtitle text short, ideally under 60 characters.

Use `Step N - Action` format for consistency.

Clear the subtitle during long pauses where the UI can speak for itself.


Verification loop for Django projects: migrations, linting, tests with coverage, security scans, and deployment readiness checks before release or PR.

Django Verification Loop
Phase 3: Migrations

Phase 3: Migrations

Report:

Number of pending migrations

Any migration conflicts

Model changes without migrations


Prevent silent decimal mismatch bugs across EVM chains. Covers runtime decimal lookup, chain-aware caching, bridged-token precision drift, and safe normalization for bots, dashboards, and DeFi tools.

EVM Token Decimals

Silent decimal mismatches are one of the easiest ways to ship balances or USD values that are off by orders of magnitude without throwing an error.


Social Media Reframing

Different platforms need different aspect ratios:

| Platform | Aspect Ratio | Resolution |
|----------|-------------|------------|
| YouTube | 16:9 | 1920x1080 |
| TikTok / Reels | 9:16 | 1080x1920 |
| Instagram Feed | 1:1 | 1080x1080 |
| X / Twitter | 16:9 or 1:1 | 1280x720 or 720x720 |


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

Autonomous Loops Skill
5. The De-Sloppify Pattern
Why Not Negative Instructions?

Why Not Negative Instructions?

Adding "don't test type systems" or "don't add unnecessary checks" to the Implementer prompt has downstream effects:

The model becomes hesitant about ALL testing

It skips legitimate edge case tests

Quality degrades unpredictably


Flutter/Dart Code Review Best Practices
8. Platform-Specific Concerns
iOS/Android differences:

8. Platform-Specific Concerns

iOS/Android differences:

[ ] Platform-adaptive widgets used where appropriate

[ ] Back navigation handled correctly (Android back button, iOS swipe-to-go-back)

[ ] Status bar and safe area handled via `SafeArea` widget

[ ] Platform-specific permissions declared in `AndroidManifest.xml` and `Info.plist`


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

Core Pattern — @concurrent for Background Work

When you need actual parallelism, explicitly offload with `@concurrent`:

**Important:** This example requires Approachable Concurrency build settings — SE-0466 (MainActor default isolation) and SE-0461 (NonisolatedNonsendingByDefault). With these enabled, `extractSticker` stays on the caller's actor, making mutable state access safe. **Without these settings, this code has a data race** — the compiler will flag it.

To use `@concurrent`:

Mark the containing type as `nonisolated`

Add `@concurrent` to the function

Add `async` if not already asynchronous

Add `await` at call sites


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
MCP Tools
GetPluginDetailsTool

GetPluginDetailsTool

Fetch detailed metrics, readme content, and version history for a specific package.

**Parameters:**

`package` (string, required): Full Composer package name (e.g. "spatie/laravel-permission")

`include_versions` (boolean, optional): Include version history in response


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

How It Works

The rules distillation process follows three phases:

Phase 1: Inventory (Deterministic Collection)

1a. Collect skill inventory

1a. Collect skill inventory

1b. Collect rules index

1b. Collect rules index

1c. Present to user

1c. Present to user


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

When NOT to Use

For API-level bugs (wrong response shape, missing endpoint) — use systematic-debugging

For styling/layout issues — visual inspection

For performance issues — profiling tools


Build a new API connector or provider by matching the target repo's existing integration pattern exactly. Use when adding one more integration without inventing a second architecture.

API Connector Builder

Use this when the job is to add a repo-native integration surface, not just a generic HTTP client.

The point is to match the host repository's pattern:

connector layout

config schema

auth model

error handling

test style

registration/discovery wiring


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.

LinkedIn

add only the context needed for people outside the niche

do not turn it into a fake founder-reflection post

do not add a closing question just because it is LinkedIn

do not force a polished "professional tone" if the author is naturally sharper


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

SwiftUI Patterns
State Management
@Observable ViewModel

@Observable ViewModel

Use `@Observable` (not `ObservableObject`) — it tracks property-level changes so SwiftUI only re-renders views that read the changed property:


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

When to Use

Use council when:

a decision has multiple credible paths and no obvious winner

you need explicit tradeoff surfacing

the user asks for second opinions, dissent, or multiple perspectives

conversational anchoring is a real risk

a go / no-go call would benefit from adversarial challenge

Examples:

monorepo vs polyrepo

ship now vs hold for polish

feature flag vs full rollout

simplify scope vs keep strategic breadth


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

Frontend Design
Design Workflow
4. Make motion meaningful

4. Make motion meaningful

Use animation to:

reveal hierarchy

stage information

reinforce user action

create one or two memorable moments

Do not scatter generic micro-interactions everywhere. One well-directed load sequence is usually stronger than twenty random hover effects.


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

Kotlin Testing Patterns
Examples
Coroutine Testing

Coroutine Testing

runTest for Suspend Functions

runTest for Suspend Functions

Testing Flows

Testing Flows

TestDispatcher

TestDispatcher


Django Verification Loop
Phase 5: Security Scan

Phase 5: Security Scan

Report:

Vulnerable dependencies found

Security configuration issues

Hardcoded secrets detected

DEBUG mode status (should be False in production)


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

Laravel Development Patterns
When to Use

When to Use

Building Laravel web applications or APIs

Structuring controllers, services, and domain logic

Working with Eloquent models and relationships

Designing APIs with resources and pagination

Adding queues, events, caching, and background jobs


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

A practical decision framework for parsing structured text (quizzes, forms, invoices, documents). The key insight: regex handles 95-98% of cases cheaply and deterministically. Reserve expensive LLM calls for the remaining edge cases.


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

Examples

Title formula

Meta description formula

JSON-LD example

Audit output shape


When to Use

Writing new Kotlin functions or classes

Adding test coverage to existing Kotlin code

Implementing property-based tests

Following TDD workflow in Kotlin projects

Configuring Kover for code coverage


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
How It Works
Phase 3: ECC Component Matching

Phase 3: ECC Component Matching

Map intent + scope + tech stack (from Phase 0) to specific ECC components.

By Intent Type

By Intent Type

| Intent | Commands | Skills | Agents |
|--------|----------|--------|--------|
| New Feature | /plan, /tdd, /code-review, /verify | tdd-workflow, verification-loop | planner, tdd-guide, code-reviewer |
| Bug Fix | /tdd, /build-fix, /verify | tdd-workflow | tdd-guide, build-error-resolver |
| Refactor | /refactor-clean, /code-review, /verify | verification-loop | refactor-cleaner, code-reviewer |
| Research | /plan | search-first, iterative-retrieval | — |
| Testing | /tdd, /e2e, /test-coverage | tdd-workflow, e2e-testing | tdd-guide, e2e-runner |
| Review | /code-review | security-review | code-reviewer, security-reviewer |
| Documentation | /update-docs, /update-codemaps | — | doc-updater |
| Infrastructure | /plan, /verify | docker-patterns, deployment-patterns, database-migrations | architect |
| Design (MEDIUM-HIGH) | /plan | — | planner, architect |
| Design (EPIC) | — | blueprint (invoke as skill) | planner, architect |

By Tech Stack

By Tech Stack

| Tech Stack | Skills to Add | Agent |
|------------|--------------|-------|
| Python / Django | django-patterns, django-tdd, django-security, django-verification, python-patterns, python-testing | python-reviewer |
| Go | golang-patterns, golang-testing | go-reviewer, go-build-resolver |
| Spring Boot / Java | springboot-patterns, springboot-tdd, springboot-security, springboot-verification, java-coding-standards, jpa-patterns | code-reviewer |
| Kotlin / Android | kotlin-coroutines-flows, compose-multiplatform-patterns, android-clean-architecture | kotlin-reviewer |
| TypeScript / React | frontend-patterns, backend-patterns, coding-standards | code-reviewer |
| Swift / iOS | swiftui-patterns, swift-concurrency-6-2, swift-actor-persistence, swift-protocol-di-testing | code-reviewer |
| PostgreSQL | postgres-patterns, database-migrations | database-reviewer |
| Perl | perl-patterns, perl-testing, perl-security | code-reviewer |
| C++ | cpp-coding-standards, cpp-testing | code-reviewer |
| Other / Unlisted | coding-standards (universal) | code-reviewer |


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.

How It Works

Collect demand signals (POS sell-through, orders, shipments) and cleanse outliers

Select forecasting method per SKU based on ABC/XYZ classification and demand pattern

Apply promotional lifts, cannibalization offsets, and external causal factors

Calculate safety stock using demand variability, lead time variability, and target fill rate

Generate suggested purchase orders, apply MOQ/EOQ rounding, and route for planner review

Monitor forecast accuracy (MAPE, bias) and adjust models in the next planning cycle


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.

Exa Search
Usage Patterns
Technical Deep Dive

Usage Patterns

Quick Lookup

Code Research

Company or People Research

Technical Deep Dive


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

Rust Development Patterns
Iterators and Closures
Use `collect()` with Type Annotation

Iterators and Closures

Prefer Iterator Chains Over Manual Loops

Use `collect()` with Type Annotation


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.

When to Activate

AI agent (Claude Code, Cursor, Codex) has modified API routes or backend logic

A bug was found and fixed — need to prevent re-introduction

Project has a sandbox/mock mode that can be leveraged for DB-free testing

Running `/bug-check` or similar review commands after code changes

Multiple code paths exist (sandbox vs production, feature flags, etc.)


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

ClickHouse Analytics Patterns
Best Practices
4. Avoid

4. Avoid

SELECT * (specify columns)

FINAL (merge data before query instead)

Too many JOINs (denormalize for analytics)

Small frequent inserts (batch instead)


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.

Reusable Starter

Use [assets/network_graph_scene.py](assets/network_graph_scene.py) as a starting point for network-graph explainers.

Example smoke test:


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

Liquid Glass Design System (iOS 26)
Anti-Patterns to Avoid

Anti-Patterns to Avoid

Using multiple standalone `.glassEffect()` views without a GlassEffectContainer

Nesting too many glass effects — degrades performance and visual clarity

Applying glass to every view — reserve for interactive elements, toolbars, and cards

Forgetting `clipsToBounds = true` in UIKit when using corner radii

Ignoring accented rendering mode in widgets — breaks tinted Home Screen appearance

Using opaque backgrounds behind glass — defeats the translucency effect


Inventory Demand Planning
Performance Indicators

Performance Indicators

Track weekly and trend monthly:

| Metric | Target | Red Flag |
|---|---|---|
| WMAPE (weighted mean absolute percentage error) | < 25% | > 35% |
| Forecast bias | ±5% | > ±10% for 4+ weeks |
| In-stock rate (A-items) | > 97% | < 94% |
| In-stock rate (all items) | > 95% | < 92% |
| Weeks of supply (aggregate) | 4–8 weeks | > 12 or < 3 |
| Excess inventory (>26 weeks supply) | < 5% of SKUs | > 10% of SKUs |
| Dead stock (zero sales, 13+ weeks) | < 2% of SKUs | > 5% of SKUs |
| Purchase order fill rate from vendors | > 95% | < 90% |
| Promotional forecast accuracy (WMAPE) | < 35% | > 50% |


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
Changeover Optimization

Changeover Optimization

**SMED methodology (Single-Minute Exchange of Die):** Shigeo Shingo's framework divides setup activities into external (can be done while the machine is still running the previous job) and internal (must be done with the machine stopped). Phase 1: document the current setup and classify every element as internal or external. Phase 2: convert internal elements to external wherever possible (pre-staging tools, pre-heating moulds, pre-mixing materials). Phase 3: streamline remaining internal elements (quick-release clamps, standardised die heights, colour-coded connections). Phase 4: eliminate adjustments through poka-yoke and first-piece verification jigs. Typical results: 40–60% setup time reduction from Phase 1–2 alone.

**Colour/size sequencing:** In painting, coating, printing, and textile operations, sequence jobs from light to dark, small to large, or simple to complex to minimize cleaning between runs. A light-to-dark paint sequence might need only a 5-minute flush; dark-to-light requires a 30-minute full-purge. Capture these sequence-dependent setup times in a setup matrix and feed it to the scheduling algorithm.

**Campaign vs. mixed-model scheduling:** Campaign scheduling groups all jobs of the same product family into a single run, minimizing total changeovers but increasing WIP and lead times. Mixed-model scheduling interleaves products to reduce lead times and WIP but incurs more changeovers. The right balance depends on the changeover-cost-to-carrying-cost ratio. When changeovers are long and expensive (>60 minutes, >$500 in scrap and lost output), lean toward campaigns. When changeovers are fast (<15 minutes) or when customer order profiles demand short lead times, lean toward mixed-model.

**Changeover cost vs. inventory carrying cost vs. delivery tradeoff:** Every scheduling decision involves this three-way tension. Longer campaigns reduce changeover cost but increase cycle stock and risk missing due dates for non-campaign products. Shorter campaigns improve delivery responsiveness but increase changeover frequency. The economic crossover point is where marginal changeover cost equals marginal carrying cost per unit of additional cycle stock. Compute it; don't guess.


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
5. XSS Prevention

5. XSS Prevention

Sanitize HTML

Sanitize HTML

Content Security Policy

Content Security Policy

Verification Steps

Verification Steps

[ ] User-provided HTML sanitized

[ ] CSP headers configured

[ ] No unvalidated dynamic content rendering

[ ] React's built-in XSS protection used


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

Investor Materials
Asset Guidance
One-Pager / Memo

One-Pager / Memo

state what the company does in one clean sentence

show why now

include traction and proof points early

make the ask precise

keep claims easy to verify


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

Security Scan Skill
Interpreting Results
High Findings (fix before production)

High Findings (fix before production)

Auto-run instructions in CLAUDE.md (prompt injection vector)

Missing deny lists in permissions

Agents with unnecessary Bash access


Engineering operating model for teams where AI agents generate a large share of implementation output.

AI-First Engineering
Architecture Requirements

Architecture Requirements

Prefer architectures that are agent-friendly:

explicit boundaries

stable contracts

typed interfaces

deterministic tests

Avoid implicit behavior spread across hidden conventions.


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

Google Workspace Ops
Workflow
1. Find the asset

Workflow

1. Find the asset

Start with the Drive search surface to locate:

the exact file

sibling assets

likely duplicates

recently modified versions

If several documents look similar, confirm by title, owner, modified time, or folder.


Backend architecture patterns, API design, database optimization, and server-side best practices for Node.js, Express, and Next.js API routes.

Backend Development Patterns
When to Activate

When to Activate

Designing REST or GraphQL API endpoints

Implementing repository, service, or controller layers

Optimizing database queries (N+1, indexing, connection pooling)

Adding caching (Redis, in-memory, HTTP cache headers)

Setting up background jobs or async processing

Structuring error handling and validation for APIs

Building middleware (auth, logging, rate limiting)


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

龙虾灵魂锻造炉
Step 6：输出完整方案 & 生成文件

Step 6：输出完整方案 & 生成文件

Step 6：输出完整方案 & 生成文件

**完整输出模板**：见 [references/output-template.md](references/output-template.md)

整合所有步骤为一份完整的龙虾灵魂方案，然后**主动引导用户生成实际文件**：

展示完整方案预览

引导用户生成文件：是否要将方案落地为 SOUL.md 和 IDENTITY.md 文件？

如果用户确认：

询问目标目录（默认当前工作目录）

用 Write 工具生成 `SOUL.md` 和 `IDENTITY.md`

如有头像图片，一并说明图片路径


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
Sync Operations
GitHub / Linear Sync

GitHub / Linear Sync

When the information affects active execution:

update the relevant GitHub issue, PR, discussion, release notes, or roadmap thread

attach supporting docs to Linear when the work needs durable planning context

only mirror a local note afterwards if it still adds value


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.

Review Rules

Never merge from title, summary, or trust alone; use the full diff

External-source features should be rebuilt inside ECC when they are valuable but not self-contained

CI red means classify and fix or block; do not pretend it is merge-ready

If the real blocker is product direction, say so instead of hiding behind tooling


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.

Good Outcomes

The user can immediately see what is connected, what is missing, and what ECC should own next.

Recommendations are specific enough to implement in the repo without another discovery pass.

The final answer is organized around workflows, not API brands.


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

Laravel Development Patterns
Examples
Controllers -> Services -> Actions

Recommended Layout

Controllers -> Services -> Actions

Keep controllers thin. Put orchestration in services and single-purpose logic in actions.


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.

Classification Model

Use two buckets only:

`DAILY`

should load every session for this repo

strongly matched to the repo's language, framework, workflow, or operator surface

`LIBRARY`

useful to retain, but not worth loading by default

should remain reachable through search, router skill, or selective manual use


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

X API

Programmatic interaction with X (Twitter) for posting, reading, searching, and analytics.


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

3. Human Grader

Flag for manual review:

Metrics

pass@k

"At least one success in k attempts"

pass@1: First attempt success rate

pass@3: Success within 3 attempts

Typical target: pass@3 > 90%


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.

Common AI Regression Patterns

Pattern 1: Sandbox/Production Path Mismatch

**Frequency**: Most common (observed in 3 out of 4 regressions)

**Test to catch it**:


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.

Anti-Patterns

Never default to:

interchangeable SaaS hero sections

generic card piles with no hierarchy

random accent colors without a system

placeholder-feeling typography

motion that exists only because animation was easy to add


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

Config Protection (Defense Against Rule-Gaming)

LLMs will modify `.ruff.toml` or `biome.json` to disable rules rather than fix code. Plankton blocks this with three layers:

**PreToolUse hook** — `protect_linter_configs.sh` blocks edits to all linter configs before they happen

**Stop hook** — `stop_config_guardian.sh` detects config changes via `git diff` at session end

**Protected files list** — `.ruff.toml`, `biome.json`, `.shellcheckrc`, `.yamllint`, `.hadolint.yaml`, and more


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

Examples

**Damage claim**: 500-unit shipment arrives with 30% salvageable. Carrier claims force majeure. Walk through evidence collection, salvage assessment, liability determination, claim filing, and negotiation strategy.

**Detention dispute**: Carrier bills 8 hours detention at a DC. Receiver says driver arrived 2 hours early. Reconcile GPS data, appointment logs, and gate timestamps to resolve.

**Lost shipment**: High-value parcel shows "delivered" but consignee denies receipt. Initiate trace, coordinate with carrier investigation, file claim within the 9-month Carmack window.


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.

6. Verify with the smallest proving steps

rerun only the targeted tests or integration slices that cover the changed path

verify whether the burn path is now:

blocked

deduped

downgraded to cheaper analysis

or rejected early

state the final status exactly:

changed locally

verified locally

pushed

deployed

still blocked


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

Error Handling Patterns

Error Wrapping with Context

Custom Error Types

Error Checking with errors.Is and errors.As


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.

Automation Audit Ops
Workflow
2. Classify each item by live state

2. Classify each item by live state

For every surfaced automation, mark:

configured

authenticated

recently verified

stale or broken

missing

Then classify the problem type:

active breakage

auth outage

stale status

overlap or redundancy

missing capability


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

Perl Security Patterns
CPAN Module Security

CPAN Module Security

**Pin versions** in cpanfile: `requires 'DBI', '== 1.643';`

**Prefer maintained modules**: Check MetaCPAN for recent releases

**Minimize dependencies**: Each dependency is an attack surface


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.

Hexagonal Architecture
Suggested Module Layout

Architecture Diagram

Suggested Module Layout

Use feature-first organization with explicit boundaries:


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

Codebase Onboarding
Anti-Patterns to Avoid

Anti-Patterns to Avoid

Generating a CLAUDE.md that's longer than 100 lines — keep it focused

Listing every dependency — highlight only the ones that shape how you write code

Describing obvious directory names — `src/` doesn't need an explanation

Copying the README — the onboarding guide adds structural insight the README lacks


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.

When to Use

the user wants a unified notification lane across GitHub, Linear, local hooks, desktop alerts, chat, or email

CI failures, review requests, issue updates, and operator events are arriving in disconnected places

the current setup creates noise instead of action

the user wants to consolidate overlapping notification branches or backlog proposals into one ECC-native lane

the workspace already has hooks, MCPs, or connected tools, but no coherent notification policy


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

Kotlin Development Patterns
Gradle Kotlin DSL
build.gradle.kts Configuration

Configuration DSL

Sequences for Lazy Evaluation

Gradle Kotlin DSL

build.gradle.kts Configuration


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.

Stage 4: Enrichment

For each qualified lead, pull:

Full name, current title, company

Company size, funding stage, recent news

Recent X posts (last 30 days) — topics, tone, interests

Mutual interests with user (shared follows, similar content)

Recent company events (product launch, funding round, hiring)


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

When to Activate

Designing new API endpoints

Reviewing existing API contracts

Adding pagination, filtering, or sorting

Implementing error handling for APIs

Planning API versioning strategy

Building public or partner-facing APIs


Hexagonal Architecture

Hexagonal architecture (Ports and Adapters) keeps business logic independent from frameworks, transport, and persistence details. The core app depends on abstract ports, and adapters implement those ports at the edges.


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

ClickHouse Analytics Patterns
Query Optimization Patterns
Efficient Filtering

AggregatingMergeTree (Pre-aggregation)

Query Optimization Patterns

Efficient Filtering


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

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

流程

根据灵魂填充 7 个个性化变量

拼接 STYLE_BASE + 个性化描述为完整提示词

**检查当前环境是否存在可用且已审核的生图 skill**：

**可用** → 写入临时文件，调用该生图 skill 生成图片，展示结果

**不可用** → 输出完整提示词文本，附使用说明：

展示结果后，引导用户进入下一步。


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.

Related Skills

`research-ops`

`backend-patterns`

`terminal-ops`


Build a new API connector or provider by matching the target repo's existing integration pattern exactly. Use when adding one more integration without inventing a second architecture.

Guardrails

do not invent a new integration architecture when the repo already has one

do not start from vendor docs alone; start from existing in-repo connectors first

do not stop at transport code if the repo expects registry wiring, tests, and docs

do not cargo-cult old connectors if the repo has a newer current pattern


Playwright E2E testing patterns, Page Object Model, configuration, CI/CD integration, artifact management, and flaky test strategies.

E2E Testing Patterns
Financial / Critical Flow Testing

Wallet / Web3 Testing

Financial / Critical Flow Testing


Test-driven development for Laravel with PHPUnit and Pest, factories, database testing, fakes, and coverage targets.

Laravel TDD Workflow
Examples
HTTP and External Services

Auth Testing (Sanctum)

HTTP and External Services

Use `Http::fake()` to isolate external APIs

Assert outbound payloads with `Http::assertSent()`


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)
Best Practices Checklist

Best Practices Checklist

[ ] Interactive elements meet the **24x24px** (Web) or **44x44pt** (Native) target size.

[ ] Focus indicators are clearly visible and high-contrast.

[ ] Modals **contain focus** while open, and release it cleanly on close (`Escape` key or close button).

[ ] Dropdowns and menus restore focus to the trigger element on close.

[ ] Forms provide text-based error suggestions.

[ ] All icon-only buttons have a descriptive text label.

[ ] Content reflows properly when text is scaled.


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.

Phase 5: Workflow & Model Recommendation

Determine where this prompt sits in the development lifecycle:

For MEDIUM+ tasks, always start with /plan. For EPIC tasks, use blueprint skill.

**Model recommendation** (include in output):

| Scope | Recommended Model | Rationale |
|-------|------------------|-----------|
| TRIVIAL-LOW | Sonnet 4.6 | Fast, cost-efficient for simple tasks |
| MEDIUM | Sonnet 4.6 | Best coding model for standard work |
| HIGH | Sonnet 4.6 (main) + Opus 4.6 (planning) | Opus for architecture, Sonnet for implementation |
| EPIC | Opus 4.6 (blueprint) + Sonnet 4.6 (execution) | Deep reasoning for multi-session planning |

**Multi-prompt splitting** (for HIGH/EPIC scope):

For tasks that exceed a single session, split into sequential prompts:

Prompt 1: Research + Plan (use search-first skill, then /plan)

Prompt 2-N: Implement one phase per prompt (each ends with /verify)

Final Prompt: Integration test + /code-review across all phases

Use /save-session and /resume-session to preserve context between sessions


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
Checklist Before Release

Checklist Before Release

[ ] Auth tokens validated and expired correctly

[ ] Authorization guards on every sensitive path

[ ] All inputs validated and sanitized

[ ] No string-concatenated SQL

[ ] CSRF posture correct for app type

[ ] Secrets externalized; none committed

[ ] Security headers configured

[ ] Rate limiting on APIs

[ ] Dependencies scanned and up to date

[ ] Logs free of sensitive data

**Remember**: Deny by default, validate inputs, least privilege, and secure-by-configuration first.


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

Task Decomposition

Apply the 15-minute unit rule:

each unit should be independently verifiable

each unit should have a single dominant risk

each unit should expose a clear done condition


Translate visa application documents (images) to English and create a bilingual PDF with original and translation

Required Python Libraries

For macOS Vision framework:

Important Guidelines

DO NOT ask for user confirmation at each step

Automatically determine the best rotation angle

Try multiple OCR methods if one fails

Ensure all numbers, dates, and amounts are accurately translated

Use clean, professional formatting

Complete the entire process and report the final PDF location


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

Project Flow Ops
Core Workflow
4. Keep the two systems consistent

4. Keep the two systems consistent

When work is active:

GitHub issue/PR should say what is happening publicly

Linear should track owner, priority, and execution lane internally

When work ships or is rejected:

post the public resolution back to GitHub

mark the Linear task accordingly


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

Autonomous Agent Harness
Setup Guide
Step 4: Enable Computer Use (Optional)

Step 2: Create Base Crons

Step 3: Initialize Memory Graph

Step 4: Enable Computer Use (Optional)

Grant computer-use MCP the necessary permissions for browser and desktop control.


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
1. Readability First

Code Quality Principles

1. Readability First

Code is read more than written

Clear variable and function names

Self-documenting code preferred over comments

Consistent formatting


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.

Council
Workflow
2. Gather only the necessary context

2. Gather only the necessary context

If the decision is codebase-specific:

collect the relevant files, snippets, issue text, or metrics

keep it compact

include only the context needed to make the decision

If the decision is strategic/general:

skip repo snippets unless they materially change the answer


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

Python Development Patterns
Anti-Patterns to Avoid

Anti-Patterns to Avoid

__Remember__: Python code should be readable, explicit, and follow the principle of least surprise. When in doubt, prioritize clarity over cleverness.


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.

GitHub Operations

Manage GitHub repositories with a focus on community health, CI reliability, and contributor experience.


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

/search-first — Research Before You Code

Development Tooling

Linting → `eslint`, `ruff`, `textlint`, `markdownlint`

Formatting → `prettier`, `black`, `gofmt`

Testing → `jest`, `pytest`, `go test`

Pre-commit → `husky`, `lint-staged`, `pre-commit`


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

Modern Perl Development Patterns

Idiomatic Perl 5.36+ patterns and best practices for building robust, maintainable applications.


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

Returns & Reverse Logistics
Escalation Protocols
Automatic Escalation Triggers

Escalation Protocols

Automatic Escalation Triggers

| Trigger | Action | Timeline |
|---|---|---|
| Return value > $5,000 (single item) | Supervisor approval required before refund | Before processing |
| Fraud score ≥ 80 | Hold refund, route to fraud review team | Immediately |
| Customer has filed chargeback simultaneously | Halt return processing, coordinate with payments team | Within 1 hour |
| Product identified as recalled | Route to recall coordinator, do not process as standard return | Immediately |
| Vendor defect rate exceeds 5% for SKU | Notify merchandise and vendor management | Within 24 hours |
| Third policy exception request from same customer in 12 months | Manager review before granting | Before processing |
| Suspected counterfeit in return stream | Pull from processing, photograph, notify LP and brand protection | Immediately |
| Return involves regulated product (pharma, hazmat, medical device) | Route to compliance team | Immediately |


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)

When to Use

Writing new C++ code (classes, functions, templates)

Reviewing or refactoring existing C++ code

Making architectural decisions in C++ projects

Enforcing consistent style across a C++ codebase

Choosing between language features (e.g., `enum` vs `enum class`, raw pointer vs smart pointer)


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.

When to Use

Production orders compete for constrained work centers

Disruptions (breakdown, shortage, absenteeism) require rapid re-sequencing

Changeover and campaign trade-offs need explicit economic decisions

New work orders need to be slotted into an existing schedule without destabilizing committed jobs

Shift-level bottleneck changes require drum reassignment


A comprehensive verification system for Claude Code sessions.

Verification Loop Skill
Verification Phases
Phase 2: Type Check

Phase 2: Type Check

Report all type errors. Fix critical ones before continuing.


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

Article Writing
Structure Guidance
Technical Guides

Structure Guidance

Technical Guides

open with what the reader gets

use code, commands, screenshots, or concrete output in major sections

end with actionable takeaways, not a soft recap


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
Const usage:

Const usage:

[ ] `const` constructors used wherever possible — prevents unnecessary rebuilds

[ ] `const` literals for collections that don't change (`const []`, `const {}`)

[ ] Constructor is declared `const` when all fields are final


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

Frontend Slides
Workflow
3. Discover Style

3. Discover Style

Default to visual exploration.

If the user already knows the desired preset, skip previews and use it directly.

Otherwise:

Ask what feeling the deck should create: impressed, energized, focused, inspired.

Generate **3 single-slide preview files** in `.ecc-design/slide-previews/`.

Each preview must be self-contained, show typography/color/motion clearly, and stay under roughly 100 lines of slide content.

Ask the user which preview to keep or what elements to mix.

Use the preset guide in `STYLE_PRESETS.md` when mapping mood to style.


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
Communication Patterns
Key Templates

Key Templates

Brief templates appear below. Adapt them to your broker, customs counsel, and regulatory workflows before using them in production.

**Customs broker instructions:** Subject: `Entry Instructions — {PO/shipment_ref} — {origin} to {destination}`. Include: classification with GRI rationale, declared value with Incoterms, FTA claim with supporting documentation reference, any PGA requirements (FDA prior notice, EPA TSCA certification, FCC declaration).

**Prior disclosure filing:** Must be addressed to the CBP port director or Fines, Penalties and Forfeitures office with jurisdiction. Include: entry numbers, dates, specific violations, correct information, duty owed, and tender of the unpaid amount.

**Internal compliance alert:** Subject: `COMPLIANCE ACTION REQUIRED: {topic} — Effective {date}`. Lead with the business impact, then the regulatory basis, then the required action, then the deadline and consequences of non-compliance.


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

API Design Patterns
Implementation Patterns
Python (Django REST Framework)

Versioning Strategy

Implementation Patterns

TypeScript (Next.js API Route)

Python (Django REST Framework)


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 5: Run Tests Again

Step 5: Run Tests Again

Rerun the same relevant test target after the fix and confirm the previously failing test is now GREEN.

Only after a valid GREEN result may you proceed to refactor.

If the repository is under Git, create a checkpoint commit immediately after GREEN is validated.
Recommended commit message format:

`fix: <feature or bug>`

The fix commit may also serve as the GREEN validation checkpoint if the same relevant test target was rerun and passed

Verify that this checkpoint commit is on the current active branch before continuing


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

The Problem

Subagents are spawned with limited context. They don't know:

Which files contain relevant code

What patterns exist in the codebase

What terminology the project uses

Standard approaches fail:

**Send everything**: Exceeds context limits

**Send nothing**: Agent lacks critical information

**Guess what's needed**: Often wrong


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

Autonomous Loops Skill
4. Continuous Claude PR Loop
CI Failure Recovery

CI Failure Recovery

When PR checks fail, Continuous Claude automatically:

Fetches the failed run ID via `gh run list`

Spawns a new `claude -p` with CI fix context

Claude inspects logs via `gh run view`, fixes code, commits, pushes

Re-waits for checks (up to `--ci-retry-max` attempts)


6. Ralphinho / RFC-Driven DAG Orchestration

Merge Queue with Eviction

After quality pipelines complete, units enter the merge queue:

**File Overlap Intelligence:**

Non-overlapping units land speculatively in parallel

Overlapping units land one-by-one, rebasing each time

**Eviction Recovery:**
When evicted, full context is captured (conflicting files, diffs, test output) and fed back to the implementer on the next Ralph pass:


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

Swift Actors for Thread-Safe Persistence

Core Pattern

Actor-Based Repository

The actor model guarantees serialized access — no data races, enforced by the compiler.


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.

5. Expensive work before persistence safety

If the system can spend tokens and then fail on PR creation, file update, or branch collision, it is burning cost without shipping value.


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.

Council
Workflow
6. Present a compact verdict

6. Present a compact verdict

Use this output shape:

Keep it scannable on a phone screen.


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

.NET Development Patterns
When to Activate

When to Activate

Writing new C# code

Reviewing C# code

Refactoring existing .NET applications

Designing service architectures with ASP.NET Core


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

GateGuard — Fact-Forcing Pre-Action Gate

Anti-Patterns

**Don't use self-evaluation instead.** "Are you sure?" always gets "yes." This is experimentally verified.

**Don't skip the data schema check.** Both A/B test agents assumed ISO-8601 dates when real data used `%Y/%m/%d %H:%M`. Checking data structure (with redacted values) prevents this entire class of bugs.

**Don't gate every single Bash command.** Routine bash gates once per session. Destructive bash gates every time. This balance avoids slowdown while catching real risks.


Quality Gate

Before delivering:

factual claims are backed by provided sources

generic AI transitions are gone

the voice matches the supplied examples or the agreed `VOICE PROFILE`

every section adds something new

formatting matches the intended medium


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

Database Migration Patterns
Django (Python)
Workflow

Workflow (kysely-ctl)

Migration File

Programmatic Migrator

Django (Python)

Workflow


When to Use

Local data storage in iOS/macOS apps (user data, settings, cached content)

Offline-first architectures that sync to a server later

Any shared mutable state that multiple parts of the app access concurrently

Replacing legacy `DispatchQueue`-based thread safety with modern Swift concurrency


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.

Investor Outreach

Write investor communication that is short, concrete, and easy to act on.


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).

References

[WCAG 2.2 Guidelines](https://www.w3.org/TR/WCAG22/)

[WAI-ARIA Authoring Practices](https://www.w3.org/TR/wai-aria-practices/)

[iOS Accessibility Programming Guide](https://developer.apple.com/documentation/accessibility)

[iOS Human Interface Guidelines - Accessibility](https://developer.apple.com/design/human-interface-guidelines/accessibility)

[Android Accessibility Developer Guide](https://developer.android.com/guide/topics/ui/accessibility)


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

4. Inject Dependencies with Default Parameters

Production code uses defaults; tests inject mocks.


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

Android Clean Architecture
Domain Layer
Domain Models

Domain Models

Domain models are plain Kotlin data classes — no framework annotations:


Best practices for Remotion - Video creation in React. 29 domain-specific rules covering 3D, animations, audio, captions, charts, transitions, and more.

When to use

Use this skills whenever you are dealing with Remotion code to obtain the domain-specific knowledge.


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.

Memory Patterns

Best Practices

Keep memory files concise. Archive old data rather than letting files grow unbounded.

Use frontmatter (YAML) for metadata on all knowledge files.

Deduplicate before storing. Search first, then create or update.

Prefer one canonical home per fact set. Avoid parallel copies of the same plan across local notes, repo files, and tracker docs.

Redact sensitive information (API keys, passwords) before committing to Git.

Use consistent naming conventions for knowledge files (lowercase-kebab-case).

Tag entries with topics/categories for easier retrieval.


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

Performance Indicators

Track weekly, review monthly with carrier management team, share quarterly with carriers:

| Metric | Target | Red Flag |
|---|---|---|
| Contract rate vs. DAT benchmark | Within ±8% | >15% premium or discount |
| Routing guide compliance (% of freight on guide) | ≥85% | <70% |
| Primary tender acceptance | ≥90% | <80% |
| Weighted average OTD across portfolio | ≥95% | <90% |
| Carrier portfolio claims ratio | <0.5% of spend | >1.0% |
| Average carrier invoice accuracy | ≥97% | <93% |
| Spot freight percentage | <20% | >30% |
| RFP cycle time (launch to implementation) | ≤12 weeks | >16 weeks |


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
Examples
Example: Get Package Details

Example: Get Package Details

Returns:

Health score and last activity

Laravel/PHP version support

Vendor reputation (risk score)

Version history

Brief description


Evidence-first live messaging workflow for ECC. Use when the user wants to read texts or DMs, recover a recent one-time code, inspect a thread before replying, or prove which message source was actually checked.

When to Use

user says "read my messages", "check texts", "look in DMs", or "find the code"

the task depends on a live thread or a recent code delivered to a local messaging surface

the user wants proof of which source or thread was inspected


5. Write Tests with Swift Testing

Best Practices

**Single Responsibility**: Each protocol should handle one concern — don't create "god protocols" with many methods

**Sendable conformance**: Required when protocols are used across actor boundaries

**Default parameters**: Let production code use real implementations by default; only tests need to specify mocks

**Error simulation**: Design mocks with configurable error properties for testing failure paths

**Only mock boundaries**: Mock external dependencies (file system, network, APIs), not internal types


Evidence-first current-state research workflow for ECC. Use when the user wants fresh facts, comparisons, enrichment, or a recommendation built from current public evidence and any supplied local context.

Research Ops

Use this when the user asks to research something current, compare options, enrich people or companies, or turn repeated lookups into a monitored workflow.

This is the operator wrapper around the repo's research stack. It is not a replacement for `deep-research`, `exa-search`, or `market-research`; it tells you when and how to use them together.


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
Pre-Deployment Security Checklist

Security Testing

Automated Security Tests

Pre-Deployment Security Checklist

Before ANY production deployment:

[ ] **Secrets**: No hardcoded secrets, all in env vars

[ ] **Input Validation**: All user inputs validated

[ ] **SQL Injection**: All queries parameterized

[ ] **XSS**: User content sanitized

[ ] **CSRF**: Protection enabled

[ ] **Authentication**: Proper token handling

[ ] **Authorization**: Role checks in place

[ ] **Rate Limiting**: Enabled on all endpoints

[ ] **HTTPS**: Enforced in production

[ ] **Security Headers**: CSP, X-Frame-Options configured

[ ] **Error Handling**: No sensitive data in errors

[ ] **Logging**: No sensitive data logged

[ ] **Dependencies**: Up to date, no vulnerabilities

[ ] **Row Level Security**: Enabled in Supabase

[ ] **CORS**: Properly configured

[ ] **File Uploads**: Validated (size, type)

[ ] **Wallet Signatures**: Verified (if blockchain)


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

Library Errors with `thiserror`, Application Errors with `anyhow`

`Option` Combinators Over Nested Matching


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

Agent Introspection Debugging
When to Activate

When to Activate

Maximum tool call / loop-limit failures

Repeated retries with no forward progress

Context growth or prompt drift that starts degrading output quality

File-system or environment state mismatch between expectation and reality

Tool failures that are likely recoverable with diagnosis and a smaller corrective action


Audits Claude Code context window consumption across agents, skills, MCP servers, and rules. Identifies bloat, redundant components, and produces prioritized token-savings recommendations.

Context Budget
How It Works
Phase 4: Report

Phase 4: Report

Produce the context budget report:

In verbose mode, additionally output per-file token counts, line-by-line breakdown of the heaviest files, specific redundant lines between overlapping components, and MCP tool list with per-tool schema size estimates.


Test-driven development for Laravel with PHPUnit and Pest, factories, database testing, fakes, and coverage targets.

Laravel TDD Workflow
How It Works
Testing Framework Choice

Testing Framework Choice

Default to **Pest** for new tests when available.

Use **PHPUnit** only if the project already standardizes on it or requires PHPUnit-specific tooling.


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

Lead Intelligence
Stage 5: Outreach Draft
Warm Intro Request (to mutual)

Warm Intro Request (to mutual)

Goal:

one clear ask

one concrete reason this intro makes sense

easy-to-forward blurb if needed

Avoid:

overexplaining your company

social-proof stacking

sounding like a fundraiser template


Build a new API connector or provider by matching the target repo's existing integration pattern exactly. Use when adding one more integration without inventing a second architecture.

Reference Shapes

Provider-style

Connector-style

TypeScript plugin-style

Quality Checklist

[ ] matches an existing in-repo integration pattern

[ ] config validation exists

[ ] auth and error handling are explicit

[ ] pagination/retry behavior follows repo norms

[ ] registry/discovery wiring is complete

[ ] tests mirror the host repo's style

[ ] docs/examples are updated if expected by the repo


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

Healthcare EMR Development Patterns
Examples
Example 2: Medication Safety Workflow

Examples

Example 1: Patient Encounter Flow

Example 2: Medication Safety Workflow


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

Ktor Server Patterns

Comprehensive Ktor patterns for building robust, maintainable HTTP servers with Kotlin coroutines.


Prevent silent decimal mismatch bugs across EVM chains. Covers runtime decimal lookup, chain-aware caching, bridged-token precision drift, and safe normalization for bots, dashboards, and DeFi tools.

EVM Token Decimals
Examples
Query decimals at runtime

Examples

Query decimals at runtime

Do not hardcode `1_000_000` because a symbol usually has 6 decimals somewhere else.


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

Quality & Non-Conformance Management
Decision Frameworks
NCR Disposition Decision Logic

Decision Frameworks

NCR Disposition Decision Logic

Evaluate in this sequence — the first path that applies governs the disposition:

**Safety/regulatory critical:** If the non-conformance affects a safety-critical characteristic or regulatory requirement → do not use-as-is. Rework if possible to full conformance, otherwise scrap. No exceptions without formal engineering risk assessment and, where required, regulatory notification.

**Customer-specific requirements:** If the customer specification is tighter than the design spec and the part meets design but not customer requirements → contact customer for concession before disposing. Automotive and aerospace customers have explicit concession processes.

**Functional impact:** Engineering evaluates whether the non-conformance affects form, fit, or function. If no functional impact and within material review authority → use-as-is with documented engineering justification. If functional impact exists → rework or scrap.

**Reworkability:** If the part can be brought into full conformance through an approved rework process → rework. Verify rework cost vs. replacement cost. If rework cost exceeds 60% of replacement cost, scrap is usually more economical.

**Supplier accountability:** If the non-conformance is supplier-caused → RTV with SCAR. Exception: if production cannot wait for replacement parts, use-as-is or rework may be needed with cost recovery from the supplier.


Rust testing patterns including unit tests, integration tests, async testing, property-based testing, mocking, and coverage. Follows TDD methodology.

Rust Testing Patterns
Benchmarking with Criterion

Trait-Based Mocking

Doc Tests

Executable Documentation

Benchmarking with Criterion


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
Widget decomposition:

3. Widget Best Practices

Widget decomposition:

[ ] No single widget with a `build()` method exceeding ~80-100 lines

[ ] Widgets split by encapsulation AND by how they change (rebuild boundaries)

[ ] Private `_build*()` helper methods that return widgets are extracted to separate widget classes (enables element reuse, const propagation, and framework optimizations)

[ ] Stateless widgets preferred over Stateful where no mutable local state is needed

[ ] Extracted widgets are in separate files when reusable


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

Code Tour

Create **CodeTour** `.tour` files for codebase walkthroughs that open directly to real files and line ranges. Tours live in `.tours/` and are meant for the CodeTour format, not ad hoc Markdown notes.

A good tour is a narrative for a specific reader:

what they are looking at

why it matters

what path they should follow next

Only create `.tour` JSON files. Do not modify source code as part of this skill.