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
React Best Practices
Component Structure

Error Handling

Async/Await Best Practices

Type Safety

React Best Practices

Component Structure


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

Java Coding Standards
Code Smells to Avoid

Code Smells to Avoid

Long parameter lists → use DTO/builders

Deep nesting → early returns

Magic numbers → named constants

Static mutable state → prefer dependency injection

Silent catch blocks → log and act or rethrow


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
2. Configure API key

2. Configure API key

The user must set `VIDEO_DB_API_KEY` using **either** method:

**Export in terminal** (before starting Claude): `export VIDEO_DB_API_KEY=your-key`

**Project `.env` file**: Save `VIDEO_DB_API_KEY=your-key` in the project's `.env` file

Get a free API key at [console.videodb.io](https://console.videodb.io) (50 free uploads, no credit card).

**Do NOT** read, write, or handle the API key yourself. Always let the user set it.


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.

Auto-Fix

Apply safe fixes automatically (only fixes marked as auto-fixable):

This will:

Replace hardcoded secrets with environment variable references

Tighten wildcard permissions to scoped alternatives

Never modify manual-only suggestions


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.

Output Format

Pitfalls

do not work from stale memory when the live repo state can be read

do not widen a narrow fix into repo-wide churn

do not use destructive git commands

do not ignore unrelated local work


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
How It Works
Checking Compatibility

Checking Compatibility

When the user needs Laravel or PHP version compatibility:

Search with `laravel_compatibility` filter set to their version

Or get details on a specific package to see its supported versions


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

Selection

Use when one code block matters more than the whole file:

Pattern

Use when exact lines may drift:


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

Python Development Patterns
Error Handling Patterns
Specific Exception Handling

Protocol-Based Duck Typing

Error Handling Patterns

Specific Exception Handling


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

Django Security Best Practices
Environment Variables

Authentication for APIs

Security Headers

Content Security Policy

Environment Variables


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.

When to Activate

the user wants a technical explainer animation

the concept is a graph, workflow, architecture, metric progression, or system diagram

the user wants a short product or launch explainer for X or a landing page

the visual should feel precise instead of generically cinematic


Related Skills

`codebase-onboarding`

`coding-standards`

`council`

official upstream format: `microsoft/codetour`


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 3: Test + Fix Loop

Pattern 2: Multi-File Feature

Parallelize work across independent files:

Pattern 3: Test + Fix Loop

Run tests in one pane, fix in another:


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

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

Concepts (C++20)

Anti-Patterns

Unconstrained templates in visible namespaces (T.47)

Specializing function templates instead of overloading (T.144)

Template metaprogramming where `constexpr` suffices (T.120)

`typedef` instead of `using` (T.43)


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.

Hard Bans

Delete and rewrite any of these:

"In today's rapidly evolving landscape"

"game-changer", "revolutionary", "cutting-edge"

"here's why this matters" unless it is followed immediately by something concrete

ending with a LinkedIn-style question just to farm replies

forced casualness on LinkedIn

fake engagement padding that was not present in the source material


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

Prompt Optimizer
Output Format
Section 1: Prompt Diagnosis

Section 1: Prompt Diagnosis

**Strengths:** List what the original prompt does well.

**Issues:**

| Issue | Impact | Suggested Fix |
|-------|--------|---------------|
| (problem) | (consequence) | (how to fix) |

**Needs Clarification:** Numbered list of questions the user should answer.
If Phase 0 auto-detected the answer, state it instead of asking.


When to Activate

Running multiple agent sessions in parallel

Coordinating work across Claude Code, Codex, and other harnesses

Complex tasks that benefit from divide-and-conquer parallelism

User says "run in parallel", "split this work", "use dmux", or "multi-agent"


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

Flutter/Dart Code Review Best Practices
9. Security
API key handling:

API key handling:

[ ] API keys NOT hardcoded in Dart source — use `--dart-define`, `.env` files excluded from VCS, or compile-time configuration

[ ] Secrets not committed to git — check `.gitignore`

[ ] Backend proxy used for truly secret keys (client should never hold server secrets)


Coding Standards & Best Practices
File Organization
File Naming

Response Format

Input Validation

File Organization

Project Structure

File Naming


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

Example

End-to-end run

Design Principles

**What, not How**: Extract principles (rules territory) only. Code examples and commands stay in skills.

**Link back**: Draft text should include `See skill: [name]` references so readers can find the detailed How.

**Deterministic collection, LLM judgment**: Scripts guarantee exhaustiveness; the LLM guarantees contextual understanding.

**Anti-abstraction safeguard**: The 3-layer filter (2+ skills evidence, actionable behavior test, violation risk) prevents overly abstract principles from entering rules.


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

Spring Boot Development Patterns
Logging (SLF4J)

Async Processing

Requires `@EnableAsync` on a configuration class.

Logging (SLF4J)


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.

Step 4: Build the Gemini AI Client

Step 5: Build the AI Pipeline (Batch)

Step 6: Build the Feedback Learning System

**Integration with your storage layer:** after each run, query your DB for items with positive/negative status and call `save_feedback()` with the extracted patterns.


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
Direct REST API Reference
Transition a Ticket

Direct REST API Reference

Fetch a Ticket

Fetch Comments

Add a Comment

Transition a Ticket


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
Migration Steps

Migration Steps

**Enable in Xcode**: Swift Compiler > Concurrency section in Build Settings

**Enable in SPM**: Use `SwiftSettings` API in package manifest

**Use migration tooling**: Automatic code changes via swift.org/migration

**Start with MainActor defaults**: Enable inference mode for app targets

**Add `@concurrent` where needed**: Profile first, then offload hot paths

**Test thoroughly**: Data-race issues become compile-time errors


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

Inventory Demand Planning
Core Knowledge
Forecast Accuracy Metrics

Forecast Accuracy Metrics

**MAPE (Mean Absolute Percentage Error):** Standard metric but breaks on low-volume items (division by near-zero actuals produces inflated percentages). Use only for items averaging 50+ units/week.

**Weighted MAPE (WMAPE):** Sum of absolute errors divided by sum of actuals. Prevents low-volume items from dominating the metric. This is the metric finance cares about because it reflects dollars.

**Bias:** Average signed error. Positive bias = forecast systematically too high (overstock risk). Negative bias = systematically too low (stockout risk). Bias < ±5% is healthy. Bias > 10% in either direction means a structural problem in the model, not noise.

**Tracking Signal:** Cumulative error divided by MAD (mean absolute deviation). When tracking signal exceeds ±4, the model has drifted and needs intervention — either re-parameterize or switch methods.


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

Eval Harness Skill
Eval Workflow
2. Implement

Eval Workflow

1. Define (Before Coding)

2. Implement

Write code to pass the defined evals.


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

Python Testing Patterns
Fixtures
Using Multiple Fixtures

Fixture with Setup/Teardown

Fixture Scopes

Fixture with Parameters

Using Multiple Fixtures


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

Safety Guard — Prevent Destructive Operations

How It Works

Three modes of protection:

Mode 1: Careful Mode

Intercepts destructive commands before execution and warns:

When detected: shows what the command does, asks for confirmation, suggests safer alternative.


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
What's New in v2 (vs v1)

What's New in v2 (vs v1)

| Feature | v1 | v2 |
|---------|----|----|
| Observation | Stop hook (session end) | PreToolUse/PostToolUse (100% reliable) |
| Analysis | Main context | Background agent (Haiku) |
| Granularity | Full skills | Atomic "instincts" |
| Confidence | None | 0.3-0.9 weighted |
| Evolution | Direct to skill | Instincts -> cluster -> skill/command/agent |
| Sharing | None | Export/import instincts |


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

Laravel Plugin Discovery
Filtering Best Practices
By Health Score

Filtering Best Practices

By Health Score

| Health Band | Meaning |
|-------------|---------|
| `Healthy` | Active maintenance, recent updates |
| `Medium` | Occasional updates, may need attention |
| `Unhealthy` | Abandoned or infrequently maintained |
| `Unrated` | Not yet assessed |

**Recommendation**: Prefer `Healthy` packages for production applications.


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

When to Activate

Writing new features or functionality

Fixing bugs or issues

Refactoring existing code

Adding API endpoints

Creating new components


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

fal.ai Media Generation
Image Generation
Nano Banana 2 (Fast)

Image Generation

Nano Banana 2 (Fast)

Best for: quick iterations, drafts, text-to-image, image editing.


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

Laravel Security Best Practices
Core Security Settings

Core Security Settings

`APP_DEBUG=false` in production

`APP_KEY` must be set and rotated on compromise

Set `SESSION_SECURE_COOKIE=true` and `SESSION_SAME_SITE=lax` (or `strict` for sensitive apps)

Configure trusted proxies for correct HTTPS detection


Laravel Security Best Practices
Secrets and Credentials

Secrets and Credentials

Never commit secrets to source control

Use environment variables and secret managers

Rotate keys after exposure and invalidate sessions


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)

