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
Anti-Patterns

Anti-Patterns

Making CDSS checks optional or skippable without documented reason

Implementing interaction checks as toast notifications

Using `any` types for drug or clinical data

Hardcoding interaction pairs instead of using a maintainable data structure

Silently catching errors in CDSS engine (must surface failures loudly)

Skipping weight-based validation when weight is not available (must block, not pass)


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.

Non-Negotiable Rules

Do not invent product truth. Mark unresolved questions explicitly.

Separate user-visible promises from implementation details.

Call out what is fixed policy, what is architecture preference, and what is still open.

If the request conflicts with existing repo constraints, say so clearly instead of smoothing it over.

Prefer one reusable capability artifact over scattered ad hoc notes.


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

Video Editing
Layer 3: Deterministic Cuts (FFmpeg)
Concatenate segments

Extract segment by timestamp

Batch cut from edit decision list

Concatenate segments


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

Voice Handling

If the user wants a specific voice, run `brand-voice` first and reuse its `VOICE PROFILE`.
Do not duplicate a second style-analysis pass here unless the user explicitly asks for one.

If no voice references are given, default to a sharp operator voice: concrete, unsentimental, useful.


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

Prompt Optimizer

Analyze a draft prompt, critique it, match it to ECC ecosystem components,
and output a complete optimized prompt the user can paste and run.


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

GitHub Operations
PR Management
Stale Policy

Stale Policy

Issues with no activity in 14+ days: add `stale` label, comment asking for update

PRs with no activity in 7+ days: comment asking if still active

Auto-close stale issues after 30 days with no response (add `closed-stale` label)


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

Prerequisites

This skill must be accessible to Claude Code before activation. Two ways to bootstrap:

**Via Plugin**: `/plugin install everything-claude-code` — the plugin loads this skill automatically

**Manual**: Copy only this skill to `~/.claude/skills/configure-ecc/SKILL.md`, then activate by saying "configure ecc"


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

Anti-Patterns to Avoid

Using `DispatchQueue` or `NSLock` instead of actors for new Swift concurrency code

Exposing the internal cache dictionary to external callers

Making the file URL configurable without validation

Forgetting that all actor method calls are `await` — callers must handle async context

Using `nonisolated` to bypass actor isolation (defeats the purpose)


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

Writing Hookify Rules
Event Type Guide
bash Events

Event Type Guide

bash Events

Match Bash command patterns:

Dangerous commands: `rm\s+-rf`, `dd\s+if=`, `mkfs`

Privilege escalation: `sudo\s+`, `su\s+`

Permission issues: `chmod\s+777`


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

Django Security Best Practices
When to Activate

When to Activate

Setting up Django authentication and authorization

Implementing user permissions and roles

Configuring production security settings

Reviewing Django application for security issues

Deploying Django applications to production


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

3. Expression Bodies and Single-Expression Functions

Use expression bodies for concise, readable functions.


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

GAN-Style Harness Skill
The Three Agents
1. Planner Agent

Architecture

The Three Agents

1. Planner Agent

**Role:** Product manager — expands a brief prompt into a full product specification.

**Key behaviors:**

Takes a one-line prompt and produces a 16-feature, multi-sprint specification

Defines user stories, technical requirements, and visual design direction

Is deliberately **ambitious** — conservative planning leads to underwhelming results

Produces evaluation criteria that the Evaluator will use later

**Model:** Opus 4.6 (needs deep reasoning for spec expansion)


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

Strategic Compact Skill
Token Optimization Patterns
Trigger-Table Lazy Loading

Token Optimization Patterns

Trigger-Table Lazy Loading

Instead of loading full skill content at session start, use a trigger table that maps keywords to skill paths. Skills load only when triggered, reducing baseline context by 50%+:

| Trigger | Skill | Load When |
|---------|-------|-----------|
| "test", "tdd", "coverage" | tdd-workflow | User mentions testing |
| "security", "auth", "xss" | security-review | Security-related work |
| "deploy", "ci/cd" | deployment-patterns | Deployment context |


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

AI Regression Testing
Sandbox-Mode API Testing

Sandbox-Mode API Testing

Most projects with AI-friendly architecture have a sandbox/mock mode. This is the key to fast, DB-free API testing.


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

Spring Boot Development Patterns
Service Layer with Transactions

REST API Structure

Repository Pattern (Spring Data JPA)

Service Layer with Transactions


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

Generate only what you need. Do not generate the whole video.


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)

Concurrency & Parallelism (CP.*)

Key Rules

| Rule | Summary |
|------|---------|
| **CP.2** | Avoid data races |
| **CP.3** | Minimize explicit sharing of writable data |
| **CP.4** | Think in terms of tasks, rather than threads |
| **CP.8** | Don't use `volatile` for synchronization |
| **CP.20** | Use RAII, never plain `lock()`/`unlock()` |
| **CP.21** | Use `std::scoped_lock` to acquire multiple mutexes |
| **CP.22** | Never call unknown code while holding a lock |
| **CP.42** | Don't wait without a condition |
| **CP.44** | Remember to name your `lock_guard`s and `unique_lock`s |
| **CP.100** | Don't use lock-free programming unless you absolutely have to |


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

Core Pattern — Global and Static Variables

MainActor Default Inference Mode

Swift 6.2 introduces a mode where MainActor is inferred by default — no manual annotations needed:

This mode is opt-in and recommended for apps, scripts, and other executable targets.


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

Use this skill when:

the user asks for a code tour, onboarding tour, architecture walkthrough, or PR tour

the user says "explain how X works" and wants a reusable guided artifact

the user wants a ramp-up path for a new engineer or reviewer

the task is better served by a guided sequence than a flat summary

Examples:

onboarding a new maintainer

architecture tour for one service or package

PR-review walk-through anchored to changed files

RCA tour showing the failure path

security review tour of trust boundaries and key checks


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

Plankton Code Quality Skill
Pairing with ECC
Recommended Combination

Recommended Combination

Install ECC as your plugin (agents, skills, commands, rules)

Add Plankton hooks for write-time quality enforcement

Use AgentShield for security audits

Use ECC's verification-loop as a final gate before PRs


Plankton Code Quality Skill

Integration reference for Plankton (credit: @alxfazio), a write-time code quality enforcement system for Claude Code. Plankton runs formatters and linters on every file edit via PostToolUse hooks, then spawns Claude subprocesses to fix violations the agent didn't catch.


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

Iterative Retrieval Pattern
The Solution: Iterative Retrieval

The Solution: Iterative Retrieval

A 4-phase loop that progressively refines context:


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.

Example: Find Laravel 12 Compatible Packages

Returns packages compatible with Laravel 12.


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

When to Activate

Designing JPA entities and table mappings

Defining relationships (@OneToMany, @ManyToOne, @ManyToMany)

Optimizing queries (N+1 prevention, fetch strategies, projections)

Configuring transactions, auditing, or soft deletes

Setting up pagination, sorting, or custom repository methods

Tuning connection pooling (HikariCP) or second-level caching


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

Frontend Design
Strong Defaults
Background

Background

Use atmosphere:

gradients

meshes

textures

subtle noise

patterns

layered transparency

Flat empty backgrounds are rarely the best answer for a product-facing page.


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.

Verification

important claims are labeled by evidence type

freshness-sensitive outputs include dates

the final recommendation matches the actual research mode used


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

Go Testing Patterns
Subtests and Sub-benchmarks
Organizing Related Tests

Table-Driven Tests with Error Cases

Subtests and Sub-benchmarks

Organizing Related Tests


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

Ktor Server Patterns
Content Negotiation & Serialization

