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

How It Works

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

**Write a test** — Use `#[test]` in a `#[cfg(test)]` module, rstest for parameterized tests, or proptest for property-based tests

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

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

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

**Refactor** — Improve while keeping tests green

**Check coverage** — Use cargo-llvm-cov, target 80%+


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

PyTorch Development Patterns
Core Principles
1. Device-Agnostic Code

Core Principles

1. Device-Agnostic Code

Always write code that works on both CPU and GPU without hardcoding devices.


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 1: Reconnaissance

How It Works

Phase 1: Reconnaissance

Gather raw signals about the project without reading every file. Run these checks in parallel:


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

Related Skills

`brand-voice` for the reusable voice profile

`social-graph-ranker` for the standalone bridge-scoring and warm-path math

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

`x-api` for X graph access, drafting, and optional apply flows

`content-engine` when the user also wants public launch content around network moves


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

Ralphinho RFC Pipeline
Quality Pipeline per Unit

Quality Pipeline per Unit

research

implementation plan

implementation

tests

review

merge-ready report


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

Dashboard Builder

Use this when the task is to build a dashboard people can operate from.

The goal is not "show every metric." The goal is to answer:

is it healthy?

where is the bottleneck?

what changed?

what action should someone take?


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

Avoid when

用户只需微调已有 SOUL.md

目标平台不是 OpenClaw，需要的是其他 Agent 框架专用格式

用户需要纯工具型 Agent，不需要角色化灵魂


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

NestJS Development Patterns
Auth, Guards, and Request Context

Auth, Guards, and Request Context

Keep auth strategies and guards module-local unless they are truly shared.

Encode coarse access rules in guards, then do resource-specific authorization in services.

Prefer explicit request types for authenticated request objects.


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

Phase 2: Cross-read, Match & Verdict (LLM Judgment)

Extraction and matching are unified in a single pass. Rules files are small enough (~800 lines total) that the full text can be provided to the LLM — no grep pre-filtering needed.

Batching

Batching

Group skills into **thematic clusters** based on their descriptions. Analyze each cluster in a subagent with the full rules text.

Cross-batch Merge

Cross-batch Merge

After all batches complete, merge candidates across batches:

Deduplicate candidates with the same or overlapping principles

Re-check the "2+ skills" requirement using evidence from **all** batches combined — a principle found in 1 skill per batch but 2+ skills total is valid

Subagent Prompt

Subagent Prompt

Launch a general-purpose Agent with the following prompt:

Verdict Reference

Verdict Reference

| Verdict | Meaning | Presented to User |
|---------|---------|-------------------|
| **Append** | Add to existing section | Target + draft |
| **Revise** | Fix inaccurate/insufficient content | Target + reason + before/after |
| **New Section** | Add new section to existing file | Target + draft |
| **New File** | Create new rule file | Filename + full draft |
| **Already Covered** | Covered in rules (possibly different wording) | Reason (1 line) |
| **Too Specific** | Should stay in skills | Link to relevant skill |

Verdict Quality Requirements

Verdict Quality Requirements


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

Escalation Chain

Level 1 (Demand Planner) → Level 2 (Planning Manager, 24 hours) → Level 3 (Director of Supply Chain Planning, 48 hours) → Level 4 (VP Supply Chain, 72+ hours or any A-item stockout at enterprise customer)


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

Autonomous Loops Skill
3. Infinite Agentic Loop
Batching Strategy

Batching Strategy

| Count | Strategy |
|-------|----------|
| 1-5 | All agents simultaneously |
| 6-20 | Batches of 5 |
| infinite | Waves of 3-5, progressive sophistication |


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
High-Signal Failure Patterns
3. Free tier on premium path

3. Free tier on premium path

If free queued jobs can still route into Anthropic or another premium provider when keys exist, that is real spend leakage even if the user never sees the premium result.


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

When to Activate

Working on any codebase where file edits affect multiple modules

Projects with data files that have specific schemas or date formats

Teams where AI-generated code must match existing patterns

Any workflow where Claude tends to guess instead of investigating


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.

Research Standards

Every important claim needs a source.

Prefer recent data and call out stale data.

Include contrarian evidence and downside cases.

Translate findings into a decision, not just a summary.

Separate fact, inference, and recommendation clearly.


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

Logistics Exception Management
Key Edge Cases

Key Edge Cases

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

**Pharma reefer failure with disputed temps:** Carrier shows correct set-point; your Sensitech data shows excursion. The dispute is about sensor placement and pre-cooling. Never accept carrier's single-point reading — demand continuous data logger download.

**Consignee claims damage but caused it during unloading:** POD is signed clean, but consignee calls 2 hours later claiming damage. If your driver witnessed their forklift drop the pallet, the driver's contemporaneous notes are your best defense. Without that, concealed damage claim against you is likely.

**72-hour scan gap on high-value shipment:** No tracking updates doesn't always mean lost. LTL scan gaps happen at busy terminals. Before triggering a loss protocol, call the origin and destination terminals directly. Ask for physical trailer/bay location.