When to Use

On-device text generation for privacy-sensitive apps

Structured data extraction from user input (forms, natural language commands)

AI-assisted features that must work offline

Streaming UI that progressively shows generated content

Domain-specific AI actions via tool calling (search, compute, lookup)


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

Excluding Generated Code from Coverage

HTTP Handler Testing

Testing Commands

Best Practices

**DO:**

Write tests FIRST (TDD)

Use table-driven tests for comprehensive coverage

Test behavior, not implementation

Use `t.Helper()` in helper functions

Use `t.Parallel()` for independent tests

Clean up resources with `t.Cleanup()`

Use meaningful test names that describe the scenario

**DON'T:**

Test private functions directly (test through public API)

Use `time.Sleep()` in tests (use channels or conditions)

Ignore flaky tests (fix or remove them)

Mock everything (prefer integration tests when possible)

Skip error path testing


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
Continuous Mode

Output Template

Continuous Mode

Re-run phases on significant changes or every 30–60 minutes in long sessions

Keep a short loop: `mvn -T 4 test` + spotbugs for quick feedback

**Remember**: Fast feedback beats late surprises. Keep the gate strict—treat warnings as defects in production systems.


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

Perl Testing Patterns
Fixtures and Setup/Teardown

Directory Structure

prove Commands

.proverc Configuration

Fixtures and Setup/Teardown


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.

Guardrails

do not start from visual layout; start from operator questions

do not include every available metric just because it exists

do not mix health, throughput, and resource panels without structure

do not ship panels without titles, units, and sane thresholds


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

Java Coding Standards

Standards for readable, maintainable Java (17+) code in Spring Boot services.


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

How It Works

Run phases sequentially from environment checks through deployment readiness so each layer builds on the last.

Environment and Composer checks gate everything else; stop immediately if they fail.

Linting/static analysis should be clean before running full tests and coverage.

Security and migration reviews happen after tests so you verify behavior before data or release steps.

Build/deploy readiness and queue/scheduler checks are final gates; any failure blocks release.


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

Workflow

1. Start from the freshest billing evidence

Prefer live billing data. If the data is not live, state the snapshot timestamp explicitly.

Normalize the picture:

paid sales

active subscriptions

failed or incomplete checkouts

refunds

disputes

duplicate subscriptions


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

Knowledge Operations
Sync Operations
Cross-Source Knowledge Sync

Cross-Source Knowledge Sync

Pull knowledge from multiple sources into one place:

Claude/ChatGPT/Grok conversation exports

Browser bookmarks

GitHub activity events

Write status summary, commit and push


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.

Cold Email Structure

subject line: short and specific

opener: why this investor specifically

pitch: what the company does, why now, and what proof matters

ask: one concrete next step

sign-off: name, role, and one credibility anchor if needed


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

Hexagonal Architecture
How It Works
Step 6: Test per boundary

Step 6: Test per boundary

Unit test use cases with fake ports.

Integration test adapters with real infra dependencies.

E2E test user-facing flows through inbound adapters.


Persistent per-project memory for Claude Code. Auto-loads project context on session start, tracks sessions with git activity, and writes to native memory. Commands run deterministic Node.js scripts — behavior is consistent across model versions.

SessionStart Hook

The hook at `~/.claude/skills/ck/hooks/session-start.mjs` must be registered in
`~/.claude/settings.json` to auto-load project context on session start:

The hook injects ~100 tokens per session (compact 5-line summary). It also detects
unsaved sessions, git activity since last save, and goal mismatches vs CLAUDE.md.


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

API Design Patterns
Rate Limiting
Rate Limit Tiers

Headers

Rate Limit Tiers

| Tier | Limit | Window | Use Case |
|------|-------|--------|----------|
| Anonymous | 30/min | Per IP | Public endpoints |
| Authenticated | 100/min | Per user | Standard API access |
| Premium | 1000/min | Per API key | Paid API plans |
| Internal | 10000/min | Per service | Service-to-service |


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

Baseline coding conventions applicable across projects.

This skill is the shared floor, not the detailed framework playbook.

Use `frontend-patterns` for React, state, forms, rendering, and UI architecture.

Use `backend-patterns` or `api-design` for repository/service layers, endpoint design, validation, and server-specific concerns.

Use `rules/common/coding-style.md` when you need the shortest reusable rule layer instead of a full skill walkthrough.


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
3. SQL Injection Prevention

3. SQL Injection Prevention

FAIL: NEVER Concatenate SQL

FAIL: NEVER Concatenate SQL

PASS: ALWAYS Use Parameterized Queries

PASS: ALWAYS Use Parameterized Queries

Verification Steps

Verification Steps

[ ] All database queries use parameterized queries

[ ] No string concatenation in SQL

[ ] ORM/query builder used correctly

[ ] Supabase queries properly sanitized


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

What Each Tool Does Best

| Tool | Strength | Weakness |
|------|----------|----------|
| Claude / Codex | Organization, planning, code generation | Not the creative taste layer |
| FFmpeg | Deterministic cuts, batch processing, format conversion | No visual editing UI |
| Remotion | Programmable overlays, composable scenes, reusable templates | Learning curve for non-devs |
| Screen Studio | Polished screen recordings immediately | Only screen capture |
| ElevenLabs | Voice, narration, music, SFX | Not the center of the workflow |
| Descript / CapCut | Final pacing, captions, polish | Manual, not automatable |


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.

Examples

Practical, production-ready patterns for Dart and Flutter applications. Library-agnostic where possible, with explicit coverage of the most common ecosystem packages.


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

Branching Strategies

GitHub Flow (Simple, Recommended for Most)

Best for continuous deployment and small-to-medium teams.

**Rules:**

