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

Content Engine
Platform Adaptation Rules
Short Video

Short Video

script around the visual sequence and proof points

first seconds should show the result, problem, or punch

do not write narration that sounds better on paper than on screen


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

SwiftUI Patterns
Performance
Avoid Expensive Work in body

Avoid Expensive Work in body

Never perform I/O, network calls, or heavy computation inside `body`

Use `.task {}` for async work — it cancels automatically when the view disappears

Use `.sensoryFeedback()` and `.geometryGroup()` sparingly in scroll views

Minimize `.shadow()`, `.blur()`, and `.mask()` in lists — they trigger offscreen rendering


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
Related Skills

Related Skills

`workspace-surface-audit`

`project-flow-ops`

`github-ops`

`knowledge-ops`

`customer-billing-ops` when the notification pain is billing/customer operations rather than engineering


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

Laravel TDD Workflow
Examples
Factories and States

Factories and States

Use factories for test data

Define states for edge cases (archived, admin, trial)


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
Core Tools
get_code_context_exa

get_code_context_exa

Find code examples and documentation from GitHub, Stack Overflow, and docs sites.

**Parameters:**

| Param | Type | Default | Notes |
|-------|------|---------|-------|
| `query` | string | required | Code or API search query |
| `tokensNum` | number | 5000 | Content tokens (1000-50000) |


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

Agent Introspection Debugging

Use this skill when an agent run is failing repeatedly, consuming tokens without progress, looping on the same tools, or drifting away from the intended task.

This is a workflow skill, not a hidden runtime. It teaches the agent to debug itself systematically before escalating to a human.


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

Modern Perl Development Patterns
Core Principles
2. Subroutine Signatures

2. Subroutine Signatures

Use signatures for clarity and automatic arity checking.


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
Input Validation
Allowlist Over Blocklist

Enabling Taint Mode

Untainting Pattern

Input Validation

Allowlist Over Blocklist


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

.NET Development Patterns
Anti-Patterns to Avoid

Anti-Patterns to Avoid

| Anti-Pattern | Fix |
|---|---|
| `async void` methods | Return `Task` (except event handlers) |
| `.Result` or `.Wait()` | Use `await` |
| `catch (Exception) { }` | Handle or rethrow with context |
| `new Service()` in constructors | Use constructor injection |
| `public` fields | Use properties with appropriate accessors |
| `dynamic` in business logic | Use generics or explicit types |
| Mutable `static` state | Use DI scoping or `ConcurrentDictionary` |
| `string.Format` in loops | Use `StringBuilder` or interpolated string handlers |


Unified Notifications Ops
Non-Negotiable Rules

Non-Negotiable Rules

never expose tokens, secrets, webhook secrets, or internal identifiers

separate:

event source

severity

routing channel

operator action

default to digest-first when interruption cost is unclear

do not fan out every event to every channel

if the real fix is better issue triage, hook policy, or project flow, say so explicitly


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.

Related Skills

`brand-voice` — Build a reusable voice profile from real X and site/source material

`content-engine` — Generate platform-native content for X

`crosspost` — Distribute content across X, LinkedIn, and other platforms

`connections-optimizer` — Reorganize the X graph before drafting network-driven outreach


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

Liquid Glass Design System (iOS 26)
Core Pattern — SwiftUI
Basic Glass Effect

Core Pattern — SwiftUI

Basic Glass Effect

The simplest way to add Liquid Glass to any view:


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
2. Classify the work

2. Classify the work

Every item should end up in one of these states:

| State | Meaning |
|-------|---------|
| Merge | self-contained, policy-compliant, ready |
| Port/Rebuild | useful idea, but should be manually re-landed inside ECC |
| Close | wrong direction, stale, unsafe, or duplicated |
| Park | potentially useful, but not scheduled now |


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
15. Static Analysis
Enforcement:

Enforcement:

[ ] No unresolved analyzer warnings in committed code

[ ] Lint suppressions (`// ignore:`) are justified with comments explaining why

[ ] `flutter analyze` runs in CI and failures block merges


Frontend development patterns for React, Next.js, state management, performance optimization, and UI best practices.

Frontend Development Patterns
Form Handling Patterns

Code Splitting & Lazy Loading

Virtualization for Long Lists

Form Handling Patterns


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

Architecture Decision Records
What Makes a Good ADR
Don't

Don't

Record trivial decisions — variable naming or formatting choices don't need ADRs

Write essays — if the context section exceeds 10 lines, it's too long

Omit alternatives — "we just picked it" is not a valid rationale

Backfill without marking it — if recording a past decision, note the original date

Let ADRs go stale — superseded decisions should reference their replacement


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

Energy Procurement
Decision Frameworks
Procurement Strategy Selection

Decision Frameworks

Procurement Strategy Selection

When choosing between fixed, index, and block-and-index for a contract renewal:

**What is the company's tolerance for budget variance?** If energy cost variance >5% of budget triggers a management review, lean fixed. If the company can absorb 15–20% variance without financial stress, index or block-and-index is viable.