Basic Routes

Route Organization with Authenticated Routes

Content Negotiation & Serialization


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.

Connections Optimizer
Tool Requirements
Fallbacks

Fallbacks

browser control for LinkedIn analysis and drafting

browser control for X if API coverage is constrained

Apple Mail or Mail.app drafting via desktop automation when email is the right channel


Multi-agent orchestration using dmux (tmux pane manager for AI agents). Patterns for parallel agent workflows across Claude Code, Codex, OpenCode, and other harnesses. Use when running multiple agent sessions in parallel or coordinating multi-agent development workflows.

ECC Helper

ECC now includes a helper for external tmux-pane orchestration with separate git worktrees:

Example `plan.json`:

The helper:

Creates one branch-backed git worktree per worker

Optionally overlays selected `seedPaths` from the main checkout into each worker worktree

Writes per-worker `task.md`, `handoff.md`, and `status.md` files under `.orchestration/<session>/`

Starts a tmux session with one pane per worker

Launches each worker command in its own pane

Leaves the main pane free for the orchestrator

Use `seedPaths` when workers need access to dirty or untracked local files that are not yet part of `HEAD`, such as local orchestration scripts, draft plans, or docs:


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.

Skill Stack

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

`workspace-surface-audit` for connector, MCP, hook, and app inventory

`knowledge-ops` when the audit needs to reconcile live repo truth with durable context

`github-ops` when the answer depends on CI, scheduled workflows, issues, or PR automation

`ecc-tools-cost-audit` when the real problem is webhook fanout, queued jobs, or billing burn in the sibling app repo

`research-ops` when local inventory must be compared against current platform support or public docs

`verification-loop` for proving post-fix state instead of relying on assumed recovery


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
Decision Frameworks
Safety Stock Service Level Selection

Safety Stock Service Level Selection

| Segment | Target Service Level | Z-Score | Rationale |
|---|---|---|---|
| AX (high-value, predictable) | 97.5% | 1.96 | High value justifies investment; low variability keeps SS moderate |
| AY (high-value, moderate variability) | 95% | 1.65 | Standard target; variability makes higher SL prohibitively expensive |
| AZ (high-value, erratic) | 92–95% | 1.41–1.65 | Erratic demand makes high SL astronomically expensive; supplement with expediting capability |
| BX/BY | 95% | 1.65 | Standard target |
| BZ | 90% | 1.28 | Accept some stockout risk on mid-tier erratic items |
| CX/CY | 90–92% | 1.28–1.41 | Low value doesn't justify high SS investment |
| CZ | 85% | 1.04 | Candidate for discontinuation; minimal investment |


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
Types

Commit Messages

Conventional Commits Format

Types

| Type | Use For | Example |
|------|---------|---------|
| `feat` | New feature | `feat(auth): add OAuth2 login` |
| `fix` | Bug fix | `fix(api): handle null response in user endpoint` |
| `docs` | Documentation | `docs(readme): update installation instructions` |
| `style` | Formatting, no code change | `style: fix indentation in login component` |
| `refactor` | Code refactoring | `refactor(db): extract connection pool to module` |
| `test` | Adding/updating tests | `test(auth): add unit tests for token validation` |
| `chore` | Maintenance tasks | `chore(deps): update dependencies` |
| `perf` | Performance improvement | `perf(query): add index to users table` |
| `ci` | CI/CD changes | `ci: add PostgreSQL service to test workflow` |
| `revert` | Revert previous commit | `revert: revert "feat(auth): add OAuth2 login"` |


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

References

| Project | Author | Link |
|---------|--------|------|
| Ralphinho | enitrat | credit: @enitrat |
| Infinite Agentic Loop | disler | credit: @disler |
| Continuous Claude | AnandChowdhary | credit: @AnandChowdhary |
| NanoClaw | ECC | `/claw` command in this repo |
| Verification Loop | ECC | `skills/verification-loop/` in this repo |


Autonomous Loops Skill
1. Sequential Pipeline (`claude -p`)
Key Design Principles

Key Design Principles

**Each step is isolated** — A fresh context window per `claude -p` call means no context bleed between steps.

**Order matters** — Steps execute sequentially. Each builds on the filesystem state left by the previous.

**Negative instructions are dangerous** — Don't say "don't test type systems." Instead, add a separate cleanup step (see [De-Sloppify Pattern](#5-the-de-sloppify-pattern)).

**Exit codes propagate** — `set -e` stops the pipeline on failure.


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

Routine Bash Gate (once per session)

Quick Start

Option A: Use the ECC hook (zero install)

The hook at `scripts/hooks/gateguard-fact-force.js` is included in this plugin. Enable it via hooks.json.


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

Blueprint — Construction Plan Generator
Source

Source

Inspired by antbotlab/blueprint — upstream project and reference design.


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

Django Verification Loop
Quick Reference

Continuous Integration

GitHub Actions Example

Quick Reference

| Check | Command |
|-------|---------|
| Environment | `python --version` |
| Type checking | `mypy .` |
| Linting | `ruff check .` |
| Formatting | `black . --check` |
| Migrations | `python manage.py makemigrations --check` |
| Tests | `pytest --cov=apps` |
| Security | `pip-audit && bandit -r .` |
| Django check | `python manage.py check --deploy` |
| Collectstatic | `python manage.py collectstatic --noinput` |
| Diff stats | `git diff --stat` |

Remember: Automated verification catches common issues but doesn't replace manual code review and testing in staging environment.


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

Swift 6.2 Approachable Concurrency
Anti-Patterns to Avoid

Anti-Patterns to Avoid