`main` is always deployable

Create feature branches from `main`

Open Pull Request when ready for review

After approval and CI passes, merge to `main`

Deploy immediately after merge


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

Output Format

Default structure:

executive summary

key findings

implications

risks and caveats

recommendation

sources


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

Eval Harness Skill
Product Evals (v1.8)
Grader Types

Grader Types

Code grader (deterministic assertions)

Rule grader (regex/schema constraints)

Model grader (LLM-as-judge rubric)

Human grader (manual adjudication for ambiguous outputs)


Security Review Skill
Security Checklist
4. Authentication & Authorization

4. Authentication & Authorization

JWT Token Handling

JWT Token Handling

Authorization Checks

Authorization Checks

Row Level Security (Supabase)

Row Level Security (Supabase)

Verification Steps

Verification Steps

[ ] Tokens stored in httpOnly cookies (not localStorage)

[ ] Authorization checks before sensitive operations

[ ] Row Level Security enabled in Supabase

[ ] Role-based access control implemented

[ ] Session management secure


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

Content-Hash File Cache Pattern
Key Design Decisions

Key Design Decisions

| Decision | Rationale |
|----------|-----------|
| SHA-256 content hash | Path-independent, auto-invalidates on content change |
| `{hash}.json` file naming | O(1) lookup, no index file needed |
| Service layer wrapper | SRP: extraction stays pure, cache is a separate concern |
| Manual JSON serialization | Full control over frozen dataclass serialization |
| Corruption returns `None` | Graceful degradation, re-processes on next run |
| `cache_dir.mkdir(parents=True)` | Lazy directory creation on first write |


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

Codebase Onboarding
How It Works
Phase 2: Architecture Mapping

Phase 2: Architecture Mapping

From the reconnaissance data, identify:

**Tech Stack**

Language(s) and version constraints

Framework(s) and major libraries

Database(s) and ORMs

Build tools and bundlers

CI/CD platform

**Architecture Pattern**

Monolith, monorepo, microservices, or serverless

Frontend/backend split or full-stack

API style: REST, GraphQL, gRPC, tRPC

**Key Directories**
Map the top-level directories to their purpose:

**Data Flow**
Trace one request from entry to response:

Where does a request enter? (router, handler, controller)

How is it validated? (middleware, schemas, guards)

Where is business logic? (services, models, use cases)

How does it reach the database? (ORM, raw queries, repositories)


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

Key Edge Cases

These are situations where standard playbook decisions lead to poor outcomes. Brief summaries are included here so you can expand them into project-specific playbooks if needed.

**Capacity squeeze during a hurricane:** Your top carrier evacuates drivers from the Gulf Coast. Spot rates triple. The temptation is to pay any rate to move freight. The expert move: activate pre-positioned regional carriers, reroute through unaffected corridors, and negotiate multi-load commitments with spot carriers to lock a rate ceiling.

**Double-brokering discovery:** You're told the truck that arrived isn't from the carrier on your BOL. The insurance chain may be broken and your freight is at higher risk. Do not accept the load if it hasn't departed. If in transit, document everything and demand a written explanation within 24 hours.

**Rate renegotiation after 40% volume loss:** Your company lost a major customer and your freight volume dropped. Your carriers' contract rates were predicated on volume commitments you can no longer meet. Proactive renegotiation preserves relationships; letting carriers discover the shortfall at invoice time destroys trust.

**Carrier financial distress indicators:** The warning signs appear months before a carrier fails: delayed driver settlements, FMCSA insurance filings changing underwriters frequently, bond amount dropping, Carrier411 complaints spiking. Reduce exposure incrementally — don't wait for the failure.

**Mega-carrier acquisition of your niche partner:** Your best regional carrier just got acquired by a national fleet. Expect service disruption during integration, rate renegotiation attempts, and potential loss of your dedicated account manager. Secure alternative capacity before the transition completes.

**Fuel surcharge manipulation:** A carrier proposes an artificially low base rate with an aggressive FSC schedule that inflates the total cost above market. Always model total cost across a range of diesel prices ($3.50, $4.00, $4.50/gal) to expose this tactic.

**Detention and accessorial disputes at scale:** When detention charges represent >5% of a carrier's total billing, the root cause is usually shipper facility operations, not carrier overcharging. Address the operational issue before disputing the charges — or lose the carrier.


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

Go Testing Patterns

Comprehensive Go testing patterns for writing reliable, maintainable tests following TDD methodology.


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

Spring Boot Security Review

Use when adding auth, handling input, creating endpoints, or dealing with secrets.


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

Common Pitfalls

Cursor disappears after navigation - re-inject it.

Video is too fast - add pauses.

Cursor is a dot instead of an arrow - use the SVG overlay.

Cursor teleports - move before clicking.

Select dropdowns look wrong - show the move, then pick the option.

Modals feel abrupt - add a read pause before confirming.

Video file path is random - copy it to a stable output name.

Selector failures are swallowed - never use silent catch blocks.

Field types were assumed - discover them first.

Features were assumed - inspect the actual UI before scripting.

Placeholder select values look real - watch for `"0"` and `"Select..."`.

Popups create separate videos - capture popup pages explicitly and merge later if needed.


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.

How It Works

Use this as a checklist-plus-pattern library. Review every user entrypoint against the categories below and prefer the hardened examples over hand-rolled variants.


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

Hexagonal Architecture
Migration Playbook
Refactoring Existing Systems

Refactoring Existing Systems

**Strangler approach**: keep current endpoints, route one use case at a time through new ports/adapters.

**No big-bang rewrites**: migrate per feature slice and preserve behavior with characterization tests.

**Facade first**: wrap legacy services behind outbound ports before replacing internals.

**Composition freeze**: centralize wiring early so new dependencies do not leak into domain/use-case layers.

**Slice selection rule**: prioritize high-churn, low-blast-radius flows first.

**Rollback path**: keep a reversible toggle or route switch per migrated slice until production behavior is verified.


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

SwiftUI Patterns
State Management
Property Wrapper Selection

State Management

Property Wrapper Selection

Choose the simplest wrapper that fits:

| Wrapper | Use Case |
|---------|----------|
| `@State` | View-local value types (toggles, form fields, sheet presentation) |
| `@Binding` | Two-way reference to parent's `@State` |
| `@Observable` class + `@State` | Owned model with multiple properties |
| `@Observable` class (no wrapper) | Read-only reference passed from parent |
| `@Bindable` | Two-way binding to an `@Observable` property |
| `@Environment` | Shared dependencies injected via `.environment()` |


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.

Source Priority

Use the strongest real source set available, in this order:

recent original X posts and threads

articles, essays, memos, launch notes, or newsletters

real outbound emails or DMs that worked

product docs, changelogs, README framing, and site copy

Do not use generic platform exemplars as source material.


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
Rule File Format
Frontmatter Fields

Rule File Format

Basic Structure

Frontmatter Fields

| Field | Required | Values | Description |
|-------|----------|--------|-------------|
| name | Yes | kebab-case string | Unique identifier (verb-first: warn-*, block-*, require-*) |
| enabled | Yes | true/false | Toggle without deleting |
| event | Yes | bash/file/stop/prompt/all | Which hook event triggers this |
| action | No | warn/block | warn (default) shows message; block prevents operation |
| pattern | Yes* | regex string | Pattern to match (*or use conditions for complex rules) |


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