**Cross-border customs hold:** When a shipment is held at customs, determine quickly if the hold is for documentation (fixable) or compliance (potentially unfixable). Carrier documentation errors (wrong harmonized codes on the carrier's portion) vs shipper errors (incorrect commercial invoice values) require different resolution paths.

**Partial deliveries against single BOL:** Multiple delivery attempts where quantities don't match. Maintain a running tally. Don't file shortage claim until all partials are reconciled — carriers will use premature claims as evidence of shipper error.

**Broker insolvency mid-shipment:** Your freight is on a truck, the broker who arranged it goes bankrupt. The actual carrier has a lien right. Determine quickly: is the carrier paid? If not, negotiate directly with the carrier for release.

**Concealed damage discovered at final customer:** You delivered to distributor, distributor delivered to end customer, end customer finds damage. The chain-of-custody documentation determines who bears the loss.

**Peak surcharge dispute during weather event:** Carrier applies emergency surcharge retroactively. Contract may or may not allow this — check force majeure and fuel surcharge clauses specifically.


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

Migration Playbook

Pick one vertical slice (single endpoint/job) with frequent change pain.

Extract a use-case boundary with explicit input/output types.

Introduce outbound ports around existing infrastructure calls.

Move orchestration logic from controllers/services into the use case.

Keep old adapters, but make them delegate to the new use case.

Add tests around the new boundary (unit + adapter integration).

Repeat slice-by-slice; avoid full rewrites.


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

Laravel Development Patterns
Examples
Form Requests and Validation

Example Migration

Form Requests and Validation

Keep validation in form requests and transform inputs to DTOs.


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

How to use

Read individual rule files for detailed explanations and code examples:

[rules/3d.md](rules/3d.md) - 3D content in Remotion using Three.js and React Three Fiber

[rules/animations.md](rules/animations.md) - Fundamental animation skills for Remotion

[rules/assets.md](rules/assets.md) - Importing images, videos, audio, and fonts into Remotion

[rules/audio.md](rules/audio.md) - Using audio and sound in Remotion - importing, trimming, volume, speed, pitch

[rules/calculate-metadata.md](rules/calculate-metadata.md) - Dynamically set composition duration, dimensions, and props

[rules/can-decode.md](rules/can-decode.md) - Check if a video can be decoded by the browser using Mediabunny

[rules/charts.md](rules/charts.md) - Chart and data visualization patterns for Remotion

[rules/compositions.md](rules/compositions.md) - Defining compositions, stills, folders, default props and dynamic metadata

[rules/display-captions.md](rules/display-captions.md) - Displaying captions in Remotion with TikTok-style pages and word highlighting

[rules/extract-frames.md](rules/extract-frames.md) - Extract frames from videos at specific timestamps using Mediabunny

[rules/fonts.md](rules/fonts.md) - Loading Google Fonts and local fonts in Remotion

[rules/get-audio-duration.md](rules/get-audio-duration.md) - Getting the duration of an audio file in seconds with Mediabunny

[rules/get-video-dimensions.md](rules/get-video-dimensions.md) - Getting the width and height of a video file with Mediabunny

[rules/get-video-duration.md](rules/get-video-duration.md) - Getting the duration of a video file in seconds with Mediabunny

[rules/gifs.md](rules/gifs.md) - Displaying GIFs synchronized with Remotion's timeline

[rules/images.md](rules/images.md) - Embedding images in Remotion using the Img component

[rules/import-srt-captions.md](rules/import-srt-captions.md) - Importing .srt subtitle files into Remotion using @remotion/captions

[rules/lottie.md](rules/lottie.md) - Embedding Lottie animations in Remotion

[rules/measuring-dom-nodes.md](rules/measuring-dom-nodes.md) - Measuring DOM element dimensions in Remotion

[rules/measuring-text.md](rules/measuring-text.md) - Measuring text dimensions, fitting text to containers, and checking overflow

[rules/sequencing.md](rules/sequencing.md) - Sequencing patterns for Remotion - delay, trim, limit duration of items

[rules/tailwind.md](rules/tailwind.md) - Using TailwindCSS in Remotion

[rules/text-animations.md](rules/text-animations.md) - Typography and text animation patterns for Remotion

[rules/timing.md](rules/timing.md) - Interpolation curves in Remotion - linear, easing, spring animations

[rules/transcribe-captions.md](rules/transcribe-captions.md) - Transcribing audio to generate captions in Remotion

[rules/transitions.md](rules/transitions.md) - Scene transition patterns for Remotion

[rules/trimming.md](rules/trimming.md) - Trimming patterns for Remotion - cut the beginning or end of animations

[rules/videos.md](rules/videos.md) - Embedding videos in Remotion - trimming, volume, speed, looping, pitch


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

Output Format

Return the result in this order:

Good Outcomes

Product intent is now concrete enough to implement without rediscovering hidden constraints mid-PR.

Engineering review has a durable artifact instead of relying on memory or Slack context.

The resulting plan is reusable across Claude Code, Codex, Cursor, OpenCode, and ECC 2.0 planning surfaces.


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

Perl Testing Patterns
Coverage with Devel::Cover
Integration Testing

Coverage with Devel::Cover

Running Coverage

Integration Testing

Use in-memory SQLite for database tests, mock HTTP::Tiny for API tests.


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

Keyword mapping

define the search intent

gather realistic keyword variants

prioritize by intent match, likely value, and competition

map one primary keyword/theme to one URL

detect and avoid cannibalization


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

C# Testing Patterns
ASP.NET Core Integration Tests
Testing with Testcontainers

ASP.NET Core Integration Tests

WebApplicationFactory Setup

Testing with Testcontainers


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

When to Activate

Adding authentication (JWT, OAuth2, session-based)

Implementing authorization (@PreAuthorize, role-based access)

Validating user input (Bean Validation, custom validators)

Configuring CORS, CSRF, or security headers

Managing secrets (Vault, environment variables)

Adding rate limiting or brute-force protection

Scanning dependencies for CVEs


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

`default`

balanced prune queue

balanced keep list

ranked add/follow queue

draft warm intros or direct outreach where useful


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
8. Sensitive Data Exposure

8. Sensitive Data Exposure

Logging

Logging

Error Messages

Error Messages

Verification Steps

Verification Steps

[ ] No passwords, tokens, or secrets in logs

[ ] Error messages generic for users

[ ] Detailed errors only in server logs

[ ] No stack traces exposed to users


Weighted social-graph ranking for warm intro discovery, bridge scoring, and network gap analysis across X and LinkedIn. Use when the user wants the reusable graph-ranking engine itself, not the broader outreach or network-maintenance workflow layered on top of it.

Social Graph Ranker
When To Use This Standalone

When To Use This Standalone

Choose this skill when the user primarily wants the ranking engine:

"who in my network is best positioned to introduce me?"

"rank my mutuals by who can get me to these people"

"map my graph against this ICP"

"show me the bridge math"

Do not use this by itself when the user really wants:

full lead generation and outbound sequencing -> use `lead-intelligence`

pruning, rebalancing, and growing the network -> use `connections-optimizer`


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

Data Scraper Agent
Core Concepts
Free Stack

Core Concepts

The Three Layers

Every data scraper agent has three layers:

Free Stack

| Layer | Tool | Why |
|---|---|---|
| **Scraping** | `requests` + `BeautifulSoup` | No cost, covers 80% of public sites |
| **JS-rendered sites** | `playwright` (free) | When HTML scraping fails |
| **AI enrichment** | Gemini Flash via REST API | 500 req/day, 1M tokens/day — free |
| **Storage** | Notion API | Free tier, great UI for review |
| **Schedule** | GitHub Actions cron | Free for public repos |
| **Learning** | JSON feedback file in repo | Zero infra, persists in git |


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

This lane owns product diagnosis, not implementation-ready specification writing.

If the user needs a durable PRD-to-SRS or capability-contract artifact, hand off to `product-capability`.


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

Debugging

Common Commands

Debugging Network Issues

Anti-Patterns


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

Coverage

Prefer target-level settings instead of global flags.

GCC + gcov + lcov:

Clang + llvm-cov:


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

Santa Method
Implementation Patterns
Pattern C: Batch Sampling

Pattern C: Batch Sampling

For large batches (100+ items), full Santa on every item is cost-prohibitive. Use stratified sampling:

Run Santa on a random sample (10-15% of batch, minimum 5 items)

Categorize failures by type (hallucination, compliance, completeness, etc.)

If systematic patterns emerge, apply targeted fixes to the entire batch

Re-sample and re-verify the fixed batch

Continue until a clean sample passes


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

/click-path-audit — Behavioural Flow Audit

Step 1: Map State Stores

Before auditing any touchpoint, build a side-effect map of every state store action:

This is the critical reference. The "New Email" bug was invisible without knowing that `selectThread` resets `composeMode`.

**Output format:**


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.

Claude API

Build applications with the Anthropic Claude API and SDKs.

When to Activate

Building applications that call the Claude API

Code imports `anthropic` (Python) or `@anthropic-ai/sdk` (TypeScript)

User asks about Claude API patterns, tool use, streaming, or vision

Implementing agent workflows with Claude Agent SDK

Optimizing API costs, token usage, or latency


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

Flutter/Dart Code Review Best Practices
5. Performance
Lazy loading:

Lazy loading:

[ ] `ListView.builder` / `GridView.builder` used instead of `ListView(children: [...])` for large or dynamic lists (concrete constructors are fine for small, static lists)

[ ] Pagination implemented for large data sets

[ ] Deferred loading (`deferred as`) used for heavy libraries in web builds


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

Healthcare CDSS Development Patterns
How It Works
Drug Interaction Checking

Drug Interaction Checking

Interaction pairs must be **bidirectional**: if Drug A interacts with Drug B, then Drug B interacts with Drug A.


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

Autonomous Loops Skill
2. NanoClaw REPL
When NanoClaw vs Sequential Pipeline

When NanoClaw vs Sequential Pipeline

| Use Case | NanoClaw | Sequential Pipeline |
|----------|----------|-------------------|
| Interactive exploration | Yes | No |
| Scripted automation | No | Yes |
| Session persistence | Built-in | Manual |
| Context accumulation | Grows per turn | Fresh each step |
| CI/CD integration | Poor | Excellent |

See the `/claw` command documentation for full details.


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

Continuous Learning Skill

Automatically evaluates Claude Code sessions on end to extract reusable patterns that can be saved as learned skills.


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

Security Monitoring

Review and auto-merge safe dependency bumps

Flag any critical/high severity alerts immediately

Check for new Dependabot alerts weekly at minimum


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
Three-Phase Architecture

How It Works

Three-Phase Architecture

Every time Claude Code edits or writes a file, Plankton's `multi_linter.sh` PostToolUse hook runs:


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

Energy Procurement
Core Knowledge
Market Structures

Market Structures

**Regulated markets:** A single utility provides generation, transmission, and distribution. Rates are set by the state Public Utility Commission (PUC) through periodic rate cases. You cannot choose your electricity supplier. Optimization is limited to tariff selection (switching between available rate schedules), demand charge management, and on-site generation. Approximately 35% of US commercial electricity load is in fully regulated markets.

**Deregulated markets:** Generation is competitive. You can buy electricity from qualified retail energy providers (REPs), directly from the wholesale market (if you have the infrastructure and credit), or through brokers/aggregators. ISOs/RTOs operate the wholesale market: PJM (Mid-Atlantic and Midwest, largest US market), ERCOT (Texas, uniquely isolated grid), CAISO (California), NYISO (New York), ISO-NE (New England), MISO (Central US), SPP (Plains states). Each ISO has different market rules, capacity structures, and pricing mechanisms.

**Locational Marginal Pricing (LMP):** Wholesale electricity prices vary by location (node) within an ISO, reflecting generation costs, transmission losses, and congestion. LMP = Energy Component + Congestion Component + Loss Component. A facility at a congested node pays more than one at an uncongested node. Congestion can add $5–$30/MWh to your delivered cost in constrained zones. When evaluating a VPPA, the basis risk between the generator's node and your load zone is driven by congestion patterns.


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

Stage 2 — Capable Models (Opus 4.5-class)

Full 3-agent harness: Planner + Generator + Evaluator

Sprint contracts before each implementation phase

10-sprint decomposition for complex apps

Context resets still useful but less critical


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

X API
Authentication
OAuth 1.0a (User Context)

OAuth 1.0a (User Context)

Required for: posting tweets, managing account, DMs, and any write flow.

Legacy aliases such as `X_API_KEY`, `X_API_SECRET`, and `X_ACCESS_SECRET` may exist in older setups. Prefer the `X_CONSUMER_*` and `X_ACCESS_TOKEN_SECRET` names when documenting or wiring new flows.


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

Eval Harness Skill
Integration Patterns
Post-Implementation

During Implementation

Runs current evals and reports status

Post-Implementation

Generates full eval report


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

Perl Security Patterns
Safe File Operations
TOCTOU Prevention and Path Traversal

Safe File Operations

Three-Argument Open

TOCTOU Prevention and Path Traversal

Use `File::Temp` for temporary files (`tempfile(UNLINK => 1)`) and `flock(LOCK_EX)` to prevent race conditions.


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.

Threads

keep it readable and direct

do not write fake hyper-casual creator copy

do not paste the LinkedIn version and shorten it


Santa Method
Phase Details
Rubric Design

Rubric Design

The rubric is the most important input. Vague rubrics produce vague reviews. Every criterion must have an objective pass/fail condition.

| Criterion | Pass Condition | Failure Signal |
|-----------|---------------|----------------|
| Factual accuracy | All claims verifiable against source material or common knowledge | Invented statistics, wrong version numbers, nonexistent APIs |
| Hallucination-free | No fabricated entities, quotes, URLs, or references | Links to pages that don't exist, attributed quotes with no source |
| Completeness | Every requirement in the spec is addressed | Missing sections, skipped edge cases, incomplete coverage |
| Compliance | Passes all project-specific constraints | Banned terms used, tone violations, regulatory non-compliance |
| Internal consistency | No contradictions within the output | Section A says X, section B says not-X |
| Technical correctness | Code compiles/runs, algorithms are sound | Syntax errors, logic bugs, wrong complexity claims |

Domain-Specific Rubric Extensions

Domain-Specific Rubric Extensions

**Content/Marketing:**

Brand voice adherence

SEO requirements met (keyword density, meta tags, structure)

No competitor trademark misuse

CTA present and correctly linked

**Code:**

Type safety (no `any` leaks, proper null handling)

Error handling coverage

Security (no secrets in code, input validation, injection prevention)

Test coverage for new paths

**Compliance-Sensitive (regulated, legal, financial):**

No outcome guarantees or unsubstantiated claims

Required disclaimers present

Approved terminology only

Jurisdiction-appropriate language


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
Common Testing Mistakes to Avoid
PASS: CORRECT: Semantic Selectors

PASS: CORRECT: Test User-Visible Behavior

FAIL: WRONG: Brittle Selectors

PASS: CORRECT: Semantic Selectors


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
ABC/XYZ Classification

ABC/XYZ Classification

**ABC (Value):** A = top 20% of SKUs driving 80% of revenue/margin. B = next 30% driving 15%. C = bottom 50% driving 5%. Classify on margin contribution, not revenue, to avoid overinvesting in high-revenue low-margin items.

**XYZ (Predictability):** X = CV of demand < 0.5 (highly predictable). Y = CV 0.5–1.0 (moderately predictable). Z = CV > 1.0 (erratic/lumpy). Compute on de-seasonalized, de-promoted demand to avoid penalizing seasonal items that are actually predictable within their pattern.

**Policy Matrix:** AX items get automated replenishment with tight safety stock. AZ items need human review every cycle — they're high-value but erratic. CX items get automated replenishment with generous review periods. CZ items are candidates for discontinuation or make-to-order conversion.


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

Frontend Development Patterns
Animation Patterns
Framer Motion Animations

Controlled Form with Validation

Error Boundary Pattern

Animation Patterns

Framer Motion Animations


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

Strategic Compact Skill
Token Optimization Patterns
Duplicate Instruction Detection

Duplicate Instruction Detection

Common sources of duplicate context:

Same rules in both `~/.claude/rules/` and project `.claude/rules/`

Skills that repeat CLAUDE.md instructions

Multiple skills covering overlapping domains


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

Testcontainers

Use reusable containers for Postgres/Redis to mirror production

Wire via `@DynamicPropertySource` to inject JDBC URLs into Spring context


Energy Procurement
Decision Frameworks
PPA Evaluation

PPA Evaluation

Before committing to a 10–25 year PPA, evaluate:

**Does the project economics pencil?** Compare the PPA strike price to the forward curve for the contract tenor. A $35/MWh solar PPA against a $45/MWh forward curve has $10/MWh positive spread. But model the full term — a 20-year PPA at $35/MWh that was in-the-money at signing can go underwater if wholesale prices drop below the strike due to overbuilding of renewables in the region.

**What is the basis risk?** If the generator is in West Texas (ERCOT West) and your load is in Houston (ERCOT Houston), congestion between the two zones can create a persistent basis spread of $3–$12/MWh that erodes the PPA value. Require the developer to provide 5+ years of historical basis data between the project node and your load zone.

**What is the curtailment exposure?** ERCOT curtails wind at 3–8% annually; CAISO curtails solar at 5–12% in spring months. If the PPA settles on generated (not scheduled) volumes, curtailment reduces your REC delivery and changes the economics. Negotiate a curtailment cap or a settlement structure that doesn't penalize you for grid-operator curtailment.

**What are the credit requirements?** Developers typically require investment-grade credit or a letter of credit / parent guarantee for long-term PPAs. A $50M notional VPPA may require a $5–$10M LC, tying up capital. Factor the LC cost into your PPA economics.


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

When to Activate

Building Ktor HTTP servers

Configuring Ktor plugins (Auth, CORS, ContentNegotiation, StatusPages)

Implementing REST APIs with Ktor

Setting up dependency injection with Koin

Writing Ktor integration tests with testApplication

Working with WebSockets in Ktor


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

Benchmark — Performance Baseline & Regression Detection

How It Works

Mode 1: Page Performance

Measures real browser metrics via browser MCP:


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.

Claude Agent SDK

Build multi-step agents:

Cost Optimization

| Strategy | Savings | When to Use |
|----------|---------|-------------|
| Prompt caching | Up to 90% on cached tokens | Repeated system prompts or context |
| Batches API | 50% | Non-time-sensitive bulk processing |
| Haiku instead of Sonnet | ~75% | Simple tasks, classification, extraction |
| Shorter max_tokens | Variable | When you know output will be short |
| Streaming | None (same cost) | Better UX, same price |


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

When to Activate

the user wants to prune their X following

the user wants to rebalance who they follow or stay connected to

the user says "clean up my network", "who should I unfollow", "who should I follow", "who should I reconnect with"

outreach quality depends on network structure, not just cold list generation


Crosspost

Distribute content across platforms without turning it into the same fake post in four costumes.


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

Modern Perl Development Patterns
Error Handling
Native try/catch (5.40+)

Error Handling

eval/die Pattern

Try::Tiny (Reliable Exception Handling)

Native try/catch (5.40+)


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

Compose Multiplatform Patterns
Anti-Patterns to Avoid

Theming

Material 3 Dynamic Theming

Anti-Patterns to Avoid

Using `mutableStateOf` in ViewModels when `MutableStateFlow` with `collectAsStateWithLifecycle` is safer for lifecycle

Passing `NavController` deep into composables — pass lambda callbacks instead

Heavy computation inside `@Composable` functions — move to ViewModel or `remember {}`

Using `LaunchedEffect(Unit)` as a substitute for ViewModel init — it re-runs on configuration change in some setups

Creating new object instances in composable parameters — causes unnecessary recomposition


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

Android Clean Architecture
When to Activate

When to Activate

Structuring Android or KMP project modules

Implementing UseCases, Repositories, or DataSources

Designing data flow between layers (domain, data, presentation)

Setting up dependency injection with Koin or Hilt

Working with Room, SQLDelight, or Ktor in a layered architecture


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.

How It Works

Profile each facility's load shape using interval meter data (15-minute kWh/kW) to identify cost drivers

Analyze current tariff structures and identify optimization opportunities (rate switching, demand response enrollment)

Structure procurement RFPs with appropriate product specifications (fixed, index, block-and-index, shaped)

Evaluate bids using total cost of energy (not just $/MWh) including capacity, transmission, ancillaries, and risk premium

Execute contracts with staggered terms and layered hedging to avoid concentration risk

Monitor market positions, rebalance hedges on trigger events, and report budget variance monthly


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

skill-stocktake
Full Stocktake Flow
Phase 2 — Quality Evaluation

Phase 2 — Quality Evaluation

Launch an Agent tool subagent (**general-purpose agent**) with the full inventory and checklist:

The subagent reads each skill, applies the checklist, and returns per-skill JSON:

`{ "verdict": "Keep"|"Improve"|"Update"|"Retire"|"Merge into [X]", "reason": "..." }`

**Chunk guidance:** Process ~20 skills per subagent invocation to keep context manageable. Save intermediate results to `results.json` (`status: "in_progress"`) after each chunk.

After all skills are evaluated: set `status: "completed"`, proceed to Phase 3.

**Resume detection:** If `status: "in_progress"` is found on startup, resume from the first unevaluated skill.

Each skill is evaluated against this checklist:

Verdict criteria:

| Verdict | Meaning |
|---------|---------|
| Keep | Useful and current |
| Improve | Worth keeping, but specific improvements needed |
| Update | Referenced technology is outdated (verify with WebSearch) |
| Retire | Low quality, stale, or cost-asymmetric |
| Merge into [X] | Substantial overlap with another skill; name the merge target |

Evaluation is **holistic AI judgment** — not a numeric rubric. Guiding dimensions:

**Actionability**: code examples, commands, or steps that let you act immediately

**Scope fit**: name, trigger, and content are aligned; not too broad or narrow

**Uniqueness**: value not replaceable by MEMORY.md / CLAUDE.md / another skill

**Currency**: technical references work in the current environment

**Reason quality requirements** — the `reason` field must be self-contained and decision-enabling:

Do NOT write "unchanged" alone — always restate the core evidence

For **Retire**: state (1) what specific defect was found, (2) what covers the same need instead

Bad: `"Superseded"`

Good: `"disable-model-invocation: true already set; superseded by continuous-learning-v2 which covers all the same patterns plus confidence scoring. No unique content remains."`

For **Merge**: name the target and describe what content to integrate

Bad: `"Overlaps with X"`

Good: `"42-line thin content; Step 4 of chatlog-to-article already covers the same workflow. Integrate the 'article angle' tip as a note in that skill."`

For **Improve**: describe the specific change needed (what section, what action, target size if relevant)

Bad: `"Too long"`

Good: `"276 lines; Section 'Framework Comparison' (L80–140) duplicates ai-era-architecture-principles; delete it to reach ~150 lines."`

For **Keep** (mtime-only change in Quick Scan): restate the original verdict rationale, do not write "unchanged"

Bad: `"Unchanged"`

Good: `"mtime updated but content unchanged. Unique Python reference explicitly imported by rules/python/; no overlap found."`


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

VideoDB Skill
When to use
Desktop Perception

When to use

Desktop Perception

Start/stop a **desktop session** capturing **screen, mic, and system audio**

Stream **live context** and store **episodic session memory**

Run **real-time alerts/triggers** on what's spoken and what's happening on screen

Produce **session summaries**, a searchable timeline, and **playable evidence links**


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

Customer Billing Ops
Workflow
2. Classify the issue

2. Classify the issue

Put the case into one bucket before acting:

| Case | Typical action |
|------|----------------|
| Duplicate personal subscription | cancel extras, consider refund |
| Real multi-seat/team intent | preserve seats, clarify billing model |
| Failed payment / incomplete checkout | recover via portal or update payment method |
| Missing self-serve controls | provide portal, cancellation path, or invoice access |
| Product failure or trust break | refund, apologize, log product issue |


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
Core Knowledge
Market Intelligence

Market Intelligence

Rate cycles are predictable in direction, unpredictable in magnitude:

**DAT and Greenscreens:** DAT RateView provides lane-level spot and contract rate benchmarks based on broker-reported transactions. Greenscreens provides carrier-specific pricing intelligence and predictive analytics. Use both — DAT for market direction, Greenscreens for carrier-specific negotiation leverage. Neither is perfectly accurate, but both are better than negotiating blind.

**Freight market cycles:** The truckload market oscillates between shipper-favorable (excess capacity, falling rates, high tender acceptance) and carrier-favorable (tight capacity, rising rates, tender rejections). Cycles last 18-36 months peak-to-peak. Key indicators: DAT load-to-truck ratio (>6:1 signals tight market), OTRI (Outbound Tender Rejection Index — >10% signals carrier leverage shifting), Class 8 truck orders (leading indicator of capacity addition 6-12 months out).

**Seasonal patterns:** Produce season (April-July) tightens reefer capacity in the Southeast and West. Peak retail season (October-January) tightens dry van capacity nationally. The last week of each month and quarter sees volume spikes as shippers meet revenue targets. Budget RFP timing to avoid awarding contracts at the peak or trough of a cycle — award during the transition for more realistic rates.


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.

Roles

| Voice | Lens |
| --- | --- |
| Architect | correctness, maintainability, long-term implications |
| Skeptic | premise challenge, simplification, assumption breaking |
| Pragmatist | shipping speed, user impact, operational reality |
| Critic | edge cases, downside risk, failure modes |

The three external voices should be launched as fresh subagents with **only the question and relevant context**, not the full ongoing conversation. That is the anti-anchoring mechanism.


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

Dashboard Builder
Workflow
4. Cut vanity panels

4. Cut vanity panels

Every panel should answer a real question. If it does not, remove it.


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.

Examples

**HS classification dispute**: CBP reclassifies your electronic component from 8542 (integrated circuits, 0% duty) to 8543 (electrical machines, 2.6%). Build the argument using GRI 1 and 3(a) with technical specifications, binding rulings, and EN commentary.

**FTA qualification**: Evaluate whether a product assembled in Mexico qualifies for USMCA preferential treatment. Trace BOM components to determine regional value content and tariff shift eligibility.

**Denied party screening hit**: Automated screening flags a customer as a potential match on OFAC's SDN list. Walk through false-positive resolution, escalation procedures, and documentation requirements.


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.

Testing Guidance (Same Hexagonal Boundaries)

**Domain tests**: test entities/value objects as pure business rules (no mocks, no framework setup).

**Use-case unit tests**: test orchestration with fakes/stubs for outbound ports; assert business outcomes and port interactions.

**Outbound adapter contract tests**: define shared contract suites at port level and run them against each adapter implementation.

**Inbound adapter tests**: verify protocol mapping (HTTP/CLI/queue payload to use-case input and output/error mapping back to protocol).

**Adapter integration tests**: run against real infrastructure (DB/API/queue) for serialization, schema/query behavior, retries, and timeouts.

**End-to-end tests**: cover critical user journeys through inbound adapter -> use case -> outbound adapter.

**Refactor safety**: add characterization tests before extraction; keep them until new boundary behavior is stable and equivalent.


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
Tool Requirements
Optional (enhance results)

Optional (enhance results)

**LinkedIn** — Direct API if available, otherwise browser control for search, profile inspection, and drafting

**Apollo/Clay API** — For enrichment cross-reference if user has access

**GitHub MCP** — For developer-centric lead qualification

**Apple Mail / Mail.app** — Draft cold or warm email without sending automatically

**Browser control** — For LinkedIn and X when API coverage is missing or constrained


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

Unified Notifications Ops

Use this skill when the real problem is not a missing ping. The real problem is a fragmented notification system.

The job is to turn scattered events into one operator surface with:

clear severity

clear ownership

clear routing

clear follow-up action


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

Google Workspace Ops
Workflow
3. Edit with precision

3. Edit with precision

For Docs: use index-aware edits, not vague rewrites

For Sheets: operate on explicit tabs and ranges

For Slides: distinguish content edits from visual cleanup or template migration

If the requested work is visual or layout-sensitive, iterate with inspection and verification instead of one giant blind update.


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

Frontend Development Patterns
When to Activate

When to Activate

Building React components (composition, props, rendering)

Managing state (useState, useReducer, Zustand, Context)

Implementing data fetching (SWR, React Query, server components)

Optimizing performance (memoization, virtualization, code splitting)

Working with forms (validation, controlled inputs, Zod schemas)

Handling client-side routing and navigation

Building accessible, responsive UI patterns


Prevent Ethereum hashing bugs in JavaScript and TypeScript. Node's sha3-256 is NIST SHA3, not Ethereum Keccak-256, and silently breaks selectors, signatures, storage slots, and address derivation.

When to Use

Computing Ethereum function selectors or event topics

Building EIP-712, signature, Merkle, or storage-slot helpers in JS/TS

Reviewing any code that hashes Ethereum data with Node crypto directly


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)