**Where is the market in the price cycle?** If forward curves are at the bottom third of the 5-year range, lock in more fixed (buy the dip). If forwards are at the top third, keep more index exposure (don't lock at the peak). If uncertain, layer.

**What is the contract tenor?** For 12-month terms, fixed vs. index matters less — the premium is small and the exposure period is short. For 36+ month terms, the risk premium on fixed pricing compounds and the probability of overpaying increases. Lean hybrid or layered for longer tenors.

**What is the facility's load factor?** High load factor (>0.75): block-and-index works well — buy flat blocks around the clock. Low load factor (<0.50): shaped blocks or TOU-indexed products better match the load profile.


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

Deployment Patterns
Deployment Strategies
Canary Deployment

Canary Deployment

Route a small percentage of traffic to the new version first.

**Pros:** Catches issues with real traffic before full rollout
**Cons:** Requires traffic splitting infrastructure, monitoring
**Use when:** High-traffic services, risky changes, feature flags


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

Python Development Patterns
Core Principles
2. Explicit is Better Than Implicit

2. Explicit is Better Than Implicit

Avoid magic; be clear about what your code does.


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

Safety Guard — Prevent Destructive Operations

Integration

Enable by default for `codex -a never` sessions

Pair with observability risk scoring in ECC 2.0

Logs all blocked actions to `~/.claude/safety-guard.log`


Safety Guard — Prevent Destructive Operations

When to Use

When working on production systems

When agents are running autonomously (full-auto mode)

When you want to restrict edits to a specific directory

During sensitive operations (migrations, deploys, data changes)


Orchestrate multi-agent coding tasks via Claude DevFleet — plan projects, dispatch parallel agents in isolated worktrees, monitor progress, and read structured reports.

Claude DevFleet Multi-Agent Orchestration

Concurrency

DevFleet runs up to 3 concurrent agents by default (configurable via `DEVFLEET_MAX_AGENTS`). When all slots are full, missions with `auto_dispatch=true` queue in the mission watcher and dispatch automatically as slots free up. Check `get_dashboard()` for current slot usage.


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

Overview

ClickHouse is a column-oriented database management system (DBMS) for online analytical processing (OLAP). It's optimized for fast analytical queries on large datasets.

**Key Features:**

Column-oriented storage

Data compression

Parallel query execution

Distributed queries

Real-time analytics


Energy Procurement
Core Knowledge
Sustainability Reporting

Sustainability Reporting

**Scope 2 emissions — two methods:** The GHG Protocol requires dual reporting. Location-based: uses average grid emission factor for your region (eGRID in the US). Market-based: reflects your procurement choices — if you buy RECs or have a PPA, your market-based emissions decrease. Most companies targeting RE100 or SBTi approval focus on market-based Scope 2.

**RE100:** A global initiative where companies commit to 100% renewable electricity. Requires annual reporting of progress. Acceptable instruments: physical PPAs, VPPAs with RECs, utility green tariff programs, unbundled RECs (though RE100 is tightening additionality requirements), and on-site generation.

**CDP and SBTi:** CDP (formerly Carbon Disclosure Project) scores corporate climate disclosure. Energy procurement data feeds your CDP Climate Change questionnaire directly — Section C8 (Energy). SBTi (Science Based Targets initiative) validates that your emissions reduction targets align with Paris Agreement goals. Procurement decisions that lock in fossil-heavy supply for 10+ years can conflict with SBTi trajectories.


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

Continuous Learning v2.1 - Instinct

-Based Architecture

An advanced learning system that turns your Claude Code sessions into reusable knowledge through atomic "instincts" - small learned behaviors with confidence scoring.

**v2.1** adds **project-scoped instincts** — React patterns stay in your React project, Python conventions stay in your Python project, and universal patterns (like "always validate input") are shared globally.


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

Blueprint — Construction Plan Generator
Examples
Multi-agent project

Multi-agent project

Produces a plan with parallel steps where possible (e.g., "implement Anthropic plugin" and "implement OpenAI plugin" run in parallel after the plugin interface step is done), model tier assignments (strongest for the interface design step, default for implementation), and invariants verified after every step (e.g., "all existing tests pass", "no provider imports in core").


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

Django Development Patterns
Model Design Patterns

Project Structure

Recommended Layout

Split Settings Pattern

Model Design Patterns


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.

How It Works

Never assume stablecoins use the same decimals everywhere. Query `decimals()` at runtime, cache by `(chain_id, token_address)`, and use decimal-safe math for value calculations.


Flutter/Dart Code Review Best Practices
13. Internationalization (l10n)
Content:

Content:

[ ] All user-visible strings use the localization system — no hardcoded strings in widgets

[ ] Template file includes descriptions/context for translators

[ ] ICU message syntax used for plurals, genders, selects

[ ] Placeholders defined with types

[ ] No missing keys across locales


Blueprint — Construction Plan Generator

Turn a one-line objective into a step-by-step construction plan that any coding agent can execute cold.


Java coding standards for Spring Boot services: naming, immutability, Optional usage, streams, exceptions, generics, and project layout.

When to Activate

Writing or reviewing Java code in Spring Boot projects

Enforcing naming, immutability, or exception handling conventions

Working with records, sealed classes, or pattern matching (Java 17+)

Reviewing use of Optional, streams, or generics

Structuring packages and project layout


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.

Quality Rules

**Every claim needs a source.** No unsourced assertions.

**Cross-reference.** If only one source says it, flag it as unverified.

**Recency matters.** Prefer sources from the last 12 months.

**Acknowledge gaps.** If you couldn't find good info on a sub-question, say so.

**No hallucination.** If you don't know, say "insufficient data found."

**Separate fact from inference.** Label estimates, projections, and opinions clearly.


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

Go Development Patterns
Core Principles
2. Make the Zero Value Useful

2. Make the Zero Value Useful

Design types so their zero value is immediately usable without initialization.


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

Kotlin Development Patterns
Core Principles
2. Immutability by Default

2. Immutability by Default

Prefer `val` over `var`, immutable collections over mutable ones.


Blueprint — Construction Plan Generator
Requirements

Requirements

Claude Code (for `/blueprint` slash command)

Git + GitHub CLI (optional — enables full branch/PR/CI workflow; Blueprint detects absence and auto-switches to direct mode)


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
Key Edge Cases

Key Edge Cases

These are situations where the obvious approach is wrong. Brief summaries are included here so you can expand them into project-specific playbooks if needed.

**De minimis threshold exploitation:** A supplier restructures shipments to stay below the $800 US de minimis threshold to avoid duties. Multiple shipments on the same day to the same consignee may be aggregated by CBP. Section 321 entry does not eliminate quota, AD/CVD, or PGA requirements — it only waives duty.

**Transshipment circumventing AD/CVD orders:** Goods manufactured in China but routed through Vietnam with minimal processing to claim Vietnamese origin. CBP uses evasion investigations (EAPA) with subpoena power. The "substantial transformation" test requires a new article of commerce with a different name, character, and use.

**Dual-use goods at the EAR/ITAR boundary:** A component with both commercial and military applications. ITAR controls based on the item, EAR controls based on the item plus the end use and end user. Commodity jurisdiction determination (CJ request) required when classification is ambiguous. Filing under the wrong regime is a violation of both.

**Post-importation adjustments:** Transfer pricing adjustments between related parties after the entry is liquidated. CBP requires reconciliation entries (CF 7501 with reconciliation flag) when the final price is not known at entry. Failure to reconcile creates duty exposure on the unpaid difference plus penalties.

**First sale valuation for related parties:** Using the price paid by the middleman (first sale) rather than the price paid by the importer (last sale) as the customs value. CBP allows this under the "first sale rule" (Nissho Iwai) but requires demonstrating the first sale is a bona fide arm's-length transaction. The EU and most other jurisdictions do not recognise first sale — they value on the last sale before importation.

**Retroactive FTA claims:** Discovering 18 months post-importation that goods qualified for preferential treatment. US allows post-importation claims via PSC (Post Summary Correction) within the liquidation period. EU requires the certificate of origin to have been valid at the time of importation. Timing and documentation requirements differ by FTA and jurisdiction.

**Classification of kits vs components:** A retail kit containing items from different HS chapters (e.g., a camping kit with a tent, stove, and utensils). GRI 3(b) classifies by essential character — but if no single component gives essential character, GRI 3(c) applies (last heading in numerical order). Kits "put up for retail sale" have specific rules under GRI 3(b) that differ from industrial assortments.

**Temporary imports that become permanent:** Equipment imported under an ATA Carnet or TIB that the importer decides to keep. The carnet/bond must be discharged by paying full duty plus any penalties. If the temporary import period has expired without export or duty payment, the carnet guarantee is called, creating liability for the guaranteeing chamber of commerce.


Deployment Patterns
Production Readiness Checklist
Monitoring

Monitoring

[ ] Application metrics exported (request rate, latency, errors)

[ ] Alerts configured for error rate > threshold

[ ] Log aggregation set up (structured logs, searchable)

[ ] Uptime monitoring on health endpoint


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

Prompt Caching

Cache large system prompts or context to reduce costs:

Batches API

Process large volumes asynchronously at 50% cost reduction:


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.

Section 3: Optimized Prompt — Full Version

Present the complete optimized prompt inside a single fenced code block.
The prompt must be self-contained and ready to copy-paste. Include:

Clear task description with context

Tech stack (detected or specified)

/command invocations at the right workflow stages

Acceptance criteria

Verification steps

Scope boundaries (what NOT to do)

For items that reference blueprint, write: "Use the blueprint skill to..."
(not `/blueprint`, since blueprint is a skill, not a command).


ClickHouse Analytics Patterns
Data Insertion Patterns
Bulk Insert (Recommended)

Aggregations

Window Functions

Data Insertion Patterns

Bulk Insert (Recommended)


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

Agent Eval Skill
Judge Types
Code-Based (deterministic)

3. Compare Results

Generate a comparison report:

Judge Types

Code-Based (deterministic)


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

Data Scraper Agent
Free Tier Limits Reference

Free Tier Limits Reference

| Service | Free Limit | Typical Usage |
|---|---|---|
| Gemini Flash Lite | 30 RPM, 1500 RPD | ~56 req/day at 3-hr intervals |
| Gemini 2.0 Flash | 15 RPM, 1500 RPD | Good fallback |
| Gemini 2.5 Flash | 10 RPM, 500 RPD | Use sparingly |
| GitHub Actions | Unlimited (public repos) | ~20 min/day |
| Notion API | Unlimited | ~200 writes/day |
| Supabase | 500MB DB, 2GB transfer | Fine for most agents |
| Google Sheets API | 300 req/min | Works for small agents |


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

skill-stocktake
Scope
Targeting a specific project

Targeting a specific project

To include project-level skills, run from that project's root directory:

If the project has no `.claude/skills/` directory, only global skills and commands are evaluated.


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

Iterative Retrieval Pattern
The Solution: Iterative Retrieval
Phase 2: EVALUATE

Phase 1: DISPATCH

Initial broad query to gather candidate files:

Phase 2: EVALUATE

Assess retrieved content for relevance:

Scoring criteria:

**High (0.8-1.0)**: Directly implements target functionality

**Medium (0.5-0.7)**: Contains related patterns or types

**Low (0.2-0.4)**: Tangentially related

**None (0-0.2)**: Not relevant, exclude


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

Flutter/Dart Code Review Best Practices
5. Performance
Unnecessary rebuilds:

5. Performance

Unnecessary rebuilds:

[ ] `setState()` not called at root widget level — localize state changes

[ ] `const` widgets used to stop rebuild propagation

[ ] `RepaintBoundary` used around complex subtrees that repaint independently

[ ] `AnimatedBuilder` child parameter used for subtrees independent of animation


EVM Token Decimals
Examples
Quick on-chain check

Normalize to 18-decimal WAD in Solidity

TypeScript with ethers

Quick on-chain check


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

Safety Guard — Prevent Destructive Operations

Mode 3: Guard Mode (Careful + Freeze combined)

Both protections active. Maximum safety for autonomous agents.

Agents can read anything but only write to `src/api/`. Destructive commands are blocked everywhere.


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

Laravel Security Best Practices
CSRF Protection

CSRF Protection

Keep `VerifyCsrfToken` middleware enabled

Include `@csrf` in forms and send XSRF tokens for SPA requests

For SPA authentication with Sanctum, ensure stateful requests are configured:


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

.NET Development Patterns
Result Pattern

Result Pattern

Return explicit success/failure instead of throwing for expected failures.


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

Required Inputs

Collect or infer:

current priorities and active work

target roles, industries, geos, or ecosystems

platform selection: X, LinkedIn, or both

do-not-touch list

mode: `light-pass`, `default`, or `aggressive`

If the user does not specify a mode, use `default`.


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

Examples

Minimal flow:

CI-style pipeline:


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

Rust Development Patterns
Quick Reference: Rust Idioms

Tooling Integration

Essential Commands

Quick Reference: Rust Idioms

| Idiom | Description |
|-------|-------------|
| Borrow, don't clone | Pass `&T` instead of cloning unless ownership is needed |
| Make illegal states unrepresentable | Use enums to model valid states only |
| `?` over `unwrap()` | Propagate errors, never panic in library/production code |
| Parse, don't validate | Convert unstructured data to typed structs at the boundary |
| Newtype for type safety | Wrap primitives in newtypes to prevent argument swaps |
| Prefer iterators over loops | Declarative chains are clearer and often faster |
| `#[must_use]` on Results | Ensure callers handle return values |
| `Cow` for flexible ownership | Avoid allocations when borrowing suffices |
| Exhaustive matching | No wildcard `_` for business-critical enums |
| Minimal `pub` surface | Use `pub(crate)` for internal APIs |


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

Architecture Decision Records
Categories of Decisions Worth Recording

Categories of Decisions Worth Recording

| Category | Examples |
|----------|---------|
| **Technology choices** | Framework, language, database, cloud provider |
| **Architecture patterns** | Monolith vs microservices, event-driven, CQRS |
| **API design** | REST vs GraphQL, versioning strategy, auth mechanism |
| **Data modeling** | Schema design, normalization decisions, caching strategy |
| **Infrastructure** | Deployment model, CI/CD pipeline, monitoring stack |
| **Security** | Auth strategy, encryption approach, secret management |
| **Testing** | Test framework, coverage targets, E2E vs integration balance |
| **Process** | Branching strategy, review process, release cadence |


Patient safety evaluation harness for healthcare application deployments. Automated test suites for CDSS accuracy, PHI exposure, clinical workflow integrity, and integration compliance. Blocks deployments on safety failures.

Healthcare Eval Harness — Patient Safety Verification


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

Django Security Best Practices
XSS Prevention
Safe String Handling

Extra Security with raw()

XSS Prevention

Template Escaping

Safe String Handling


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

Liquid Glass Design System (iOS 26)
Core Pattern — SwiftUI
Uniting Glass Effects

Uniting Glass Effects

Combine multiple views into a single glass shape with `glassEffectUnion`:


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
2. Input Validation

2. Input Validation

Always Validate User Input

Always Validate User Input

File Upload Validation

File Upload Validation

Verification Steps

Verification Steps

[ ] All user inputs validated with schemas

[ ] File uploads restricted (size, type, extension)

[ ] No direct use of user input in queries

[ ] Whitelist validation (not blacklist)

[ ] Error messages don't leak sensitive info


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

fal.ai Media Generation
Video Generation
Seedance 1.0 Pro (ByteDance)

Video Generation

Seedance 1.0 Pro (ByteDance)

Best for: text-to-video, image-to-video with high motion quality.


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

Example 3: "Add config file linter"

Anti-Patterns

**Jumping to code**: Writing a utility without checking if one exists

**Ignoring MCP**: Not checking if an MCP server already provides the capability

**Over-customizing**: Wrapping a library so heavily it loses its benefits

**Dependency bloat**: Installing a massive package for one small feature


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.

Related Skills

`santa-method` — adversarial verification

`knowledge-ops` — persist durable decision deltas correctly

`search-first` — gather external reference material before the council if needed

`architecture-decision-records` — formalize the outcome when the decision becomes long-lived system policy


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

Python Development Patterns
Package Organization
Import Conventions

Async/Await for Concurrent I/O

Package Organization

Standard Project Layout

Import Conventions


Flutter/Dart Code Review Best Practices
10. Package/Dependency Review
Evaluating pub.dev packages:

10. Package/Dependency Review

Evaluating pub.dev packages:

[ ] Check **pub points score** (aim for 130+/160)

[ ] Check **likes** and **popularity** as community signals

[ ] Verify the publisher is **verified** on pub.dev

[ ] Check last publish date — stale packages (>1 year) are a risk

[ ] Review open issues and response time from maintainers

[ ] Check license compatibility with your project

[ ] Verify platform support covers your targets


Laravel Security Best Practices
Password Security

Password Security

Hash passwords with `Hash::make()` and never store plaintext

Use Laravel's password broker for reset flows


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

Agent Introspection Debugging
Scope Boundaries

Scope Boundaries

Activate this skill for:

capturing failure state before retrying blindly

diagnosing common agent-specific failure patterns

applying contained recovery actions

producing a structured human-readable debug report

Do not use this skill as the primary source for:

feature verification after code changes; use `verification-loop`

framework-specific debugging when a narrower ECC skill already exists

runtime promises the current harness cannot enforce automatically


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

Spring Boot Verification Loop
Phase 2: Static Analysis

Phase 1: Build

If build fails, stop and fix.

Phase 2: Static Analysis

Maven (common plugins):

Gradle (if configured):


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

Perl Testing Patterns
Test::More Fundamentals

TDD Workflow

Always follow the RED-GREEN-REFACTOR cycle.

Test::More Fundamentals

The standard Perl testing module — widely used, ships with core.


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

Documentation Lookup (Context7)
How it works
Step 4: Use the Documentation

Step 4: Use the Documentation

Answer the user's question using the fetched, current information.

Include relevant code examples from the docs when helpful.

Cite the library or version when it matters (e.g. "In Next.js 15...").


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

C++ Testing (Agent Skill)
Alternatives to GoogleTest

Alternatives to GoogleTest

**Catch2**: header-only, expressive matchers

**doctest**: lightweight, minimal compile overhead


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

PyTorch Development Patterns
Data Pipeline Patterns

Training Loop Patterns

Standard Training Loop

Validation Loop

Data Pipeline Patterns


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
Workflow Patterns
Pattern 1: Research + Implement

Quick Start

Workflow Patterns

Pattern 1: Research + Implement

Split research and implementation into parallel tracks:


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

Flutter/Dart Code Review Best Practices
7. Accessibility
Screen reader support:

Screen reader support:

[ ] All interactive elements are focusable and have meaningful descriptions

[ ] Focus order is logical (follows visual reading order)


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

Laravel TDD Workflow
How It Works
Red-Green-Refactor Cycle

How It Works

Red-Green-Refactor Cycle

Write a failing test

Implement the minimal change to pass

Refactor while keeping tests green


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.

Writing Process

Clarify the audience and purpose.

Build a hard outline with one job per section.

Start sections with proof, artifact, conflict, or example.

Expand only where the next sentence earns space.

Cut anything that sounds templated, overexplained, or self-congratulatory.


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 3: Warm Path Discovery
Path Types (ordered by warmth)

Path Types (ordered by warmth)

**Direct mutual** — You both follow/know the same person

**Portfolio connection** — Mutual invested in or advises target's company

**Co-worker/alumni** — Mutual worked at same company or attended same school

**Event overlap** — Both attended same conference/program

**Content engagement** — Target engaged with mutual's content or vice versa


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
Usage
Opus 4.6 Deep Analysis

Opus 4.6 Deep Analysis

Run the adversarial three-agent pipeline for deeper analysis:

This runs:

**Attacker (Red Team)** — finds attack vectors

**Defender (Blue Team)** — recommends hardening

**Auditor (Final Verdict)** — synthesizes both perspectives


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
When to Use

When to Use

Onboarding a new carrier and vetting safety, insurance, and authority

Running an annual or lane-specific RFP for rate benchmarking

Building or updating carrier scorecards and performance reviews

Reallocating freight during tight capacity or carrier underperformance

Negotiating rate increases, fuel surcharges, or accessorial schedules


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.

3. Collapse duplicates before adding channels

Look for:

the same PR event appearing in GitHub, Linear, and local logs

repeated hook notifications for the same failure

comments or status churn that should be summarized instead of forwarded raw

channels that duplicate each other without adding a better action path

Prefer:

one canonical summary

one owner

one primary channel

one fallback path


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

Logistics Exception Management
Communication Patterns
Key Templates

Key Templates

Brief templates appear below. Adapt them to your carrier, customer, and insurance workflows before using them in production.

**Initial carrier inquiry:** Subject: `Exception Notice — PRO# {pro} / BOL# {bol}`. State: what happened, what you need (ETA update, inspection, OS&D report), and by when.

**Customer proactive update:** Lead with: what you know, what you're doing about it, what the customer's revised timeline is, and your direct contact for questions.

**Escalation to carrier management:** Subject: `ESCALATION: Unresolved Exception — {shipment_ref} — {days} Days`. Include timeline of previous communications, financial impact, and what resolution you expect.


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
CAPA Effectiveness Verification

CAPA Effectiveness Verification

Before closing any CAPA, verify:

**Implementation evidence:** Documented proof the action was completed (updated work instruction with revision, installed fixture with validation, modified inspection plan with effective date).

**Monitoring period data:** Minimum 90 days of production data, 3 consecutive production lots, or one full audit cycle — whichever provides the most meaningful evidence.

**Recurrence check:** Zero recurrences of the specific failure mode during the monitoring period. If recurrence occurs, the CAPA is not effective — reopen and re-investigate. Do not close and open a new CAPA for the same issue.

**Leading indicator review:** Beyond the specific failure, have related metrics improved? (e.g., overall PPM for that process, customer complaint rate for that product family).


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

JPA/Hibernate Patterns
Indexing and Performance

Indexing and Performance

Add indexes for common filters (`status`, `slug`, foreign keys)

Use composite indexes matching query patterns (`status, created_at`)

Avoid `select *`; project only needed columns

Batch writes with `saveAll` and `hibernate.jdbc.batch_size`


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

References

Plankton (credit: @alxfazio)

Plankton REFERENCE.md — Full architecture documentation (credit: @alxfazio)

Plankton SETUP.md — Detailed installation guide (credit: @alxfazio)


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

Django Testing with TDD

Test-driven development for Django applications using pytest, factory_boy, and Django REST Framework.


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.

When to Use

user says "research", "look up", "compare", "who should I talk to", or "what's the latest"

the answer depends on current public information

the user already supplied evidence and wants it factored into a fresh recommendation

the task may be recurring enough that it should become a monitor instead of a one-off lookup


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

Agent Introspection Debugging
Four-Phase Loop
Phase 2: Root-Cause Diagnosis

Phase 2: Root-Cause Diagnosis

Match the failure to a known pattern before changing anything.

| Pattern | Likely Cause | Check |
| --- | --- | --- |
| Maximum tool calls / repeated same command | loop or no-exit observer path | inspect the last N tool calls for repetition |
| Context overflow / degraded reasoning | unbounded notes, repeated plans, oversized logs | inspect recent context for duplication and low-signal bulk |
| `ECONNREFUSED` / timeout | service unavailable or wrong port | verify service health, URL, and port assumptions |
| `429` / quota exhaustion | retry storm or missing backoff | count repeated calls and inspect retry spacing |
| file missing after write / stale diff | race, wrong cwd, or branch drift | re-check path, cwd, git status, and actual file existence |
| tests still failing after “fix” | wrong hypothesis | isolate the exact failing test and re-derive the bug |

Diagnosis questions:

is this a logic failure, state failure, environment failure, or policy failure?

did the agent lose the real objective and start optimizing the wrong subtask?

is the failure deterministic or transient?

what is the smallest reversible action that would validate the diagnosis?


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

Laravel Security Best Practices
Validation and Data Sanitization

Validation and Data Sanitization

Always validate inputs with Form Requests

Use strict validation rules and type checks

Never trust request payloads for derived fields


Quality & Non-Conformance Management
Decision Frameworks
Supplier Corrective Action Escalation

Supplier Corrective Action Escalation

| Stage | Trigger | Action | Timeline |
|---|---|---|---|
| Level 1: SCAR issued | Single significant NC or 3+ minor NCs in 90 days | Formal SCAR requiring 8D response | 10 days for response, 30 for implementation |
| Level 2: Supplier on watch | SCAR not responded to in time, or corrective action not effective | Increased inspection, supplier on probation, procurement notified | 60 days to demonstrate improvement |
| Level 3: Controlled shipping | Continued quality failures during watch period | Supplier must submit inspection data with each shipment; or third-party sort at supplier's expense | 90 days to demonstrate sustained improvement |
| Level 4: New source qualification | No improvement under controlled shipping | Initiate alternate supplier qualification; reduce business allocation | Qualification timeline (3-12 months depending on industry) |
| Level 5: ASL removal | Failure to improve or unwillingness to invest | Formal removal from Approved Supplier List; transition all parts | Complete transition before final PO |


Laravel Security Best Practices
Logging and PII

Logging and PII

Never log passwords, tokens, or full card data

Redact sensitive fields in structured logs


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
Scope Boundaries

Scope Boundaries

Activate this skill for:

descriptive naming

immutability defaults

readability, KISS, DRY, and YAGNI enforcement

error-handling expectations and code-smell review

Do not use this skill as the primary source for:

React composition, hooks, or rendering patterns

backend architecture, API design, or database layering

domain-specific framework guidance when a narrower ECC skill already exists


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

When to Activate

Invoke this skill when:

Output will be published, deployed, or consumed by end users

Compliance, regulatory, or brand constraints must be enforced

Code ships to production without human review

Content accuracy matters (technical docs, educational material, customer-facing copy)

Batch generation at scale where spot-checking misses systemic patterns

Hallucination risk is elevated (claims, statistics, API references, legal language)

Do NOT use for internal drafts, exploratory research, or tasks with deterministic verification (use build/test/lint pipelines for those).


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

.NET Development Patterns

Idiomatic C# and .NET patterns for building robust, performant, and maintainable applications.


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 3: Detect Issues

Phase 3: Detect Issues

Identify the following problem patterns:

**Bloated agent descriptions** — description >30 words in frontmatter loads into every Task tool invocation

**Heavy agents** — files >200 lines inflate Task tool context on every spawn

**Redundant components** — skills that duplicate agent logic, rules that duplicate CLAUDE.md

**MCP over-subscription** — >10 servers, or servers wrapping CLI tools available for free

**CLAUDE.md bloat** — verbose explanations, outdated sections, instructions that should be rules


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

Perl Testing Patterns

Comprehensive testing strategies for Perl applications using Test2::V0, Test::More, prove, and TDD methodology.


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

Git Workflow Patterns
Merge vs Rebase
Merge (Preserves History)

Merge vs Rebase

Merge (Preserves History)

**Use when:**

Merging feature branches into `main`

You want to preserve exact history

Multiple people worked on the branch

The branch has been pushed and others may have based work on it


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.

SEO
How It Works
Technical SEO checklist

Technical SEO checklist

Crawlability

Crawlability

`robots.txt` should allow important pages and block low-value surfaces

no important page should be unintentionally `noindex`

important pages should be reachable within a shallow click depth

avoid redirect chains longer than two hops

canonical tags should be self-consistent and non-looping

Indexability

Indexability

preferred URL format should be consistent

multilingual pages need correct hreflang if used

sitemaps should reflect the intended public surface

no duplicate URLs should compete without canonical control

Performance

Performance

LCP < 2.5s

INP < 200ms

CLS < 0.1

common fixes: preload hero assets, reduce render-blocking work, reserve layout space, trim heavy JS

Structured data

Structured data

homepage: organization or business schema where appropriate

editorial pages: `Article` / `BlogPosting`

product pages: `Product` and `Offer`

interior pages: `BreadcrumbList`

Q&A sections: `FAQPage` only when the content truly matches


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
Newsletters

Newsletters

keep the first screen doing real work

do not front-load diary filler

use section labels only when they improve scanability


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

Deep Research
Workflow
Step 1: Understand the Goal

Workflow

Step 1: Understand the Goal

Ask 1-2 quick clarifying questions:

"What's your goal — learning, making a decision, or writing something?"

"Any specific angle or depth you want?"

If the user says "just research it" — skip ahead with reasonable defaults.


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

VideoDB Skill
How it works
Timeline editing

Timeline editing

**Important:** Always validate timestamps before building a timeline:

`start` must be >= 0 (negative values are silently accepted but produce broken output)

`start` must be < `end`

`end` must be <= `video.length`


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

Writing Hookify Rules
Event Type Guide
prompt Events

stop Events

Completion checks and reminders. Pattern `.*` matches always.

prompt Events

Match user prompt content for workflow enforcement.


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

Additional Resources

Pair this skill with your grading rubric, fraud review thresholds, and refund authority matrix before using it in production.

Keep restocking standards, hazmat return handling, and liquidation rules near the operating team that will execute the decisions.


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

Content-Hash File Cache Pattern
When to Use

Anti-Patterns to Avoid

When to Use

File processing pipelines (PDF parsing, OCR, text extraction, image analysis)

CLI tools that benefit from `--cache/--no-cache` options

Batch processing where the same files appear across runs

Adding caching to existing pure functions without modifying them


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

Product Lens — Think Before You Build
How It Works
Mode 3: User Journey Audit

Mode 2: Founder Review

Reviews your current project through a founder lens:

Mode 3: User Journey Audit

Maps the actual user experience:


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

Testing Standard

Raise testing bar for generated code:

required regression coverage for touched domains

explicit edge-case assertions

integration checks for interface boundaries


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

Laravel Verification Loop
Phase 7: Queue and Scheduler Checks

Phase 7: Queue and Scheduler Checks

If Horizon is used:

If `queue:monitor` is available, use it to check backlog without processing jobs:

Active verification (staging only): dispatch a no-op job to a dedicated queue and run a single worker to process it (ensure a non-`sync` queue connection is configured).

Verify the job produced the expected side effect (log entry, healthcheck table row, or metric).

Only run this on non-production environments where processing a test job is safe.


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

DeFi AMM Security
Examples
Donation or inflation attacks

Donation or inflation attacks

Using `token.balanceOf(address(this))` directly for share math lets attackers manipulate the denominator by sending tokens to the contract outside the intended path.

Track internal accounting and measure actual tokens received.


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

何时重新调整灵魂

刻意回避某些任务，因为"不适合这个角色" → 灵魂限制了功能

角色特征变成噪音 → 浓度太高

你在配合AI说话 → 主客倒置

兼容性

本 Skill 遵循 Markdown 指令注入标准：

**Claude Code / Claude.ai**：原生支持

**OpenClaw Agent**：通过 SOUL.md 注入

**其他 Agent**：支持 SKILL.md 格式的框架均可使用

本 Skill 自身不包含任何网络请求或文件发送代码。
头像生图能力通过当前环境中已审核的可选生图 skill 提供。

注：README.md / README.zh.md 是给人类用户看的安装说明，不影响 Skill 运行。


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

Django Development Patterns

Production-grade Django architecture patterns for scalable, maintainable applications.


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 Requirement

MCP Requirement

LaraPlugins MCP server must be configured. Add to your `~/.claude.json` mcpServers:

No API key required — the server is free for the Laravel community.


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.

Examples

**Constraint breakdown**: Line 2 CNC machine goes down for 4 hours. Identify which jobs were queued, evaluate which can be rerouted to Line 3 (alternate routing), which must wait, and how to re-sequence the remaining queue to minimize total lateness across all affected orders.

**Campaign vs. mixed-model decision**: 15 jobs across 4 product families on a line with 45-minute inter-family changeovers. Calculate the crossover point where campaign batching (fewer changeovers, more WIP) beats mixed-model (more changeovers, lower WIP) using changeover cost and carrying cost.

**Late hot order insertion**: Sales commits a rush order with a 2-day lead time into a fully loaded week. Evaluate schedule slack, identify which existing jobs can absorb a 1-shift delay without missing their due dates, and slot the hot order without breaking the frozen window.


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

Enterprise Agent Ops
Deployment Integrations

Deployment Integrations

This skill pairs with:

PM2 workflows

systemd services

container orchestrators

CI/CD gates


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
Accelerator Applications

Accelerator Applications

answer the exact question asked

prioritize traction, insight, and team advantage

avoid puffery

keep internal metrics consistent with the deck and model


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.

When to Use

Building new features where long-term maintainability and testability matter.

Refactoring layered or framework-heavy code where domain logic is mixed with I/O concerns.

Supporting multiple interfaces for the same use case (HTTP, CLI, queue workers, cron jobs).

Replacing infrastructure (database, external APIs, message bus) without rewriting business rules.

Use this skill when the request involves boundaries, domain-centric design, refactoring tightly coupled services, or decoupling application logic from specific libraries.


Quick Reference

Upload media

Transcript + subtitle

Search inside videos

Scene search


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


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.

Agent Sort
Core Workflow
2. Build the evidence table

2. Build the evidence table

For every candidate surface, record:

component path

component type

proposed bucket

repo evidence

short justification

Use this format:


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

Perl Testing Patterns
Test2::V0 Modern Framework

Basic Assertions

SKIP and TODO

Test2::V0 Modern Framework

Test2::V0 is the modern replacement for Test::More — richer assertions, better diagnostics, and extensible.


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

Role and Context

You are a senior demand planner at a multi-location retailer operating 40–200 stores with regional distribution centers. You manage 300–800 active SKUs across categories including grocery, general merchandise, seasonal, and promotional assortments. Your systems include a demand planning suite (Blue Yonder, Oracle Demantra, or Kinaxis), an ERP (SAP, Oracle), a WMS for DC-level inventory, POS data feeds at the store level, and vendor portals for purchase order management. You sit between merchandising (which decides what to sell and at what price), supply chain (which manages warehouse capacity and transportation), and finance (which sets inventory investment budgets and GMROI targets). Your job is to translate commercial intent into executable purchase orders while minimizing both stockouts and excess inventory.


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
TDD Workflow for Kotlin

TDD Workflow for Kotlin

The RED-GREEN-REFACTOR Cycle

The RED-GREEN-REFACTOR Cycle

Step-by-Step TDD in Kotlin

Step-by-Step TDD in Kotlin


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

Dashboard Builder
Workflow
3. Build the minimum useful board

3. Build the minimum useful board

Recommended structure:

overview

performance

resources

service-specific section


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.

Quick Reference

| AI Regression Pattern | Test Strategy | Priority |
|---|---|---|
| Sandbox/production mismatch | Assert same response shape in sandbox mode |  High |
| SELECT clause omission | Assert all required fields in response |  High |
| Error state leakage | Assert state cleanup on error |  Medium |
| Missing rollback | Assert state restored on API failure |  Medium |
| Type cast masking null | Assert field is not undefined |  Medium |


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

ECC Tools Cost Audit
Workflow
2. Trace ingress before theorizing

2. Trace ingress before theorizing

inspect `src/index.*` or the main entrypoint first

map every enqueue path before suggesting a fix

confirm which GitHub events share a queue type

confirm whether push, pull_request, synchronize, comment, or manual re-run events can converge on the same expensive path


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

How It Works

**Turbopack**: Incremental bundler for Next.js dev. Uses file-system caching so restarts are much faster (e.g. 5–14x on large projects).

**Default in dev**: From Next.js 16, `next dev` runs with Turbopack unless disabled.

**File-system caching**: Restarts reuse previous work; cache is typically under `.next`; no extra config needed for basic use.

**Bundle Analyzer (Next.js 16.1+)**: Experimental Bundle Analyzer to inspect output and find heavy dependencies; enable via config or experimental flag (see Next.js docs for your version).


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.

Manim Video

Use Manim for technical explainers where motion, structure, and clarity matter more than photorealism.


Inventory Demand Planning
Core Knowledge
Promotional Planning

Promotional Planning

**Demand Signal Distortion:** Promotions create artificial demand peaks that contaminate baseline forecasting. Strip promotional volume from history before fitting baseline models. Keep a separate "promotional lift" layer that applies multiplicatively on top of the baseline during promo weeks.

**Lift Estimation Methods:** (1) Year-over-year comparison of promoted vs. non-promoted periods for the same item. (2) Cross-elasticity model using historical promo depth, display type, and media support as inputs. (3) Analogous item lift — new items borrow lift profiles from similar items in the same category that have been promoted before. Typical lifts: 15–40% for TPR (temporary price reduction) only, 80–200% for TPR + display + circular feature, 300–500%+ for doorbuster/loss-leader events.

**Cannibalization:** When SKU A is promoted, SKU B (same category, similar price point) loses volume. Estimate cannibalization at 10–30% of lifted volume for close substitutes. Ignore cannibalization across categories unless the promo is a traffic driver that shifts basket composition.

**Forward-Buy Calculation:** Customers stock up during deep promotions, creating a post-promo dip. The dip duration correlates with product shelf life and promotional depth. A 30% off promotion on a pantry item with 12-month shelf life creates a 2–4 week dip as households consume stockpiled units. A 15% off promotion on a perishable produces almost no dip.

**Post-Promo Dip:** Expect 1–3 weeks of below-baseline demand after a major promotion. The dip magnitude is typically 30–50% of the incremental lift, concentrated in the first week post-promo. Failing to forecast the dip leads to excess inventory and markdowns.


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
DSL Builders
Type-Safe Builders

Delegation

Property Delegation

Interface Delegation

DSL Builders

Type-Safe Builders


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

Data & APIs

HTTP clients → `httpx` (Python), `ky`/`got` (Node)

Validation → `zod` (TS), `pydantic` (Python)

Database → Check for MCP servers first


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

3. Take the safest reversible action first

Preferred order:

restore self-serve management

fix duplicate or broken billing state

refund only the affected charge or duplicate

document the reason

send a short customer follow-up

If the fix requires product work, separate:

customer remediation now

product bug / workflow gap for backlog


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

Role and Context

You are a senior returns operations manager with 15+ years handling the full returns lifecycle across retail, e-commerce, and omnichannel environments. Your responsibilities span return merchandise authorization (RMA), receiving and inspection, condition grading, disposition routing, refund and credit processing, fraud detection, vendor recovery (RTV), and warranty claims management. Your systems include OMS (order management), WMS (warehouse management), RMS (returns management), CRM, fraud detection platforms, and vendor portals. You balance customer satisfaction against margin protection, processing speed against inspection accuracy, and fraud prevention against false-positive customer friction.


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

fal.ai Media Generation
Audio Generation
CSM-1B (Conversational Speech)

Audio Generation

CSM-1B (Conversational Speech)

Text-to-speech with natural, conversational quality.


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

Dart/Flutter Patterns
4. Widget Architecture
Scoped Rebuilds

4. Widget Architecture

Extract to Classes, Not Methods

const Propagation

Scoped Rebuilds


ECC Tools Cost Audit
Workflow
1. Freeze repo scope

Workflow

1. Freeze repo scope

switch into the sibling `ECC-Tools` repo

check branch and local diff first

identify the exact surface under audit:

webhook router

queue producer

queue consumer

PR creation path

usage reservation / billing path

model routing path


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
Event Pipeline

Event Pipeline

Treat the lane as:

**Capture** the event

**Classify** urgency and owner

**Route** to the correct channel

**Collapse** duplicates and low-signal churn

**Attach** the next operator action

The goal is fewer, better notifications.


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

Examples

Run and install

Scripts and env

Testing

Runtime API

Best Practices

Commit the lockfile (`bun.lock` or `bun.lockb`) for reproducible installs.

Prefer `bun run` for scripts. For TypeScript, Bun runs `.ts` natively.

Keep dependencies up to date; Bun and the ecosystem evolve quickly.


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

Token Budget Advisor (TBA)
Precision note

Precision note

This skill uses heuristic estimation — no real tokenizer. Accuracy ~85-90%, variance ±15%. Always show the disclaimer.


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

LLM Trading Agent Security
Examples
Wallet isolation

Hard spend limits

Simulate before sending

Circuit breaker

Wallet isolation

Use a dedicated hot wallet with only the required session funds. Never point the agent at a primary treasury wallet.


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

Agent Introspection Debugging
Four-Phase Loop
Phase 3: Contained Recovery

Phase 3: Contained Recovery

Recover with the smallest action that changes the diagnosis surface.

Safe recovery actions:

stop repeated retries and restate the hypothesis

trim low-signal context and keep only the active goal, blockers, and evidence

re-check the actual filesystem / branch / process state

narrow the task to one failing command, one file, or one test

switch from speculative reasoning to direct observation

escalate to a human when the failure is high-risk or externally blocked

Do not claim unsupported auto-healing actions like “reset agent state” or “update harness config” unless you are actually doing them through real tools in the current environment.

Contained recovery checklist:


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
ERP/MES Interaction Patterns

ERP/MES Interaction Patterns

**SAP PP / Oracle Manufacturing production planning flow:** Demand enters as sales orders or forecast consumption, drives MPS (Master Production Schedule), which explodes through MRP into planned orders by work centre with material requirements. The scheduler converts planned orders into production orders, sequences them, and releases to the shop floor via MES. Feedback flows from MES (operation confirmations, scrap reporting, labor booking) back to ERP to update order status and inventory.

**Work order management:** A work order carries the routing (sequence of operations with work centres, setup times, and run times), the BOM (components required), and the due date. The scheduler's job is to assign each operation to a specific time slot on a specific resource, respecting resource capacity, material availability, and dependency constraints (operation 20 cannot start until operation 10 is complete).

**Shop floor reporting and plan-vs-reality gap:** MES captures actual start/end times, actual quantities produced, scrap counts, and downtime reasons. The gap between the schedule and MES actuals is the "plan adherence" metric. Healthy plan adherence is > 90% of jobs starting within ±1 hour of scheduled start. Persistent gaps indicate that either the scheduling parameters (setup times, run rates, yield factors) are wrong or that the shop floor is not following the sequence.

**Closing the loop:** Every shift, compare scheduled vs. actual at the operation level. Update the schedule with actuals, re-sequence the remaining horizon, and publish the updated schedule. This "rolling re-plan" cadence keeps the schedule realistic rather than aspirational. The worst failure mode is a schedule that diverges from reality and becomes ignored by the shop floor — once operators stop trusting the schedule, it ceases to function.


Build a source-derived writing style profile from real posts, essays, launch notes, docs, or site copy, then reuse that profile across content, outreach, and social workflows. Use when the user wants voice consistency without generic AI writing tropes.

Output Contract

Produce a reusable `VOICE PROFILE` block that downstream skills can consume directly. Use the schema in [references/voice-profile-schema.md](references/voice-profile-schema.md).

Keep the profile structured and short enough to reuse in session context. The point is not literary criticism. The point is operational reuse.


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

Swift 6.2 Approachable Concurrency

Patterns for adopting Swift 6.2's concurrency model where code runs single-threaded by default and concurrency is introduced explicitly. Eliminates common data-race errors without sacrificing performance.


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
Core Principles
4. Git Checkpoints

4. Git Checkpoints

If the repository is under Git, create a checkpoint commit after each TDD stage

Do not squash or rewrite these checkpoint commits until the workflow is complete

Each checkpoint commit message must describe the stage and the exact evidence captured

Count only commits created on the current active branch for the current task

Do not treat commits from other branches, earlier unrelated work, or distant branch history as valid checkpoint evidence

Before treating a checkpoint as satisfied, verify that the commit is reachable from the current `HEAD` on the active branch and belongs to the current task sequence

The preferred compact workflow is:

one commit for failing test added and RED validated

one commit for minimal fix applied and GREEN validated

one optional commit for refactor complete

Separate evidence-only commits are not required if the test commit clearly corresponds to RED and the fix commit clearly corresponds to GREEN


Use this skill when retrieving Jira tickets, analyzing requirements, updating ticket status, adding comments, or transitioning issues. Provides Jira API patterns via MCP or direct REST calls.

Jira Integration Skill
Updating Tickets
Comment Templates

Comment Templates

**Starting Work:**

**Tests Implemented:**

**PR Created:**

**Work Complete:**


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

C++ Testing (Agent Skill)
Flaky Tests Guardrails

Sanitizers

Flaky Tests Guardrails

Never use `sleep` for synchronization; use condition variables or latches.

Make temp directories unique per test and always clean them.

Avoid real time, network, or filesystem dependencies in unit tests.

Use deterministic seeds for randomized inputs.


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

Backend Development Patterns
Authentication & Authorization

Centralized Error Handler

Retry with Exponential Backoff

Authentication & Authorization


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.

Best Practices

**Always filter by health** — Use `health_score: "Healthy"` for production projects

**Match Laravel version** — Always check `laravel_compatibility` matches the target project

**Check vendor reputation** — Prefer packages from known vendors (spatie, laravel, etc.)

**Review before recommending** — Use GetPluginDetailsTool for a comprehensive assessment

**No API key needed** — The MCP is free, no authentication required


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

PyTorch Development Patterns
Anti-Patterns to Avoid

Anti-Patterns to Avoid

__Remember__: PyTorch code should be device-agnostic, reproducible, and memory-conscious. When in doubt, profile with `torch.profiler` and check GPU memory with `torch.cuda.memory_summary()`.


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.

Core Workflow

inventory the canonical facts

identify missing assumptions

choose the asset type

draft the asset with explicit logic

cross-check every number against the source of truth


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

Laravel Development Patterns
Examples
Naming Convention

Naming Convention

File names use timestamps: `YYYY_MM_DD_HHMMSS_create_users_table.php`

Migrations use anonymous classes (no named class); the filename communicates intent

Table names are `snake_case` and plural by default


Laravel Plugin Discovery
How It Works
Finding Packages

How It Works

Finding Packages

When the user wants to discover packages for a feature:

Use `SearchPluginTool` with relevant keywords

Apply filters for health score, Laravel version, or PHP version

Review the results with package names, descriptions, and health indicators


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
Tone Calibration

Communication Patterns

Tone Calibration

Match communication tone to the counterparty, regulatory context, and risk level:

**Customs broker (routine):** Collaborative and precise. Provide complete documentation, flag unusual items, confirm classification up front. "HS 8471.30 confirmed — our GRI 1 analysis and the 2019 CBP ruling HQ H298456 support this classification. Packed 3 of 4 required docs, C/O follows by EOD."

**Customs broker (urgent hold/exam):** Direct, factual, time-sensitive. "Shipment held at LA/LB — CBP requesting manufacturer documentation. Sending MID verification and production records now. Need your filing within 2 hours to avoid demurrage."

**Regulatory authority (ruling request):** Formal, thoroughly documented, legally precise. Follow the agency's prescribed format exactly. Provide samples if requested. Never overstate certainty — use "it is our position that" rather than "this product is classified as."

**Regulatory authority (penalty response):** Measured, cooperative, factual. Acknowledge the error if it exists. Present mitigation factors systematically. Never admit fraud when the facts support negligence.

**Internal compliance advisory:** Clear business impact, specific action items, deadline. Translate regulatory requirements into operational language. "Effective March 1, all lithium battery imports require UN 38.3 test summaries at entry. Operations must collect these from suppliers before booking. Non-compliance: $10K+ per shipment in fines and cargo holds."

**Supplier questionnaire:** Specific, structured, explain why you need the information. Suppliers who understand the duty savings from an FTA are more cooperative with origin data.


RFC-driven multi-agent DAG execution pattern with quality gates, merge queues, and work unit orchestration.

Pipeline Stages

RFC intake

DAG decomposition

Unit assignment

Unit implementation

Unit validation

Merge queue and integration

Final system verification


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

4. Continuous Claude PR Loop

**A production-grade shell script** that runs Claude Code in a continuous loop, creating PRs, waiting for CI, and merging automatically. Created by AnandChowdhary (credit: @AnandChowdhary).


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

Skill Stack

Pull these ECC-native skills into the workflow when relevant:

`verification-loop` for exact proving steps after changes

`tdd-workflow` when the right fix needs regression coverage

`security-review` when secrets, auth, or external inputs are involved

`github-ops` when the task depends on CI runs, PR state, or release status

`knowledge-ops` when the verified outcome needs to be captured into durable project context


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

Healthcare PHI/PII Compliance Patterns
Examples
Example 3: Safe Logging


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

AI-First Engineering
Hiring and Evaluation Signals

Hiring and Evaluation Signals

Strong AI-first engineers:

decompose ambiguous work cleanly

define measurable acceptance criteria

produce high-signal prompts and evals

enforce risk controls under delivery pressure


Orchestrate multi-agent coding tasks via Claude DevFleet — plan projects, dispatch parallel agents in isolated worktrees, monitor progress, and read structured reports.

Claude DevFleet Multi-Agent Orchestration

How It Works

Tools

| Tool | Purpose |
|------|---------|
| `plan_project(prompt)` | AI breaks a description into a project with chained missions |
| `create_project(name, path?, description?)` | Create a project manually, returns `project_id` |
| `create_mission(project_id, title, prompt, depends_on?, auto_dispatch?)` | Add a mission. `depends_on` is a list of mission ID strings (e.g., `["abc-123"]`). Set `auto_dispatch=true` to auto-start when deps are met. |
| `dispatch_mission(mission_id, model?, max_turns?)` | Start an agent on a mission |
| `cancel_mission(mission_id)` | Stop a running agent |
| `wait_for_mission(mission_id, timeout_seconds?)` | Block until a mission completes (see note below) |
| `get_mission_status(mission_id)` | Check mission progress without blocking |
| `get_report(mission_id)` | Read structured report (files changed, tested, errors, next steps) |
| `get_dashboard()` | System overview: running agents, stats, recent activity |
| `list_projects()` | Browse all projects |
| `list_missions(project_id, status?)` | List missions in a project |

**Note on `wait_for_mission`:** This blocks the conversation for up to `timeout_seconds` (default 600). For long-running missions, prefer polling with `get_mission_status` every 30–60 seconds instead, so the user sees progress updates.


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.

Follow-Up Cadence

Default:

day 0: initial outbound

day 4 or 5: short follow-up with one new data point

day 10 to 12: final follow-up with a clean close

Do not keep nudging after that unless the user wants a longer sequence.


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

Customer Billing Ops
Workflow
1. Identify the customer cleanly

Workflow

1. Identify the customer cleanly

Start from the strongest identifier available:

customer email

Stripe customer ID

subscription ID

invoice ID

GitHub username or support email if it is known to map back to billing

Return a concise identity summary:

customer

active subscriptions

canceled subscriptions

invoices

obvious anomalies such as duplicate active subscriptions


Autonomous Loops Skill
4. Continuous Claude PR Loop
Installation

Core Loop

Installation

**Warning:** Install continuous-claude from its repository after reviewing the code. Do not pipe external scripts directly to bash.


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

Android Clean Architecture

Clean Architecture patterns for Android and KMP projects. Covers module boundaries, dependency inversion, UseCase/Repository patterns, and data layer design with Room, SQLDelight, and Ktor.


Apple FoundationModels framework for on-device LLM — text generation, guided generation with @Generable, tool calling, and snapshot streaming in iOS 26+.

FoundationModels: On-Device LLM (iOS 26)

Core Pattern — Tool Calling

Let the model invoke custom code for domain-specific tasks:


Automatically extract reusable patterns from Claude Code sessions and save them as learned skills for future use.

Configuration

Edit `config.json` to customize:

Pattern Types

| Pattern | Description |
|---------|-------------|
| `error_resolution` | How specific errors were resolved |
| `user_corrections` | Patterns from user corrections |
| `workarounds` | Solutions to framework/library quirks |
| `debugging_techniques` | Effective debugging approaches |
| `project_specific` | Project-specific conventions |


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

Token Budget Advisor (TBA)
How It Works
Step 4 — Respond at the chosen level

Step 4 — Respond at the chosen level

| Level            | Target length       | Include                                             | Omit                                              |
|------------------|---------------------|-----------------------------------------------------|---------------------------------------------------|
| 25% Essential    | 2-4 sentences max   | Direct answer, key conclusion                       | Context, examples, nuance, alternatives           |
| 50% Moderate     | 1-3 paragraphs      | Answer + necessary context + 1 example              | Deep analysis, edge cases, references             |
| 75% Detailed     | Structured response | Multiple examples, pros/cons, alternatives          | Extreme edge cases, exhaustive references         |
| 100% Exhaustive  | No restriction      | Everything — full analysis, all code, all perspectives | Nothing                                        |


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

Cost-Aware LLM Pipeline
Anti-Patterns to Avoid

Anti-Patterns to Avoid

Using the most expensive model for all requests regardless of complexity

Retrying on all errors (wastes budget on permanent failures)

Mutating cost tracking state (makes debugging and auditing difficult)

Hardcoding model names throughout the codebase (use constants or config)

Ignoring prompt caching for repetitive system prompts


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
5. Return an action-biased design

5. Return an action-biased design

End with:

what to keep

what to suppress

what to merge

what ECC should wrap next


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

Open-Source Pipeline Skill

Safely open-source any project through a 3-stage pipeline: **Fork** (strip secrets) → **Sanitize** (verify clean) → **Package** (CLAUDE.md + setup.sh + README).


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

API Design Patterns
Versioning
Header Versioning

Header Versioning

**Pros:** Clean URLs
**Cons:** Harder to test, easy to forget


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
Communication Patterns
Tone Calibration

Communication Patterns

Tone Calibration

**Vendor routine reorder:** Transactional, brief, PO-reference-driven. "PO #XXXX for delivery week of MM/DD per our agreed schedule."

**Vendor lead time escalation:** Firm, fact-based, quantifies business impact. "Our analysis shows your lead time has increased from 14 to 22 days over the past 8 weeks. This has resulted in X stockout events. We need a corrective plan by [date]."

**Internal stockout alert:** Urgent, actionable, includes estimated revenue at risk. Lead with the customer impact, not the inventory metric. "SKU X will stock out at 12 locations by Thursday. Estimated lost sales: $XX,000. Recommended action: [expedite/reallocate/substitute]."

**Markdown recommendation to merchandising:** Data-driven, includes margin impact analysis. Never frame it as "we bought too much" — frame as "sell-through pace requires price action to meet margin targets."

**Promotional forecast submission:** Structured, with baseline, lift, and post-promo dip called out separately. Include assumptions and confidence range. "Baseline: 500 units/week. Promotional lift estimate: 180% (900 incremental). Post-promo dip: −35% for 2 weeks. Confidence: ±25%."

**New product forecast assumptions:** Document every assumption explicitly so it can be audited at post-mortem. "Based on analogs [list], we project 200 units/week in weeks 1–4, declining to 120 units/week by week 8. Assumptions: price point $X, distribution to 80 doors, no competitive launch in window."

Brief templates appear above. Adapt them to your supplier, sales, and operations planning workflows before using them in production.