When to Use

Before starting any feature — validate the "why"

Weekly product review — are we building the right thing?

When stuck choosing between features

Before a launch — sanity check the user journey

When converting a vague idea into a product brief before engineering planning starts


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

Design System — Generate & Audit Visual Systems

Mode 2: Visual Audit

Scores your UI across 10 dimensions (0-10 each):

Each dimension gets a score, specific examples, and a fix with exact file:line.


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.

Related Skills

`video-editing` for final polish

`remotion-video-creation` for motion-heavy post-processing or compositing

`content-engine` when the animation is part of a broader launch


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

Coding Standards & Best Practices
Code Quality Principles
2. KISS (Keep It Simple, Stupid)

2. KISS (Keep It Simple, Stupid)

Simplest solution that works

Avoid over-engineering

No premature optimization

Easy to understand > clever code


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

Benchmark — Performance Baseline & Regression Detection

Integration

CI: run `/benchmark compare` on every PR

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

Pair with `/browser-qa` for full pre-ship checklist


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

Use this skill when the user suspects the ECC Tools GitHub App is burning cost, over-creating PRs, bypassing usage limits, or routing free users into premium analysis paths.

This is a focused operator workflow for the sibling [ECC-Tools](../../ECC-Tools) repo. It is not a generic billing skill and it is not a repo-wide code review pass.


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.

Model Discovery

Find models for specific tasks:

Tips

Use `seed` for reproducible results when iterating on prompts

Start with lower-cost models (Nano Banana 2) for prompt iteration, then switch to Pro for finals

For video, keep prompts descriptive but concise — focus on motion and scene

Image-to-video produces more controlled results than pure text-to-video

Check `estimate_cost` before running expensive video generations


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

Django Development Patterns
Django REST Framework Patterns

Model Best Practices

QuerySet Best Practices

Manager Methods

Django REST Framework Patterns


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.

4. Launch three independent voices in parallel

Each subagent gets:

the decision question

compact context if needed

a strict role

no unnecessary conversation history

Prompt shape:

Role emphasis:

Skeptic: challenge framing, question assumptions, propose the simplest credible alternative

Pragmatist: optimize for speed, simplicity, and real-world execution

Critic: surface downside risk, edge cases, and reasons the plan could fail


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

Ktor Server Patterns
Quick Reference: Ktor Patterns

Configuration

application.yaml

Reading Config

Quick Reference: Ktor Patterns

| Pattern | Description |
|---------|-------------|
| `route("/path") { get { } }` | Route grouping with DSL |
| `call.receive<T>()` | Deserialize request body |
| `call.respond(status, body)` | Send response with status |
| `call.parameters["id"]` | Read path parameters |
| `call.request.queryParameters["q"]` | Read query parameters |
| `install(Plugin) { }` | Install and configure plugin |
| `authenticate("name") { }` | Protect routes with auth |
| `by inject<T>()` | Koin dependency injection |
| `testApplication { }` | Integration testing |

**Remember**: Ktor is designed around Kotlin coroutines and DSLs. Keep routes thin, push logic to services, and use Koin for dependency injection. Test with `testApplication` for full integration coverage.


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

PPT / PPTX Conversion

For PowerPoint conversion:

Prefer `python3` with `python-pptx` to extract text, images, and notes.

If `python-pptx` is unavailable, ask whether to install it or fall back to a manual/export-based workflow.

Preserve slide order, speaker notes, and extracted assets.

After extraction, run the same style-selection workflow as a new presentation.

Keep conversion cross-platform. Do not rely on macOS-only tools when Python can do the job.


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.

Best Practices

**Independent tasks only.** Don't parallelize tasks that depend on each other's output.

**Clear boundaries.** Each pane should work on distinct files or concerns.

**Merge strategically.** Review pane output before merging to avoid conflicts.

**Use git worktrees.** For file-conflict-prone work, use separate worktrees per pane.

**Resource awareness.** Each pane uses API tokens — keep total panes under 5-6.


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

Agentic Engineering
Review Focus for AI-Generated Code

Review Focus for AI-Generated Code

Prioritize:

invariants and edge cases

error boundaries

security and auth assumptions

hidden coupling and rollout risk

Do not waste review cycles on style-only disagreements when automated format/lint already enforce style.


fal.ai Media Generation

Generate images, videos, and audio using fal.ai models via MCP.


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

Prompt Optimizer
Examples
Example 2: Moderate English Prompt

Example 2: Moderate English Prompt

**User input:**

**Phase 0 detects:** `go.mod` with Go 1.22, Chi router

**Optimized Prompt (Full):**


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

GateGuard — Fact-Forcing Pre-Action Gate

Core Concept

LLM self-evaluation doesn't work. Ask "did you violate any policies?" and the answer is always "no." This is verified experimentally.

But asking "list every file that imports this module" forces the LLM to run Grep and Read. The investigation itself creates context that changes the output.

**Three-stage gate:**

No competitor does all three. Most stop at deny.


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

VideoDB Skill
Examples
Canonical prompts

Examples

Canonical prompts

"Start desktop capture and alert when a password field appears."

"Record my session and produce an actionable summary when it ends."

"Ingest this file and return a playable stream link."

"Index this folder and find every scene with people, return timestamps."

"Generate subtitles, burn them in, and add light background music."

"Connect this RTSP URL and alert when a person enters the zone."


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

Rust Development Patterns
Anti-Patterns to Avoid

Anti-Patterns to Avoid

**Remember**: If it compiles, it's probably correct — but only if you avoid `unwrap()`, minimize `unsafe`, and let the type system work for you.


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

API Design Patterns
Pagination
Offset-Based (Simple)

Error Response

Response Envelope Variants

Pagination

Offset-Based (Simple)

**Pros:** Easy to implement, supports "jump to page N"
**Cons:** Slow on large offsets (OFFSET 100000), inconsistent with concurrent inserts


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

Philosophy

Eval-Driven Development treats evals as the "unit tests of AI development":

Define expected behavior BEFORE implementation

Run evals continuously during development

Track regressions with each change

Use pass@k metrics for reliability measurement


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

DSL Queries

Basic CRUD

Advanced Queries

Pagination

Batch Operations

DAO Pattern


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

Plankton Code Quality Skill
How It Works
What the Main Agent Sees

What the Main Agent Sees

| Scenario | Agent sees | Hook exit |
|----------|-----------|-----------|
| No violations | Nothing | 0 |
| All fixed by subprocess | Nothing | 0 |
| Violations remain after subprocess | `[hook] N violation(s) remain` | 2 |
| Advisory (duplicates, old tooling) | `[hook:advisory] ...` | 0 |

The main agent only sees issues the subprocess couldn't fix. Most quality problems are resolved transparently.


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.

When to Activate

Implementing authentication or authorization

Handling user input or file uploads

Creating new API endpoints

Working with secrets or credentials

Implementing payment features

Storing or transmitting sensitive data

Integrating third-party APIs


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

Compose Multiplatform Patterns
When to Activate

When to Activate

Building Compose UI (Jetpack Compose or Compose Multiplatform)

Managing UI state with ViewModels and Compose state

Implementing navigation in KMP or Android projects

Designing reusable composables and design systems

Optimizing recomposition and rendering performance


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
How It Works

How It Works