Initialization

Anti-Patterns

Uninitialized variables (ES.20)

Using `0` or `NULL` as pointer (ES.47 -- use `nullptr`)

C-style casts (ES.48 -- use `static_cast`, `const_cast`, etc.)

Casting away `const` (ES.50)

Magic numbers without named constants (ES.45)

Mixing signed and unsigned arithmetic (ES.100)

Reusing names in nested scopes (ES.12)


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

Hydration Safety

Keep the first render deterministic. Do not put `Date.now()`, `Math.random()`, browser-only APIs, or storage reads directly into SSR-rendered template state.

Move browser-only logic behind `onMounted()`, `import.meta.client`, `ClientOnly`, or a `.client.vue` component when the server cannot produce the same markup.

Use Nuxt's `useRoute()` composable, not the one from `vue-router`.

Do not use `route.fullPath` to drive SSR-rendered markup. URL fragments are client-only, which can create hydration mismatches.

Treat `ssr: false` as an escape hatch for truly browser-only areas, not a default fix for mismatches.


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

API Connector Builder
Workflow
3. Build in repo-native layers

3. Build in repo-native layers

Typical slices:

config/schema

client/transport

mapping layer

connector/provider entrypoint

registration

tests


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

核心理念

好的龙虾灵魂 = **身份张力** + **底线规则** + **性格缺陷** + **名字** + **视觉锚点**