Applying `@concurrent` to every async function (most don't need background execution)

Using `nonisolated` to suppress compiler errors without understanding isolation

Keeping legacy `DispatchQueue` patterns when actors provide the same safety

Skipping `model.availability` checks in concurrency-related Foundation Models code

Fighting the compiler — if it reports a data race, the code has a real concurrency issue

Assuming all async code runs in the background (Swift 6.2 default: stays on calling actor)


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

Agent Harness Construction

Use this skill when you are improving how an agent plans, calls tools, recovers from errors, and converges on completion.


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

Writing Hookify Rules
Pattern Writing Tips
Regex Basics

Pattern Writing Tips

Regex Basics

Escape special chars: `.` to `\.`, `(` to `\(`

`\s` whitespace, `\d` digit, `\w` word char

`+` one or more, `*` zero or more, `?` optional

`|` OR operator


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

Example: The Bug That Inspired This Skill

**ThreadList.tsx "New Email" button:**

Store definition:

**Systematic debugging missed it** because:

The button has an onClick handler (not dead)

Both functions exist (no missing wiring)

Neither function crashes (no runtime error)

The data types are correct (no type mismatch)

**Click-path audit catches it** because:

Step 1 maps `selectThread` resets `composeMode`

Step 2 traces the handler: call 1 sets true, call 2 resets false

Verdict: Sequential Undo — final state contradicts button intent


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

AI-First Engineering
Code Review in AI-First Teams

Code Review in AI-First Teams

Review for:

behavior regressions

security assumptions

data integrity

failure handling

rollout safety

Minimize time spent on style issues already covered by automation.


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

ClickHouse Analytics Patterns
Best Practices
1. Partitioning Strategy

Best Practices

1. Partitioning Strategy

Partition by time (usually month or day)

Avoid too many partitions (performance impact)

Use DATE type for partition key


Codified expertise for production scheduling, job sequencing, line balancing, changeover optimization, and bottleneck resolution in discrete and batch manufacturing. Informed by production schedulers with 15+ years experience. Includes TOC/drum-buffer-rope, SMED, OEE analysis, disruption response frameworks, and ERP/MES interaction patterns. Use when scheduling production, resolving bottlenecks, optimizing changeovers, responding to disruptions, or balancing manufacturing lines.

Production Scheduling
Core Knowledge
OEE — Overall Equipment Effectiveness

OEE — Overall Equipment Effectiveness

**Calculation:** OEE = Availability × Performance × Quality. Availability = (Planned Production Time − Downtime) / Planned Production Time. Performance = (Ideal Cycle Time × Total Pieces) / Operating Time. Quality = Good Pieces / Total Pieces. World-class OEE is 85%+; typical discrete manufacturing runs 55–65%.

**Planned vs. unplanned downtime:** Planned downtime (scheduled maintenance, changeovers, breaks) is excluded from the Availability denominator in some OEE standards and included in others. Use TEEP (Total Effective Equipment Performance) when you need to compare across plants or justify capital expansion — TEEP includes all calendar time.

**Availability losses:** Breakdowns and unplanned stops. Address with preventive maintenance, predictive maintenance (vibration analysis, thermal imaging), and TPM operator-level daily checks. Target: unplanned downtime < 5% of scheduled time.

**Performance losses:** Speed losses and micro-stops. A machine rated at 100 parts/hour running at 85 parts/hour has a 15% performance loss. Common causes: material feed inconsistencies, worn tooling, sensor false-triggers, and operator hesitation. Track actual cycle time vs. standard cycle time per job.

**Quality losses:** Scrap and rework. First-pass yield below 95% on a constraint operation directly reduces effective capacity. Prioritise quality improvement at the constraint — a 2% yield improvement at the constraint delivers the same throughput gain as a 2% capacity expansion.


Agent Harness Construction
Action Space Design

Action Space Design

Use stable, explicit tool names.

Keep inputs schema-first and narrow.

Return deterministic output shapes.

Avoid catch-all tools unless isolation is impossible.


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

Strategic Compact Skill

Suggests manual `/compact` at strategic points in your workflow rather than relying on arbitrary auto-compaction.


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
Analyzing a Ticket
2. Test Types Needed

2. Test Types Needed

**Unit tests** — Individual functions and utilities

**Integration tests** — API endpoints and service interactions

**E2E tests** — User-facing UI flows

**API tests** — Endpoint contracts and error handling


Autonomous Loops Skill
1. Sequential Pipeline (`claude -p`)

1. Sequential Pipeline (`claude -p`)

**The simplest loop.** Break daily development into a sequence of non-interactive `claude -p` calls. Each call is a focused step with a clear prompt.


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

Good Use Cases

"We have GitHub, Linear, and local hook alerts, but no single operator flow"

"Our CI failures are noisy and people ignore them"

"I want one notification policy across Claude, OpenCode, and Codex surfaces"

"Figure out what should interrupt versus land in a digest"

"Collapse overlapping notification PR ideas into one canonical ECC lane"


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

When to Use

New features or endpoints in Laravel

Bug fixes or refactors

Testing Eloquent models, policies, jobs, and notifications

Prefer Pest for new tests unless the project already standardizes on PHPUnit


Git Workflow Patterns
Conflict Resolution
Conflict Prevention Strategies

Conflict Resolution

Identify Conflicts

Resolve Conflicts

Conflict Prevention Strategies


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.

Issue Triage

Classify each issue by type and priority:

**Types:** bug, feature-request, question, documentation, enhancement, duplicate, invalid, good-first-issue

**Priority:** critical (breaking/security), high (significant impact), medium (nice to have), low (cosmetic)


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.

Get User by Username

Upload Media and Post

Rate Limits

X API rate limits vary by endpoint, auth method, and account tier, and they change over time. Always:

Check the current X developer docs before hardcoding assumptions

Read `x-rate-limit-remaining` and `x-rate-limit-reset` headers at runtime

Back off automatically instead of relying on static tables in code


Neural search via Exa MCP for web, code, and company research. Use when the user needs web search, code examples, company intel, people lookup, or AI-powered deep research with Exa's neural search engine.

When to Activate

User needs current web information or news

Searching for code examples, API docs, or technical references

Researching companies, competitors, or market players

Finding professional profiles or people in a domain

Running background research for any development task

User says "search for", "look up", "find", or "what's the latest on"


Build an evidence-backed ECC install plan for a specific repo by sorting skills, commands, rules, hooks, and extras into DAILY vs LIBRARY buckets using parallel repo-aware review passes. Use when ECC should be trimmed to what a project actually needs instead of loading the full bundle.

Evidence Sources

Use repo-local evidence before making any classification:

file extensions

package managers and lockfiles

framework configs

CI and hook configs

build/test scripts

imports and dependency manifests

repo docs that explicitly describe the stack

Useful commands include:


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
Examples of Good Recommendations

Output Format

Use this structure:

Examples of Good Recommendations

"The right fix is a billing portal, not a custom dashboard yet"

"This looks like duplicate personal checkout, not a real team-seat purchase"

"Refund one duplicate charge, keep the remaining active subscription, then convert the customer to org billing later if needed"


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

Python Testing Patterns
Fixtures
Basic Fixture Usage

pytest Fundamentals

Basic Test Structure

Assertions

Fixtures

Basic Fixture Usage


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

Kotlin Coroutines & Flows
Cancellation
Cooperative Cancellation

Cancellation

Cooperative Cancellation

Long-running loops must check for cancellation:


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.

Example 2: Generate CLAUDE.md for existing project

**User**: "Generate a CLAUDE.md for this project"
**Action**: Run Phases 1-3, skip Onboarding Guide, produce only CLAUDE.md
**Output**: Project-specific `CLAUDE.md` with detected conventions


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

Healthcare PHI/PII Compliance Patterns
When to Use

When to Use

Building any feature that touches patient records

Implementing access control or authentication for clinical systems

Designing database schemas for healthcare data

Building APIs that return patient or clinician data

Implementing audit trails or logging

Reviewing code for data exposure vulnerabilities

Setting up Row-Level Security (RLS) for multi-tenant healthcare systems


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

How It Works

Exposed provides two query styles: DSL for direct SQL-like expressions and DAO for entity lifecycle management. HikariCP manages a pool of reusable database connections configured via `HikariConfig`. Flyway runs versioned SQL migration scripts at startup to keep the schema in sync. All database operations run inside `newSuspendedTransaction` blocks for coroutine safety and atomicity. The repository pattern wraps Exposed queries behind an interface so business logic stays decoupled from the data layer and tests can use an in-memory H2 database.


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.

Output Format

Return:

core visual thesis

storyboard

scene outline

render plan

any follow-on polish recommendations


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

Architecture Decision Records
When to Activate

When to Activate

User explicitly says "let's record this decision" or "ADR this"

User chooses between significant alternatives (framework, library, pattern, database, API design)

User says "we decided to..." or "the reason we're doing X instead of Y is..."

User asks "why did we choose X?" (read existing ADRs)

During planning phases when architectural trade-offs are discussed


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

Examples

`帮我设计一只 OpenClaw 龙虾灵魂，气质要冷幽默但可靠`

`抽卡，给我来 3 只风格完全不同的龙虾`

`我已经有 SOUL.md 草稿了，帮我补全名字、底线规则和头像提示词`

参考细节见：

`references/identity-tension.md`

`references/boundary-rules.md`

`references/naming-system.md`

`references/avatar-style.md`

`references/output-template.md`


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.

Skill Stack

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

`autonomous-loops` for bounded multi-step audits that cross webhooks, queues, billing, and retries

`agentic-engineering` for tracing the request path into discrete, provable units

`customer-billing-ops` when repo behavior and customer-impact math must be separated cleanly

`search-first` before inventing helpers or re-implementing repo-local utilities

`security-review` when auth, usage gates, entitlements, or secrets are touched

`verification-loop` for proving rerun safety and exact post-fix state

`tdd-workflow` when the fix needs regression coverage in the worker, router, or billing paths


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

When to Use

user asks to triage inbox or archive low-signal mail

user wants a draft, reply, or new outbound email

user wants to know whether a mail was already sent

the user wants proof of which account, thread, or Sent entry was used


Agent Sort
Core Workflow
4. Build the install plan

4. Build the install plan

Translate the classification into action:

DAILY skills -> install or keep in `.claude/skills/`

DAILY commands -> keep as explicit shims only if still useful

DAILY rules -> install only matching language sets

DAILY hooks/scripts -> keep only compatible ones

LIBRARY surfaces -> keep accessible through search or `skill-library`

If the repo already uses selective installs, update that plan instead of creating another system.


Laravel TDD Workflow
Examples
Coverage Targets

Coverage Targets

Enforce 80%+ coverage for unit + feature tests

Use `pcov` or `XDEBUG_MODE=coverage` in CI


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.

Reactivity discipline (for reactive-mutation solutions: MobX, GetX, Signals):

[ ] State is only mutated through the solution's reactive API (`@action` in MobX, `.value` on signals, `.obs` in GetX) — direct field mutation bypasses change tracking

[ ] Derived values use the solution's computed mechanism rather than being stored redundantly

[ ] Reactions and disposers are properly cleaned up (`ReactionDisposer` in MobX, effect cleanup in Signals)


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

API Design Patterns
API Design Checklist

Go (net/http)

API Design Checklist

Before shipping a new endpoint:

[ ] Resource URL follows naming conventions (plural, kebab-case, no verbs)

[ ] Correct HTTP method used (GET for reads, POST for creates, etc.)

[ ] Appropriate status codes returned (not 200 for everything)

[ ] Input validated with schema (Zod, Pydantic, Bean Validation)

[ ] Error responses follow standard format with codes and messages

[ ] Pagination implemented for list endpoints (cursor or offset)

[ ] Authentication required (or explicitly marked as public)

[ ] Authorization checked (user can only access their own resources)

[ ] Rate limiting configured

[ ] Response does not leak internal details (stack traces, SQL errors)

[ ] Consistent naming with existing endpoints (camelCase vs snake_case)

[ ] Documented (OpenAPI/Swagger spec updated)


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

Santa Method
Failure Modes and Mitigations

Failure Modes and Mitigations

| Failure Mode | Symptom | Mitigation |
|-------------|---------|------------|
| Infinite loop | Reviewers keep finding new issues after fixes | Max iteration cap (3). Escalate. |
| Rubber stamping | Both reviewers pass everything | Adversarial prompt: "Your job is to find problems, not approve." |
| Subjective drift | Reviewers flag style preferences, not errors | Tight rubric with objective pass/fail criteria only |
| Fix regression | Fixing issue A introduces issue B | Fresh reviewers each round catch regressions |
| Reviewer agreement bias | Both reviewers miss the same thing | Mitigated by independence, not eliminated. For critical output, add a third reviewer or human spot-check. |
| Cost explosion | Too many iterations on large outputs | Batch sampling pattern. Budget caps per verification cycle. |


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

How It Works

This skill enforces idiomatic Rust conventions across six key areas: ownership and borrowing to prevent data races at compile time, `Result`/`?` error propagation with `thiserror` for libraries and `anyhow` for applications, enums and exhaustive pattern matching to make illegal states unrepresentable, traits and generics for zero-cost abstraction, safe concurrency via `Arc<Mutex<T>>`, channels, and async/await, and minimal `pub` surfaces organized by domain.


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
Analyzing a Ticket

Search with JQL

Analyzing a Ticket

When retrieving a ticket for development or test automation, extract:


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

Python Development Patterns
Type Hints
Type Aliases and TypeVar

Type Hints

Basic Type Annotations

Modern Type Hints (Python 3.9+)

Type Aliases and TypeVar


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

Deployment Patterns
Docker
Multi-Stage Dockerfile (Python/Django)

Docker

Multi-Stage Dockerfile (Node.js)

Multi-Stage Dockerfile (Go)

Multi-Stage Dockerfile (Python/Django)


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

Lead Intelligence
Stage 3: Warm Path Discovery

Output Format

Stage 3: Warm Path Discovery

For each target, find the shortest introduction chain:


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

Java Coding Standards
Testing Expectations

Testing Expectations

JUnit 5 + AssertJ for fluent assertions

Mockito for mocking; avoid partial mocks where possible

Favor deterministic tests; no hidden sleeps

**Remember**: Keep code intentional, typed, and observable. Optimize for maintainability over micro-optimizations unless proven necessary.


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

Agent Eval Skill
Core Concepts
Git Worktree Isolation

Git Worktree Isolation

Each agent run gets its own git worktree — no Docker required. This provides reproducibility isolation so agents cannot interfere with each other or corrupt the base repo.


Core Principles

Prefer clarity over cleverness

Immutable by default; minimize shared mutable state

Fail fast with meaningful exceptions

Consistent naming and package structure


Flutter/Dart Code Review Best Practices
7. Accessibility
Interaction accessibility:

Interaction accessibility:

[ ] No no-op `onPressed` callbacks — every button does something or is disabled

[ ] Error fields suggest corrections

[ ] Context does not change unexpectedly while user is inputting data


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

Test-Driven Development Workflow
TDD Workflow Steps
Step 6: Refactor

Step 6: Refactor

Improve code quality while keeping tests green:

Remove duplication

Improve naming

Optimize performance

Enhance readability

If the repository is under Git, create a checkpoint commit immediately after refactoring is complete and tests remain green.
Recommended commit message format:

`refactor: clean up after <feature or bug> implementation`

Verify that this checkpoint commit is on the current active branch before considering the TDD cycle complete


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

Removing a Column Safely

Large Data Migrations

Prisma (TypeScript/Node.js)

Workflow


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

ClickHouse Analytics Patterns
Table Design Patterns
ReplacingMergeTree (Deduplication)

Table Design Patterns

MergeTree Engine (Most Common)

ReplacingMergeTree (Deduplication)


4. App-generated branches re-enter the webhook

If `pull_request.synchronize`, branch pushes, or comment-triggered runs fire on app-owned branches, the app can recursively analyze its own output.


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)
Troubleshooting
"Rules not working"