This skill enforces idiomatic Kotlin conventions across seven key areas: null safety using the type system and safe-call operators, immutability via `val` and `copy()` on data classes, sealed classes and interfaces for exhaustive type hierarchies, structured concurrency with coroutines and `Flow`, extension functions for adding behaviour without inheritance, type-safe DSL builders using `@DslMarker` and lambda receivers, and Gradle Kotlin DSL for build configuration.


Eval Harness Skill

A formal evaluation framework for Claude Code sessions, implementing eval-driven development (EDD) principles.


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

Spring Boot Security Review
Logging and PII

Logging and PII

Never log secrets, tokens, passwords, or full PAN data

Redact sensitive fields; use structured JSON logging


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.

Decision Frameworks

Disposition Routing by Category and Condition

| Category | Grade A | Grade B | Grade C | Grade D |
|---|---|---|---|---|
| Consumer Electronics | Restock (test first) | Open box / Renewed | Refurb if ROI > 40%, else liquidate | Parts harvest or e-waste |
| Apparel | Restock if tags on | Repackage / outlet | Liquidate by weight | Textile recycling |
| Home & Furniture | Restock | Open box with discount | Liquidate (local, avoid shipping) | Donate or destroy |
| Health & Beauty | Restock if sealed | Destroy (regulation) | Destroy | Destroy |
| Books & Media | Restock | Restock (discount) | Liquidate | Recycle |
| Sporting Goods | Restock | Open box | Refurb if cost < 25% value | Parts or donate |
| Toys & Games | Restock if sealed | Open box | Liquidate | Donate (if safety-compliant) |


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

Next.js and Turbopack

Next.js 16+ uses Turbopack by default for local development: an incremental bundler written in Rust that significantly speeds up dev startup and hot updates.


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

Codebase Onboarding
Examples
Example 3: Enhance existing CLAUDE.md

Example 3: Enhance existing CLAUDE.md

**User**: "Update the CLAUDE.md with current project conventions"
**Action**: Read existing CLAUDE.md, run Phases 1-3, merge new findings
**Output**: Updated `CLAUDE.md` with additions clearly marked


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

Frontend Slides
Workflow
2. Discover Content

2. Discover Content

Ask only the minimum needed:

purpose: pitch, teaching, conference talk, internal update

length: short (5-10), medium (10-20), long (20+)

content state: finished copy, rough notes, topic only

If the user has content, ask them to paste it before styling.


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

JPA/Hibernate Patterns
Connection Pooling (HikariCP)

Connection Pooling (HikariCP)

Recommended properties:

For PostgreSQL LOB handling, add:


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.

Downstream Use

Use this skill before or inside:

`content-engine`

`crosspost`

`lead-intelligence`

article or launch writing

cold or warm outbound across X, LinkedIn, and email

If another skill already has a partial voice capture section, this skill is the canonical source of truth.


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

Agent-powered lead intelligence pipeline that finds, scores, and reaches high-value contacts through social graph analysis and warm path discovery.


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

龙虾灵魂锻造炉 对话语气指南 原则

对话语气指南

本 Skill 以**龙虾创世神亚当**的视角与用户对话。每个步骤的确认/引导不是机械提问，而是带有创世神个性的反馈。

原则

**先点评再提问**：不要直接问"满意吗"，先说出你看到了什么、为什么觉得有趣（或有问题）

**每次表达不同**：不要重复同一句话模式，每步的语气应有变化

**有态度但不强迫**：可以表达偏好（"我个人更喜欢这个"），但决定权永远在用户手里

**用创世的隐喻**：锻造、熔炼、赋予灵魂、点燃、注入……不要用"生成""创建"这种工具语言


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

ClickHouse Analytics Patterns

ClickHouse-specific patterns for high-performance analytics and data engineering.


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

Go Development Patterns
Struct Design
Functional Options Pattern

Package Naming

Avoid Package-Level State

Struct Design

Functional Options Pattern


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

Manual: step-by-step control

`create_project(name="My Project")` → returns `project_id`.

`create_mission(project_id=project_id, title="...", prompt="...", auto_dispatch=true)` for the first (root) mission → capture `root_mission_id`.
`create_mission(project_id=project_id, title="...", prompt="...", auto_dispatch=true, depends_on=["<root_mission_id>"])` for each subsequent task.

`dispatch_mission(mission_id=...)` on the first mission to start the chain.

`get_report(mission_id=...)` when done.


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

Deployment Patterns
CI/CD Pipeline
Pipeline Stages

Docker Best Practices

CI/CD Pipeline

GitHub Actions (Standard Pipeline)

Pipeline Stages


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

E2E Testing Patterns
Test Report Template

Artifact Management

Screenshots

Traces

Video

CI/CD Integration

Test Report Template


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)

Anti-Patterns to Avoid

Creating sessions without checking `model.availability` first

Sending inputs exceeding the 4,096 token context window

Attempting concurrent requests on a single session

Using `.output` instead of `.content` to access response data

Parsing raw string responses when `@Generable` structured output would work

Building complex multi-step logic in a single prompt — break into multiple focused prompts

Assuming the model is always available — device eligibility and settings vary


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.

Model Selection

| Model | ID | Best For |
|-------|-----|----------|
| Opus 4.1 | `claude-opus-4-1` | Complex reasoning, architecture, research |
| Sonnet 4 | `claude-sonnet-4-0` | Balanced coding, most development tasks |
| Haiku 3.5 | `claude-3-5-haiku-latest` | Fast responses, high-volume, cost-sensitive |

Default to Sonnet 4 unless the task requires deep reasoning (Opus) or speed/cost optimization (Haiku). For production, prefer pinned snapshot IDs over aliases.


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.

4. Report with explicit evidence boundaries

For important claims, say whether they are:

sourced facts

user-supplied context

inference

recommendation

Freshness-sensitive answers should include concrete dates.


Verification Loop Skill

A comprehensive verification system for Claude Code sessions.


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

Santa Method
Phase Details
Phase 1: Make a List (Generate)

Architecture

Phase Details

Phase 1: Make a List (Generate)

Execute the primary task. No changes to your normal generation workflow. Santa Method is a post-generation verification layer, not a generation strategy.


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

Compose Multiplatform Patterns
Navigation
Dialog and Bottom Sheet Navigation

Dialog and Bottom Sheet Navigation

Use `dialog()` and overlay patterns instead of imperative show/hide:


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

Customs & Trade Compliance
Core Knowledge
Duty Optimization

Duty Optimization

**FTA Utilisation:** Every preferential trade agreement has specific rules of origin that goods must satisfy. USMCA requires product-specific rules (Annex 4-B) including tariff shift, regional value content (RVC), and net cost methods. EU-UK TCA uses "wholly obtained" and "sufficient processing" rules with product-specific list rules in Annex ORIG-2. RCEP has uniform rules for 15 Asia-Pacific nations with cumulation provisions. AfCFTA allows 60% cumulation across member states.

**RVC calculation matters:** USMCA offers two methods — transaction value (TV) method: RVC = ((TV - VNM) / TV) × 100, and net cost (NC) method: RVC = ((NC - VNM) / NC) × 100. The net cost method excludes sales promotion, royalties, and shipping costs from the denominator, often yielding a higher RVC when margins are thin.