五者互相印证，缺一不可。

How It Works


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.

Hard Bans

Delete and rewrite any of these:

fake curiosity hooks

"not X, just Y"

"no fluff"

forced lowercase

LinkedIn thought-leader cadence

bait questions

"Excited to share"

generic founder-journey filler

corny parentheticals


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

When to Activate

Building or updating apps for iOS 26+ with the new design language

Implementing glass-style buttons, cards, toolbars, or containers

Creating morphing transitions between glass elements

Applying Liquid Glass effects to widgets

Migrating existing blur/material effects to the new Liquid Glass API


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.

Default Output

short 16:9 MP4

one thumbnail or poster frame

storyboard plus scene plan


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

Documentation Lookup (Context7)
Core Concepts

Core Concepts

**Context7**: MCP server that exposes live documentation; use it instead of training data for libraries and APIs.

**resolve-library-id**: Returns Context7-compatible library IDs (e.g. `/vercel/next.js`) from a library name and query.

**query-docs**: Fetches documentation and code snippets for a given library ID and question. Always call resolve-library-id first to get a valid library ID.


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

Test-Driven Development Workflow
Core Principles
3. Test Types

3. Test Types

Unit Tests

Unit Tests

Individual functions and utilities

Component logic

Pure functions

Helpers and utilities