"Rules not working"

Rules are flat files, not in subdirectories: `$TARGET/rules/coding-style.md` (correct) vs `$TARGET/rules/common/coding-style.md` (incorrect for flat install)

Restart Claude Code after installing rules


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

Context Budget

Analyze token overhead across every loaded component in a Claude Code session and surface actionable optimizations to reclaim context space.


Flutter/Dart Code Review Best Practices
7. Accessibility
Semantic widgets:

7. Accessibility

Semantic widgets:

[ ] `Semantics` widget used to provide screen reader labels where automatic labels are insufficient

[ ] `ExcludeSemantics` used for purely decorative elements

[ ] `MergeSemantics` used to combine related widgets into a single accessible element

[ ] Images have `semanticLabel` property set


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

Role and Context

You are a senior transportation manager with 15+ years managing carrier portfolios ranging from 40 to 200+ active carriers across truckload, LTL, intermodal, and brokerage. You own the full lifecycle: sourcing new carriers, negotiating rates, running RFPs, building routing guides, tracking performance via scorecards, managing contract renewals, and making allocation decisions. Your systems include TMS (transportation management), rate management platforms, carrier onboarding portals, DAT/Greenscreens for market intelligence, and FMCSA SAFER for compliance. You balance cost reduction pressure against service quality, capacity security, and carrier relationship health — because when the market tightens, your carriers' willingness to cover your freight depends on how you treated them when capacity was loose.


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)