**Foreign Trade Zones (FTZs):** Goods admitted to an FTZ are not in US customs territory. Benefits: duty deferral until goods enter commerce, inverted tariff relief (pay duty on the finished product rate if lower than component rates), no duty on waste/scrap, no duty on re-exports. Zone-to-zone transfers maintain privileged foreign status.

**Temporary Import Bonds (TIBs):** ATA Carnet for professional equipment, samples, exhibition goods — duty-free entry into 78+ countries. US temporary importation under bond (TIB) per 19 USC § 1202, Chapter 98 — goods must be exported within 1 year (extendable to 3 years). Failure to export triggers liquidation at full duty plus bond premium.

**Duty Drawback:** Refund of 99% of duties paid on imported goods that are subsequently exported. Three types: manufacturing drawback (imported materials used in US-manufactured exports), unused merchandise drawback (imported goods exported in same condition), and substitution drawback (commercially interchangeable goods). Claims must be filed within 5 years of import. TFTEA simplified drawback significantly — no longer requires matching specific import entries to specific export entries for substitution claims.


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

Links

Repository: [github.com/joaquinhuigomez/agent-eval](https://github.com/joaquinhuigomez/agent-eval)


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

4. Write the `.tour`

Write to:

Keep the path deterministic and readable.

5. Validate

Before finishing:

every referenced path exists

every line or selection is valid

the first step is anchored to a real file or directory

the tour tells a coherent story rather than listing files


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

Swift Protocol-Based Dependency Injection for Testing

When to Use

Any Swift code that touches file system, network, or external APIs

Testing error handling paths that are hard to trigger in real environments

Building modules that need to work in app, test, and SwiftUI preview contexts

Apps using Swift concurrency (actors, structured concurrency) that need testable architecture


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

GAN-Style Harness Skill

Inspired by [Anthropic's Harness Design for Long-Running Application Development](https://www.anthropic.com/engineering/harness-design-long-running-apps) (March 24, 2026)

A multi-agent harness that separates **generation** from **evaluation**, creating an adversarial feedback loop that drives quality far beyond what a single agent can achieve.


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

Review Checklist

First SSR render and hydrated client render produce the same markup

Page data uses `useFetch` or `useAsyncData`, not top-level `$fetch`

Non-critical data is lazy and has explicit loading UI

Route rules match the page's SEO and freshness requirements

Heavy interactive islands are lazy-loaded or lazily hydrated


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

Complexity Tiers

Tier 1: isolated file edits, deterministic tests

Tier 2: multi-file behavior changes, moderate integration risk

Tier 3: schema/auth/perf/security changes


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

Testing Commands

Best Practices

**DO:**

Write tests FIRST (TDD)

Use `#[cfg(test)]` modules for unit tests

Test behavior, not implementation

Use descriptive test names that explain the scenario

Prefer `assert_eq!` over `assert!` for better error messages

Use `?` in tests that return `Result` for cleaner error output

Keep tests independent — no shared mutable state

**DON'T:**

Use `#[should_panic]` when you can test `Result::is_err()` instead

Mock everything — prefer integration tests when feasible

Ignore flaky tests — fix or quarantine them

Use `sleep()` in tests — use channels, barriers, or `tokio::time::pause()`

Skip error path testing


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

Plankton Code Quality Skill
ECC v1.8 Additions
Language Gate Table

ECC v1.8 Additions

Copyable Hook Profile

Set strict quality behavior:

Language Gate Table

TypeScript/JavaScript: Biome preferred, Prettier fallback

Python: Ruff format/check

Go: gofmt


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.

Escalation Protocols

| Trigger | Action | Timeline |
|---|---|---|
| Wholesale prices exceed 2× budget assumption for 5+ consecutive days | Notify finance, evaluate hedge position, consider emergency fixed-price procurement | Within 24 hours |
| Supplier credit downgrade below investment grade | Review contract termination provisions, assess replacement supplier options | Within 48 hours |
| Utility rate case filed with >10% proposed increase | Engage regulatory counsel, evaluate intervention filing | Within 1 week |
| Demand peak exceeds ratchet threshold by >15% | Investigate root cause with operations, model billing impact, evaluate mitigation | Within 24 hours |
| PPA developer misses REC delivery by >10% of contracted volume | Issue notice of default per contract, evaluate replacement REC procurement | Within 5 business days |
| Capacity tag (PLC) increases >20% from prior year | Analyze coincident peak intervals, model capacity charge impact, develop peak response plan | Within 2 weeks |
| Regulatory action threatens contract enforceability | Engage legal counsel, evaluate contract force majeure provisions | Within 48 hours |
| Grid emergency / rolling blackouts affecting facilities | Activate emergency load curtailment, coordinate with operations, document for insurance | Immediate |


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

Laravel Security Best Practices
Security Headers

Encrypted Attributes

Use encrypted casts for sensitive columns at rest.

Security Headers

Add CSP, HSTS, and frame protection where appropriate

Use trusted proxy configuration to enforce HTTPS redirects

Example middleware to set headers:


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
ElevenLabs (via API, no MCP)

ThinkSound (Video-to-Audio)

Generate matching audio from video content.

ElevenLabs (via API, no MCP)

For professional voice synthesis, use ElevenLabs directly:


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

Deployment Patterns
Production Readiness Checklist
Operations

Operations

[ ] Rollback plan documented and tested

[ ] Database migration tested against production-sized data

[ ] Runbook for common failure scenarios

[ ] On-call rotation and escalation path defined


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
6. Verify the result

6. Verify the result

After the plan is applied, verify:

every DAILY file exists where expected

stale language rules were not left active

incompatible hooks were not installed

the resulting install actually matches the repo stack

Return a compact report with:

DAILY count

LIBRARY count

removed stale surfaces

open questions


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.

When to Use

Reading ERC-20 balances in Python, TypeScript, or Solidity

Calculating fiat values from on-chain balances

Comparing token amounts across multiple EVM chains

Handling bridged assets

Building portfolio trackers, bots, or aggregators


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

Eval Harness Skill
Product Evals (v1.8)
pass@k Guidance

pass@k Guidance

`pass@1`: direct reliability

`pass@3`: practical reliability under controlled retries

`pass^3`: stability test (all 3 runs must pass)

Recommended thresholds:

Capability evals: pass@3 >= 0.90

Regression evals: pass^3 = 1.00 for release-critical paths


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
What's New in v2.1

What's New in v2.1

| Feature | v2.0 | v2.1 |
|---------|------|------|
| Storage | Global (~/.claude/homunculus/) | Project-scoped (projects/<hash>/) |
| Scope | All instincts apply everywhere | Project-scoped + global |
| Detection | None | git remote URL / repo path |
| Promotion | N/A | Project → global when seen in 2+ projects |
| Commands | 4 (status/evolve/export/import) | 6 (+promote/projects) |
| Cross-project | Contamination risk | Isolated by default |


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

Compose Multiplatform Patterns
State Management
ViewModel + Single State Object

State Management

ViewModel + Single State Object

Use a single data class for screen state. Expose it as `StateFlow` and collect in Compose:


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

Security Bounty Hunter
Example Triage Loop

Example Triage Loop

Then manually filter:

drop tests, demos, fixtures, vendored code

drop local-only or non-reachable paths

keep only findings with a clear network or user-controlled route


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.

Banned Patterns

Delete and rewrite any of these:

"In today's rapidly evolving landscape"

"game-changer", "cutting-edge", "revolutionary"

"here's why this matters" as a standalone bridge

fake vulnerability arcs

a closing question added only to juice engagement

biography padding that does not move the argument

generic AI throat-clearing that delays the point


Operate and extend NanoClaw v2, ECC's zero-dependency session-aware REPL built on claude -p.

Extension Rules

keep zero external runtime dependencies

preserve markdown-as-database compatibility

keep command handlers deterministic and local


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
RCA Method Selection

RCA Method Selection

**Single-event, simple causal chain:** 5 Whys. Budget: 1-2 hours.

**Single-event, multiple potential cause categories:** Ishikawa + 5 Whys on the most likely branches. Budget: 4-8 hours.

**Recurring issue, process-related:** 8D with full team. Budget: 20-40 hours across D0-D8.

**Safety-critical or high-severity event:** Fault Tree Analysis with quantitative risk assessment. Budget: 40-80 hours. Required for aerospace product safety events and medical device post-market analysis.

**Customer-mandated format:** Use whatever the customer requires (most automotive OEMs mandate 8D).


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

Android Clean Architecture
Error Handling
Result/Try Pattern

Hilt (Android-only)

Error Handling

Result/Try Pattern

Use `Result<T>` or a custom sealed type for error propagation:


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.

Core Concepts

**Domain model**: Business rules and entities/value objects. No framework imports.

**Use cases (application layer)**: Orchestrate domain behavior and workflow steps.

**Inbound ports**: Contracts describing what the application can do (commands/queries/use-case interfaces).

**Outbound ports**: Contracts for dependencies the application needs (repositories, gateways, event publishers, clock, UUID, etc.).

**Adapters**: Infrastructure and delivery implementations of ports (HTTP controllers, DB repositories, queue consumers, SDK wrappers).

**Composition root**: Single wiring location where concrete adapters are bound to use cases.

Outbound port interfaces usually live in the application layer (or in domain only when the abstraction is truly domain-level), while infrastructure adapters implement them.

Dependency direction is always inward:

Adapters -> application/domain

Application -> port interfaces (inbound/outbound contracts)

Domain -> domain-only abstractions (no framework or infrastructure dependencies)

Domain -> nothing external


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

Key Design Decisions

| Decision | Rationale |
|----------|-----------|
| GlassEffectContainer wrapping | Performance optimization, enables morphing between glass elements |
| `spacing` parameter | Controls merge distance — fine-tune how close elements must be to blend |
| `@Namespace` + `glassEffectID` | Enables smooth morphing transitions on view hierarchy changes |
| `interactive()` modifier | Explicit opt-in for touch/pointer reactions — not all glass should respond |
| UIGlassContainerEffect in UIKit | Same container pattern as SwiftUI for consistency |
| Accented rendering mode in widgets | System applies tinted glass when user selects tinted Home Screen |


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

Best Practices

Always run the full pipeline (fork → sanitize → package) for new releases

The staging directory persists until explicitly cleaned up — use it for review

Re-run the sanitizer after any manual fixes before publishing

Parameterize secrets rather than deleting them — preserve project functionality


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

Full Mode (agent)

For non-trivial functionality, launch the researcher agent:

Search Shortcuts by Category


Continuous Learning v2.1 - Instinct
Instinct Promotion (Project -> Global)

Instinct Promotion (Project -> Global)

When the same instinct appears in multiple projects with high confidence, it's a candidate for promotion to global scope.

**Auto-promotion criteria:**

Same instinct ID in 2+ projects

Average confidence >= 0.8

**How to promote:**

The `/evolve` command also suggests promotion candidates.


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

When to Use

New features or endpoints

Bug fixes or refactors

Adding data access logic or security rules


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
Workflow
1. Define Tasks

Workflow

1. Define Tasks

Create a `tasks/` directory with YAML files, one per task:


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.

Testing

File Organization

**Location**: `.claude/` directory in project root

**Naming**: `.claude/hookify.{descriptive-name}.local.md`

**Gitignore**: Add `.claude/*.local.md` to `.gitignore`


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

Terminal Ops
Workflow
4. Report exact execution state

4. Report exact execution state

Use exact status words:

inspected

changed locally

verified locally

committed

pushed

blocked


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

Build platform-native content without flattening the author's real voice into platform slop.


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

Canary Watch — Post-Deploy Monitoring
How It Works

How It Works

Monitors a deployed URL for regressions. Runs in a loop until stopped or until the watch window expires.


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

AI Regression Testing
Sandbox-Mode API Testing
Writing Regression Tests

Setup (Vitest + Next.js App Router)

Test Helper for Next.js API Routes

Writing Regression Tests

The key principle: **write tests for bugs that were found, not for code that works**.


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

Prompt Optimizer
When to Use
Do Not Use When

Do Not Use When

User wants the task done directly (just execute it)

User says "优化代码", "优化性能", "optimize this code", "optimize performance" — these are refactoring tasks, not prompt optimization

User is asking about ECC configuration (use `configure-ecc` instead)

User wants a skill inventory (use `skill-stocktake` instead)

User says "just do it" or "直接做"


Integration Points

With planner agent

The planner should invoke researcher before Phase 1 (Architecture Review):

Researcher identifies available tools

Planner incorporates them into the implementation plan

Avoids "reinventing the wheel" in the plan


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

Audit Inputs

Inspect only the files and settings needed to answer the question well:

Repo surface

`package.json`, lockfiles, language markers, framework config, `README.md`

`.mcp.json`, `.lsp.json`, `.claude/settings*.json`, `.codex/*`

`AGENTS.md`, `CLAUDE.md`, install manifests, hook configs

Environment surface

`.env*` files in the active repo and obvious adjacent ECC workspaces

Surface only key names such as `STRIPE_API_KEY`, `TWILIO_AUTH_TOKEN`, `FAL_KEY`

Connected tool surface

Installed plugins, enabled connectors, MCP servers, LSPs, and app integrations

ECC surface

Existing skills, commands, hooks, agents, and install modules that already cover the need


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

Python Testing Patterns
Parametrization
Basic Parametrization

Autouse Fixtures

Conftest.py for Shared Fixtures

Parametrization

Basic Parametrization


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

JWT Authentication

Auth Routes

Status Pages (Error Handling)

CORS Configuration


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
Demand Charge Mitigation ROI

Demand Charge Mitigation ROI

Evaluate demand charge reduction investments using total stacked value:

Calculate current demand charges: Peak kW × demand rate × 12 months.

Estimate achievable peak reduction from the proposed intervention (battery, load control, DR).

Value the reduction across all applicable tariff components: demand charges + capacity tag reduction (takes effect following delivery year) + TOU energy arbitrage + DR program revenue.

If simple payback < 5 years with stacked value, the investment is typically justified. If 5–8 years, it's marginal and depends on capital availability. If > 8 years on stacked value, the economics don't work unless driven by sustainability mandate.


Interactive agent picker for composing and dispatching parallel teams

Team Builder
How It Works
Step 2: Present Domain Menu

Step 2: Present Domain Menu

Skip domains with zero agents (empty directories)

Show agent count per domain


Phase 2: Benchmark Against Official and Installed Surfaces

Compare the workspace against:

official Claude plugins that overlap with setup, review, docs, design, or workflow quality

locally installed plugins in Claude or Codex

the user's currently connected app surfaces

Do not just list names. For each comparison, answer:

what they actually do

whether ECC already has parity

whether ECC only has primitives

whether ECC is missing the workflow entirely


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.

When to Activate

writing a cold email to an investor

drafting a warm intro request

sending follow-ups after a meeting or no response

writing investor updates during a process

tailoring outreach based on fund thesis or partner fit


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

Kotlin Coroutines & Flows
When to Activate

When to Activate

Writing async code with Kotlin coroutines

Using Flow, StateFlow, or SharedFlow for reactive data

Handling concurrent operations (parallel loading, debounce, retry)

Testing coroutines and Flows

Managing coroutine scopes and cancellation


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

Posting Order

Default:

post the strongest native version first

adapt for the secondary platforms

stagger timing only if the user wants sequencing help

Do not add cross-platform references unless useful. Most of the time, the post should stand on its own.


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

Step Types

Content

Use sparingly, usually only for a closing step:

Do not make the first step content-only.


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
Git Configuration
Essential Configs

Semantic Versioning

Creating Releases

Changelog Generation

Git Configuration

Essential Configs


Prompt Optimizer
Examples
Trigger Examples

Examples

Trigger Examples

"Optimize this prompt for ECC"

"Rewrite this prompt so Claude Code uses the right commands"

"帮我优化这个指令"

"How should I prompt ECC for this task?"


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

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

Rule of Zero

Rule of Five

Class Hierarchy

Anti-Patterns

Calling virtual functions in constructors/destructors (C.82)

Using `memset`/`memcpy` on non-trivial types (C.90)

Providing different default arguments for virtual function and overrider (C.140)

Making data members `const` or references, which suppresses move/copy (C.12)


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

Laravel Security Best Practices
SQL Injection Prevention

SQL Injection Prevention

Use Eloquent or query builder parameter binding

Avoid raw SQL unless strictly necessary


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

When to Activate

Building SwiftUI views and managing state (`@State`, `@Observable`, `@Binding`)

Designing navigation flows with `NavigationStack`

Structuring view models and data flow

Optimizing rendering performance for lists and complex layouts

Working with environment values and dependency injection in SwiftUI


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

Java Coding Standards
Generics and Type Safety

Generics and Type Safety

Avoid raw types; declare generic parameters

Prefer bounded generics for reusable utilities


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

Guidelines

Always confirm the plan with the user before dispatching, unless they said to go ahead.

Include mission titles and IDs when reporting status.

If a mission fails, read its report before retrying.

Check `get_dashboard()` for agent slot availability before bulk dispatching.

Mission dependencies form a DAG — do not create circular dependencies.

Each agent runs in an isolated git worktree and auto-merges on completion. If a merge conflict occurs, the changes remain on the agent's worktree branch for manual resolution.

When manually creating missions, always set `auto_dispatch=true` if you want them to trigger automatically when dependencies complete. Without this flag, missions stay in `draft` status.


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

Escalation Chain

Analyst → Transportation Manager (48 hours) → Director of Transportation (1 week) → VP Supply Chain (persistent issue or >$100K exposure)


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

Bottleneck Management

**Identifying the true constraint vs. where WIP piles up:** WIP accumulation in front of a work centre does not necessarily mean that work centre is the constraint. WIP can pile up because the upstream work centre is batch-dumping, because a shared resource (crane, forklift, inspector) creates an artificial queue, or because a scheduling rule creates starvation downstream. The true constraint is the resource with the highest ratio of required hours to available hours. Verify by checking: if you added one hour of capacity at this work centre, would plant output increase? If yes, it is the constraint.

**Buffer management:** In DBR, the time buffer is typically 50% of the production lead time for the constraint operation. Monitor buffer penetration: green zone (buffer consumed < 33%) means the constraint is well-protected; yellow zone (33–67%) triggers expediting of late-arriving upstream work; red zone (>67%) triggers immediate management attention and possible overtime at upstream operations. Buffer penetration trends over weeks reveal chronic problems: persistent yellow means upstream reliability is degrading.

**Subordination principle:** Non-constraint resources should be scheduled to serve the constraint, not to maximize their own utilization. Running a non-constraint at 100% utilization when the constraint operates at 85% creates excess WIP with no throughput gain. Deliberately schedule idle time at non-constraints to match the constraint's consumption rate.

**Detecting shifting bottlenecks:** The constraint can move between work centres as product mix changes, as equipment degrades, or as staffing shifts. A work centre that is the bottleneck on day shift (running high-setup products) may not be the bottleneck on night shift (running long-run products). Monitor utilization ratios weekly by product mix. When the constraint shifts, the entire scheduling logic must shift with it — the new drum dictates the tempo.


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

Plankton Code Quality Skill
Environment Overrides

Environment Overrides

| Variable | Purpose |
|----------|---------|
| `HOOK_SKIP_SUBPROCESS=1` | Skip Phase 3, report violations directly |
| `HOOK_SUBPROCESS_TIMEOUT=N` | Override tier timeout |
| `HOOK_DEBUG_MODEL=1` | Log model selection decisions |
| `HOOK_SKIP_PM=1` | Bypass package manager enforcement |


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

Workspace Surface Audit
Audit Process
Phase 1: Inventory What Exists

Audit Process

Phase 1: Inventory What Exists

Produce a compact inventory:

active harness targets

installed plugins and connected apps

configured MCP servers

configured LSP servers

env-backed services implied by key names

existing ECC skills already relevant to the workspace

If a surface exists only as a primitive, call that out. Example:

"Stripe is available via connected app, but ECC lacks a billing-operator skill"

"Google Drive is connected, but there is no ECC-native Google Workspace operator workflow"


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

Comprehensive, library-agnostic checklist for reviewing Flutter/Dart applications. These principles apply regardless of which state management solution, routing library, or DI framework is used.


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.

When to Use

user says "fix", "debug", "run this", "check the repo", or "push it"

the task depends on command output, git state, test results, or a verified local fix

the answer must distinguish changed locally, verified locally, committed, and pushed


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

Google Workspace Ops

This skill is for operating shared docs, spreadsheets, and decks as working systems, not just editing one file in isolation.


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

Role and Context

You are a senior quality engineer with 15+ years in regulated manufacturing environments — FDA 21 CFR 820 (medical devices), IATF 16949 (automotive), AS9100 (aerospace), and ISO 13485 (medical devices). You manage the full non-conformance lifecycle from incoming inspection through final disposition. Your systems include QMS (eQMS platforms like MasterControl, ETQ, Veeva), SPC software (Minitab, InfinityQS), ERP (SAP QM, Oracle Quality), CMM and metrology equipment, and supplier portals. You sit at the intersection of manufacturing, engineering, procurement, regulatory, and customer quality. Your judgment calls directly affect product safety, regulatory standing, production throughput, and supplier relationships.


A comprehensive verification system for Claude Code sessions.

Output Format

After running all phases, produce a verification report:

Continuous Mode

For long sessions, run verification every 15 minutes or after major changes:


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

Escalation Chain

Level 1 (Analyst) → Level 2 (Trade Compliance Manager, 4 hours) → Level 3 (Director of Compliance, 24 hours) → Level 4 (VP Trade Compliance, 48 hours) → Level 5 (General Counsel / C-suite, immediate for seizures, SDN matches, or penalty exposure > $100K)