Integration Tests

Integration Tests

API endpoints

Database operations

Service interactions

External API calls

E2E Tests (Playwright)

E2E Tests (Playwright)

Critical user flows

Complete workflows

Browser automation

UI interactions


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

Database Migration Patterns
Core Principles

Core Principles

**Every change is a migration** — never alter production databases manually

**Migrations are forward-only in production** — rollbacks use new forward migrations

**Schema and data migrations are separate** — never mix DDL and DML in one migration

**Test migrations against production-sized data** — a migration that works on 100 rows may lock on 10M

**Migrations are immutable once deployed** — never edit a migration that has run in production


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
13. Internationalization (l10n)
Setup:

13. Internationalization (l10n)

Setup:

[ ] Localization solution configured (Flutter's built-in ARB/l10n, easy_localization, or equivalent)

[ ] Supported locales declared in app configuration


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

Product Capability
Core Workflow
1. Restate the capability

Core Workflow

1. Restate the capability

Compress the ask into one precise statement:

who the user or operator is

what new capability exists after this ships

what outcome changes because of it

If this statement is weak, the implementation will drift.


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

Logistics Exception Management
Decision Frameworks
Eat-the-Cost vs Fight-the-Claim

Eat-the-Cost vs Fight-the-Claim

This is the most common judgment call. Thresholds:

**< $500 and carrier relationship is strong:** Absorb. The admin cost of claims processing ($150-250 internal) makes it negative-ROI. Log for carrier scorecard.

**$500 - $2,500:** File claim but don't escalate aggressively. This is the "standard process" zone. Accept partial settlements above 70% of value.

**$2,500 - $10,000:** Full claims process. Escalate at 30-day mark if no resolution. Involve carrier account manager. Reject settlements below 80%.

**> $10,000:** VP-level awareness. Dedicated claims handler. Independent inspection if damage. Reject settlements below 90%. Legal review if denied.

**Any amount + pattern:** If this is the 3rd+ exception from the same carrier in 30 days, treat it as a carrier performance issue regardless of individual dollar amounts.


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

Automation Audit Ops
Workflow
1. Inventory the real surface

Workflow

1. Inventory the real surface

Read the current live surface before theorizing:

repo hooks and local hook scripts

GitHub Actions and scheduled workflows

MCP configs and enabled servers

connector- or app-backed integrations

wrapper scripts and repo-specific automation entrypoints

Group them by surface:

local runtime

repo CI / automation

connected external systems

messaging / notifications

billing / customer operations

research / monitoring


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

Autonomous Agent Harness
Core Components
5. Task Queue

5. Task Queue

Manage a persistent queue of tasks that survive session boundaries.

**Implementation:**


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

ECC Tools Cost Audit
Workflow
5. Fix in burn order

5. Fix in burn order

If the user asked for code changes, prioritize fixes in this order:

stop automatic PR multiplication

stop quota bypass

stop premium leakage

stop duplicate-job fanout and pointless retries

close rerun/update safety gaps

Keep the pass bounded to one to three direct fixes unless the same root cause clearly spans multiple files.


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

6. Ralphinho / RFC-Driven DAG Orchestration

Key Design Principles

**Deterministic execution** — Upfront decomposition locks in parallelism and ordering

**Human review at leverage points** — The work plan is the single highest-leverage intervention point

**Separate concerns** — Each stage in a separate context window with a separate agent

**Conflict recovery with context** — Full eviction context enables intelligent re-runs, not blind retries

**Tier-driven depth** — Trivial changes skip research/review; large changes get maximum scrutiny

**Resumable workflows** — Full state persisted to SQLite; resume from any point


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

Configure Everything Claude Code (ECC)
Step 2: Select & Install Skills
2a: Choose Scope (Core vs Niche)

Step 2: Select & Install Skills

2a: Choose Scope (Core vs Niche)

Default to **Core (recommended for new users)** — copy `.agents/skills/*` plus `skills/search-first/` for research-first workflows. This bundle covers engineering, evals, verification, security, strategic compaction, frontend design, and Anthropic cross-functional skills (article-writing, content-engine, market-research, frontend-slides).

Use `AskUserQuestion` (single select):

If the user chooses niche or core + niche, continue to category selection below and only include those niche skills they pick.


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

fal.ai Media Generation
Video Generation
Veo 3 (Google DeepMind)

Kling Video v3 Pro

Best for: text/image-to-video with native audio generation.

Veo 3 (Google DeepMind)

Best for: video with generated sound, high visual quality.


fal.ai Media Generation
Image Generation
Common Image Parameters

Common Image Parameters

| Param | Type | Options | Notes |
|-------|------|---------|-------|
| `prompt` | string | required | Describe what you want |
| `image_size` | string | `square`, `portrait_4_3`, `landscape_16_9`, `portrait_16_9`, `landscape_4_3` | Aspect ratio |
| `num_images` | number | 1-4 | How many to generate |
| `seed` | number | any integer | Reproducibility |
| `guidance_scale` | number | 1-20 | How closely to follow the prompt (higher = more literal) |


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
Additional docs
When to use what

When to use what

| Problem | VideoDB solution |
|---------|-----------------|
| Platform rejects video aspect ratio or resolution | `video.reframe()` or `conn.transcode()` with `VideoConfig` |
| Need to resize video for Twitter/Instagram/TikTok | `video.reframe(target="vertical")` or `target="square"` |
| Need to change resolution (e.g. 1080p → 720p) | `conn.transcode()` with `VideoConfig(resolution=720)` |
| Need to overlay audio/music on video | `AudioAsset` on a `Timeline` |
| Need to add subtitles | `video.add_subtitle()` or `CaptionAsset` |
| Need to combine/trim clips | `VideoAsset` on a `Timeline` |
| Need to generate voiceover, music, or SFX | `coll.generate_voice()`, `generate_music()`, `generate_sound_effect()` |


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.

Batch API Calls for Efficiency

Never call the LLM once per item. Always batch:

Workflow


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

Django Verification Loop
Phase 7: Performance Checks

Phase 6: Django Management Commands

Phase 7: Performance Checks

Report:

Number of queries per page (should be < 50 for typical pages)

Missing database indexes

Duplicate queries detected


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

Quality & Non-Conformance Management
Escalation Protocols
Automatic Escalation Triggers

Escalation Protocols

Automatic Escalation Triggers

| Trigger | Action | Timeline |
|---|---|---|
| Safety-critical non-conformance | Notify VP Quality and Regulatory immediately | Within 1 hour |
| Field failure or customer complaint | Assign dedicated investigator, notify account team | Within 4 hours |
| Repeat NCR (same failure mode, 3+ occurrences) | Mandatory CAPA initiation, management review | Within 24 hours |
| Supplier falsified documentation | Quarantine all supplier material, notify regulatory and legal | Immediately |
| Non-conformance on shipped product | Initiate customer notification protocol, containment | Within 4 hours |
| Audit finding (external) | Management review, response plan development | Within 48 hours |
| CAPA overdue > 30 days past target | Escalate to Quality Director for resource allocation | Within 1 week |
| NCR backlog exceeds 50 open items | Process review, resource allocation, management briefing | Within 1 week |


A comprehensive verification system for Claude Code sessions.

Verification Loop Skill
Verification Phases
Phase 1: Build Verification

Verification Phases

Phase 1: Build Verification

If build fails, STOP and fix before continuing.


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

Quick Reference

| Task | Command / Pattern |
|---|---|
| Run all tests | `prove -lr t/` |
| Run one test verbose | `prove -lv t/unit/user.t` |
| Parallel test run | `prove -lr -j8 t/` |
| Coverage report | `cover -test && cover -report html` |
| Test equality | `is($got, $expected, 'label')` |
| Deep comparison | `is($got, hash { field k => 'v'; etc() }, 'label')` |
| Test exception | `like(dies { ... }, qr/msg/, 'label')` |
| Test no exception | `ok(lives { ... }, 'label')` |
| Mock a method | `Test::MockModule->new('Pkg')->mock(m => sub { ... })` |
| Skip tests | `SKIP: { skip 'reason', $count unless $cond; ... }` |
| TODO tests | `TODO: { local $TODO = 'reason'; ... }` |


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

Deployment Patterns
Production Readiness Checklist
Security

Security

[ ] Dependencies scanned for CVEs

[ ] CORS configured for allowed origins only

[ ] Rate limiting enabled on public endpoints

[ ] Authentication and authorization verified

[ ] Security headers set (CSP, HSTS, X-Frame-Options)


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

/click-path-audit — Behavioural Flow Audit

When to Use

After systematic debugging finds "no bugs" but users report broken UI

After modifying any Zustand store action (check all callers)

After any refactor that touches shared state

Before release, on critical user flows

When a button "does nothing" — this is THE tool for that


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.

Voice Handling

`brand-voice` is the canonical voice layer.

Run it first when:

there are multiple downstream outputs

the user explicitly cares about writing style

the content is launch, outreach, or reputation-sensitive

Reuse the resulting `VOICE PROFILE` here instead of rebuilding a second voice model.
If the user wants Affaan / ECC voice specifically, still treat `brand-voice` as the source of truth and feed it the best live or source-derived material available.


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

Dashboard Builder
Example Panel Sets
API gateway / ingress

API gateway / ingress

request rate

p50 / p95 / p99 latency

error rate

upstream health

active connections


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

Spring Boot Verification Loop
Phase 4: Security Scan

API Tests with MockMvc

Test controller layer with full Spring context:

Phase 4: Security Scan


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.

Workflow

1. Start from what the user already gave you

Normalize any supplied material into:

already-evidenced facts

needs verification

open questions

Do not restart the analysis from zero if the user already built part of the model.


How It Works

For EVERY interactive touchpoint in the target area:

Execution Steps


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 Smell Detection
1. Long Functions

Test Naming

Code Smell Detection

Watch for these anti-patterns:

1. Long Functions


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

Section 4: Optimized Prompt — Quick Version

A compact version for experienced ECC users. Vary by intent type:

| Intent | Quick Pattern |
|--------|--------------|
| New Feature | `/plan [feature]. /tdd to implement. /code-review. /verify.` |
| Bug Fix | `/tdd — write failing test for [bug]. Fix to green. /verify.` |
| Refactor | `/refactor-clean [scope]. /code-review. /verify.` |
| Research | `Use search-first skill for [topic]. /plan based on findings.` |
| Testing | `/tdd [module]. /e2e for critical flows. /test-coverage.` |
| Review | `/code-review. Then use security-reviewer agent.` |
| Docs | `/update-docs. /update-codemaps.` |
| EPIC | `Use blueprint skill for "[objective]". Execute phases with /verify gates.` |


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
Commit Messages
Commit Message Template

Good vs Bad Examples

Commit Message Template

Create `.gitmessage` in repo root:

Enable with: `git config commit.template .gitmessage`


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

Find, evaluate, and choose healthy Laravel packages using the LaraPlugins.io MCP server.


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

Examples

Example 1: Safe vs Unsafe Error Handling

Example 2: RLS Policy for Multi-Facility Isolation


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

When to Use

Writing new C++ tests or fixing existing tests

Designing unit/integration test coverage for C++ components

Adding test coverage, CI gating, or regression protection

Configuring CMake/CTest workflows for consistent execution

Investigating test failures or flaky behavior

Enabling sanitizers for memory/race diagnostics


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

Modern Perl Development Patterns
Regular Expressions
Named Captures and `/x` Flag

Moo Roles

Native `class` Keyword (5.38+, Corinna)

Regular Expressions

Named Captures and `/x` Flag


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

MCP Tools Reference

When the `mcp-atlassian` MCP server is configured, these tools are available:

| Tool | Purpose | Example |
|------|---------|---------|
| `jira_search` | JQL queries | `project = PROJ AND status = "In Progress"` |
| `jira_get_issue` | Fetch full issue details by key | `PROJ-1234` |
| `jira_create_issue` | Create issues (Task, Bug, Story, Epic) | New bug report |
| `jira_update_issue` | Update fields (summary, description, assignee) | Change assignee |
| `jira_transition_issue` | Change status | Move to "In Review" |
| `jira_add_comment` | Add comments | Progress update |
| `jira_get_sprint_issues` | List issues in a sprint | Active sprint review |
| `jira_create_issue_link` | Link issues (Blocks, Relates to) | Dependency tracking |
| `jira_get_issue_development_info` | See linked PRs, branches, commits | Dev context |

**Tip:** Always call `jira_get_transitions` before transitioning — transition IDs vary per project workflow.


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

UI Demo Video Recorder
Phase 1: Discover
What to look for

How

Navigate to each page in the flow and dump its interactive elements:

What to look for

**Form fields**: Are they `<select>`, `<input>`, custom dropdowns, or comboboxes?

**Select options**: Dump option values AND text. Placeholders often have `value="0"` or `value=""` which looks non-empty. Use `Array.from(el.options).map(o => ({ value: o.value, text: o.text }))`. Skip options where text includes "Select" or value is `"0"`.

**Rich text**: Does the comment box support `@mentions`, `#tags`, markdown, or emoji? Check placeholder text.

**Required fields**: Which fields block form submission? Check `required`, `*` in labels, and try submitting empty to see validation errors.

**Dynamic content**: Do fields appear after other fields are filled?

**Button labels**: Exact text such as `"Submit"`, `"Submit Request"`, or `"Send"`.

**Table column headers**: For table-driven modals, map each `input[type="number"]` to its column header instead of assuming all numeric inputs mean the same thing.


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

Laravel TDD Workflow
Examples
Feature Test Pest Example (HTTP Layer)

Examples

PHPUnit Example

Feature Test Example (HTTP Layer)

Pest Example

Feature Test Pest Example (HTTP Layer)


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

Accessibility (WCAG 2.2)
How It Works
Step 5: Verify Robust Compatibility

Step 5: Verify Robust Compatibility

Use correct `Name, Role, Value` patterns.

Implement `aria-live` or live regions for dynamic status updates.


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

Kotlin Testing Patterns
Examples
Quick Reference

Quick Reference

**Kotest specs** — StringSpec, FunSpec, BehaviorSpec, DescribeSpec examples in [Kotest Spec Styles](#kotest-spec-styles)

**Mocking** — MockK setup, coroutine mocking, argument capture in [MockK](#mockk)

**TDD walkthrough** — Full RED/GREEN/REFACTOR cycle with EmailValidator in [TDD Workflow for Kotlin](#tdd-workflow-for-kotlin)

**Coverage** — Kover configuration and commands in [Kover Coverage](#kover-coverage)

**Ktor testing** — testApplication setup in [Ktor testApplication Testing](#ktor-testapplication-testing)


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

FoundationModels: On-Device LLM (iOS 26)

Core Pattern — Availability Check

Always check model availability before creating a session:


Laravel Plugin Discovery
Response Interpretation
Search Results

Combining Filters

Response Interpretation

Search Results

Each result includes:

Package name (e.g. `spatie/laravel-permission`)

Brief description

Health status indicator

Laravel version support badges


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.

VideoDB Generative Audio

If VideoDB is configured, use its generative audio:

Cost Estimation

Before generating, check estimated cost:


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

Lead Intelligence
Stage 5: Outreach Draft

Stage 5: Outreach Draft

Generate personalized outreach for each lead. The draft should match the source-derived voice profile and the target channel.


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

Session Strategy

Continue session for closely-coupled units.

Start fresh session after major phase transitions.

Compact after milestone completion, not during active debugging.


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

Links

[GitHub Repository](https://github.com/haibindev/repo-scan)


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
Evolution Across Model Capabilities

Usage

Via Command

Via Shell Script

Via Claude Code (Manual)

Evolution Across Model Capabilities

The harness should simplify as models improve. Following Anthropic's evolution:


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)

Smart Pointer Usage

RAII Pattern

Anti-Patterns

Naked `new`/`delete` (R.11)

`malloc()`/`free()` in C++ code (R.10)

Multiple resource allocations in a single expression (R.13 -- exception safety hazard)

`shared_ptr` where `unique_ptr` suffices (R.21)


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

Android Clean Architecture
Module Structure
Dependency Rules

Module Structure

Recommended Layout

Dependency Rules

**Critical**: `domain` must NEVER depend on `data`, `presentation`, or any framework. It contains pure Kotlin only.


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

Laravel Verification Loop
Phase 3: Tests and Coverage

Phase 3: Tests and Coverage

Coverage (CI):

CI example (format -> static analysis -> tests):


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

How It Works

Source and vet carriers through FMCSA SAFER, insurance verification, and reference checks

Structure RFPs with lane-level data, volume commitments, and scoring criteria

Negotiate rates by decomposing line-haul, fuel, accessorials, and capacity guarantees

Build routing guides with primary/backup assignments and auto-tender rules in TMS

Track performance via weighted scorecards (on-time, claims ratio, tender acceptance, cost)

Conduct quarterly business reviews and adjust allocation based on scorecard rankings


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
Strategy: Test Where Bugs Were Found

Pattern 4: Optimistic Update Without Proper Rollback

Strategy: Test Where Bugs Were Found

Don't aim for 100% coverage. Instead:

**Why this works with AI development:**

AI tends to make the **same category of mistake** repeatedly

Bugs cluster in complex areas (auth, multi-path logic, state management)

Once tested, that exact regression **cannot happen again**

Test count grows organically with bug fixes — no wasted effort


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
Testing Patterns
API Integration Test Pattern

Step 7: Verify Coverage

Testing Patterns

Unit Test Pattern (Jest/Vitest)

API Integration Test Pattern


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

Strategic Compact Skill
Why Strategic Compaction?

Why Strategic Compaction?

Auto-compaction triggers at arbitrary points:

Often mid-task, losing important context

No awareness of logical task boundaries

Can interrupt complex multi-step operations

Strategic compaction at logical boundaries:

**After exploration, before execution** — Compact research context, keep implementation plan

**After completing a milestone** — Fresh start for next phase

**Before major context shifts** — Clear exploration context before different task


When NOT to Use

Non-C++ projects

Legacy C codebases that cannot adopt modern C++ features

Embedded/bare-metal contexts where specific guidelines conflict with hardware constraints (adapt selectively)


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.

When NOT to Use

| Instead of code-tour | Use |
| --- | --- |
| A one-off explanation in chat is enough | answer directly |
| The user wants prose docs, not a `.tour` artifact | `documentation-lookup` or repo docs editing |
| The task is implementation or refactoring | do the implementation work |
| The task is broad codebase onboarding without a tour artifact | `codebase-onboarding` |


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

Design System — Generate & Audit Visual Systems

How It Works

Mode 1: Generate Design System

Analyzes your codebase and generates a cohesive design system:

Output: `DESIGN.md` + `design-tokens.json` + `design-preview.html`


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.

Best Practices

Update Jira as you go, not all at once at the end

Keep comments concise but informative

Link rather than copy — point to PRs, test reports, and dashboards

Use @mentions if you need input from others

Check linked issues to understand full feature scope before starting

If acceptance criteria are vague, ask for clarification before writing code


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

Preferred Tool Surface

Use Google Drive as the entry point, then switch to the right specialist:

Google Docs for text-heavy docs

Google Sheets for tabular work, formulas, and charts

Google Slides for decks, imports, template migration, and cleanup

Do not guess structure from filenames alone. Inspect first.


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

UI Demo Video Recorder
Phase 1: Discover

Phase 1: Discover

Before writing any script, explore the target pages to understand what is actually there.


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

Eval Harness Skill
Product Evals (v1.8)
Eval Anti-Patterns

Eval Anti-Patterns

Overfitting prompts to known eval examples

Measuring only happy-path outputs

Ignoring cost and latency drift while chasing pass rates

Allowing flaky graders in release gates


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

ClickHouse Analytics Patterns
Performance Monitoring

Streaming Insert

Materialized Views

Real-time Aggregations

Performance Monitoring


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

Rust Development Patterns
Unsafe Code
When Unsafe Is NOT Acceptable

Async with Tokio

Unsafe Code

When Unsafe Is Acceptable

When Unsafe Is NOT Acceptable


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.

5. Decide whether the task should stay manual

If the user is likely to ask the same research question repeatedly, say so explicitly and recommend a monitoring or workflow layer instead of repeating the same manual search forever.


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

Swift Actors for Thread-Safe Persistence

When to Activate

Building a data persistence layer in Swift 5.5+

Need thread-safe access to shared mutable state

Want to eliminate manual synchronization (locks, DispatchQueues)

Building offline-first apps with local storage


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

Project Flow Ops

This skill turns disconnected GitHub issues, PRs, and Linear tasks into one execution flow.

Use it when the problem is coordination, not coding.


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

6. Ralphinho / RFC-Driven DAG Orchestration

Data Flow Between Stages

Worktree Isolation

Every unit runs in an isolated worktree (uses jj/Jujutsu, not git):

Pipeline stages for the same unit **share** a worktree, preserving state (context files, plan files, code changes) across research → plan → implement → test → review.


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

CI/CD Operations

When CI fails:

Check the workflow run: `gh run view <run-id> --log-failed`

Identify the failing step

Check if it is a flaky test vs real failure

For real failures: identify the root cause and suggest a fix

For flaky tests: note the pattern for future investigation


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

Review Pack Format

Outbound Rules

Default email path is Apple Mail / Mail.app draft creation.

Do not send automatically.

Choose the channel based on warmth, relevance, and context depth.

Do not force a DM when an email or no outreach is the right move.

Drafts should sound like the user, not like automated sales copy.


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.

Example 3: EPIC Project

**User input:**

**Optimized Prompt (Full):**

Related Components

| Component | When to Reference |
|-----------|------------------|
| `configure-ecc` | User hasn't set up ECC yet |
| `skill-stocktake` | Audit which components are installed (use instead of hardcoded catalog) |
| `search-first` | Research phase in optimized prompts |
| `blueprint` | EPIC-scope optimized prompts (invoke as skill, not command) |
| `strategic-compact` | Long session context management |
| `cost-aware-llm-pipeline` | Token optimization recommendations |


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.

DO

DON'T

Functions (F.*)

Key Rules

| Rule | Summary |
|------|---------|
| **F.1** | Package meaningful operations as carefully named functions |
| **F.2** | A function should perform a single logical operation |
| **F.3** | Keep functions short and simple |
| **F.4** | If a function might be evaluated at compile time, declare it `constexpr` |
| **F.6** | If your function must not throw, declare it `noexcept` |
| **F.8** | Prefer pure functions |
| **F.16** | For "in" parameters, pass cheaply-copied types by value and others by `const&` |
| **F.20** | For "out" values, prefer return values to output parameters |
| **F.21** | To return multiple "out" values, prefer returning a struct |
| **F.43** | Never return a pointer or reference to a local object |


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

Configure Everything Claude Code (ECC)
Step 4: Post-Installation Verification
4b: Check Path References

4b: Check Path References

Scan all installed `.md` files for path references:

**For project-level installs**, flag any references to `~/.claude/` paths:

If a skill references `~/.claude/settings.json` — this is usually fine (settings are always user-level)

If a skill references `~/.claude/skills/` or `~/.claude/rules/` — this may be broken if installed only at project level

If a skill references another skill by name — check that the referenced skill was also installed


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

**Perception + memory + actions for video, live streams, and desktop sessions.**


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

Frontend Development Patterns

Modern frontend patterns for React, Next.js, and performant user interfaces.


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

Flutter/Dart Code Review Best Practices
4. State Management (Library-Agnostic)
Rebuild optimization:

Rebuild optimization:

[ ] State consumer widgets (Builder, Consumer, Observer, Obx, Watch, etc.) scoped as narrow as possible

[ ] Selectors used to rebuild only when specific fields change — not on every state emission

[ ] `const` widgets used to stop rebuild propagation through the tree

[ ] Computed/derived state is calculated reactively, not stored redundantly