Parameter Passing

Pure Functions and constexpr

Anti-Patterns

Returning `T&&` from functions (F.45)

Using `va_arg` / C-style variadics (F.55)

Capturing by reference in lambdas passed to other threads (F.53)

Returning `const T` which inhibits move semantics (F.49)


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

Three-Phase Process

Every demo goes through three phases: **Discover -> Rehearse -> Record**. Never skip straight to recording.


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

Security Scan Skill

Audit your Claude Code configuration for security issues using [AgentShield](https://github.com/affaan-m/agentshield).


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.

When to Activate

User wants to scrape or monitor any public website or API

User says "build a bot that checks...", "monitor X for me", "collect data from..."

User wants to track jobs, prices, news, repos, sports scores, events, listings

User asks how to automate data collection without paying for hosting

User wants an agent that gets smarter over time based on their decisions


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.

Related Skills

`laravel-patterns` — Laravel architecture and patterns

`laravel-tdd` — Test-driven development for Laravel

`laravel-security` — Laravel security best practices

`documentation-lookup` — General library documentation lookup (Context7)


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

Rust Development Patterns
Concurrency
Channels for Message Passing

Concurrency

`Arc<Mutex<T>>` for Shared Mutable State

Channels for Message Passing


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

Example Usage

Output Example

The skill will:

Extract text using available OCR method

Translate to professional English

Generate `<filename>_Translated.pdf` with:

Page 1: Original document image

Page 2: Professional English translation

Perfect for visa applications to Australia, USA, Canada, UK, and other countries requiring translated documents.


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.

Best Practices

Start with `standard` depth for first-time audits

Use `fast` for monorepos with 100+ modules to get a quick inventory

Run `deep` incrementally on modules flagged for refactoring

Review the cross-module analysis for duplicate detection across sub-projects


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

Ralphinho RFC Pipeline

Inspired by [humanplane](https://github.com/humanplane) style RFC decomposition patterns and multi-unit orchestration workflows.

Use this skill when a feature is too large for a single agent pass and must be split into independently verifiable work units.


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

Python Development Patterns
When to Activate

When to Activate

Writing new Python code

Reviewing Python code

Refactoring existing Python code

Designing Python packages/modules


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.

4. End with keep / merge / cut / fix-next

For each overlapping or suspect surface, return one call:

keep

merge

cut

fix next

The value is in collapsing noisy automation into one canonical ECC lane, not in preserving every historical path.


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

How It Works

The CDSS engine is a **pure function library with zero side effects**. Input clinical data, output alerts. This makes it fully testable.

Three primary modules:

**`checkInteractions(newDrug, currentMeds, allergies)`** — Checks a new drug against current medications and known allergies. Returns severity-sorted `InteractionAlert[]`. Uses `DrugInteractionPair` data model.

**`validateDose(drug, dose, route, weight, age, renalFunction)`** — Validates a prescribed dose against weight-based, age-adjusted, and renal-adjusted rules. Returns `DoseValidationResult`.

**`calculateNEWS2(vitals)`** — National Early Warning Score 2 from `NEWS2Input`. Returns `NEWS2Result` with total score, risk level, and escalation guidance.


Constants & Immutability (Con.*)

All Rules

| Rule | Summary |
|------|---------|
| **Con.1** | By default, make objects immutable |
| **Con.2** | By default, make member functions `const` |
| **Con.3** | By default, pass pointers and references to `const` |
| **Con.4** | Use `const` for values that don't change after construction |
| **Con.5** | Use `constexpr` for values computable at compile time |


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

/search-first — Research Before You Code

Systematizes the "search for existing solutions before implementing" workflow.


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
4. Validate against the source pattern

4. Validate against the source pattern

The new connector should look obvious in the codebase, not imported from a different ecosystem.


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

Backend Development Patterns

Backend architecture patterns and best practices for scalable server-side applications.


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.

Related Skills

`brand-voice` for source-derived voice profiles

`crosspost` for platform-specific distribution

`x-api` for sourcing recent posts and publishing approved X output


Testing CDSS (Zero Tolerance for False Negatives)

Pass criteria: 100%. A single missed interaction is a patient safety event.


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

Test Data Builders

CI Commands

Maven: `mvn -T 4 test` or `mvn verify`

Gradle: `./gradlew test jacocoTestReport`

**Remember**: Keep tests fast, isolated, and deterministic. Test behavior, not implementation details.


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

Execution Rules

preserve the established design system when working inside an existing product

match technical complexity to the visual idea

keep accessibility and responsiveness intact

frontends should feel deliberate on desktop and mobile


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

Laravel Development Patterns
Examples
Nested Routes and Binding Names

Nested Routes and Binding Names

Keep prefixes and paths consistent to avoid double nesting (e.g., `conversation` vs `conversations`).

Use a single parameter name that matches the bound model (e.g., `{conversation}` for `Conversation`).

Prefer scoped bindings when nesting to enforce parent-child relationships.

If you want a parameter to resolve to a different model class, define explicit binding. For custom binding logic, use `Route::bind()` or implement `resolveRouteBinding()` on the model.


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
Example Workflows
Meeting Prep Agent

Example Workflows

Autonomous PR Reviewer

Personal Research Agent

Meeting Prep Agent


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

Laravel Security Best Practices
Session and Cookie Hardening

Session and Cookie Hardening

Set `SESSION_HTTP_ONLY=true` to prevent JavaScript access

Use `SESSION_SAME_SITE=strict` for high-risk flows

Regenerate sessions on login and privilege changes


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.

Performance (Per.*)

Key Rules

| Rule | Summary |
|------|---------|
| **Per.1** | Don't optimize without reason |
| **Per.2** | Don't optimize prematurely |
| **Per.6** | Don't make claims about performance without measurements |
| **Per.7** | Design to enable optimization |
| **Per.10** | Rely on the static type system |
| **Per.11** | Move computation from run time to compile time |
| **Per.19** | Access memory predictably |


Spring Boot TDD Workflow
Persistence Tests (DataJpaTest)

Web Layer Tests (MockMvc)

Integration Tests (SpringBootTest)

Persistence Tests (DataJpaTest)


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

When to Use Ralphinho vs Simpler Patterns

| Signal | Use Ralphinho | Use Simpler Pattern |
|--------|--------------|-------------------|
| Multiple interdependent work units | Yes | No |
| Need parallel implementation | Yes | No |
| Merge conflicts likely | Yes | No (sequential is fine) |
| Single-file change | No | Yes (sequential pipeline) |
| Multi-day project | Yes | Maybe (continuous-claude) |
| Spec/RFC already written | Yes | Maybe |
| Quick iteration on one thing | No | Yes (NanoClaw or pipeline) |


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

GitHub Operations
PR Management
Review Checklist

PR Management

Review Checklist

Check CI status: `gh pr checks <number>`

Check if mergeable: `gh pr view <number> --json mergeable`

Check age and last activity

Flag PRs >5 days with no review

For community PRs: ensure they have tests and follow conventions


Backend Development Patterns
API Design Patterns
Service Layer Pattern

API Design Patterns

RESTful API Structure

Repository Pattern

Service Layer Pattern


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

Architecture Decision Records
What Makes a Good ADR
Do

What Makes a Good ADR

Do

**Be specific** — "Use Prisma ORM" not "use an ORM"

**Record the why** — the rationale matters more than the what

**Include rejected alternatives** — future developers need to know what was considered

**State consequences honestly** — every decision has trade-offs

**Keep it short** — an ADR should be readable in 2 minutes

**Use present tense** — "We use X" not "We will use X"


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

Healthcare EMR Development Patterns
How It Works
Medication Safety Pattern

Medication Safety Pattern

Critical interactions **block prescribing by default**. The clinician must explicitly override with a documented reason stored in the audit trail. The system never silently allows a critical interaction.


Laravel Development Patterns
Examples
Custom Casts and Value Objects

Eloquent Model Patterns

Model Configuration

Custom Casts and Value Objects

Use enums or value objects for strict typing.


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

Python Development Patterns
Quick Reference: Python Idioms

Essential Commands

pyproject.toml Configuration

Quick Reference: Python Idioms

| Idiom | Description |
|-------|-------------|
| EAFP | Easier to Ask Forgiveness than Permission |
| Context managers | Use `with` for resource management |
| List comprehensions | For simple transformations |
| Generators | For lazy evaluation and large datasets |
| Type hints | Annotate function signatures |
| Dataclasses | For data containers with auto-generated methods |
| `__slots__` | For memory optimization |
| f-strings | For string formatting (Python 3.6+) |
| `pathlib.Path` | For path operations (Python 3.4+) |
| `enumerate` | For index-element pairs in loops |


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

Frontend Development Patterns
Accessibility Patterns
Focus Management

Accessibility Patterns

Keyboard Navigation

Focus Management

**Remember**: Modern frontend patterns enable maintainable, performant user interfaces. Choose patterns that fit your project complexity.


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

Write Gate (first new file creation)

Destructive Bash Gate (every destructive command)

Triggers on: `rm -rf`, `git reset --hard`, `git push --force`, `drop table`, etc.


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

Deliverable Checklist

presentation runs from a local file in a browser

every slide fits the viewport without scrolling

style is distinctive and intentional

animation is meaningful, not noisy

reduced motion is respected

file paths and customization points are explained at handoff


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

Core Concepts

**POUR Principles**: The foundation of WCAG (Perceivable, Operable, Understandable, Robust).

**Semantic Mapping**: Using native elements over generic containers to provide built-in accessibility.

**Accessibility Tree**: The representation of the UI that assistive technologies actually "read."

**Focus Management**: Controlling the order and visibility of the keyboard/screen reader cursor.

**Labeling & Hints**: Providing context through `aria-label`, `accessibilityLabel`, and `contentDescription`.


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

Anti-Patterns

**Remember**: Perl's flexibility is powerful but requires discipline. Use taint mode for web-facing code, validate all input with allowlists, use DBI placeholders for every query, and encode all output for its context. Defense in depth — never rely on a single layer.


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.

Node.js Keccak-256

Ethereum uses Keccak-256, not the NIST-standardized SHA3 variant exposed by Node's `crypto.createHash('sha3-256')`.


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

Best Practices

**Start with the cheapest model** and only route to expensive models when complexity thresholds are met

**Set explicit budget limits** before processing batches — fail early rather than overspend

**Log model selection decisions** so you can tune thresholds based on real data

**Use prompt caching** for system prompts over 1024 tokens — saves both cost and latency

**Never retry on authentication or validation errors** — only transient failures (network, rate limit, server error)


Autonomous Agent Harness
Replacing Hermes

Replacing Hermes

| Hermes Component | ECC Equivalent | How |
|------------------|---------------|-----|
| Gateway/Router | Claude Code dispatch + crons | Scheduled tasks trigger agent sessions |
| Memory System | Claude memory + MCP memory server | Built-in persistence + knowledge graph |
| Tool Registry | MCP servers | Dynamically loaded tool providers |
| Orchestration | ECC skills + agents | Skill definitions direct agent behavior |
| Computer Use | computer-use MCP | Native browser and desktop control |
| Context Manager | Session management + memory | ECC 2.0 session lifecycle |
| Task Queue | Memory-persisted task list | TodoWrite + memory files |


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
Decision Frameworks
Markdown Timing Decision

Markdown Timing Decision

| Sell-Through at Season Midpoint | Action | Expected Margin Recovery |
|---|---|---|
| ≥ 80% of plan | Hold price. Reorder cautiously if weeks of supply < 3. | Full margin |
| 60–79% of plan | Take 20–25% markdown. No reorder. | 70–80% of original margin |
| 40–59% of plan | Take 30–40% markdown immediately. Cancel any open POs. | 50–65% of original margin |
| < 40% of plan | Take 50%+ markdown. Explore liquidation channels. Flag buying error for post-mortem. | 30–45% of original margin |


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

Plankton Code Quality Skill
ECC v1.8 Additions
Config Tamper Guard

Config Tamper Guard

During quality enforcement, flag changes to config files in same iteration:

`biome.json`, `.eslintrc*`, `prettier.config*`, `tsconfig.json`, `pyproject.toml`

If config is changed to suppress violations, require explicit review before merge.


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

Android Clean Architecture
Domain Layer
UseCase Pattern

Domain Layer

UseCase Pattern

Each UseCase represents one business operation. Use `operator fun invoke` for clean call sites:


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

Philosophy & Interfaces (P.*, I.*)

Key Rules

| Rule | Summary |
|------|---------|
| **P.1** | Express ideas directly in code |
| **P.3** | Express intent |
| **P.4** | Ideally, a program should be statically type safe |
| **P.5** | Prefer compile-time checking to run-time checking |
| **P.8** | Don't leak any resources |
| **P.10** | Prefer immutable data to mutable data |
| **I.1** | Make interfaces explicit |
| **I.2** | Avoid non-const global variables |
| **I.4** | Make interfaces precisely and strongly typed |
| **I.11** | Never transfer ownership by a raw pointer or reference |
| **I.23** | Keep the number of function arguments low |


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

Key Templates

Brief templates appear below. Adapt them to your MRB, supplier quality, and CAPA workflows before using them in production.

**NCR Notification (internal):** Subject: `NCR-{number}: {part_number} — {defect_summary}`. State: what was found, specification violated, quantity affected, current containment status, and initial assessment of scope.

**SCAR to Supplier:** Subject: `SCAR-{number}: Non-Conformance on PO# {po_number} — Response Required by {date}`. Include: part number, lot, specification, measurement data, quantity affected, impact statement, expected response format.

**Customer Quality Notification:** Lead with: containment actions taken, product traceability (lot/serial numbers), recommended customer actions, timeline for corrective action, and direct contact for quality engineering.


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

Content Engine
Platform Adaptation Rules
YouTube

YouTube

show the result or tension early

organize by argument or progression, not filler sections

use chaptering only when it helps clarity


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.

Internal linking

link from strong pages to pages you want to rank

use descriptive anchor text

avoid generic anchors when a more specific one is possible

backfill links from new pages to relevant existing ones


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

When to Activate

Setting up eval-driven development (EDD) for AI-assisted workflows

Defining pass/fail criteria for Claude Code task completion

Measuring agent reliability with pass@k metrics

Creating regression test suites for prompt or agent changes

Benchmarking agent performance across model versions


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)
Examples
Example: Supabase auth methods

Example: Supabase auth methods

Call **resolve-library-id** with `libraryName: "Supabase"`, `query: "What are the auth methods?"`.

Pick the Supabase docs library ID.

Call **query-docs**; summarize the auth methods and show minimal examples from the fetched docs.


How It Works

Principles

Fix technical blockers before content optimization.

One page should have one clear primary search intent.

Prefer long-term quality signals over manipulative patterns.

Mobile-first assumptions matter because indexing is mobile-first.

Recommendations should be page-specific and implementable.


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.

Connections Optimizer
Modes
`light-pass`

Modes

`light-pass`

prune only high-confidence low-value one-way follows

surface the rest for review

generate a small add/follow list


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

Agent Harness Construction
Error Recovery Contract

Error Recovery Contract

For every error path, include:

root cause hint

safe retry instruction

explicit stop condition


Codified expertise for managing carrier portfolios, negotiating freight rates, tracking carrier performance, allocating freight, and maintaining strategic carrier relationships. Informed by transportation managers with 15+ years experience. Includes scorecarding frameworks, RFP processes, market intelligence, and compliance vetting. Use when managing carriers, negotiating rates, evaluating carrier performance, or building freight strategies.

Carrier Relationship Management
Decision Frameworks
Spot vs. Contract Decisions

Spot vs. Contract Decisions

**Stay on contract when:** The spread between contract and spot is <10%. You have consistent, predictable volume. Capacity is tightening (spot rates are rising). The lane is customer-critical with tight delivery windows.

**Go to spot when:** Spot rates are >15% below your contract rate (market is soft). The lane is irregular (<1 load/week). You need one-time surge capacity beyond your routing guide. Your contract carrier is consistently rejecting tenders on this lane (they're effectively pricing you into spot anyway).

**Renegotiate contract when:** The spread between your contract rate and DAT benchmark exceeds 15% for 60+ consecutive days. A carrier's tender acceptance drops below 75% for 30 days. You've had a significant volume change (up or down) that changes the lane economics.


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.

Output Format

Return:

Good Use Cases

"Audit the open PR backlog and tell me what to merge vs rebuild"

"Map GitHub issues into our ECC 1.x and ECC 2.0 program lanes"

"Check whether this needs a Linear issue or should stay GitHub-only"


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

2. NanoClaw REPL

**ECC's built-in persistent loop.** A session-aware REPL that calls `claude -p` synchronously with full conversation history.


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

Frontend Design
Design Workflow
3. Compose with intention

3. Compose with intention

Prefer:

asymmetry when it sharpens hierarchy

overlap when it creates depth

strong whitespace when it clarifies focus

dense layouts only when the product benefits from density

Avoid defaulting to a symmetrical card grid unless it is clearly the right fit.


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

Python Testing Patterns
Common Patterns
Testing Database Operations

Common Patterns

Testing API Endpoints (FastAPI/Flask)

Testing Database Operations


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

Commands

`/hookify [description]` - Create new rules (auto-analyzes conversation if no args)

`/hookify-list` - View all rules in table format

`/hookify-configure` - Toggle rules on/off interactively

`/hookify-help` - Full documentation


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

C++ Testing (Agent Skill)
When to Use
When NOT to Use

When NOT to Use

Implementing new product features without test changes

Large-scale refactors unrelated to test coverage or failures

Performance tuning without test regressions to validate

Non-C++ projects or non-test tasks


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

Go Development Patterns
Quick Reference: Go Idioms

Essential Commands

Recommended Linter Configuration (.golangci.yml)

Quick Reference: Go Idioms

| Idiom | Description |
|-------|-------------|
| Accept interfaces, return structs | Functions accept interface params, return concrete types |
| Errors are values | Treat errors as first-class values, not exceptions |
| Don't communicate by sharing memory | Use channels for coordination between goroutines |
| Make the zero value useful | Types should work without explicit initialization |
| A little copying is better than a little dependency | Avoid unnecessary external dependencies |
| Clear is better than clever | Prioritize readability over cleverness |
| gofmt is no one's favorite but everyone's friend | Always format with gofmt/goimports |
| Return early | Handle errors first, keep happy path unindented |


Build an evidence-backed ECC install plan for a specific repo by sorting skills, commands, rules, hooks, and extras into DAILY vs LIBRARY buckets using parallel repo-aware review passes. Use when ECC should be trimmed to what a project actually needs instead of loading the full bundle.

Agent Sort
Core Workflow
5. Create the optional library router

5. Create the optional library router

If the project wants a searchable library surface, create:

`.claude/skills/skill-library/SKILL.md`

That router should contain:

a short explanation of DAILY vs LIBRARY

grouped trigger keywords

where the library references live

Do not duplicate every skill body inside the router.


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

PostgreSQL Patterns
Quick Reference
Common Patterns

Common Patterns

**Composite Index Order:**

**Covering Index:**

**Partial Index:**

**RLS Policy (Optimized):**

**UPSERT:**

**Cursor Pagination:**

**Queue Processing:**


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

Guardrails

resolve the source first:

local messages

X / social DM

another browser-gated message surface

do not claim a thread was checked without naming the source

do not improvise raw database access if a checked helper or standard path exists

if auth or MFA blocks the surface, report the exact blocker


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

Continuous Learning v2.1 - Instinct
When to Activate

When to Activate

Setting up automatic learning from Claude Code sessions

Configuring instinct-based behavior extraction via hooks

Tuning confidence thresholds for learned behaviors

Reviewing, exporting, or importing instinct libraries

Evolving instincts into full skills, commands, or agents

Managing project-scoped vs global instincts

Promoting instincts from project to global scope


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

When to Activate

Writing new tests for C# code

Reviewing test quality and coverage

Setting up test infrastructure for .NET projects

Debugging flaky or slow tests


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
1. Persistent Memory

Architecture

Core Components

1. Persistent Memory

Use Claude Code's built-in memory system enhanced with MCP memory server for structured data.

**Built-in memory** (`~/.claude/projects/*/memory/`):

User preferences, feedback, project context

Stored as markdown files with frontmatter

Automatically loaded at session start

**MCP memory server** (structured knowledge graph):

Entities, relations, observations

Queryable graph structure

Cross-session persistence

**Memory patterns:**


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
Configuration
Environment Variables

Configuration

Environment Variables

| Variable | Default | Description |
|----------|---------|-------------|
| `GAN_MAX_ITERATIONS` | `15` | Maximum generator-evaluator cycles |
| `GAN_PASS_THRESHOLD` | `7.0` | Weighted score to pass (1-10) |
| `GAN_PLANNER_MODEL` | `opus` | Model for planning agent |
| `GAN_GENERATOR_MODEL` | `opus` | Model for generator agent |
| `GAN_EVALUATOR_MODEL` | `opus` | Model for evaluator agent |
| `GAN_EVAL_CRITERIA` | `design,originality,craft,functionality` | Comma-separated criteria |
| `GAN_DEV_SERVER_PORT` | `3000` | Port for the live app |
| `GAN_DEV_SERVER_CMD` | `npm run dev` | Command to start dev server |
| `GAN_PROJECT_DIR` | `.` | Project working directory |
| `GAN_SKIP_PLANNER` | `false` | Skip planner, use spec directly |
| `GAN_EVAL_MODE` | `playwright` | `playwright`, `screenshot`, or `code-only` |


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


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 6: Diff Review

Common Security Findings

Phase 5: Lint/Format (optional gate)

Phase 6: Diff Review

Checklist:

No debugging logs left (`System.out`, `log.debug` without guards)

Meaningful errors and HTTP statuses

Transactions and validation present where needed

Config changes documented


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

Content-Hash File Cache Pattern
Core Pattern
1. Content-Hash Based Cache Key

Core Pattern

1. Content-Hash Based Cache Key

Use file content (not path) as the cache key:

**Why content hash?** File rename/move = cache hit. Content change = automatic invalidation. No index file needed.


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

Strategic Compact Skill
Token Optimization Patterns
Context Composition Awareness

Context Composition Awareness

Monitor what's consuming your context window:

**CLAUDE.md files** — Always loaded, keep lean

**Loaded skills** — Each skill adds 1-5K tokens

**Conversation history** — Grows with each exchange

**Tool results** — File reads, search results add bulk


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

Quality & Non-Conformance Management
Core Knowledge
Supplier Quality Management

Supplier Quality Management

**Audit Methodology:** Process audits assess how work is done (observe, interview, sample). System audits assess QMS compliance (document review, record sampling). Product audits verify specific product characteristics. Use a risk-based audit schedule — high-risk suppliers annually, medium biennially, low every 3 years plus cause-based. Announce audits for system assessments; unannounced audits for process verification when performance concerns exist.

**Supplier Scorecards:** Measure PPM (parts per million defective), on-time delivery, SCAR response time, SCAR effectiveness (recurrence rate), and lot acceptance rate. Weight the metrics by business impact. Share scorecards quarterly. Scores drive inspection level adjustments, business allocation, and ASL status.

**Corrective Action Requests (CARs/SCARs):** Issue for each significant non-conformance or repeated minor non-conformances. Expect 8D or equivalent root cause analysis. Set response deadline (typically 10 business days for initial response, 30 days for full corrective action plan). Follow up on effectiveness verification.

**Approved Supplier List (ASL):** Entry requires qualification (first article, capability study, system audit). Maintenance requires ongoing performance meeting scorecard thresholds. Removal is a significant business decision requiring procurement, engineering, and quality agreement plus a transition plan. Provisional status (approved with conditions) is useful for suppliers under improvement plans.

**Develop vs. Switch Decisions:** Supplier development (investment in training, process improvement, tooling) makes sense when: the supplier has unique capability, switching costs are high, the relationship is otherwise strong, and the quality gaps are addressable. Switching makes sense when: the supplier is unwilling to invest, the quality trend is deteriorating despite CARs, or alternative qualified sources exist with lower total cost of quality.


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 3: Select & Install Rules

Step 3: Select & Install Rules

Use `AskUserQuestion` with `multiSelect: true`:

Execute installation:

**Important**: If the user selects any language-specific rules but NOT common rules, warn them:

"Language-specific rules extend the common rules. Installing without common rules may result in incomplete coverage. Install common rules too?"


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

Flutter/Dart Code Review Best Practices
9. Security
Input validation:

Input validation:

[ ] All user input validated before sending to API

[ ] Form validation uses proper validation patterns

[ ] No raw SQL or string interpolation of user input

[ ] Deep link URLs validated and sanitized before navigation


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

Laravel Security Best Practices
CORS and API Exposure

CORS and API Exposure

Restrict origins in `config/cors.php`

Avoid wildcard origins for authenticated routes


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.

Related Skills

`backend-patterns`

`mcp-server-patterns`

`github-ops`


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

Laravel Verification Loop
Phase 6: Build and Deployment Readiness

Phase 6: Build and Deployment Readiness

Ensure cache warmups succeed in production configuration

Verify queue workers and scheduler are configured

Confirm `storage/` and `bootstrap/cache/` are writable in the target environment


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

Healthcare Eval Harness — Patient Safety Verification

How It Works

The eval harness runs five test categories in order. The first three (CDSS Accuracy, PHI Exposure, Data Integrity) are CRITICAL gates requiring 100% pass rate — a single failure blocks deployment. The remaining two (Clinical Workflow, Integration) are HIGH gates requiring 95%+ pass rate.

Each category maps to a Jest test path pattern. The CI pipeline runs CRITICAL gates with `--bail` (stop on first failure) and enforces coverage thresholds with `--coverage --coverageThreshold`.


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.

Integrating Tests into Bug-Check Workflow

Custom Command Definition

The Workflow


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

.NET Development Patterns
Core Principles
2. Explicit Over Implicit

2. Explicit Over Implicit

Be clear about nullability, access modifiers, and intent.


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

Modern Perl Development Patterns
Modern OO with Moo

Modern OO with Moo

Prefer Moo for lightweight, modern OO. Use Moose only when its metaprotocol is needed.


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

CI Integration

**Remember**: Tests are documentation. They show how your code is meant to be used. Write them clearly and keep them up to date.


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

Regex vs LLM for Structured Text Parsing

Best Practices

**Start with regex** — even imperfect regex gives you a baseline to improve

**Use confidence scoring** to programmatically identify what needs LLM help

**Use the cheapest LLM** for validation (Haiku-class models are sufficient)

**Never mutate** parsed items — return new instances from cleaning/validation steps

**TDD works well** for parsers — write tests for known patterns first, then edge cases

**Log metrics** (regex success rate, LLM call count) to track pipeline health


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
Branching Strategies
When to Use Which

When to Use Which

| Strategy | Team Size | Release Cadence | Best For |
|----------|-----------|-----------------|----------|
| GitHub Flow | Any | Continuous | SaaS, web apps, startups |
| Trunk-Based | 5+ experienced | Multiple/day | High-velocity teams, feature flags |
| GitFlow | 10+ | Scheduled | Enterprise, regulated industries |


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

Market Research
Common Research Modes
Technology / Vendor Research

Technology / Vendor Research

Collect:

how it works

trade-offs and adoption signals

integration complexity

lock-in, security, compliance, and operational risk


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

Agent Payment Execution (x402)
Best Practices

Best Practices

**Set budgets before delegation**: When spawning sub-agents, attach a SpendingPolicy via your orchestration layer. Never give an agent unlimited spend.

**Pin your dependencies**: Always specify an exact version in your MCP config (e.g., `agentwallet-sdk@6.0.0`). Verify package integrity before deploying to production.

**Audit trails**: Use `list_transactions` in post-task hooks to log what was spent and why.

**Fail closed**: If the payment tool is unreachable, block the paid action — don't fall back to unmetered access.

**Pair with security-review**: Payment tools are high-privilege. Apply the same scrutiny as shell access.

**Test with testnets first**: Use Base Sepolia for development; switch to Base mainnet for production.


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.

Integration with Content Engine

Use `brand-voice` plus `content-engine` to generate platform-native content, then post via X API:

Pull recent original posts when voice matching matters

Build or reuse a `VOICE PROFILE`

Generate content with `content-engine` in X-native format

Validate length and thread structure

Return the draft for approval unless the user explicitly asked to post now

Post via X API only after approval

Track engagement via public_metrics


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

Frontend Slides
Implementation Requirements
JavaScript

JavaScript

Include:

keyboard navigation

touch / swipe navigation

mouse wheel navigation

progress indicator or slide index

reveal-on-enter animation triggers


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

NestJS Development Patterns
Persistence and Transactions

Persistence and Transactions

Keep repository / ORM code behind providers that speak domain language.

For Prisma or TypeORM, isolate transactional workflows in services that own the unit of work.

Do not let controllers coordinate multi-step writes directly.


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
5. Produce the operator handoff

5. Produce the operator handoff

End with:

customer state summary

action taken

revenue impact

follow-up text to send

product or backlog issue to create


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

Token Budget Advisor (TBA)
How It Works
Step 3 — Present depth options

Step 3 — Present depth options

Present this block **before** answering, using the actual estimated numbers:

Level token estimates (within the response window):

25%  → `min + (max - min) × 0.25`

50%  → `min + (max - min) × 0.50`

75%  → `min + (max - min) × 0.75`

100% → `max`