affaan-m/ecc
272 skills355k installs65M starsGitHub
Install
npx skills add https://github.com/affaan-m/eccSkills in this repo
1Everything Claude Codeeverything-claude-code is a repo-specific agent skill generated from affaan-m/everything-claude-code on 2026-03-20 that encodes development patterns and workflows for a JavaScript project using conventional commits. Developers invoke it with the default prompt to follow repository conventions and workflows instead of generic coding advice. The skill supports implicit invocation so Claude applies ECC patterns automatically during edits, reviews, and commits. Reach for everything-claude-code when contributing to or extending the everything-claude-code project and need agents to mirror its established architecture and commit message rules.2.3kinstalls2Frontend Patternsfrontend-patterns is an ecc repository skill documenting modern frontend development patterns for React, Next.js, and performant user interfaces. It activates when building components with composition and props, managing state through useState, useReducer, Zustand, or Context, implementing data fetching with SWR, React Query, or server components, optimizing via memoization and virtualization, and handling forms with Zod validation plus accessible responsive UI. Developers reach for frontend-patterns when an agent might otherwise guess at state, fetching, or performance tradeoffs during everyday React and Next.js feature work across multiple frontend concerns.1.9kinstalls3Backend Patternsbackend-patterns is an affaan-m/ecc skill cataloging server-side architecture guidance for Node.js, Express, and Next.js API routes. It activates when designing REST or GraphQL endpoints, implementing repository-service-controller layers, optimizing database queries against N+1 problems with indexing and connection pooling, adding Redis or in-memory caching with HTTP cache headers, setting up background jobs, and structuring validation plus middleware for auth, logging, and rate limiting. The skill encodes repeatable patterns for scalable APIs rather than one-off snippets. Developers reach for backend-patterns when scaffolding a new service layer, hardening error handling, or reviewing data-access performance before production load.1.8kinstalls4Frontend Design Directionfrontend-design-direction is an ECC community skill salvaged from stale PR #1659 that guides developers to define aesthetic principles and a coherent design language before implementing web pages, apps, dashboards, artifacts, or components. The skill targets work where UI must feel purposeful and appropriate to the product domain, not merely functional. ECC intentionally does not rebundle Anthropic's canonical frontend-design skill; developers install that from anthropics/skills for the official upstream version. Reach for frontend-design-direction when starting a new frontend surface and you need domain-appropriate visual direction, typography, spacing, and polish decisions documented before coding begins.1.7kinstalls5Security Reviewsecurity-review is an ECC-origin agent skill that activates when developers implement authentication, authorization, user input, file uploads, API endpoints, secrets, payments, or third-party integrations. The skill walks through security best practices and identifies common vulnerability classes before code merges or deploys. Developers reach for security-review when sensitive features land and they need a structured audit instead of ad-hoc grep passes. Triggers cover storing or transmitting sensitive data and integrating external APIs. The checklist spans auth flows, input validation, credential handling, and payment surfaces so gaps surface early in the review cycle.1.7kinstalls6Api Designapi-design is an affaan-m/ecc skill that codifies REST API design patterns for consistent, developer-friendly HTTP services. It covers plural kebab-case resource URLs, CRUD route shapes, pagination and filtering query parameters, structured error payloads, versioning strategy, and rate limiting guidance. Developers reach for api-design when designing new endpoints, reviewing existing contracts, or planning public or partner APIs where convention consistency matters. The skill activates on endpoint design, pagination additions, error-handling plans, and versioning discussions rather than implementation code generation alone.1.7kinstalls7Frontend Slidesfrontend-slides from affaan-m/ecc builds stunning, animation-rich HTML presentations that run entirely in the browser with zero dependencies. The skill activates for talk decks, pitch decks, workshop decks, or internal presentations, and can convert PPT/PPTX files into web slides. It guides visual exploration so developers pick aesthetics through rendered examples rather than abstract design briefs, inspired by zarazhangrui’s exploration approach. Teams reach for frontend-slides when they need shareable HTML decks for demos or conferences without wiring a slide framework or design toolchain.1.7kinstalls8Seoseo is an ECC-origin agent skill for technical SEO, on-page optimization, structured data, Core Web Vitals, and content strategy. It activates when developers audit crawlability and indexability, fix canonical and redirect issues, improve title tags and meta descriptions, add or validate schema markup, tune Core Web Vitals, run keyword research, map keywords to URLs, or plan internal links and sitemap or robots.txt changes. The skill prioritizes fixing technical blockers before content tweaks, enforces one primary search intent per page, and favors long-term quality signals over manipulative patterns with mobile-first assumptions. Recommendations are page-specific and implementation-ready for engineering handoff.1.6kinstalls9Market Researchmarket-research is a decision-oriented research skill from affaan-m/ecc that turns vague market questions into attributed intelligence developers can act on. The skill guides agents through TAM/SAM/SOM estimation, competitor and adjacent-product comparisons, fund and investor dossiers, and technology trend scans, emphasizing sourced claims over research theater. Developers reach for market-research when pressure-testing a thesis before building, fundraising, or entering a new category, and when they need structured summaries that support go/no-go calls rather than open-ended browsing. It activates on triggers like market sizing, competitive analysis, investor outreach prep, and industry intelligence that informs product or business decisions.1.6kinstalls10Python Patternspython-patterns is an ECC-origin agent skill from affaan-m/ecc that activates on Python source via globs for **/*.py and **/*.pyi. It teaches structural subtyping with Protocol, dataclasses, context managers, decorators, async/await, type hints, and package layout patterns drawn from battle-tested practice. When an agent edits or generates Python, the skill steers choices toward duck typing with types, safer resource handling, and clearer module boundaries that reduce bugs and speed maintenance. Developers reach for python-patterns when refactoring legacy scripts, scaffolding APIs, or reviewing Python that feels unidiomatic. It is a build-time companion for anyone shipping Python services, CLIs, or libraries who wants consistent patterns without re-reading style guides on every file.1.6kinstalls11Design Systemdesign-system is a Design & UI/UX skill from affaan-m/ecc (origin: ECC) for building scalable, maintainable design systems with accessibility, responsive layouts, and theme configuration. Core elements include centralized design tokens for color, typography, spacing, and shadows; reusable button, input, and card components; layout patterns for pages, forms, and grids; and SVG icon libraries. The skill integrates Figma for design, Storybook for component showcase, Chromatic for visual testing, and JSON-managed design tokens. Its checklist covers token definition, base component implementation, Storybook setup, accessibility testing, documentation, and team adoption. Developers reach for design-system when initializing a component library or syncing design and implementation before release.1.6kinstalls12Coding Standardscoding-standards is a cross-project Claude Code skill from affaan-m/ecc that sets the minimum bar for naming, immutability, readability, and code-quality review before agents reach for specialized playbooks. The skill explicitly defers React, state, and UI architecture to frontend-patterns, repository and endpoint design to backend-patterns or api-design, and the shortest reusable rule layer to rules/common/coding-style.md. Developers reach for coding-standards when onboarding an agent onto a new repo, standardizing PR review language, or preventing inconsistent style drift across services written in different frameworks. It is the shared floor, not the detailed framework playbook, so teams pair it with domain skills rather than replacing them.1.6kinstalls13Article Writingarticle-writing is a long-form content skill for developers and technical founders publishing blog posts, essays, guides, tutorials, and newsletter issues. It activates when output must exceed a paragraph and voice consistency, structure, and credibility matter. The skill transforms notes, transcripts, or research into polished drafts that match supplied examples or brand guidance instead of generic LLM tone. Developers reach for article-writing when documenting launches, explaining architecture decisions publicly, or converting internal research into SEO-friendly technical articles without sounding like auto-generated paste.1.6kinstalls14Deep Researchdeep-research is an ECC (Everything Claude Code) skill that produces thorough, cited research reports from multiple web sources. It activates Firecrawl and Exa MCP tools to search, crawl, and synthesize findings with source attribution. Use cases include competitive analysis, technology evaluation, market sizing, and due diligence on companies or investors. Developers reach for deep-research when a question needs synthesis across sources rather than a single documentation lookup. Trigger phrases include research, deep dive, investigate, and what's the landscape. Output is a structured report with citations agents and humans can verify.1.6kinstalls15Tdd Workflowtdd-workflow is a TDD enforcement skill activated when writing new features, fixing bugs, refactoring, adding API endpoints, or creating components. Core rules require tests before code and a minimum 80% coverage spanning unit, integration, and end-to-end tests. Developers reach for tdd-workflow when an agent session drifts into implementation-first habits or when teams want consistent red-green-refactor discipline across bug fixes and new endpoints. The skill defines activation triggers and coverage expectations rather than binding to one test framework, so it pairs with project-specific runners the agent discovers in the repo.1.6kinstalls16Prompt Optimizerprompt-optimizer is an ECC (Everything Claude Code) skill that turns vague or weak prompts into precise, ECC-aware instructions Claude Code or Cursor can execute reliably. It targets developers who struggle with ambiguous agent requests that produce inconsistent edits, missed constraints, or partial implementations. The skill aligns phrasing with ECC conventions so downstream agents inherit clear scope, constraints, and success criteria. Reach for prompt-optimizer before kicking off complex multi-file changes, refactors, or workflow automations where prompt quality directly affects output. The repository notes a Japanese translation is in progress; the English ECC origin skill defines the authoritative behavior.1.6kinstalls17Video Editingvideo-editing is a Claude Code skill from affaan-m/ecc for AI-assisted editing of real footage—not prompt-based generation. The pipeline spans raw capture through FFmpeg cuts, Remotion compositions, ElevenLabs voiceover, fal.ai augmentations, and final polish in Descript or CapCut. Developers reach for video-editing when turning long recordings into short-form content, building tutorials or demo videos, or adding overlays, subtitles, and music to screen captures. The skill activates for vlog structuring, footage cutting, and platform-specific clip preparation from existing video assets.1.6kinstalls18Postgres Patternspostgres-patterns is an ECC agent skill offering battle-tested PostgreSQL patterns for schema design, indexing, data types, query optimization, and Row Level Security. The skill includes an index cheat sheet mapping query patterns to index types, anti-pattern detection guidance, and connection pooling notes, credited to Supabase best practices under MIT License. Developers reach for postgres-patterns when writing SQL migrations, troubleshooting slow queries, or implementing RLS policies. For deeper review workflows, the skill points to the database-reviewer agent while serving as an in-editor quick reference during build.1.5kinstalls19Docker Patternsdocker-patterns is an ECC agent skill cataloging Docker and Docker Compose best practices for containerized development. It guides developers through local Compose setups, multi-container architectures, networking and volume strategies, and Dockerfile reviews for image size and security. Reach for docker-patterns when migrating from bare-metal local dev to containers, troubleshooting service discovery or persistent storage, or standardizing repeatable dev environments across a team. The skill emphasizes practical patterns over theory: compose file structure, inter-service networking, volume mounts, and secure base-image choices. It suits backend and full-stack engineers standing up dependent services like databases, queues, and APIs behind a single docker compose up workflow.1.5kinstalls20Brand Voicebrand-voice is an ECC-origin skill from affaan-m/ecc that constructs a durable voice profile from real source material—posts, essays, launch notes, documentation, or site copy—then reapplies that profile across content workflows. Instead of re-deriving tone each session or defaulting to generic AI phrasing, the skill captures diction, rhythm, and framing from authenticated examples. Developers and technical founders reach for it when writing for X, LinkedIn, email, launch posts, threads, or product updates in a recognizable voice. Activation triggers include requests for voice consistency, channel-specific outreach, or adapting a known author's tone. The output is a reusable style profile engineers can attach to downstream content, outreach, and social generation tasks inside agent sessions.1.5kinstalls21E2e TestingE2E Testing is an ECC skill cataloging comprehensive Playwright patterns for stable, fast, and maintainable end-to-end suites. It prescribes tests/e2e folder layout with auth, features, and api spec groups plus shared fixtures and playwright.config.ts at the repo root. Page Object Model examples show encapsulating selectors and navigation in dedicated classes consumed by login, browse, search, and create specs. Guidance also covers CI/CD integration, artifact management for traces and screenshots, and flaky test strategies so pipelines stay green under parallel runs. Reach for E2E Testing when bootstrapping Playwright in a web app, refactoring brittle selectors into POM classes, or hardening GitHub Actions jobs that run headless browsers. Assumes TypeScript and Playwright installed; complements unit testing skills rather than replacing them.1.5kinstalls22Nextjs Turbopacknextjs-turbopack is a Claude Code skill from affaan-m/ecc covering Next.js 16+ local development with Turbopack, the Rust-based incremental bundler enabled by default for faster cold starts and hot module replacement. The skill explains when to stay on Turbopack for day-to-day work versus falling back to Webpack with --webpack or --no-turbopack when a Turbopack bug or webpack-only plugin blocks dev. It addresses incremental bundling, filesystem caching, and diagnosing slow HMR or startup in large apps. Developers reach for nextjs-turbopack when Next.js dev feels sluggish, when evaluating bundler tradeoffs, or when a legacy webpack plugin forces a temporary dev fallback while production builds may still use the default pipeline.1.5kinstalls23Accessibilityaccessibility is an ECC agent skill focused on WCAG 2.2 Level AA technical implementation across web, iOS, and Android. It applies POUR principles—Perceivable, Operable, Understandable, and Robust—to translate high-level design requirements into concrete attributes such as ARIA roles, accessibility traits, hints, and focus behavior. Developers reach for accessibility when defining new component specs, implementing WCAG 2.2 criteria like Target Size and Focus Appearance, or auditing existing code for screen reader, keyboard, and switch-control barriers. The skill emphasizes semantic mapping over generic containers so assistive technologies read a correct accessibility tree. Use it during component design, pre-release audits, and remediation sprints where compliance gaps must become actionable implementation tasks.1.5kinstalls24Database Migrationsdatabase-migrations is an ECC-origin skill covering safe, reversible database schema changes, data migrations, rollbacks, and zero-downtime deployments. It supports PostgreSQL, MySQL, and common ORMs including Prisma, Drizzle, Django ORM, TypeORM, and golang-migrate. Developers reach for database-migrations when creating or altering tables, adding indexes, running backfills, or planning production schema changes without downtime. Core principles emphasize reversibility and production-safe sequencing for schema and data migration work.1.5kinstalls25Architecture Decision Recordsarchitecture-decision-records is an ECC-origin skill that turns coding-session architecture choices into structured ADR markdown following Michael Nygard's format adapted for AI-assisted development. It activates when developers explicitly ask to record a decision, select among frameworks, libraries, databases, or API patterns, or explain why X was chosen over Y. Each ADR includes date, status (proposed, accepted, deprecated), context, considered alternatives, and rationale so future contributors understand trade-offs without digging through Slack or PR threads. Use architecture-decision-records whenever a non-trivial structural choice should outlive the current Claude Code session.1.5kinstalls26Literature Reviewliterature-review is a skill from affaan-m/ecc for systematic academic and technical literature workflows spanning narrative, scoping, systematic, and meta-analysis review types. The workflow starts by turning prompts into searchable research questions, then screens sources, synthesizes findings, verifies citations, and logs evidence across peer-reviewed papers, preprints, patents, and technical reports. Developers default to scoping reviews for exploratory work and systematic reviews for publishable or clinical claims when rigor level is unspecified. Reach for literature-review when mapping state of the art, finding gaps, preparing cited background sections, or comparing contradictory evidence before greenlighting engineering investment.1.5kinstalls27Python Testingpython-testing is an ECC agent skill for comprehensive Python testing using pytest as the primary framework. The skill documents basic test structure, fixtures, parametrization, mocking dependencies, async testing patterns, coverage analysis, and test organization with globs targeting **/*.py and **/*.pyi files. Developers reach for python-testing when writing new tests, improving coverage toward 80%+, or applying TDD during Python service development. The skill emphasizes clean pytest syntax and maintainable test suites over ad hoc unittest patterns.1.5kinstalls28Verification Loopverification-loop is a comprehensive verification skill from affaan-m/ecc for Claude Code sessions that enforces quality gates in six phases before merge-ready code ships. Phase 1 runs build verification via npm or pnpm build and stops on failure. Phase 2 type-checks TypeScript with npx tsc --noEmit or Python with pyright. Additional phases cover linting, tests, and further gates defined in the skill workflow. Invoke after completing a feature, before creating a PR, after refactoring, or whenever quality gates must pass systematically. Reach for verification-loop when ad hoc checks miss steps and you need a ordered stop-on-failure verification pipeline.1.5kinstalls29Codebase Onboardingcodebase-onboarding is an ECC skill that systematically analyzes unfamiliar codebases without reading every file. Phase 1 reconnaissance runs parallel checks: package manifests (package.json, go.mod, Cargo.toml, pyproject.toml, pom.xml), framework fingerprints (next.config, nuxt.config, angular.json, vite.config), and entry-point discovery. The output is a structured onboarding guide with architecture map, key entry points, project conventions, and a ready-to-use CLAUDE.md. Developers reach for codebase-onboarding when opening a repo in Claude Code for the first time, joining a new team, or when asked to explain or onboard to an existing repository.1.5kinstalls30Documentation Lookupdocumentation-lookup is an ECC agent skill that routes library and framework questions to the Context7 MCP instead of relying on model training cutoffs. When a developer asks about React, Next.js, Prisma, or any named API, the skill calls Context7 tools resolve-library-id and query-docs to resolve a canonical library ID and return current documentation snippets and examples. The workflow replaces guesswork during setup, configuration, and API usage with source-aligned answers pulled at query time. Developers reach for documentation-lookup whenever they need version-accurate method signatures, migration notes, or official code samples while coding inside Claude Code, Cursor, or Codex. The skill activates on setup questions, API reference requests, and explicit framework names, making it a lightweight documentation bridge for full-stack and backend work without leaving the agent session.1.5kinstalls31Fastapi PatternsFastAPI Patterns is an ECC community skill that treats a FastAPI app as a thin HTTP layer over explicit routers, schemas, dependencies, and database access modules. It activates when building or reviewing FastAPI services—splitting routers from Pydantic request/response models, wiring async endpoints that call databases or external services, and adding authentication, authorization, OpenAPI documentation, tests, and deployment settings. Developers reach for it instead of assembling patterns from scattered docs when scaffolding a new API or reviewing a FastAPI PR for production risks. The skill emphasizes copy-pasteable, production-oriented examples covering dependency injection, async I/O, and security rather than toy CRUD snippets.1.5kinstalls32Git Workflowgit-workflow in affaan-m/ecc documents Git collaboration patterns including GitHub Flow for continuous deployment, GitFlow for release branches, and trunk-based development options. The skill activates when setting up a new repository workflow, writing commit messages and PR descriptions, resolving merge conflicts, managing release tags, or onboarding contributors to shared Git practices. GitHub Flow is recommended for most teams with a protected main branch that stays deployable and short-lived feature branches merged via pull request. Examples illustrate branch naming, protected main policies, and PR description structure agents should follow when committing on behalf of developers. Developers reach for git-workflow when agent-assisted coding risks inconsistent branch hygiene or nonstandard commit messages across sessions. The skill originates from ECC and includes Japanese documentation in the source README while patterns apply to any Git-hosted project. Triggers include branching strategy choice, commit conventions, merge conflict resolution, and release tag management.1.5kinstalls33Content Enginecontent-engine is an ECC agent skill that turns source material—articles, transcripts, demos, docs, and internal notes—into platform-native content systems that preserve the author's voice. The skill drafts X posts and threads, LinkedIn launch updates, short-form video scripts, YouTube explainers, newsletter editions, and repurposed multi-platform campaigns from a single asset. It activates when writing social posts, scripting video, building launch sequences, or adapting one source cleanly across X, LinkedIn, TikTok, YouTube, and email channels. content-engine emphasizes voice fidelity over flattened platform templates, structuring calendars and sequences for ongoing distribution rather than one-off copy dumps. Developers reach for content-engine after shipping features or recording demos when they need consistent public storytelling without rewriting every channel manually.1.5kinstalls34Golang Patternsgolang-patterns is an affaan-m/ecc skill activated on **/*.go, **/go.mod, and **/go.sum files, extending design principles with Go-specific idioms. Coverage includes functional options constructors, small interface design, dependency injection, concurrency patterns, error handling discipline, and package organization. Example snippets show Option func(*Server) helpers like WithPort for flexible configuration without sprawling constructors. Developers reach for golang-patterns when refactoring Go microservices, CLIs, or libraries to avoid fighting language quirks and to align new modules with community-accepted structure before code review.1.5kinstalls35Remotion Video Creationremotion-video-creation is a Remotion best-practices skill from affaan-m/ecc providing 29 domain-specific rules for creating animated videos in React. Rule files cover 3D content with Three.js and React Three Fiber, fundamental animations, assets, audio, captions, charts, transitions, and more. Developers reach for remotion-video-creation whenever agents touch Remotion code to avoid common pitfalls in composition timing, asset loading, and render pipelines. The skill supplies curated domain knowledge so coding agents produce production-quality Remotion projects rather than generic React patterns.1.5kinstalls36React Patternsreact-patterns is an ECC-origin skill for writing and reviewing robust React 18/19 applications. It covers hooks discipline, explicit Server versus Client component boundaries, Suspense paired with error boundaries, form actions, data-fetching choices, state-management decision trees, and accessibility-first composition. Developers activate it when editing function components, custom hooks, JSX or TSX files, migrating class components, or replacing heavy useEffect and forwardRef patterns. The skill helps choose between local state, context, and external stores with clear composition rules. Teams reach for react-patterns during feature work and code review when components must stay performant, accessible, and aligned with modern React conventions across React 18 and React 19 APIs.1.5kinstalls37Java Coding Standardsjava-coding-standards is an ECC agent skill that enforces readable, maintainable Java 17+ conventions across Spring Boot and Quarkus microservices. The skill automatically applies framework-specific rules for naming, immutability, Optional usage, streams, exception handling, generics, CDI, reactive patterns, and project package layout. It activates when writing or reviewing Java backend code, structuring records and sealed classes, applying pattern matching, or aligning Quarkus and Spring Boot services to shared ECC standards. java-coding-standards covers Optional and stream idioms, exception boundaries, and reactive service patterns so agents produce consistent JVM code instead of ad hoc style per file. Developers reach for java-coding-standards when onboarding agents onto existing Spring Boot or Quarkus repos that need enforced conventions during implementation and review.1.5kinstalls38Agent Architecture Auditagent-architecture-audit is an ECC diagnostic workflow (origin: oh-my-agent-check) for agent and LLM applications. It audits a 12-layer agent stack for wrapper-layer regressions, stale memory pollution, tool discipline failures, hidden retry loops, and transport or rendering mutations that mask root causes. Required before production when tool calls, memory, or multi-step workflows ship—or when the same model works in a playground but breaks inside wrappers. Tools used include Read, Write, Edit, Bash, Grep, and Glob. Developers reach for agent-architecture-audit after 15+ minutes of blind agent debugging or when users report unstable tools and degraded agent behavior.1.5kinstalls39Deployment PatternsDeployment Patterns is an ECC-origin skill that catalogs production-grade deployment workflows and CI/CD best practices for web applications. It activates when setting up CI/CD pipelines, Dockerizing services, choosing deployment strategies—rolling, blue-green, or canary—or implementing health checks, readiness probes, and environment-specific configuration before a production release. Developers reach for it to avoid reinventing rollback procedures, container layouts, and release checklists on every project. The skill packages opinionated patterns for production readiness rather than one-off shell snippets, making it a reference during infrastructure setup and release planning for SaaS and API backends.1.5kinstalls40Flutter Dart Code Reviewflutter-dart-code-review is an ECC-origin agent skill that provides a comprehensive, library-agnostic checklist for reviewing Flutter and Dart applications before merge or ship. The checklist spans project health, widget best practices, state management patterns including BLoC, Riverpod, Provider, GetX, MobX, and Signals, Dart idioms, performance, accessibility, security, and clean architecture. It applies regardless of routing, DI, or state library choices and inspects pubspec.yaml hygiene, analysis_options.yaml lint strictness, and production code quality such as avoiding print() in favor of dart:developer logging. Developers reach for this skill when they need a consistent PR review rubric across Flutter codebases rather than ad-hoc comments.1.5kinstalls41Nestjs Patternsnestjs-patterns is a skill from affaan-m/ecc that codifies production-grade NestJS backend structure for modular TypeScript APIs. The skill activates when building NestJS services, organizing app.module.ts layouts with common filters and guards folders, adding DTO validation, configuring environment-aware settings, and testing HTTP endpoints. Developers reach for nestjs-patterns when they need opinionated folder conventions—src/main.ts, feature modules, and shared common utilities—instead of ad hoc NestJS scaffolding. It covers controllers, providers, guards, interceptors, exception filters, and database integrations as first-class building blocks for maintainable server code.1.5kinstalls42Continuous Learning V2continuous-learning-v2 is an instinct-based learning system from affaan-m/ecc (Everything Claude Code) at version 2.1.0. It watches Claude Code sessions via hooks, records small learned behaviors as atomic instincts with confidence scores, and promotes mature instincts into skills, slash commands, and subagents. Version 2.1 adds project-scoped instincts so React conventions stay in React repos and Python patterns stay in Python repos, preventing cross-project contamination. Developers reach for continuous-learning-v2 when repeated session patterns should compound into reusable agent knowledge instead of being re-explained each chat. The architecture treats instincts as evolvable units rather than one-off prompt snippets.1.5kinstalls43Rust Patternsrust-patterns is an ECC-origin skill that encodes idiomatic Rust across six areas: ownership and borrowing, Result and `?` propagation with `thiserror` for libraries and `anyhow` for applications, traits, concurrency, and crate module layout. It activates when writing new Rust, reviewing pull requests, refactoring modules, or designing crate structure. The skill pushes compile-first output that follows community conventions instead of Java-style or overly verbose patterns. Developers reach for rust-patterns when they want agents to generate Rust that passes `cargo check` without iterative borrow-checker fixes.1.5kinstalls44Context Budgetcontext-budget is an ECC skill that analyzes token overhead for every component loaded in a Claude Code session and surfaces practical optimizations to reclaim context space. Phase one inventories agents/*.md, skills/*/SKILL.md, MCP servers, and rules, estimating tokens per file as word count times 1.3 while flagging agent files over 200 lines and frontmatter descriptions over 30 words as bloated. Developers invoke it when session performance drops, output quality degrades after adding many skills or MCP servers, or when running the /context-budget command. The skill answers how much headroom remains before adding more components. context-budget suits maintainers curating large Claude Code workspaces who need data-driven trimming instead of guessing which SKILL.md files to disable.1.5kinstalls45Search Firstsearch-first is a research-before-coding workflow skill from affaan-m/ecc that systematizes discovery of existing tools, libraries, MCP servers, and patterns before writing custom code. Developers reach for search-first when starting new features, adding dependencies or integrations, or when a user asks to add functionality and the agent is about to implement from scratch. The skill triggers on new feature work where existing solutions likely exist and guides agents to search repositories, package ecosystems, and MCP catalogs first. search-first prevents duplicate utilities, helpers, and abstractions by making discovery a mandatory gate before implementation.1.5kinstalls46Motion Advancedmotion-advanced is a skill from affaan-m/ecc in the Everything Claude Code collection, focused on advanced Motion-powered interactions for React and Next.js UIs. The published readme notes the public file is a Japanese translation placeholder and points to the original English SKILL.md for full guidance on drag-and-drop, gesture handling, text reveals, SVG path animations, and imperative animation control. Developers reach for motion-advanced when standard fade or slide transitions are insufficient and interfaces need physics-based dragging, gesture-driven states, or path-based SVG motion. The skill complements baseline motion-ui guidance by covering higher-complexity interaction patterns during active frontend implementation.1.4kinstalls47Investor MaterialsInvestor Materials is an ECC agent skill for creating and updating investor-facing documents that stay internally consistent. It produces pitch decks, one-pagers, investor memos, accelerator applications, financial models, milestone plans, and use-of-funds tables tied to one shared source of truth. Developers reach for Investor Materials when fundraising assets drift out of sync or accelerator questionnaires need aligned projections. The skill emphasizes credible, defensible numbers across multiple artifacts rather than one-off slide copy. It activates during deck revisions, memo writing, and financial model updates.1.4kinstalls48Error Handlingerror-handling is a skill from affaan-m/ecc that standardizes robust error patterns for production applications in TypeScript, Python, and Go. The skill promotes failing fast at boundaries, using typed errors instead of string messages, separating user-facing text from developer logs, and documenting every client-visible error code as part of the API contract. Developers activate error-handling when designing exception hierarchies, adding retry or circuit-breaker logic for unreliable dependencies, reviewing missing endpoint error handling, or debugging cascade failures and silent catch blocks. Five core principles anchor every recommendation so errors surface early and never disappear inside empty catch blocks.1.4kinstalls49Motion Uimotion-ui is a skill from affaan-m/ecc in the Everything Claude Code collection that helps teams define a coherent Motion-based animation system for React and Next.js applications. The public readme indicates a Japanese translation is in progress and references the original English SKILL.md for the full motion-ui guidance on accessibility, performance, and reusable transition patterns. Developers reach for motion-ui when adding animations without introducing janky interactions, inconsistent timing, or accessibility regressions across components. motion-ui pairs naturally with motion-advanced when a project needs a solid baseline motion language before layering complex gestures or SVG path effects.1.4kinstalls50Strategic Compactstrategic-compact is an ECC agent skill that coaches when to run Claude Code's manual `/compact` command at logical workflow boundaries instead of relying on automatic compaction. The skill activates when sessions approach context limits above 200K tokens, when switching between unrelated tasks, or after major milestones like finishing research before implementation. It maps compaction points to multi-phase work—research, plan, implement, test—so developers retain decisions, file paths, and constraints that arbitrary auto-compaction would drop. Developers reach for strategic-compact when responses slow down, coherence drops, or they notice the model forgetting earlier agreements mid-session. The workflow is advisory: identify boundary, compact, then continue with a cleaner context window.1.4kinstalls51Android Clean Architectureandroid-clean-architecture from affaan-m/ecc covers Clean Architecture patterns for Android and Kotlin Multiplatform projects. It defines recommended module layouts—app entry, core utilities, domain UseCases, data repositories—and dependency inversion rules across presentation, domain, and data layers. The skill applies when structuring modules, implementing UseCase, Repository, and DataSource patterns, designing cross-layer data flow, or setting up Koin or Hilt dependency injection with Room, SQLDelight, or Ktor in layered architectures. Developers reach for it when agents need explicit guidance on Android/KMP boundaries instead of ad-hoc package organization.1.4kinstalls52Browser Qabrowser-qa is an agent skill from affaan-m/ecc (Everything Claude Code) that automates visual testing and UI interaction verification using browser automation MCP tools such as claude-in-chrome, Playwright, or Puppeteer. Phase 1 smoke tests navigate target URLs, filter console noise, check for 4xx/5xx network errors, capture desktop and mobile screenshots, and validate Core Web Vitals thresholds (LCP under 2.5s, CLS under 0.1, INP under 200ms). Phase 2 interaction tests click navigation links, submit forms with valid and invalid data, and verify error states. Developers reach for browser-qa after deploying to staging or preview, when reviewing frontend PRs, or before shipping to confirm layouts, forms, and interactions actually work in a real browser.1.4kinstalls53Agentic Engineeringagentic-engineering is a skill from affaan-m/ecc for operating as an agentic engineer when AI agents handle most coding and humans enforce quality gates. Four operating principles require defining completion criteria before execution, decomposing work into agent-sized units, routing model tiers by task complexity, and measuring outcomes with evals and regression checks. The eval-first loop defines capability evals and regression suites before agents execute changes. Developers reach for agentic-engineering when shifting from manual implementation to supervised agent execution without sacrificing reliability, cost discipline, or verifiable completion criteria across multi-step software tasks.1.4kinstalls54Cpp Coding Standardscpp-coding-standards is an ECC agent skill derived from the C++ Core Guidelines (isocpp.github.io) for modern C++17, C++20, and C++23. The skill steers AI agents toward type-safe, resource-safe, immutable, and clear patterns when creating classes, functions, templates, or architectural decisions. Developers reach for cpp-coding-standards during new feature work, code review, and refactors where legacy C++ risks undefined behavior, leaks, or inconsistent style. It complements compiler warnings by encoding guideline-level rules agents can apply consistently across files and modules.1.4kinstalls55Eval HarnessEval Harness is an ECC agent skill that formalizes eval-driven development (EDD) for Claude Code sessions. It lets developers define pass/fail criteria before work begins, measure agent reliability with pass@k metrics, and build regression test suites for prompt or agent changes. The skill activates when benchmarking agent performance across model versions or setting structured completion gates for AI-assisted workflows. Eval Harness treats evaluations as first-class artifacts rather than ad hoc manual checks. Developers reach for it when they need repeatable agent quality gates instead of one-off prompt tweaks.1.4kinstalls56Dashboard Builderdashboard-builder is version 1.0.0 ECC skill adapted for Grafana, SigNoz, and similar observability platforms. It starts from operator questions—Is it healthy? Where is the bottleneck? What changed? What action should someone take?—rather than dumping every available metric into unstructured panels. Guardrails forbid mixing health, throughput, and resource panels without structure, and require titles, units, and reasonable thresholds on every panel. Developers reach for dashboard-builder when asked to build Kafka monitoring dashboards, create Grafana boards for Elasticsearch, stand up SigNoz dashboards for a service, or turn a raw metrics list into a functioning operational dashboard operators can act on.1.4kinstalls57Mcp Server Patternsmcp-server-patterns is an ECC skill for developers implementing or maintaining MCP servers using the Node/TypeScript SDK. The Model Context Protocol lets AI assistants call tools, read resources, and use prompts from a custom server, and this skill covers when to add each capability, how to choose stdio versus Streamable HTTP transport, and how to debug registration issues during SDK upgrades. Because the MCP SDK API evolves, the skill directs developers to Context7 MCP docs or official MCP documentation for current method names. Developers reach for mcp-server-patterns when wiring a new integration surface for coding agents—whether exposing an internal API, document store, or workflow engine—rather than hardcoding one-off scripts per agent session.1.4kinstalls58Vite Patternsvite-patterns is an ECC-origin skill covering Vite 8+ development server and build toolchain patterns. It activates for vite.config.ts or vite.config.js setup, .env and environment variables, dev-server proxy to API backends, build output optimization for chunks and minification, build.lib library publishing, dependency pre-bundling, and CJS/ESM interop troubleshooting. Developers also use it when selecting plugin order or debugging HMR and build errors. The skill replaces trial-and-error Vite configuration with repeatable patterns for modern frontend and library packages.1.4kinstalls59Councilcouncil is an ECC agent skill that gathers four perspectives—contextual Claude, a skeptic sub-agent, a pragmatist sub-agent, and a critic sub-agent—to challenge conversational anchoring on fuzzy decisions. It is designed for moments with multiple credible paths and no obvious winner, such as monorepo versus polyrepo, ship now versus delay for polish, feature flags versus full rollout, or simplifying scope versus keeping strategic breadth. council explicitly excludes output verification, feature implementation planning, and system architecture design, pointing those tasks to other ECC skills. Developers reach for council when they need explicit tradeoff visibility, opposing viewpoints, or adversarial challenge before a go/no-go call.1.4kinstalls60Motion Foundationsmotion-foundations is an Everything Claude Code (ECC) skill for setting animation baselines in React and Next.js apps. It guides developers to define performant, accessible motion patterns before importing animation libraries, reducing jank and a11y regressions. Teams reach for motion-foundations when starting UI motion work or standardizing transitions across components. The published readme notes Japanese translation is in progress; the English skill file in the ECC repository holds the full motion guidance referenced by the stub.1.4kinstalls61Motion Patternsmotion-patterns is a Claude Code skill from affaan-m/ecc (Everything Claude Code) that delivers reusable animation patterns for React and Next.js interfaces. The skill covers accessible motion defaults—durations, spring configurations, and easing functions—so developers avoid inconsistent or performance-heavy custom animations. Developers reach for motion-patterns when building dashboards, marketing pages, or interactive components that need polished enter, exit, and layout transitions aligned with modern motion libraries. The published readme notes Japanese translation is in progress, but the skill origin and description target English-language React and Next.js animation workflows with accessibility considerations baked in.1.4kinstalls62Springboot Patternsspringboot-patterns is an ECC skill for developers building scalable Spring Boot backends with consistent architecture. It activates when creating REST APIs with Spring MVC or WebFlux, structuring controller-to-service-to-repository layers, configuring Spring Data JPA, caching, or async processing, and adding validation, exception handling, or pagination. The skill also covers profile-based dev, staging, and production configuration plus event-driven patterns with Spring Events. Developers reach for springboot-patterns when a Java API needs opinionated layering and cross-cutting concerns—rather than one-off controller snippets—so new endpoints follow the same validation, logging, and data-access conventions across the codebase.1.4kinstalls63Security Scansecurity-scan is an ECC skill that wraps AgentShield to inspect a project's `.claude/` configuration before commits or onboarding. It scans CLAUDE.md for hardcoded secrets and injection patterns, settings.json for permissive allow lists and missing deny rules, mcp.json for risky MCP servers and embedded env secrets, plus hooks and agent definitions. Triggers include new Claude Code project setup, changes to settings or MCP config, pre-commit review, and periodic hygiene checks. Developers reach for security-scan when they want automated guardrails on agent configuration rather than manual checklist review.1.4kinstalls64Agent Introspection DebuggingAgent Introspection Debugging is an ECC workflow skill for structured self-debugging when AI agent runs stall. It activates on maximum tool-call or loop-limit failures, repeated retries without progress, context growth, prompt drift, and filesystem errors. The workflow captures failure state, diagnoses root causes, attempts contained recovery, and produces introspection reports before escalating to a human. Developers reach for Agent Introspection Debugging when agents consume tokens without forward motion or revisit the same tools endlessly. The skill is an explicit workflow, not a hidden runtime patch.1.4kinstalls65Github Opsgithub-ops is a skill from affaan-m/ecc for managing GitHub repositories with a focus on community health, CI reliability, and contributor experience. The skill activates when triaging and labeling issues, checking PR review and CI status, debugging broken pipelines, preparing releases and changelogs, or monitoring Dependabot and security alerts. All GitHub API operations go through the gh CLI as the required tool. Developers reach for github-ops when they say check GitHub, triage issues, review PRs, merge, release, or CI is broken and need structured automation instead of ad hoc web UI clicks across mature repositories.1.4kinstalls66Liquid Glass Designliquid-glass-design is an ECC skill for building Apple's iOS 26 Liquid Glass interface material in native Apple frameworks. The skill walks through blur stacks, reflection layers, and interactive morphing patterns that match the system aesthetic across SwiftUI, UIKit, and WidgetKit targets. Developers reach for liquid-glass-design when shipping iOS 26-era interfaces that need depth, glass translucency, and touch-responsive visual transitions without reverse-engineering WWDC samples from scratch. The published readme notes Japanese translation is still in progress, so the English SKILL.md in the ECC repository remains the authoritative implementation reference for layout, materials, and widget constraints.1.4kinstalls67Product Capabilityproduct-capability is an ECC agent skill that turns fuzzy product intent into explicit engineering constraints before coding starts. Instead of answering what to build in prose, the skill produces a capability plan listing invariants, interfaces, cross-service boundaries, and unresolved decisions developers must settle first. Teams use product-capability when a PRD, roadmap ticket, or stakeholder note exists but implementation assumptions remain implicit. The output is an ECC-native PRD-to-SRS lane that prevents agents from jumping straight into code without a shared contract.1.4kinstalls68Blueprintblueprint is a construction-plan generator skill from affaan-m/ecc that converts a one-line objective into a step-by-step build plan any fresh coding agent can execute without prior context. The skill runs a 5-stage pipeline including research, dependency-graph ordering, parallel step detection, adversarial review gates, anti-pattern catalogs, and plan-change protocols. Developers reach for blueprint when splitting large features across multiple PRs, planning multi-session refactors or migrations, or coordinating parallel sub-agent work. blueprint explicitly avoids single-PR tasks completable in fewer than 3 tool calls or when the user says just do it.1.4kinstalls69Ui Demoui-demo is a Playwright-based demo recording skill from affaan-m/ecc that produces polished WebM walkthrough videos of web applications with injected visible cursor overlays, natural pacing, and narrative flow. The skill follows a mandatory 3-phase process—explore, rehearse, record—never jumping straight to recording without first mapping real page elements. Developers reach for ui-demo when users request demo videos, screen recordings, walkthroughs, or tutorial captures for documentation, onboarding, or stakeholder presentations. ui-demo inspects actual DOM structure before scripting to avoid assumptions about inputs, dropdowns, and interactive components.1.4kinstalls70Fal Ai Mediafal-ai-media in affaan-m/ecc provides unified media generation through fal.ai MCP covering image, video, and audio workflows. Supported models include text-to-image Nano Banana, text and image-to-video with Seedance, Kling, and Veo 3, text-to-speech via CSM-1B, and video-to-audio with ThinkSound. Developers reach for fal-ai-media when users ask to generate images, create videos from text or images, produce speech or sound effects, or make thumbnails without leaving the agent environment. The skill activates on phrases like generate image, create video, text to speech, or make a thumbnail. MCP configuration is required to reach fal.ai endpoints from Claude Code or Cursor. Triggers span marketing assets, prototype media, and app placeholder content generated directly from prompts rather than stock libraries.1.4kinstalls71Rust Testingrust-testing is an ECC agent skill for comprehensive Rust test design following test-driven development. It guides agents through identifying target functions, traits, or modules, then writing unit and integration tests, async tests, property-based validation, mocks, and performance benchmarks. Developers invoke rust-testing when shipping new Rust logic, backfilling coverage on legacy crates, or standardizing test style across a workspace. The skill encodes repeatable TDD steps so agents produce maintainable #[test] modules, integration test layouts, and coverage-oriented workflows instead of one-off examples.1.4kinstalls72Agent Sortagent-sort is an ECC skill that builds an evidence-backed install plan for a specific repository by classifying ECC components with parallel repo-aware review passes. Instead of guessing what feels useful, agent-sort sorts skills, commands, rules, hooks, and extras into DAILY buckets for everyday use and LIBRARY buckets for occasional reference based on signals from the actual codebase. Developers use agent-sort when full ECC installs are too noisy, the repo stack is known, but nobody wants to manually audit dozens of skills and rules. The output is a trimmed ECC surface that loads only what the project needs, reducing agent context bloat and conflicting guidance. It pairs naturally with configure-ecc for installation after the sort plan is approved, and suits monorepos or polyglot projects where only a subset of ECC domains applies.1.4kinstalls73Bun Runtimebun-runtime is an ECC agent skill for Bun as a unified JavaScript toolkit: runtime, package manager, bundler, and test runner in one binary. It clarifies when to prefer Bun—new JS/TS projects, speed-sensitive scripts, Vercel deployments with Bun runtime, and single-toolchain workflows—and when to stay on Node for maximum ecosystem compatibility or legacy tooling dependencies. Developers reach for bun-runtime when adopting Bun, migrating from Node, debugging Bun-specific behavior, or configuring install, run, test, and build commands under one runtime.1.4kinstalls74Make Interfaces Feel Bettermake-interfaces-feel-better in affaan-m/ecc (origin ECC) guides agents to elevate generic UI components into polished, tactile interfaces that feel finished and delightful rather than template-default. The skill targets micro-interactions, visual hierarchy, spacing, motion, and affordances that separate prototype UIs from production-quality surfaces. A Japanese translation of the skill file is in progress; the English source remains the authoritative workflow reference. Developers reach for make-interfaces-feel-better when a React or web UI technically works but feels flat, when design review asks for more polish, or when shipping a user-facing screen that needs perceived quality improvements without a full redesign. Triggers include make UI feel better, polish components, improve tactile feedback, and refine generic shadcn or Tailwind layouts.1.4kinstalls75Agent Harness Constructionagent-harness-construction is an ECC skill for developers building AI agent harnesses that constrain output quality through four pillars: action-space design, observation quality, recovery quality, and context-budget quality. The skill prescribes stable explicit tool names, schema-first narrowed inputs, deterministic output shapes, and avoidance of catch-all tools except when isolation is impossible. Granularity rules separate micro-tools for high-risk deploy and migration operations, medium tools for edit-read-search loops, and macro-tools only when round-trip overhead dominates. Every tool response should expose status, summary, next_actions, and artifacts, while error paths follow a structured recovery contract. Developers reach for agent-harness-construction when agent completion rates stall despite capable models, usually because tool design—not model choice—is the bottleneck.1.4kinstalls76Ai Regression Testingai-regression-testing is an ECC agent skill for AI-assisted development that addresses the blind spot when the same model writes a fix and then approves its own review. The skill documents database-free sandbox API testing, automated bug-check workflows, and patterns for multi-path code such as sandbox versus production or feature-flag branches. Developers reach for ai-regression-testing after an AI agent edits API routes or backend logic, when a fixed bug needs a guard against recurrence, or when running commands like /bug-check after code changes. The workflow targets predictable failure modes where automated tests are the only systematic check that breaks shared assumptions between generation and review.1.4kinstalls77Mysql Patternsmysql-patterns is an ECC-origin agent skill that encodes production MySQL and MariaDB conventions for schema design, query tuning, indexing strategy, transactional safety, replication setup, and connection pool configuration. It activates when developers design tables, write slow queries, plan indexes, or configure pools in MySQL-compatible backends. The skill distills repeatable patterns so agents propose normalized schemas, efficient indexes, and pool settings without rediscovering common pitfalls. Developers reach for mysql-patterns when building or refactoring SaaS APIs, admin dashboards, or services backed by MySQL or MariaDB and need opinionated guidance instead of generic SQL snippets.1.4kinstalls78Research Opsresearch-ops is an ECC workflow skill that tells coding agents when and how to combine native research skills—exa-search, deep-research, market-research, lead-intelligence, and knowledge-ops—instead of replacing them. The skill fires on triggers like investigate, compare, who to contact, or latest information, and routes tasks to quick web discovery, multi-source cited synthesis, ranked recommendations, people or company enrichment, or persistent knowledge storage. Developers reach for research-ops when answers must reflect current public evidence plus local repository context, or when a one-off query should become a repeatable monitored workflow. It is a coordination layer over affaan-m/ecc’s research stack, not a standalone search API.1.4kinstalls79Data Scraper Agentdata-scraper-agent is a community ECC skill that builds production-ready, AI-powered data collection agents for public sources such as job boards, prices, news, GitHub repos, sports scores, and event listings. The generated stack uses Python, Gemini Flash for free LLM enrichment, GitHub Actions for scheduled runs at no hosting cost, and storage in Notion, Google Sheets, or Supabase. The agent scrapes on a schedule, enriches results with an LLM, persists output, and improves from user feedback over time. Developers reach for data-scraper-agent when they want to monitor or track public data without writing a scraper from scratch or paying for dedicated hosting infrastructure.1.4kinstalls80Agent EvalAgent Eval is an ECC agent skill that systematizes head-to-head comparisons of coding agents on reproducible custom tasks. Tasks are declared in YAML specifying actions, target files, and success criteria, replacing subjective agent selection with measured pass rates, cost, runtime, and consistency metrics. Developers reach for Agent Eval before adopting a new tool or model, after agent updates, or when teams need data-backed agent choices on their own codebase. The skill supports Claude Code, Aider, Codex, and similar agents. Installation is performed from the ECC repository after reviewing source.1.4kinstalls81Ai First Engineeringai-first-engineering from affaan-m/ecc is an ECC skill for designing process, review, and architecture when AI-assisted code generation drives most implementation output. It shifts emphasis from typing speed to plan quality, from personal confidence to evaluation coverage, and from syntax nitpicks to system behavior during review. Architecture guidance favors explicit boundaries, stable contracts, typed interfaces, and deterministic tests over implicit conventions. Review targets regressions, security assumptions, data integrity, failure handling, and rollout safety while minimizing style debates already covered by automation. Strong adoption signals include decomposing ambiguous work, defining measurable acceptance criteria, writing high-signal prompts and evaluations, and enforcing risk controls under deadline pressure.1.4kinstalls82Pytorch Patternspytorch-patterns is an Everything Claude Code reference for idiomatic PyTorch deep learning development. The skill encodes best practices for device-agnostic code that runs on CPU and GPU, robust training loops, efficient data loading, GPU memory optimization, and reproducible experiment configuration. Developers reach for pytorch-patterns when writing new models or training scripts, reviewing deep learning code, debugging training pipelines, or optimizing throughput and memory on accelerators. Core principles start with portable device handling and extend through structured patterns for model architecture, dataloaders, and experiment repeatability rather than ad-hoc notebook code.1.4kinstalls83Springboot Securityspringboot-security is an ECC-origin expert review skill for Java Spring Boot applications using Spring Security. It activates when developers add authentication via JWT, OAuth2, or sessions, implement authorization with @PreAuthorize and role-based access, validate input with Bean Validation, configure CORS and CSRF protections, set security headers, manage secrets through Vault or environment variables, add rate limiting or brute-force defenses, and scan dependencies for known vulnerabilities. The skill provides opinionated best practices across the full request lifecycle so endpoints resist common OWASP-class failures before production deploys. Teams reach for springboot-security during endpoint creation, auth refactors, or pre-release security passes on Spring Boot microservices and monoliths rather than generic Java code review without a security lens.1.4kinstalls84Cpp Testingcpp-testing is an affaan-m ECC agent skill for modern C++17 and C++20 test workflows using GoogleTest, GoogleMock, CMake, and CTest. It activates when developers write or fix C++ tests, design unit and integration coverage, configure CI gating, or diagnose failing and flaky cases. The skill also covers enabling AddressSanitizer and thread sanitizers for memory and race diagnostics during test runs. Developers reach for cpp-testing when C++ components need regression protection, consistent CMake test targets, or structured failure investigation rather than ad hoc compile-and-pray checks. It explicitly avoids non-test C++ feature work, keeping agents focused on test design, build integration, and reliability improvements ahead of release.1.4kinstalls85BenchmarkBenchmark is an ECC performance skill for measuring baselines, catching PR regressions, and comparing stack alternatives. Mode 1 drives a real browser via browser MCP to capture Core Web Vitals—LCP under 2.5s, CLS under 0.1, INP under 200ms, FCP under 1.8s, and TTFB under 800ms—plus total page weight under 1MB and JS bundles under 200KB gzipped. Developers reach for Benchmark before launch, when users report slowness, or when evaluating framework swaps. The skill turns subjective performance complaints into measured thresholds suitable for CI-style gates.1.4kinstalls86Golang Testinggolang-testing is an ECC-origin skill that teaches and generates Go testing patterns aligned with the standard go test toolchain. It centers on table-driven tests as the primary idiom, with guidance for test helpers, benchmarking, race detection, coverage analysis, integration testing, and fuzzing. The skill activates on Go source files matched by globs for **/*.go, go.mod, and go.sum, making it repo-aware during test authoring sessions. Developers reach for golang-testing when writing new Test functions, improving flaky suites, or applying TDD cycles in Go services and CLIs. Patterns extend general testing principles with Go-specific conventions such as subtests, parallel flags, and helper hygiene so generated tests read like idiomatic production code rather than generic templates.1.4kinstalls87Configure Eccconfigure-ecc is an interactive step-by-step installer wizard for the Everything Claude Code (ECC) project. The skill uses AskUserQuestion to guide selective installation of skills and rules into user-level or project-level directories, validates paths and file correctness, and offers optimization passes on installed assets. Developers reach for configure-ecc when they say phrases like configure ecc, install ecc, or setup everything claude code, or when they want to verify or fix an existing ECC install. Bootstrap paths include installing via the ecc plugin with /plugin install ecc@ecc, which auto-loads the skill, or loading it directly from the ECC repository. The workflow covers fresh installs, selective skill picks, validation of broken paths, and project-specific tuning so agents load only what the workspace needs.1.4kinstalls88Marketing CampaignMarketing Campaign is an ECC-origin Claude skill for end-to-end launch planning and execution from one product brief. The skill guides audience research, positioning, campaign angle definition, landing page copy, email sequences, social posts, ad copy, short-form video scripts, and a content calendar as an orchestration layer across channels. Developers reach for Marketing Campaign when planning a product or feature launch, defining positioning before writing copy, or building a full content suite from a single brief. The workflow emphasizes campaigns that convert—not just campaigns that ship—by keeping messaging consistent across every touchpoint.1.4kinstalls89Kotlin Patternskotlin-patterns is an ECC skill for idiomatic Kotlin development across seven key areas: null safety with the type system and safe-call operators, coroutines, DSL builders, module design, and Gradle Kotlin DSL configuration. Developers activate kotlin-patterns when writing new Kotlin, reviewing pull requests, refactoring legacy code, designing libraries, or tuning Gradle builds. The skill steers agents away from Java-style patterns toward Kotlin-first APIs, efficient concurrency, and type-safe null handling. It fits Android apps, Ktor or Spring Kotlin services, and shared multiplatform modules where consistent style reduces review churn. Use kotlin-patterns whenever Kotlin output must be production-grade rather than syntactically correct Java ports.1.4kinstalls90Api Connector Builderapi-connector-builder is an ECC agent skill (version 1.0.0) for adding repository-native API connectors without inventing a parallel integration architecture. Agents first study in-repo connectors—layout, configuration schema, authentication, error handling, test style, and registration wiring—then implement new providers such as Jira or Slack to match those conventions. The skill blocks generic HTTP-client shortcuts and vendor-doc-only starts when the repo already defines integration patterns. Developers use api-connector-builder when extending multi-connector codebases that expect full transport, registry, test, and documentation coverage per integration.1.4kinstalls91Autonomous Loopsautonomous-loops is an ECC agent skill covering architectures for running Claude Code autonomously in loops. It spans simple sequential claude -p pipelines through RFC-driven multi-agent DAG systems with patterns and reference implementations teams can adopt. A v1.8.0 compatibility note states autonomous-loops is retained for one release while continuous-agent-loop becomes the canonical name for new loop guidance. Developers invoke autonomous-loops when choosing orchestration for long-running agent tasks, designing RFC-based multi-agent flows, or migrating existing ECC loop workflows without breaking references.1.4kinstalls92Code Tourcode-tour is an Everything Claude Code skill that produces CodeTour-format walkthroughs instead of ad-hoc Markdown notes. The skill creates .tour JSON files under .tours/ with steps anchored to real files and line ranges, targeting specific reader personas for onboarding tours, architecture walkthroughs, PR reviews, and root-cause analysis paths. Developers reach for code-tour when a guided sequence serves better than a flat repository overview, such as ramping new engineers or explaining how a subsystem works with reusable artifacts. The skill only authors tour files and does not modify source code as part of the workflow.1.4kinstalls93Ecc Guideecc-guide is the navigation skill for the Everything Claude Code ecosystem in the affaan-m/ecc repository. The skill explains how agents, skills, commands, hooks, rules, and install profiles relate, helps developers find the right ECC component for a task, and directs users to read live repository surfaces instead of relying on stale training data. Developers reach for ecc-guide when onboarding to ECC, choosing install profiles, asking what ECC includes, or resolving confusion about install paths and component boundaries. The skill is marked with community origin metadata and should be invoked before deep-diving into specialized ECC skills when the question is which tool to use.1.4kinstalls94Production Auditproduction-audit is an ECC agent skill that performs a local production-readiness audit to surface issues that could break in production while keeping all repository data on the developer machine. The audit is designed for teams that want pre-deploy confidence without uploading code or configuration to third-party scanning services. Developers reach for production-audit when preparing a release, hardening an AI-assisted codebase, or validating that environment, dependency, and operational gaps are caught before traffic hits production. The skill originates from the Everything Claude Code collection and complements external CI checks with an offline-first review pass.1.4kinstalls95Laravel Patternslaravel-patterns is an ECC-origin agent skill for production Laravel architecture covering routing, controllers, Eloquent ORM, service layers, background queues, events, caching, and API resources with pagination. Developers reach for it when building Laravel web apps or APIs, structuring domain logic away from fat controllers, designing Eloquent relationships, or adding jobs and event-driven workflows. The skill enforces clear boundaries—controllers delegate to services, models stay thin, and API responses use resources with consistent pagination. It activates during greenfield Laravel builds and refactors where maintainable layer separation prevents common Laravel anti-patterns.1.4kinstalls96Agentic Osagentic-os is an ECC skill that treats Claude Code as a persistent runtime rather than a disposable chat session. It documents a four-layer architecture rooted in project directories: a kernel that routes tasks to specialist agents, slash-command interfaces, file-based JSON and Markdown memory, and scheduled automation—all without relying on an external database for state. Developers reach for agentic-os when building multi-agent workflows, personal or agentic operating systems, or long projects where context must survive session restarts. Trigger phrases include "agentic OS," "personal OS," "multi-agent," "agent coordinator," and "persistent agent." The pattern formalizes production agentic setups used inside ECC projects.1.4kinstalls97Ui To Vueui-to-vue is a community ECC skill that transforms directories of UI design screenshots and design exports into ready-to-use Vue 3 Composition API component code. Input is organized by module and page state, with supported asset folder names such as assets and icons for sliced images. The skill supports three component libraries: Vant for mobile-oriented UIs, Element Plus, and Ant Design Vue. Developers use ui-to-vue when migrating a design folder into initial page components, shared components, and starter router wiring for a Vue 3 codebase. It is built for batch conversion across many screens, not single-screenshot one-off components. The skill explicitly avoids projects that need deep interaction logic, data-flow design, accessibility review, or screenshots containing private customer data sent to external model APIs.1.4kinstalls98Angular Developerangular-developer is an ECC skill that generates Angular code and provides architectural guidance across projects, components, services, directives, pipes, guards, and resolvers. It covers modern reactivity with Angular Signals, linkedSignal, and resource APIs, plus dependency injection, routing, SSR, accessibility with ARIA, animations, component styles, Tailwind CSS, testing, and Angular CLI tooling. Developers reach for angular-developer when scaffolding a new Angular app or library, implementing signal-based state, building typed forms, or aligning generated code with current Angular best practices. The skill triggers on any Angular codebase work so agents produce framework-correct patterns instead of generic React-style component code.1.4kinstalls99Dotnet Patternsdotnet-patterns is an ECC-origin agent skill covering idiomatic C# and .NET conventions for building robust, performant, maintainable applications with ASP.NET Core. Developers activate it when writing new C# code, reviewing pull requests, refactoring legacy .NET apps, or designing service architectures with proper dependency injection boundaries. Core guidance includes preferring immutable records and init-only properties, structured async/await usage, sealed record value objects like Money DTOs, and clean separation in service layers. The skill encodes when-to-activate triggers for new code, reviews, and refactors so agents apply consistent .NET idioms instead of generic OOP patterns from other languages.1.4kinstalls100Mle WorkflowMLE Workflow is an ECC agent skill for turning experimental notebook code into production-grade machine learning systems. It structures work around data contracts, reproducible training runs, measurable quality evaluation gates, deployable model artifacts, operational monitoring, and rollback procedures. Developers activate MLE Workflow when planning or reviewing production ML features such as ranking systems, recommenders, classifiers, embedding workflows, or model refresh cycles that must move beyond one-off Jupyter experiments. The skill uses Read, Write, Edit, Bash, Grep, and Glob to audit and harden ML codebases, ensuring training is repeatable, evaluation is gated, and deployed models remain observable in production.1.4kinstalls101Prisma Patternsprisma-patterns is an ECC skill with production Prisma ORM guidance for TypeScript backends, tested against Prisma 5.x and 6.x with noted differences from Prisma 4. It documents schema design, query optimization, transactions, pagination, and non-obvious traps: `updateMany` returning a count not records, `$transaction` timeouts, `migrate dev` resetting the database, `@updatedAt` skipped on bulk writes, and serverless connection exhaustion. Prisma 5's `relationJoins` preview can load related records in fewer queries. Developers check versions with `npx prisma --version` before applying version-specific advice. Reach for prisma-patterns when agents generate Prisma code and you want battle-tested guardrails instead of rediscovering ORM footguns.1.4kinstalls102Skill Scoutskill-scout is an affaan-m ECC community skill that developers invoke before building a new agent skill from scratch. It extracts the target task, trigger conditions, related frameworks, and three to five search keywords, then queries local skill folders, marketplaces, GitHub repositories, and the broader web for matches to review, adopt, or fork. The workflow prevents duplicate community skills while still requiring proper inspection before external adoption. Developers reach for skill-scout when they ask whether a skill already exists, propose a new workflow skill, or want to extend an existing package. If a user explicitly demands greenfield creation, the skill confirms that choice then proceeds with the requested build path instead of searching further.1.4kinstalls103Pubmed Databasepubmed-database is a community skill from affaan-m/ecc that teaches coding agents to search MEDLINE through PubMed and NCBI E-utilities with reproducible Boolean queries. The workflow starts from a research question, splits concepts, and combines synonyms with AND/OR/NOT while applying field tags such as [ti], [ab], [tiab], [au], [ta], and MeSH filters for date or publication type. Developers reach for pubmed-database when they need PMID abstracts, citation metadata, literature monitoring, or systematic-review search paths callable from Python, shell, or any HTTP client. The skill replaces noisy general web search with API-backed biomedical retrieval suitable for life-science tooling, clinical software research, and evidence-backed engineering decisions.1.4kinstalls104Laravel Securitylaravel-security is an ECC agent skill with a complete Laravel security guide covering authentication, authorization, input validation, CSRF middleware, mass-assignment protection, file upload safety, API endpoint hardening, secrets management, rate limiting, and secure production deployment. Developers activate it when adding Laravel auth, handling user input and uploads, building new API routes, or reinforcing environment configuration. The skill explains how Laravel middleware delivers baseline CSRF and session protections and where developers must add validation, policy checks, and deployment hardening. Reach for laravel-security during new endpoint work or pre-production security reviews on Laravel codebases.1.4kinstalls105Springboot Tddspringboot-tdd is an ECC skill for test-driven development on Spring Boot services with a target of 80%+ unit and integration coverage enforced through JaCoCo. The workflow follows classic TDD: write failing tests first, implement minimal passing code, refactor while green, and verify coverage gates. It applies when adding endpoints, fixing bugs, refactoring, or introducing data-access and security logic. The stack includes JUnit 5 for unit tests, Mockito for mocks, MockMvc for web layer tests, and Testcontainers for integration scenarios. Developers reach for springboot-tdd when they want agent-guided red-green-refactor discipline on Java Spring Boot backends rather than ad hoc test-after coding.1.4kinstalls106Automation Audit Opsautomation-audit-ops is an ECC operator skill that audits which automations are live, which jobs are broken, where overlap exists, and which connectors actually perform useful work—before rewriting anything. The first deliverable is an evidence-backed inventory plus keep, merge, cut, and fix recommendations covering jobs, hooks, MCP servers, wrappers, and connectors. It integrates related ECC skills such as workspace-surface-audit for connector and hook inventory, knowledge-ops for durable context alignment, github-ops for CI and scheduled workflows, ecc-tools-cost-audit for webhook fan-out and billing burn, and research-ops for platform truth checks. Developers reach for automation-audit-ops when automation sprawl, redundant MCP servers, or failing scheduled jobs obscure what is safe to change.1.4kinstalls107Crosspostcrosspost is an ECC content-distribution skill that adapts a single underlying idea into platform-native posts for X, LinkedIn, Threads, and Bluesky using content-engine patterns. It never publishes identical copy across platforms, preserving voice while respecting each network's format and tone constraints. Developers reach for crosspost when a launch, release, update, or essay must appear on multiple social channels with tailored versions rather than one duplicated blast. Activation triggers include requests to crosspost, post everywhere, or adapt content for specific networks. The skill enforces a core rule: do not publish the same fake post in four costumes—each platform gets a distinct native rewrite of the same core message.1.4kinstalls108Django Patternsdjango-patterns is an ECC skill that encodes production-grade Django architecture for scalable, maintainable applications. It activates when building Django web apps, designing Django REST Framework APIs, working with the ORM and models, or setting up project structure with caching, signals, and middleware. The skill recommends a split settings layout under config/settings with base.py and environment-specific modules, plus conventions for apps, models, serializers, and API endpoints. Developers reach for django-patterns when scaffolding a new Django service, refactoring a monolithic settings file, or aligning DRF serializers and viewsets with team standards. Guidance stays inside the agent workflow so architecture decisions land directly in generated code and file trees.1.4kinstalls109Django Securitydjango-security is an ECC agent skill with comprehensive Django security guidelines covering authentication, authorization, CSRF protection, SQL injection prevention, XSS prevention, and production settings configuration. The skill walks through production settings.py patterns, user permissions, role-based access, and pre-deployment security reviews. Developers reach for django-security when setting up Django auth, implementing permissions, reviewing apps for vulnerabilities, or configuring secure production deployments. The guidance targets common OWASP-class risks in Django ORM queries, templates, middleware, and environment-specific settings before traffic hits production.1.4kinstalls110Investor Outreachinvestor-outreach is a fundraising communication skill from affaan-m/ecc that generates short, concrete investor-facing messages instead of generic pitch spam. The skill activates when a developer needs a cold email to a partner, a warm intro request, a post-meeting follow-up, or a process update tailored to fund thesis and partner fit. Core rules enforce personalization on every outbound message and keep copy easy to act on with clear asks. investor-outreach fits technical founders who have product context but need high-signal wording for investor inboxes. Skip it when the task is product copy, hiring outreach, or customer sales emails rather than capital raising.1.4kinstalls111Jira Integrationjira-integration is an ECC skill that brings Jira issue management into AI coding workflows. It supports two paths: the recommended mcp-atlassian MCP server (Python 3.10+, uvx) and direct Jira REST API calls. Developers use jira-integration to fetch tickets for requirements, extract testable acceptance criteria, add progress comments, transition issues (To Do → In Progress → Done), link branches or merge requests, and search with JQL. The skill documents MCP configuration patterns and REST fallbacks so agents pick the right integration surface. Reach for jira-integration when implementation work is tracked in Jira and the agent must read ticket state or write back status during development.1.4kinstalls112Continuous Learningcontinuous-learning is a legacy affaan-m/ecc skill marked DEPRECATED as of 2026-04-28 in favor of continuous-learning-v2. Version 1 used stop-hook observation to extract reusable patterns and instincts from Claude Code sessions into stored skills. continuous-learning-v2 is documented as a strict superset: stop-hook observation becomes PreToolUse and PostToolUse observation, full skills become atomic instincts with confidence scoring, and global-only storage becomes project-scoped with global promotion. Developers should route continuous learning, session learning, and pattern extraction requests to continuous-learning-v2 instead of invoking this v1 skill.1.4kinstalls113Springboot Verificationspringboot-verification is an ECC-origin agent skill that chains Maven/Gradle build, static analysis, unit and integration tests with coverage thresholds, security scans, and diff review into one repeatable gate for Spring Boot microservices. Developers reach for it before opening a PR, after large refactors or dependency bumps, and immediately prior to staging or production deploys when a single missed regression or CVE would be costly. The skill encodes when to activate the full pipeline versus a lighter check and documents coverage thresholds and scan expectations so agents do not skip steps. It targets Java/Spring teams who want agent-driven CI parity on a laptop without wiring a custom script each sprint.1.4kinstalls114Product Lensproduct-lens is an ECC-origin skill designed to challenge product assumptions and surface the underlying why before agents translate requests into code. Developers reach for product-lens when stakeholders hand over underspecified features, when the motivation behind a ticket is unclear, or when a quick sanity check could prevent building the wrong thing. The skill acts as a pre-build lens on intent, forcing clarity on user problems, success criteria, and tradeoffs instead of jumping straight to files and functions. It fits early validation workflows alongside prototyping and scoping skills. The published readme notes an in-progress Japanese translation, but the skill definition and description remain active in the ECC catalog for English-language product questioning sessions inside Claude Code agent workflows.1.4kinstalls115Redis Patternsredis-patterns is an ECC backend reference skill covering Redis data structures, atomic workflows, and production configuration for common application workloads. The skill explains when to use strings, hashes, lists, sets, sorted sets, and streams, and how multi-step operations require Lua scripts, MULTI/EXEC transactions, or explicit synchronization beyond single-command atomicity. Developers reach for redis-patterns when adding caching layers, rate limiters, distributed locks, session stores, or pub/sub and Redis Streams messaging, including pooling, eviction, and clustering setup. The included data-structure cheat sheet maps use cases to Redis types with concrete command examples for backend services.1.4kinstalls116Token Budget Advisortoken-budget-advisor, abbreviated TBA, intercepts the response flow before Claude answers so users pick how much depth to consume. Trigger phrases include token budget, token count, response length, answer depth, short version, detailed answer, exhaustive answer, and explicit percentage requests such as respond at 50%. The skill does not fire when the user already set a level for the session, wants a one-word reply, or refers to auth or payment tokens instead of LLM tokens. Use token-budget-advisor when answer size should be negotiated up front to save tokens on large explanations or reserve depth for complex tasks.1.4kinstalls117Autonomous Agent Harnessautonomous-agent-harness is an Everything Claude Code skill for building self-directing agent systems without external frameworks like Hermes or AutoGPT. The skill composes Claude Code native crons, dispatch, MCP servers, and persistent memory to queue tasks, run scheduled operations, and maintain state across sessions while enforcing explicit user consent and safety boundaries before scheduling, remote dispatch, credential use, or external posting. Developers reach for autonomous-agent-harness when they need continuous automated operations, scheduled background tasks, or self-directed agent loops scoped to an approved workspace. The skill prefers dry-run plans and local queue files before enabling credential access or modifying third-party resources.1.4kinstalls118Blender Motion State InspectionBlender Motion State Inspection is an ECC agent skill for diagnosing Blender character and animation problems when visual screenshots are insufficient. It compares rendered evidence against structured facts such as bone hierarchies, bounding boxes, foot-ground contacts, and facing direction vectors to detect twisted, mirrored, flattened, or offset rigs and foot-sliding in retargeted motion. Developers reach for Blender Motion State Inspection when imported avatars, armatures, or retargeted animations may not match expected poses or when model-vs-motion alignment must be verified programmatically. The skill uses Read, Write, Edit, Bash, Grep, and Glob tools to inspect .blend assets and produce factual diagnostics agents can act on.1.4kinstalls119Scholar Evaluationscholar-evaluation is an ECC community skill that scores academic and technical artifacts with structured 1-to-5 rubrics across methodology, evidence, citations, and limitations. It supports empirical papers, theoretical work, technical reports, systematic or narrative literature reviews, proposals, thesis chapters, and conference abstracts—with comprehensive, targeted, or comparative evaluation modes. Developers and researchers reach for scholar-evaluation when reviewing agent-generated research summaries, validating that claims are citation-backed, comparing multiple papers on the same rubric, or producing structured revision feedback. Each dimension scores from 1 (substantial revision needed) through 5 (publication-ready), making quality gaps explicit before outputs inform product or publication decisions.1.4kinstalls120Videodbvideodb is an ECC agent skill that extends coding agents with end-to-end video intelligence: ingest from local files, URLs, RTSP feeds, or live desktop capture; build visual, semantic, and temporal indexes; search moments with timestamps and auto-clips; and act via transcoding, subtitle overlays, dubbing, translation, and real-time event alerts. The skill declares allowed tools Read, Grep, Glob, and Bash with python execution, signaling Python-driven media pipelines. Developers reach for videodb when building agents or apps that must process video, monitor live streams, or generate edited media assets without hand-rolling FFmpeg and search infrastructure. Use it for video RAG, stream monitoring, desktop session analysis, and programmatic timeline edits.1.4kinstalls121Security Bounty Huntersecurity-bounty-hunter is an ECC skill (version 1.0.0) that focuses security review on exploitable, remotely reachable attack paths platforms like HackerOne and Huntr actually pay for. The workflow deprioritizes noisy local-only issues and patterns bounty platforms routinely reject as informational or out of scope. Documented in-scope patterns include user-controlled URL SSRF (CWE-918), middleware or API guard authentication bypass (CWE-287), and remote deserialization chains with concrete CWE mappings and impact notes. Developers reach for security-bounty-hunter when triaging a repo for paid bounty eligibility rather than running a generic secure-coding checklist.1.4kinstalls122Skill Stocktakeskill-stocktake is an ECC slash command (/skill-stocktake) that audits Claude skills and commands for quality using a checklist plus AI holistic judgment. It offers Quick Scan for recently changed skills and Full Stocktake for a complete sequential subagent batch evaluation across global and project paths such as ~/.claude/skills/ and the current working directory. Developers reach for skill-stocktake when custom skills drift in quality, duplicate triggers, or lack clear activation criteria after rapid iteration. The command scopes paths relative to the invocation directory and targets both global and project-local skill trees. Results help teams retire weak skills, tighten descriptions, and align slash commands before wider agent rollout.1.4kinstalls123Compose Multiplatform Patternscompose-multiplatform-patterns is an ECC skill cataloging production patterns for Jetpack Compose and Compose Multiplatform in Kotlin multiplatform projects. It covers state management with ViewModel plus single state data classes exposed as StateFlow, navigation setup, reusable composables, design-system theming, and recomposition performance tuning across Android, iOS, desktop, and Web targets. Developers reach for compose-multiplatform-patterns when implementing Compose UI, wiring ViewModel-driven screen state, building KMP navigation graphs, or optimizing render performance in shared UI codebases. Patterns emphasize a single screen-state data class collected in Compose rather than scattered mutable state. The skill activates whenever shared composable architecture decisions arise in KMP or Android-only Compose projects.1.4kinstalls124Exa Searchexa-search is a Claude Code skill from affaan-m/ecc that routes research through the Exa MCP server's neural search engine. Developers activate it for current web information, code examples, API documentation references, company and competitor research, and professional people lookup during development tasks. Trigger phrases include search for, look up, find, and what's the latest, steering agents away from stale training data toward Exa-backed results. The skill fits background research for any build task where verified external sources matter more than model recall, and it documents when to prefer Exa over generic web search for technical and company queries.1.4kinstalls125Jpa PatternsJPA Patterns is an ECC-origin skill from affaan-m/ecc covering JPA and Hibernate work in Spring Boot applications. The skill activates when designing entities and table mappings, defining @OneToMany, @ManyToOne, and @ManyToMany relationships, optimizing queries with fetch strategies and projections to prevent N+1 problems, configuring transactions and auditing, implementing soft deletes, setting up pagination and custom repository methods, and tuning HikariCP connection pooling or second-level caching. Developers reach for JPA Patterns when scaffolding persistence layers or debugging slow Hibernate queries in production services. It consolidates entity design, relationship cardinality, indexing, and pooling guidance into one agent reference instead of scattered Stack Overflow threads.1.4kinstalls126Dart Flutter Patternsdart-flutter-patterns is an ECC skill with production-ready, copy-paste Dart and Flutter patterns organized by concern. Coverage includes null safety (avoiding `!`, preferring `?.`/`??`/pattern matching), immutable state with sealed types, freezed, and copyWith, async composition, widget architecture, BLoC, Riverpod, and Provider state management, GoRouter navigation with auth guards, Dio HTTP clients, Freezed code generation, WebView integration, local storage, and widget/Cubit/Riverpod tests. Developers reach for dart-flutter-patterns when starting Flutter features, choosing state libraries, wiring authenticated routes, or reviewing Dart for null-safety and sealed-type conventions. The skill accelerates consistent mobile code instead of mixing ad hoc patterns across modules.1.4kinstalls127Cost Trackingcost-tracking is a Claude Code skill that analyzes Claude Code spending from the local SQLite database at ~/.claude-cost-tracker/usage.db. It assumes a cost-tracking hook or plugin already writes usage rows to that database, then answers questions about session cost, token usage, budgets, overages, and breakdowns by project, tool, session, model, or date. Developers can compare today versus yesterday, inspect recent trends, and export recent usage records to CSV. The skill originated from community PR #1304 by MayurBhavsar and uses sqlite3 to query stored metrics when users ask how much they spent.1.4kinstalls128Claude DevfleetClaude DevFleet is a multi-agent orchestration skill for Claude Code that connects to a running DevFleet MCP server at http://localhost:18801/mcp. Developers register the server with `claude mcp add devfleet --transport http http://localhost:18801/mcp`, then call plan_project to turn a prompt into a mission DAG, approve the plan, and dispatch missions so each agent works in its own git worktree with full tool access. Completed missions auto-merge before dependent missions dispatch, and get_report returns files_changed and structured completion data. Reach for Claude DevFleet when a single agent cannot safely parallelize backend, auth, tests, or refactors across branches.1.4kinstalls129Continuous Agent Loopcontinuous-agent-loop is an ECC v1.8+ standard loop skill that replaces autonomous-loops while preserving compatibility for one release cycle. The skill routes work through a decision flow—continuous-pr for strict CI/PR control, rfc-dag for RFC decomposition, infinite for parallel exploration, or sequential as the default—and documents a production stack pairing RFC decomposition, plankton-code-quality gates, eval-harness evaluation, and nanoclaw-repl session persistence. Developers reach for continuous-agent-loop when agent runs churn without measurable progress, repeat the same root-cause retries, stall merge queues, or drift costs through unbounded escalation. The skill encodes failure modes and recovery patterns so agent loops terminate with evidence instead of infinite retries.1.4kinstalls130Django Verificationdjango-verification is a verification-loop skill for Django projects from the affaan-m/ecc collection. The workflow walks through environment checks (Python version, virtualenv, DJANGO_SECRET_KEY), code quality with mypy, ruff, and Black, test execution with coverage, security scanning, and deployment readiness before merging or shipping. Developers reach for django-verification after large refactors, before opening a pull request, or ahead of a production deploy when manual checklists are easy to skip. The skill stops on misconfigured environments instead of masking failures, and encodes bash commands agents can run in sequence. It targets Django backends using pyproject.toml-driven tooling rather than greenfield scaffolding.1.4kinstalls131Laravel Tddlaravel-tdd is an affaan-m/ecc skill for test-driven development on Laravel applications using PHPUnit and Pest with an 80%+ coverage target across unit and feature tests. It follows a red-green-refactor cycle: write a failing test, implement code to pass, then refactor. The skill covers Eloquent models, policies, jobs, notifications, database factories, fakes, and new API endpoints. Pest is preferred for new tests unless the project is already standardized on PHPUnit. Developers reach for laravel-tdd when adding Laravel features, fixing bugs with regression tests, or refactoring with safety nets. It triggers on new endpoints, model changes, and any Laravel work where coverage and TDD discipline are required.1.4kinstalls132Django Tdddjango-tdd is a test-driven development skill for Django applications using pytest, pytest-django, factory_boy, mocking, coverage reporting, and Django REST Framework. It walks developers through the red-green-refactor cycle: write a failing test for models or views, implement minimal code to pass, then refactor while keeping coverage high. Use django-tdd when creating new Django apps, building DRF APIs, setting up test infrastructure, or testing serializers and authentication flows. The workflow emphasizes factory_boy data setup, isolated unit tests, and API endpoint verification instead of manual QA after features ship.1.4kinstalls133Hexagonal Architecturehexagonal-architecture is a Ports and Adapters design skill that keeps domain logic independent from frameworks, transport layers, and persistence details. The core application depends on abstract ports, while adapters at the edges implement HTTP handlers, CLI commands, queue workers, cron jobs, databases, and external APIs. Use hexagonal-architecture when building features where long-term testability matters, refactoring layered code where I/O bleeds into domain logic, or supporting multiple interfaces for the same use case. The skill helps replace infrastructure such as databases or message brokers without rewriting business rules.1.4kinstalls134Kotlin Testingkotlin-testing is a Claude Code skill from affaan-m/ecc that teaches and applies Kotlin testing patterns using Kotest, MockK, coroutine testing, property-based testing, and Kover coverage reporting while following strict TDD methodology. The workflow starts by identifying a target function, class, or module, then writes failing tests first, implements mocks and coroutine test dispatchers, and configures Kover for coverage thresholds. Developers reach for kotlin-testing when adding coverage to existing Kotlin services, writing new domain logic, or standardizing test style across a multi-module Gradle project. The skill emphasizes idiomatic Kotlin practices—structured concurrency tests, MockK verification, and maintainable spec layouts—rather than generic JUnit snippets ported from Java.1.4kinstalls135Ckck (Context Keeper) is a version 2.0.0 community agent skill by sreedhargs89 that gives Claude Code persistent per-project memory loading automatically at every session start. Scripts live at ~/.claude/skills/ck/commands/ and run deterministically via /ck:* commands, presenting stdout verbatim for consistent behavior across model versions. The skill tracks sessions with git activity and writes to native Claude memory under ~/.claude/. Developers reach for ck when context resets between sessions break continuity on long-running repositories. Invoke any /ck:* command to run the matching Node.js script rather than relying on model recall alone.1.4kinstalls136Cost Aware Llm Pipelinecost-aware-llm-pipeline is an ECC agent skill that documents a composable Python pipeline for controlling LLM API spend while preserving quality. The pattern routes simple tasks to cheaper models such as claude-haiku-4-5-20251001 and reserves claude-sonnet-4-6 for workloads exceeding 10,000 characters or 30 items, with explicit thresholds in select_model(). Developers combine budget tracking, retry logic, and prompt caching when building Claude or GPT integrations, batching mixed-complexity items, or enforcing API budgets. Reach for cost-aware-llm-pipeline when LLM bills spike during development or when heterogeneous workloads need automatic tier selection instead of a single default model.1.4kinstalls137Plan Orchestrateplan-orchestrate is a planning skill that turns any multi-step plan document into ready-to-paste /orchestrate custom prompts without manually selecting agents for each step. Developers write or import a structured plan, and the skill formats orchestration prompts that dispatch the right agent work per stage. Reach for plan-orchestrate when a written implementation plan already exists and you want to batch-convert steps into Claude Code orchestration commands. The ECC repo notes some localized readme copies are still being translated, but the skill targets English plan-to-orchestrate prompt generation.1.4kinstalls138Repo Scanrepo-scan is a cross-stack source audit skill that classifies each file, detects third-party libraries embedded without package managers, and assigns practical four-level verdicts per module alongside an interactive HTML report. Developers install it from haibindev/repo-scan via a pinned git fetch into ~/.claude/skills/repo-scan for reproducible runs. Use repo-scan when taking over large legacy codebases, planning refactors to separate core from duplicate or dead code, auditing vendored C++, Android, iOS, or Web dependencies, or preparing architecture decision records for monorepo reorganization. The skill addresses ecosystems where no single dependency manager explains what code is owned versus third-party.1.4kinstalls139Workspace Surface Auditworkspace-surface-audit is an ECC read-only audit skill answering what a workspace and machine can currently do and what to add or enable next. It reviews active repositories, MCP servers, plugins, connectors, and environment surfaces including .env, .mcp.json, and plugin configuration without modifying files unless the user explicitly requests implementation. Developers reach for workspace-surface-audit when asking to set up Claude Code, recommend automation, choose plugins or MCP servers, or identify missing workflow layers. The skill compares official marketplace plugins against ECC-native coverage and determines whether a capability should be a skill, hook, agent, MCP server, or external connector. It is the ECC-native alternative to generic setup audit plugins.1.4kinstalls140Canary WatchCanary Watch is an ECC agent skill that monitors a deployed URL for regressions after production or staging deploys, risky PR merges, dependency upgrades, or during launch windows. It runs in a loop until stopped or until the monitoring window expires, checking six signal categories: HTTP status codes, new browser console errors, failed network and 5xx API calls, LCP/CLS/INP performance against baseline, missing critical DOM elements such as h1, nav, footer, and CTA, and API endpoint health within SLA. Quick-check mode runs a single pass and reports results via `/canary-watch https://myapp.com`, while continuous mode rechecks every N minutes for M hours with `--interval 5m`. Developers reach for Canary Watch when they need automated post-deploy confidence without standing up a full APM stack.1.4kinstalls141Dmux Workflowsdmux-workflows is an affaan-m/ecc skill for multi-agent orchestration using dmux, a tmux pane manager built for AI agent harnesses. It defines patterns to run Claude Code, Codex, OpenCode, and other agents in parallel panes, split large tasks, and merge results from concurrent sessions. Activate when a user says run in parallel, split this work, use dmux, or coordinate multi-agent development on a complex refactor or feature slice. The skill covers pane layout, work partitioning, and cross-harness coordination rather than single-threaded prompting. Developers with tmux-based terminals and multiple agent CLIs gain the most from these workflows.1.4kinstalls142Knowledge Opsknowledge-ops is an ECC agent skill for managing a multi-store knowledge base spanning local files, MCP memory, vector stores, Supabase, and Git repositories. The skill follows a live-workspace model: code stays in cloned repos, active execution context lives in GitHub, Linear, and working-context files, human notes can sit outside the repo, and cross-machine durable memory belongs in the knowledge base. Developers reach for knowledge-ops when they ask to save to a KB, sync knowledge, ingest documents, deduplicate entries, or query what the system already knows about a topic. It covers ingestion, structured storage, cross-system sync, deduplication, and retrieval tasks that exceed a single memory_store invocation.1.4kinstalls143Lead Intelligencelead-intelligence is an ECC agent-powered pipeline for finding, qualifying, and reaching high-value contacts through social graph analysis and warm-path discovery. It replaces manual prospecting workflows with signal scoring, mutual ranking, source-derived voice modeling, and outreach tailored to email, LinkedIn, and X channels. Developers or technical founders reach for lead-intelligence when building partnership lists, investor outreach, or industry-specific prospect pipelines without traditional enrichment SaaS. Activation covers requests to find leads, qualify prospects, or launch outreach in a target industry. The skill models authentic voice from source material and prioritizes warm introduction paths over cold blasts.1.4kinstalls144Clickhouse Ioclickhouse-io is an affaan-m/ecc agent skill covering ClickHouse database patterns, query optimization, and data engineering practices for analytical workloads. ClickHouse is a column-oriented OLAP DBMS optimized for fast analytics on large datasets with columnar storage, compression, parallel query execution, distributed queries, and real-time analysis. The skill documents MergeTree engine table design with Date partitioning, typed columns such as UInt64 volume and UInt32 trades, and markets_analytics-style schemas. Developers reach for clickhouse-io when designing analytical tables, writing performant aggregation queries, or tuning high-volume telemetry and market data pipelines. It focuses on OLAP-specific patterns rather than transactional CRUD database design.1.4kinstalls145Click Path Auditclick-path-audit is a behavioral flow audit skill from affaan-m/ecc that finds bugs static reading and unit tests miss. Traditional checks verify functions exist, avoid crashes, and return correct types, but not whether final UI state matches button labels or whether one handler silently undoes another. The skill traces user-facing touchpoints through ordered calls, race conditions, and shared store side effects in Zustand, Redux, or context. Developers reach for click-path-audit when users report broken buttons despite green tests, especially after refactors touching global state. Example failure modes include compose mode toggles canceled by thread selection side effects.1.4kinstalls146Kotlin Coroutines Flowskotlin-coroutines-flows is an affaan-m/ecc skill covering structured concurrency, Flow-based reactive streams, and coroutine testing for Android and Kotlin Multiplatform projects. It prescribes scope hierarchies from Application through viewModelScope down to structured child coroutineScope blocks, forbids GlobalScope, and documents patterns for parallel loads, debounce, retry, cancellation, and testing Flow emissions. Developers reach for kotlin-coroutines-flows when writing asynchronous Kotlin, wiring StateFlow or SharedFlow for reactive UI state, or debugging concurrency bugs in mobile and KMP codebases. The skill encodes production-ready coroutine idioms so agents generate cancellable, testable async code instead of fire-and-forget launches.1.4kinstalls147Safety Guardsafety-guard is an ECC protection skill for autonomous agent runs on production systems and sensitive repositories. It provides three protection modes: Careful mode detects destructive commands such as rm -rf, git push --force, DROP TABLE, kubectl delete, and --no-verify hooks before execution and prompts for confirmation with safer alternatives; Freeze mode locks edits to specific directory trees via commands like freeze src. Developers reach for safety-guard during full-auto agent sessions, migrations, deploys, and data changes where a mistaken shell or Git command could wipe state. The skill watches roughly a dozen high-risk command patterns and offers directory-scoped edit locks instead of relying on post-hoc review.1.4kinstalls148Content Hash Cache Patterncontent-hash-cache-pattern is an ECC skill for caching expensive file processing—PDF parsing, text extraction, image analysis—using SHA-256 content hashes as cache keys instead of file paths. Keys survive renames and moves and auto-invalidate when file bytes change. The pattern separates cache logic into a service layer and supports --cache/--no-cache CLI toggles. Developers reach for content-hash-cache-pattern when pipelines reprocess the same documents, processing cost is high, or agents add caching to file-ingestion tools. Unlike path-based caches, hash keys prevent stale hits after content edits even when filenames stay the same. Use it while building ingestion CLIs, document AI preprocessors, or batch analyzers.1.4kinstalls149Iterative RetrievalIterative Retrieval is an ECC agent skill that solves the subagent context problem in multi-agent workflows where agents cannot know which files, patterns, or project terminology they need until work begins. Standard approaches fail by sending the entire codebase and exceeding token limits, sending nothing and leaving agents uninformed, or guessing required context and often missing critical files. Iterative Retrieval implements a four-phase loop—dispatch, evaluate, refine, and repeat—that progressively narrows retrieved context based on what each subagent discovers it still needs. Developers reach for Iterative Retrieval when delegating codebase tasks to subagents in large repositories where upfront context selection is unreliable and token budgets are tight.1.4kinstalls150Laravel Verificationlaravel-verification is an ECC skill that runs a complete Laravel quality gate before pull requests, major refactors, or production deploys. The loop spans eight sequential phases: environment and Artisan checks, Composer validation, Pint linting, PHPStan or Psalm static analysis, PHPUnit tests with optional Xdebug coverage, composer audit security scans, migration pretend runs with rollback review, and deployment readiness including config, route, and view cache warmups plus queue and scheduler checks. Each phase gates the next—failed environment or Composer checks stop the pipeline before expensive test runs. The skill documents Sail-compatible commands, Horizon status checks, queue:monitor backlog inspection, and a staging-only queue healthcheck job pattern. CI examples chain pint --test, phpstan analyse, and coverage-enabled php artisan test. Developers reach for laravel-verification when Laravel changes need proof that lint, tests, security, migrations, and release caches all pass together.1.4kinstalls151Skill Complyskill-comply is an automated compliance measurement skill for coding agents. It auto-generates expected behavioral sequences from any .md skill, rule, or agent definition, then builds scenarios at three prompt strictness levels: supportive, neutral, and competing. The skill runs `claude -p`, captures tool call traces via stream-js, classifies behavioral sequences, and reports compliance rates with full tool call timelines. Use skill-comply when custom agent instructions exist but behavior consistency is unverified. Required tools are Read and Bash, making it suited to CI-style agent definition audits before wider rollout.1.4kinstalls152Terminal OpsTerminal Ops is an ECC agent skill for evidence-priority repository execution when users ask to fix, debug, run commands, inspect the repo, or push narrow verified changes. It deliberately scopes narrower than generic coding guidance, focusing on command output, git state, test results, and documented verification rather than open-ended refactors. The skill stacks with related ECC skills: verification-loop for post-change checks, tdd-workflow when regression coverage is required, security-review when keys or external input are involved, github-ops for CI and PR status, and knowledge-ops to persist validated findings. Developers reach for Terminal Ops when tasks depend on real command execution and provable local verification before any push.1.4kinstalls153X Apix-api is an ECC skill for programmatic interaction with the X (Twitter) API v2 from Python agents and scripts. It documents OAuth 2.0 bearer tokens for read-heavy search and public data, plus OAuth 1.0a user context required for posting tweets, threads, DMs, and media uploads. Core operations include posting single tweets and reply chains, reading user timelines with public_metrics fields, recent search with query operators such as from:username and -is:retweet, username lookup, and v1.1 media upload followed by v2 tweet creation. Rate-limit handling reads x-rate-limit-remaining and x-rate-limit-reset headers at runtime rather than hardcoding static quotas, and the skill flags itself as drift-prone because X tiers and permissions change frequently. Security guidance forbids hardcoded tokens, requires .gitignore for .env files, and recommends read-only credentials when writes are unnecessary. Developers reach for x-api when agents or scripts must post threads, search recent tweets, or pull engagement metrics from X.1.4kinstalls154Frontend A11yfrontend-a11y is a community-origin Claude Code skill from affaan-m/ecc delivering practical accessibility patterns for React and Next.js. It covers semantic HTML, ARIA attributes, form labeling for input, select, and textarea elements, keyboard navigation, focus management, and screen reader support for modals, dropdowns, and interactive UI. The skill targets issues commonly flagged in code review: missing labels, incorrect ARIA, non-semantic interactive elements, and broken keyboard flows. Developers reach for frontend-a11y when building or reviewing forms, modals, dropdowns, or any interactive React and Next.js component requiring WCAG-aligned patterns.1.4kinstalls155Django CeleryDjango Celery is an ECC agent skill for adding asynchronous task processing to Django projects using Celery with Redis or RabbitMQ brokers. It walks through installing Celery and Redis via pip, defining `@shared_task` functions, starting workers with `celery -A myapp worker -l info`, and enqueueing work with `.delay()` for immediate async execution or crontab-based schedules for periodic jobs like daily reports and cleanup tasks. Developers reach for Django Celery when email sending, heavy processing, recurring maintenance, external API calls, or multi-step workflows should not block HTTP request threads. The skill covers task queuing, worker management, error handling, and broker integration patterns standard in production Django deployments.1.4kinstalls156Agent Payment X402agent-payment-x402 is an agent payments skill from affaan-m/ecc that adds policy-gated spending through the x402 HTTP payment protocol and MCP tools. The skill supports non-custodial wallets via agentwallet-sdk on Base and OKX Payments on X Layer without custodial risk. Use cases include agents paying for API calls, purchasing services, settling with other agents, and enforcing per-task spend limits. A decision table routes integrations depending on whether the agent buys access to 402-gated APIs or charges others. agent-payment-x402 pairs naturally with cost-aware-llm-pipeline and security-review skills during paid agent workflows.1.4kinstalls157Swiftui Patternsswiftui-patterns is an ECC skill documenting modern SwiftUI architecture for Apple platforms using the Observation framework. It guides property-wrapper selection among @State, @Binding, and @Observable classes, designs NavigationStack navigation flows, structures view models and data flow, optimizes list and complex layout rendering, and applies environment values for dependency injection. Developers reach for swiftui-patterns when Claude or Cursor agents propose SwiftUI views that need consistent state boundaries, type-safe navigation, and performance-conscious composition instead of ad hoc UIKit-era patterns ported into declarative code.1.4kinstalls158Team Builderteam-builder is an affaan-m/ecc agent skill that presents an interactive menu to browse a collection of agent persona markdown files and assemble parallel teams for a task. Agent files must include role, identity, rules, workflow, and deliverable sections; the first heading becomes the agent name and the first paragraph becomes its description. The skill supports flat layouts and domain subdirectories where folder names infer specialties such as engineering, marketing, or sales. Developers reach for team-builder when they have many agent roles and need to mix domains—security plus SEO plus architecture—before committing to a workflow. It does not run agents itself; it helps choose and compose the right roster from existing markdown definitions.1.4kinstalls159Nuxt4 Patternsnuxt4-patterns is an ECC skill for building and debugging Nuxt 4 applications that mix SSR, hybrid rendering, and client-only islands. Hydration guidance keeps the first render deterministic by moving Date.now(), Math.random(), browser APIs, and storage reads behind onMounted, import.meta.client, ClientOnly, or .client.vue components. Data-fetching rules prefer await useFetch for SSR-safe reads, useAsyncData with stable keys for composed sources, and reserve $fetch for user-triggered writes. Route rules in nuxt.config.ts cover prerender, swr, isr, ssr false, and Nitro cache strategies per route group rather than globally. Performance patterns use Lazy-prefixed dynamic imports, hydrate-on-visible lazy hydration, and NuxtLink prefetching. A five-item review checklist verifies matching server and client markup, correct fetch composables, lazy non-critical data, aligned route rules, and lazy-loaded interactive islands. Developers reach for nuxt4-patterns when hydration warnings, route-rule tuning, or payload bloat appear in Nuxt 4 apps.1.4kinstalls160Connections Optimizerconnections-optimizer is a growth networking skill from affaan-m/ecc (origin ECC) that reorganizes a developer's X and LinkedIn graph instead of treating outbound as a cold prospect list. The skill delivers review-first cleanup queues for X follows and LinkedIn connections, recommends new follows and connections matched to current priorities, identifies warm introduction paths, and drafts outreach in the user's voice across Apple Mail, X DM, and LinkedIn. Required inputs include current priorities, target roles or ecosystems, and platform choice (X, LinkedIn, or both). Developers reach for connections-optimizer when they want to prune low-signal follows, rebalance toward relevant peers and partners, or draft warm reconnection messages tied to network structure rather than bulk cold outreach.1.4kinstalls161Email OpsEmail-ops is an operator workflow that turns an AI coding agent into a reliable mailbox coworker. It handles inbox triage, drafts replies, sends messages through the actual mail surface, and provides verifiable proof of what landed in Sent. The skill is deliberately not a generic writing tool; it enforces an evidence-first process that requires real client-side confirmation before claiming any message was sent. It automatically pulls in the right supporting ECC skills such as brand-voice for tone, investor-outreach for fundraising emails, or knowledge-ops to capture threads into durable context. Builders use it whenever the next concrete task is real email work rather than code or content generation.1.4kinstalls162Csharp Testingcsharp-testing is an ECC agent skill for comprehensive .NET test development using a six-tool stack: xUnit as the test framework, FluentAssertions for readable assertions, NSubstitute or Moq for mocking, Testcontainers for real infrastructure in integration tests, WebApplicationFactory for ASP.NET Core integration tests, and Bogus for realistic test data. The skill covers Arrange-Act-Assert unit structure, test infrastructure setup, coverage review, and debugging flaky or slow tests. Developers reach for csharp-testing when writing new C# tests, auditing test quality, or standing up .NET test projects. Triggers include new test authoring, test infrastructure configuration, and flaky test investigation for .NET APIs and services.1.4kinstalls163Healthcare Phi Compliancehealthcare-phi-compliance is an affaan-m/ecc skill (version 1.0.0) contributed from healthcare practice, providing patterns to protect patient, clinician, and financial data in clinical systems. It guides access control, authentication, database schema design, API response filtering, audit trails, and logging when building features that touch patient records. The skill spans HIPAA (US), DISHA (India), and GDPR (EU) requirements alongside general healthcare data protection. Developers invoke it when designing EHR integrations, patient portals, or clinician dashboards where PHI leakage, weak authorization, or non-compliant logs create regulatory risk. Outputs include concrete schema, API, and logging patterns rather than generic security checklists.1.4kinstalls164Ios Icon Genios-icon-gen is an ECC community skill that builds PNG icon imagesets for Xcode asset catalogs from two sources: Apple SF Symbols (5000+ native symbols) and the Iconify API (275k+ open-source icons across 200+ collections). It searches collections, selects symbols, and outputs 1x, 2x, and 3x PNG imagesets ready for Assets.xcassets. iOS and macOS developers reach for ios-icon-gen when replacing placeholder tab bar or toolbar icons, prototyping UI chrome, or standardizing icon assets without hand-exporting every density from design tools.1.4kinstalls165Kotlin Exposed Patternskotlin-exposed-patterns in affaan-m/ecc documents comprehensive database access with JetBrains Exposed ORM for Kotlin backends. Exposed offers two query styles: a DSL resembling direct SQL for expressive queries and a DAO pattern for entity lifecycle management. HikariCP connection pooling is configured through HikariConfig for reusable database connections under load. Flyway runs versioned SQL migration scripts at startup to keep schemas synchronized across environments. The skill covers repository pattern implementations, JSON column handling, complex queries, and coroutine-safe transaction boundaries. Developers reach for kotlin-exposed-patterns when standing up Kotlin microservices, replacing JDBC boilerplate, or standardizing data access across a team. Typical deliverables include Table definitions, transaction wrappers, migration files, and repository interfaces wired to a pooled DataSource. Triggers include Exposed DSL setup, Flyway migrations in Kotlin, HikariCP configuration, and repository pattern with Exposed DAO.1.4kinstalls166Ecc Tools Cost Auditecc-tools-cost-audit is a Claude Code skill from affaan-m/ecc focused on the ECC Tools GitHub App sibling repository. The workflow investigates runaway costs, quota bypasses, duplicate PRs, and premium model routing for free users by analyzing prompt input tokens and quantifying compute efficiency. It composes with ECC-native skills such as autonomous-loops for cross-webhook billing audits and agentic-engineering for implementation review, but stays a targeted operator pass—not generic billing or full repo review. Developers reach for ecc-tools-cost-audit when ECC Tools webhooks, queues, or retries appear to burn tokens or spawn excess pull requests.1.4kinstalls167Google Workspace Opsgoogle-workspace-ops is an ECC skill for treating Google Workspace as an integrated workflow system rather than editing isolated files. It uses Google Drive as the entry point, then routes work to Docs, Sheets, or Slides for in-place updates, consolidation, restructuring, import repair, and decision-ready summaries. Developers reach for google-workspace-ops when locating shared plans or customer lists in Drive, cleaning messy spreadsheets, reformatting slide decks, or producing summaries from living documents and trackers. The skill also covers Sheets automation and Gmail integration per its manifest. It fits teams whose operational truth lives in Google Workspace instead of a dedicated project database.1.4kinstalls168Regex Vs Llm Structured Textregex-vs-llm-structured-text is an affaan-m/ecc decision framework for parsing structured text such as quizzes, forms, invoices, and tables in agent and data pipeline contexts. The core insight is that regex handles 95-98% of cases deterministically at low cost, reserving expensive LLM calls for edge cases where pattern matching falls below a 95% success threshold. When over 90% of text follows repeatable patterns, developers start with regex and add LLM fallback only where confidence is low. Free-form or highly variable text goes directly to LLM. The skill covers hybrid architecture with a regex parser extracting structure first and an LLM layer handling exceptions. Developers reach for it when optimizing cost and reliability tradeoffs in text extraction pipelines.1.4kinstalls169Gateguardgateguard is a Claude Code skill from affaan-m/ecc implementing GateGuard, a PreToolUse hook that forces investigation before any file edit. Instead of LLM self-evaluation prompts like are you sure, gateguard demands concrete facts—actual paths, schema fields, date formats, and import dependencies—so the act of reading creates awareness self-checks never provide. Developers activate it on multi-module codebases, data files with strict schemas, and teams requiring AI edits to match existing patterns. The skill targets workflows where agents tend to hallucinate file layout or API shapes, turning pre-edit investigation into a hard gate rather than a soft suggestion.1.4kinstalls170Inventory Demand Planninginventory-demand-planning is an ECC skill (version 1.0.0, Apache-2.0) that codifies retail supply-chain expertise for demand forecasting, safety stock optimization, replenishment planning, and promotional lift estimation across multi-location retailers managing hundreds of SKUs. It guides forecasting method selection, ABC/XYZ segmentation, seasonal transition management, and vendor negotiation frameworks informed by long-running demand-planning practice. Developers and inventory-system builders reach for inventory-demand-planning when tuning ERP or WMS replenishment rules, modeling promotion spikes, or reducing stockouts and overstock without hiring a dedicated demand planner for every analysis cycle.1.4kinstalls171Quality Nonconformancequality-nonconformance is an ECC agent skill for building manufacturing quality workflows inside software: defect logging, root cause analysis, corrective and preventive actions, and audit-ready nonconformance records. The skill helps developers model investigation steps, escalation paths, and compliance traceability when shipping QMS, ERP, or MES features rather than ad-hoc ticket handling. Developers reach for quality-nonconformance when regulatory-grade quality processes must be encoded as structured application logic. The affaan-m/ecc readme is a Japanese translation placeholder referencing the English SKILL.md upstream. Use it when nonconformance management, CAPA, or defect RCA is a domain requirement in the codebase.1.4kinstalls172Rules Distillrules-distill is an affaan-m/ecc meta-skill that scans installed skills, extracts cross-cutting principles appearing in multiple skills, and distills them into agent rule files by appending, revising outdated content, or creating new rules. It applies a deterministic collection plus LLM judgment pattern: scripts collect facts exhaustively, then an LLM cross-reads full context and produces verdicts. Developers reach for rules-distill during periodic rules maintenance, monthly upkeep, or after installing new skills when a skill stocktake reveals overlapping guidance. The skill prevents rule drift and duplication across a growing skill library. It is designed for teams accumulating many agent skills who need consolidated, maintainable rule governance.1.4kinstalls173Cisco Ios Patternscisco-ios-patterns is an ECC community skill that codifies Cisco IOS and IOS-XE review workflows for planned changes, troubleshooting, and incident response. It structures read-only show command selection, config hierarchy explanation (global, interface, routing process, line modes), ACL wildcard mask and interface direction checks, and maintenance-window validation before writes hit running config. The workflow prefers capturing current state, reviewing exact candidate configs, confirming out-of-band access, and verifying intentional saves—treating examples as patterns rather than copy-paste production configs. Network engineers reach for cisco-ios-patterns when reviewing router or switch snippets, building change checklists, or explaining how to collect evidence without worsening an outage.1.4kinstalls174Customs Trade Compliancecustoms-trade-compliance is an Apache-2.0 ECC skill at version 1.0.0 that role-plays a senior trade compliance specialist with 15+ years covering US, EU, UK, and Asia-Pacific customs operations. It codifies expertise for customs documentation, HS tariff classification, duty optimization, restricted-party screening, and multi-jurisdiction regulatory compliance inside AI agents that process import/export orders or supply-chain workflows. Referenced systems include ACE (Automated Commercial Environment), CHIEF/CDS (UK), ATLAS (DE), customs broker portals, screening platforms, and ERP trade management modules. Developers reach for customs-trade-compliance when agents must apply Incoterms, leverage FTAs, reduce penalties, and validate clearance logic—not generic shipping labels. It protects organizations from seizures and debarment while optimizing lawful cross-border movement. Use when handling customs clearance, tariff classification, trade compliance documents, or duty optimization in agent-driven commerce pipelines.1.4kinstalls175Enterprise Agent Opsenterprise-agent-ops is an ECC agent skill for operating cloud-hosted or continuously running agent systems beyond single CLI sessions. It structures four operational domains: runtime lifecycle with start, pause, stop, and restart controls; observability through logs, metrics, and traces; safety controls including scopes, permissions, and kill switches; and change management with rollout, rollback, and audit trails. Baseline controls include immutable deployment artifacts, least-privilege credentials, environment-level secret injection, hard timeout and retry budgets, and audit logs for high-risk actions. Developers reach for enterprise-agent-ops when production agents need operational guardrails, incident response hooks, and governed deployment practices rather than ephemeral local agent runs.1.4kinstalls176Manim Videomanim-video is an ECC-origin Claude Code skill for building reusable Manim explainers where motion, structure, and clarity matter more than photorealism. It guides agents to scaffold scenes for graphs, workflows, architecture diagrams, metric progressions, and short product or launch explainers suitable for X posts or landing pages. The skill integrates with the wider ECC video stack when a project needs compositing or handoff beyond raw Manim output. Developers reach for manim-video when a concept is inherently spatial or temporal and static screenshots fail to communicate behavior, topology, or step-by-step flow.1.4kinstalls177Nutrient Document Processingnutrient-document-processing is an affaan-m/ecc skill for the Nutrient DWS Processor API at https://api.nutrient.io/build. Developers authenticate with a NUTRIENT_API_KEY and send multipart POST requests carrying an instructions JSON payload to convert formats, extract text and tables, OCR scanned documents, redact PII, add watermarks, apply digital signatures, and fill PDF forms. Supported input formats include PDF, DOCX, XLSX, PPTX, HTML, and images. Teams reach for nutrient-document-processing when building document pipelines—invoice ingestion, compliance redaction, or e-sign workflows—without maintaining local conversion libraries.1.4kinstalls178Customer Billing Opscustomer-billing-ops is an ECC agent skill for real customer billing operations, not generic payment API design. It walks developers and support engineers through Stripe-first workflows to answer who the customer is, what failed, the safest fix, and what follow-up to send. The skill covers refund handling, churn triage, duplicate or accidental charges, failed renewals, subscription and invoice inspection, plan-mix review, and billing-portal flow validation. It prioritizes connected billing tools like Stripe and hosted customer portals over custom account-management code, and treats email, GitHub, or issue trackers as supplemental evidence only. Reach for customer-billing-ops when a paying user reports broken billing, cancellation problems, or subscription confusion that directly affects revenue.1.4kinstalls179Llm Trading Agent Securityllm-trading-agent-security is an ECC skill for adding layered security controls when LLM agents receive authority to sign transactions or manage treasury operations. Developers reach for it when autonomous trading bots, DeFi agents, or treasury automation could move funds without human-in-the-loop safeguards. The skill targets key management boundaries, transaction approval flows, and agent permission minimization for high-risk financial automation. The published catalog entry notes an in-progress Japanese translation in some mirrors, but the English skill intent remains: prevent credential leakage and unauthorized signing before agents connect to wallets or exchange APIs. Use during security design reviews of LLM trading systems where a single prompt injection or tool misconfiguration could drain accounts. Pair with broader agent sandbox skills when shell, network, and secrets permissions overlap.1.4kinstalls180Carrier Relationship Managementcarrier-relationship-management is an Apache-2.0 skill version 1.0.0 from affaan-m/ecc that encodes senior transportation manager expertise for carrier relationship workflows. It covers carrier portfolio management across truckload, LTL, intermodal, and brokerage modes for portfolios of 40–200+ active carriers, including sourcing, rate negotiation, RFP execution, routing guides, scorecard-based performance tracking, and contract renewals. The skill references TMS platforms, rate management tools, carrier onboarding portals, and market intelligence from DAT/Greenscreens. Developers building freight allocation, carrier scorecard, or rate strategy features reach for carrier-relationship-management to ground UI and business rules in operational logistics practice.1.4kinstalls181Healthcare Eval Harnesshealthcare-eval-harness is a version 1.0.0 ECC skill contributed from Health1 Super Speciality Hospitals that implements an automated verification system for healthcare application deployments. A single CRITICAL failure blocks deployment because patient safety is non-negotiable. It validates healthcare AI models, clinical metrics, and regulatory compliance checks before EMR/EHR releases or after CDSS logic changes such as drug-interaction rules. Examples reference Jest as the test runner, but categories and pass thresholds are framework-agnostic and adapt to Vitest, pytest, or PHPUnit. Developers reach for healthcare-eval-harness when agents touch clinical decision support, protected health information, or regulated hospital software where manual QA cannot catch safety regressions. The harness turns patient safety, CDSS accuracy, and PHI protection into gateable automated tests instead of checklist reminders.1.4kinstalls182Nodejs Keccak256nodejs-keccak256 is an ECC skill at version 1.0.0 that stops a silent Ethereum hashing bug in Node.js and TypeScript codebases. Node's crypto.createHash('sha3-256') implements the NIST-standardized SHA3 variant, not Ethereum Keccak-256, and produces different digests for the same input without warnings—breaking function selectors, event topics, EIP-712 signatures, storage slots, and address derivation. The skill documents correct patterns with ethers v6 keccak256 and id helpers, viem toBytes hashing, and web3.js utils.keccak256, plus mapping slot encoding and public-key-to-address derivation. It includes grep audit commands to find createHash('sha3-256') misuse across .ts and .js files and worked examples for solidityPackedKeccak256 and Transfer event topics. Developers reach for nodejs-keccak256 when reviewing Web3 backends or building Merkle, signature, or ABI selector utilities in JavaScript.1.4kinstalls183React Performancereact-performance from affaan-m/ecc adapts Vercel Engineering React Best Practices (MIT, v1.0.0 from vercel-labs/agent-skills) into an agent skill for React 18/19 and Next.js performance work. The skill organizes 70+ rules across 8 priority categories: waterfalls, bundle size, server-side, client fetching, re-render, rendering, JS micro-perf, and advanced patterns. Developers use react-performance when writing, reviewing, or refactoring React and Next.js code for performance—not for generic CSS layout or backend API design. Rules cover eliminating request waterfalls, shrinking client bundles, optimizing server components, reducing unnecessary re-renders, and JS micro-optimizations aligned with Vercel engineering guidance. With 749 catalog installs, frontend engineers reach for react-performance during perf-sensitive refactors, PR reviews, and Next.js App Router tuning instead of ad hoc optimization guesses.1.4kinstalls184Santa Methodsanta-method is an affaan-m/ecc adversarial verification framework originating from Ronald Skelton's RapportScore.ai work. A single self-reviewing agent shares the same biases and knowledge gaps as the generator; Santa Method breaks that failure mode by spawning two independent reviewers without shared context who must both approve before output ships. Developers invoke santa-method before publishing customer-facing copy, deploying code without human review, or releasing compliance-sensitive, legally worded, or hallucination-prone content such as API references and statistics. The skill iterates fixes until both reviewers pass, but is not intended for internal drafts, exploratory research, or tasks already covered by build, test, and lint pipelines.1.4kinstalls185Defi Amm Securitydefi-amm-security is an ECC skill that codifies automated market maker smart-contract audit patterns for Uniswap-style, Curve-style, and Balancer-style protocols. It walks swap, mint, and burn logic through checks for flash-loan price manipulation, missing slippage guards, sandwich attacks, unsafe on-chain price oracles, reentrancy via checks-effects-interactions, and integer overflow handling. The embedded checklist verifies oracle-sourced pricing, flash-loan assumptions, slippage limits, reentrancy mutexes, and economic invariants across liquidity pools. Solidity developers reach for defi-amm-security when reviewing new AMM code, hardening swap functions, or testing protocol economics before mainnet deployment.1.4kinstalls186Healthcare Cdss Patternshealthcare-cdss-patterns is an ECC agent skill at version 1.0.0 contributed from Health1 Super Speciality Hospitals for building Clinical Decision Support Systems integrated into EMR workflows. CDSS modules are patient-safety critical with zero tolerance for false negatives. The skill covers drug interaction checking, dose validation engines, clinical scoring systems including NEWS2, qSOFA, APACHE, and GCS, alert systems for abnormal clinical values, medication order entry safety checks, and lab result interpretation hooks. Developers reach for healthcare-cdss-patterns when implementing evidence-based clinical logic in hospital or health-tech backends rather than generic CRUD APIs. Use it when alerts, scoring, and medication safety checks must meet clinical reliability standards.1.4kinstalls187Hermes Importshermes-imports is an ECC skill for turning stable Hermes operator loops into public-ready Claude Code skills. Hermes acts as the local operator shell while ECC holds the reusable workflow layer; this skill moves repeatable patterns across that boundary without copying private state. The workflow follows a six-step conversion pattern: identify the loop, strip private inputs, rewrite paths as repo-relative examples, add When To Use guidance, define output requirements, and run a secret scan before PR. A sanitization checklist targets absolute paths, tokens, OAuth files, CRM or health data, and raw private logs. The output contract returns a candidate skill name, sanitized summary, required public inputs, removed private inputs, remaining risks, and files to create. Developers reach for hermes-imports when a Hermes job has repeated enough to merit ECC publication.1.4kinstalls188Production Schedulingproduction-scheduling is an ECC agent skill that guides coding agents through manufacturing production scheduling, bottleneck resolution, and line-balancing decisions when building ERP, MES, or shop-floor tools. The skill translates operational scheduling expertise into implementable patterns for capacity planning, work-center assignment, and throughput optimization inside custom software. Developers reach for production-scheduling when modeling job queues, finite-capacity schedules, or constraint-based planners rather than generic CRUD backends. The published readme in affaan-m/ecc is a Japanese translation stub pointing to the English SKILL.md source, so triggers and workflow detail live in the upstream ECC skill file. Use it when manufacturing logic is a first-class domain concern in the codebase.1.4kinstalls189Project Flow Opsproject-flow-ops is an ECC skill that codifies a dual-track engineering workflow: GitHub remains the authoritative public record for issues, PRs, and roadmap visibility, while Linear holds only active, scheduled internal execution work. Teams adopt project-flow-ops to prevent duplicate ticket systems, reduce context switching, and keep external contributors aligned with GitHub while engineers run sprints and schedules in Linear. The published SKILL.md notes a Japanese translation in progress, but the described GitHub-plus-Linear operating model is the core deliverable. Engineering leads reach for project-flow-ops when scaling coordination across open-source visibility and private execution cadences.1.4kinstalls190Windows Desktop E2ewindows-desktop-e2e is an ECC skill for end-to-end testing Windows native desktop applications with pywinauto backed by Windows UI Automation. It covers WPF, WinForms, Win32 and MFC, and Qt 5.x through 6.x, rating AutomationId reliability per framework in a comparison table. Setup installs pywinauto, pytest, pytest-html, Pillow, and pytest-timeout on Python 3.8+ Windows hosts and recommends Accessibility Insights for inspecting the UIA element tree. The skill teaches page-object models, AutomationId-first locator strategy, wait patterns, per-step trace artifacts, flaky-test skips, and sandboxed APPDATA isolation via subprocess fixtures. Qt guidance documents QT_ACCESSIBILITY=1 for older releases and keyboard fallbacks when UIA ValuePattern is missing. CI integration targets GitHub Actions windows-latest runners. Developers reach for windows-desktop-e2e when Playwright cannot drive a native .exe GUI and desktop automation tests need stable UIA selectors or CI wiring.1.4kinstalls191Finance Billing Opsfinance-billing-ops is an ECC workflow skill for operators and backend developers who need code-backed truth about how money moves through a product. Instead of generic payment advice, it walks through revenue state, pricing decisions, team seat logic, duplicate-charge diagnosis, and refund behavior by pulling evidence from implementation details, sales snapshots, and related repositories. The skill composes with five related ECC skills—customer-billing-ops, research-ops, market-research, github-ops, and verification-loop—when competitive pricing, backlog state, or checkout proof is required. Reach for finance-billing-ops when website copy, dashboards, or support tickets disagree with what billing code enforces.1.4kinstalls192Gan Style Harnessgan-style-harness in affaan-m/ecc implements a GAN-inspired harness that separates generation from evaluation, creating an adversarial feedback loop for long-running application development. Inspired by Anthropic's harness design for long-running apps (March 24, 2026), the skill addresses a core failure mode: agents evaluating their own work tend toward pathological optimism, praising mediocre output and dismissing legitimate defects. The harness assigns distinct generator and evaluator roles so critique stays adversarial rather than self-congratulatory. Documented tools include Read, Write, Edit, Bash, Grep, Glob, and Task for filesystem and subprocess orchestration across agents. Developers reach for gan-style-harness when bootstrapping full applications from sparse prompts where iterative quality pressure beats one-shot codegen. The loop drives repeated generate-critique-revise cycles until evaluators accept production readiness. Triggers include multi-agent harness, generator-evaluator loop, adversarial code review, and long-running app scaffolding from minimal specs.1.4kinstalls193Healthcare Emr Patternshealthcare-emr-patterns is version 1.0.0 from affaan-m/ecc, contributed by Health1 Super Speciality Hospitals via Dr. Keyur Patel, for building Electronic Medical Record and Electronic Health Record systems. It prioritizes patient safety, clinical accuracy, and practitioner efficiency across encounter workflows—from complaint and exam through diagnosis and prescription—and clinical note-taking with structured fields, free text, and voice-to-text. The skill covers prescription modules with drug interaction checking, Clinical Decision Support Systems, and HL7/FHIR integration patterns. Developers reach for healthcare-emr-patterns when implementing regulated clinical UI flows rather than generic form builders.1.4kinstalls194Laravel Plugin Discoverylaravel-plugin-discovery is an ECC skill for finding, evaluating, and choosing healthy Laravel packages using the LaraPlugins.io MCP server. Developers use it when searching packages for features like auth, permissions, or admin panels; asking what package to use for a capability; checking active maintenance; verifying Laravel version compatibility; or assessing package health before composer require. The LaraPlugins MCP server must be configured in the Claude environment—typically under ~/.claude MCP settings. The skill covers package discovery, dependency resolution context, and service provider integration planning without blindly adding unmaintained forks. Reach for it early in Laravel feature spikes when multiple Packagist options exist and compatibility with the project's Laravel version must be confirmed before integration work begins.1.4kinstalls195Foundation Models On Devicefoundation-models-on-device in affaan-m/ecc documents patterns for integrating Apple's on-device language model on iOS 26 through the FoundationModels framework. Coverage spans text generation and summarization without cloud dependency, structured output via the @Generable macro, custom tool calling for domain-specific actions, and snapshot streaming for responsive UI updates—all running on-device for privacy and offline support. The skill addresses quantization, optimization, and privacy-conscious inference patterns suited to Apple Intelligence workloads in production Swift apps. Developers reach for foundation-models-on-device when shipping AI-powered iOS features that must avoid network round-trips or external API keys. Typical flows include extracting structured data from natural language, streaming partial model output into SwiftUI views, and wiring custom tools the on-device model can invoke locally. Triggers include FoundationModels setup, @Generable structured output, on-device LLM streaming, and Apple Intelligence integration without cloud APIs.1.4kinstalls196Hipaa Compliancehipaa-compliance is a thin, canonical entrypoint skill from affaan-m/ecc (version 1.0.0) for US healthcare compliance tasks. Instead of duplicating implementation detail, it delegates PHI/PII classification, audit logging, encryption, and leak prevention to healthcare-phi-compliance, healthcare-aware code review to healthcare-reviewer, and general auth, secrets, API, and deployment checks to security-review. Developers reach for hipaa-compliance when a task clearly involves HIPAA-regulated systems so the agent selects the right downstream compliance skills rather than applying generic security guidance. The skill stays intentionally minimal so healthcare-specific rules remain centralized in specialized companions.1.4kinstalls197Hookify Ruleshookify-rules is an ECC skill for writing Hookify rules—markdown files with YAML frontmatter that define regex patterns to watch and messages to show when patterns match during Claude sessions. Rules are stored as .claude/hookify.{rule-name}.local.md files. Frontmatter fields include name, enabled, event (bash|file|stop|prompt|all), and pattern (regex), followed by the message body shown on trigger with markdown formatting, warnings, and suggestions. Developers reach for hookify-rules when they want automatic guardrails against dangerous bash commands, risky file edits, or stop/prompt patterns without building a full pre-commit hook stack. The skill covers rule file format, event types, and rule-driven workflows for event-driven execution inside Claude. Use when creating, editing, or managing custom Hookify rules that surface guidance the moment matching code or commands appear.1.4kinstalls198Kotlin Ktor Patternskotlin-ktor-patterns is an ECC skill delivering comprehensive Ktor patterns for robust, maintainable HTTP servers built with Kotlin coroutines. It activates when building Ktor servers, configuring plugins (Auth, CORS, ContentNegotiation, StatusPages), implementing REST APIs, setting Koin dependency injection, writing testApplication integration tests, or adding WebSockets. The documented project layout places Application.kt at the entry point with plugins/Routing.kt, Serialization.kt, and related modules under src/main/kotlin. Developers reach for kotlin-ktor-patterns when agent-generated Ktor code drifts from idiomatic routing DSL, kotlinx.serialization setup, or coroutine-safe plugin configuration. It encodes standard structure and testing approaches so REST and WebSocket services stay consistent across modules. Use during Ktor greenfield APIs or refactors where Kotlin backend conventions must be preserved.1.4kinstalls199Logistics Exception Managementlogistics-exception-management is an Apache-2.0 ECC agent skill (version 1.0.0) that encodes 15+ years of freight operations expertise into structured exception-handling playbooks. The skill walks an agent through a five-step workflow: classify exceptions by type and severity, apply mode-specific resolution paths, document carrier evidence, escalate by dollar and time thresholds, and file claims inside statutory windows such as the 9-month Carmack Amendment deadline. Coverage spans six transport modes—LTL, FTL, parcel, intermodal, ocean, and air—with decision frameworks for eat-the-cost versus fight-the-claim calls, eight automatic escalation triggers, and eight weekly KPI targets. Developers reach for logistics-exception-management when building logistics SOP generators, claims automation, carrier-dispute assistants, or AI support for supply-chain operations teams integrating TMS, WMS, and ERP order systems.1.4kinstalls200Swift Actor Persistenceswift-actor-persistence is an ECC skill with patterns for thread-safe data persistence using Swift actors on Swift 5.9+ targeting iOS 17+ and macOS 14+. It combines in-memory caching with file-backed storage so shared mutable state stays isolated without manual locks or DispatchQueues. Developers activate it when building offline-first apps that need compile-time data-race safety instead of ad hoc synchronization. The actor model serializes access while preserving ergonomic Swift concurrency for read and write paths.1.4kinstalls201Homelab Wireguard Vpnhomelab-wireguard-vpn is a community ECC skill for deploying WireGuard as a fast, modern VPN for homelab remote access. The skill walks through server setup on Raspberry Pi, Linux hosts, pfSense, or routers, generating WireGuard keypairs, writing peer configuration files, and applying iptables forwarding rules with correct key file permissions. Developers reach for homelab-wireguard-vpn when they need simpler, faster remote access than OpenVPN for phones and laptops connecting to a home network. All examples are reviewed before application and changes are expected during a defined maintenance window. The workflow emphasizes end-to-end encryption and practical homelab access patterns.1.4kinstalls202Opensource Pipelineopensource-pipeline is a three-stage Claude Code skill from affaan-m/ecc that prepares private repositories for safe public release on GitHub. The pipeline forks a project and removes secrets, verifies the sanitized state, then packages required OSS files including CLAUDE.md, setup.sh, and README. Developers invoke it with `/opensource fork`, `/opensource verify`, or `/opensource package`, or by saying phrases like "open source this" or "make this public." The skill is built for teams that need a repeatable, agent-driven checklist instead of manual grep-and-hope secret audits before the first public push.1.4kinstalls203Homelab Network Setuphomelab-network-setup is a community ECC skill for developers planning or redesigning home and small-lab networks that must scale without tearing everything down later. It separates device roles—from modem through gateway, switch, and access points—and designs IP ranges, DHCP scopes, static reservations, and DNS with headroom for future VLANs, Pi-hole, NAS, lab servers, and VPN access. Use homelab-network-setup when escaping ISP-router-only setups, fixing double NAT, stabilizing Wi-Fi, or stopping servers from getting new addresses on every reboot. The skill produces a growth-ready foundation that pairs naturally with homelab-vlan-segmentation and homelab-pihole-dns follow-on work.1.4kinstalls204Evm Token Decimalsevm-token-decimals is an ECC skill at version 1.0.0 that stops silent decimal-mismatch bugs where ERC-20 balances or USD values appear correct but are wrong by orders of magnitude. The skill queries decimals() at runtime, caches results by chain_id and token_address, and applies decimal-safe math in Python, TypeScript, or Solidity. Developers reach for evm-token-decimals when reading on-chain balances, computing fiat values, comparing token amounts across EVM chains, or handling bridged assets in portfolio trackers, bots, and DeFi aggregators. The workflow never assumes stablecoins share the same decimals and covers bridged token precision drift. Runtime inspection plus cached chain-aware normalization is the core pattern.1.4kinstalls205Homelab Network Readinesshomelab-network-readiness is a community ECC planning skill for home and small-lab networks that mix VLANs, local DNS resolvers like Pi-hole or Unbound, firewall rules, and remote VPN access. The skill reviews current topology, rollback paths, console access, and maintenance windows before recommending VLAN splits across trusted, IoT, guest, server, or management segments. It deliberately stops short of copy-paste router or firewall configuration until platform details and rollback plans are confirmed. Developers reach for homelab-network-readiness when moving from a flat LAN to segmented VLANs or when migrating DHCP clients to a local DNS resolver. The workflow emphasizes security evaluation and performance testing as pre-change gates.1.4kinstalls206Network Config Validationnetwork-config-validation is an ECC skill that statically reviews router and switch configuration files before they reach production. It flags dangerous commands, duplicate IP assignments, overlapping subnets, and stale interface or neighbor references that commonly cause outages during cutovers. Network engineers and platform teams reach for network-config-validation when reviewing candidate configs from templates, automations, or peer review—especially when a bad push could black-hole traffic or duplicate addressing across VLANs. The published SKILL.md excerpt notes an in-progress Japanese translation, but the skill description and intended validation workflow remain the authoritative capability.1.4kinstalls207Network Interface Healthnetwork-interface-health is an ECC community skill for diagnosing physical-link and switch-port problems that masquerade as application or routing failures. The skill teaches baseline-then-delta counter analysis: capture interface statistics, wait a measurement interval, capture again, and compare increments rather than trusting absolute totals. It documents Cisco-style show interfaces commands, Linux ip -s link, ethtool, and ethtool -S queries, plus SNMP counters such as ifInErrors, ifOutErrors, and ifOutDiscards. A counter reference table explains eight error types—CRC, runts, giants, input drops, output drops, resets, and collisions—with common causes and remediation order. Diagnosis flows separate CRC and input-error investigation from congestion-driven output drops and duplex or speed negotiation mismatches. A bundled Python parser safely slices show interfaces blocks without arbitrary character windows. Developers reach for network-interface-health when monitoring reports rising interface errors or intermittent reachability on a VLAN or WAN link.1.4kinstalls208Social Graph Rankersocial-graph-ranker is an ECC-origin Claude Code skill that applies a normalized weighted graph ranking layer across X and LinkedIn to score mutual followers and connections for warm-intro value. The skill ranks existing ties by intrinsic relationship strength, maps warm paths from your graph to a target ICP list, measures bridge value across first- and second-degree connections, and recommends warm introduction versus cold outreach. Developers reach for social-graph-ranker when they need the ranking engine itself—questions like who in my network can best introduce me—rather than full lead-generation pipelines handled by sibling ECC skills such as lead-intelligence or connections-optimizer. Use it standalone to inspect bridge math, compare introducer candidates, and prioritize network-aware distribution before sending messages.1.4kinstalls209Homelab Vlan Segmentationhomelab-vlan-segmentation is a community ECC skill for developers running home labs or small offices who want VLAN-based isolation between IoT gadgets, guest Wi-Fi, trusted workstations, and servers. It explains how to add firewall rules that block lateral movement between segments while preserving existing protections, and it stresses applying changes in a maintenance window with connectivity checks after each step. The skill covers UniFi, pfSense, OPNsense, and MikroTik setups where smart bulbs, cameras, TVs, and lab servers should not share one broadcast domain. Reach for homelab-vlan-segmentation when flattening IoT and trusted devices on one subnet creates unnecessary attack surface.1.4kinstalls210Recsys Pipeline Architectrecsys-pipeline-architect in affaan-m/ecc is a spec-and-scaffold skill for composable recommendation, ranking, and feed pipelines encoding a six-stage pattern: Source, Hydrator, Filter, Scorer, Selector, and SideEffect. The framework generalizes beyond social feeds to any system picking the top K items for a user-context pair—content CMS ranking, RAG rerankers, task prioritizers, notification triage, search reranking, and ad ranking. Each stage has a defined responsibility: sourcing candidates, hydrating features, filtering ineligible items, scoring relevance, selecting the final set, and executing side effects like logging or writes. The pattern draws from xAI's open-sourced For You algorithm structure. Developers reach for recsys-pipeline-architect when greenfield ranking services need clear stage boundaries instead of monolithic recommenders. Output includes pipeline specs and scaffold code organized by stage interfaces. Triggers include feed ranking architecture, recommendation pipeline design, top-K selector patterns, and modular reranker scaffolding.1.4kinstalls211Swift Concurrency 6 2swift-concurrency-6-2 is an ECC skill covering Swift 6.2 Accessible Concurrency, where code runs single-threaded by default and concurrency is introduced explicitly. It explains when to use @concurrent for background CPU work, how MainActor types maintain isolation consistency, and why Swift 6.1 implicit background offloading caused data-race errors in seemingly safe async code. Developers reach for swift-concurrency-6-2 when upgrading Swift 5.x or 6.0/6.1 projects to Swift 6.2, resolving Sendable and isolation diagnostics, or enabling Accessible Concurrency in Xcode 26 build settings. The skill targets performance-preserving patterns that eliminate common data races without over-offloading to background threads.1.4kinstalls212Energy Procurementenergy-procurement is an Apache-2.0 licensed ECC skill at version 1.0.0 that packages codified expertise from energy procurement managers with 15+ years of experience at large commercial and industrial consumers. It guides tariff optimization, demand charge reduction, load profiling, hedging strategies, market structure analysis, renewable PPA evaluation, and sustainability reporting for multi-facility energy programs. Developers and platform teams running homelabs, colocation, or office/server facilities reach for energy-procurement when power contracts—not application code—drive a significant operating line item. The skill applies when procuring energy, comparing rate schedules, managing peak demand, or building facility-level cost strategies.1.4kinstalls213Messages OpsMessages-ops is an ECC agent skill that implements an evidence-first workflow for live messaging surfaces including iMessage, social DMs, and browser-gated inboxes. The SKILL.md defines a four-step process to resolve the exact thread, read inbound messages before drafting replies, recover recent one-time codes with focused search, and report verifiable evidence naming the source, sender, time window, and status. Developers reach for messages-ops when an AI coding agent must check local texts, inspect a DM thread, or find an MFA code delivered to a messaging app instead of guessing or conflating mailbox work with DM retrieval. Guardrails block unverified retrieval claims, document four adjacent ECC skills for handoff, and require structured OUTPUT with SOURCE, RESULT, and STATUS blocks. Install with npx skills add affaan-m/everything-claude-code --skill messages-ops.1.4kinstalls214Plankton Code Qualityplankton-code-quality is an ECC-origin skill that keeps code clean during active editing rather than deferring quality checks to pre-commit hooks or CI. It triggers formatting, lint passes, and Claude-assisted fixes immediately after file changes so developers see corrected code before pushing. Teams reach for plankton-code-quality when noisy lint debt accumulates between commits or when they want agent-driven fix suggestions inline with edits. The skill fits projects with established formatters and linters wired into the workspace. It complements but does not replace full test suites or security review pipelines.1.4kinstalls215Quarkus Patternsquarkus-patterns is an ECC skill documenting Quarkus 3.x LTS architecture for cloud-native, event-driven Java services. It covers JAX-RS and RESTEasy Reactive APIs structured as resource → service → repository layers, Apache Camel routes with RabbitMQ, Hibernate Panache persistence, caching, reactive streams, validation, exception mapping, and pagination. Developers activate it when scaffolding Quarkus microservices instead of assembling patterns from scattered docs. The skill README is Spanish-language but the patterns target standard Quarkus 3.x APIs familiar to Java backend engineers.1.4kinstalls216Flox Environmentsflox-environments teaches agents to provision reproducible dev environments using Flox, a Nix-based declarative environment manager. Use it when projects need system-level dependencies—compilers, OpenSSL, libvips, BLAS, LAPACK—or pinned toolchains for Python, Node.js, Rust, Go, C/C++, Java, Ruby, Elixir, PHP, and more across macOS and Linux. Flox lets agents install project-scoped tools without sudo, system pollution, or sandbox limits, then commit .flox/ and manifest.toml so any developer reproduces the environment with flox activate. It also covers co-locating local services like PostgreSQL, Redis, and Kafka beside dev tools to fix works-on-my-machine drift.1.4kinstalls217Homelab Pihole Dnshomelab-pihole-dns is a community ECC skill for developers running Pi-hole as network-wide DNS on a Raspberry Pi or any Linux host. Every device on the LAN inherits ad and malware domain blocking without per-browser extensions. The skill covers Pi-hole installation, pointing the home network DNS to Pi-hole, managing blocklists, configuring DNS-over-HTTPS upstream resolvers, and creating local records such as nas.home.lan or pi.home.lan. It also troubleshoots devices that lose internet access after Pi-hole deployment. Use homelab-pihole-dns after homelab-network-setup when you need centralized DNS privacy, ad blocking, and friendly local names for NAS and lab servers.1.4kinstalls218Fsharp Testingfsharp-testing is an ECC skill documenting comprehensive testing patterns for F# applications on the standard .NET test stack. It maps four core tools—xUnit as the test framework, FsUnit.xUnit for F#-friendly assertions, Unquote for quotation-based failure messages, and FsCheck.xUnit for property-based tests—plus modern .NET practices for integration coverage. Developers activate fsharp-testing when writing new F# tests, reviewing test quality, setting up test infrastructure, or debugging flaky and slow suites. The skill emphasizes functional approaches such as property tests alongside example-based unit and integration tests. Reach for fsharp-testing whenever F# services need reliable automated coverage rather than ad hoc C#-style assertion patterns.1.4kinstalls219Ggetgget is an ECC community skill for developers and bioinformatics engineers who need fast, reproducible lookups against public genome databases. It walks agents through Ensembl ID searches, transcript metadata, sequence retrieval, BLAST- or BLAT-style queries, reference genome links, and pathway or disease module checks using the gget CLI or Python interface inside a clean virtual environment. The workflow emphasizes logging first-pass evidence before graduating to heavier stacks such as Biopython, Snakemake, Nextflow, or BLAST+ with local indexes. Use gget for exploratory genomics questions, annotation pulls, and quick validation—not regulated clinical interpretation or high-throughput production pipelines requiring pinned database versions.1.4kinstalls220Nanoclaw Replnanoclaw-repl is an ECC-origin skill for running persistent, branching REPL sessions that keep Claude agent work on-task across multiple turns and branches. It targets developers extending agent workflows who want REPL-like continuity instead of stateless prompt chains. Sessions remain focused on the active task while supporting branch exploration for alternatives or parallel hypotheses. The published readme excerpt is a Japanese translation stub pointing to the English SKILL.md source, so behavior is defined by the skill metadata and ECC agent patterns rather than the stub file alone.1.4kinstalls221Network Bgp Diagnosticsnetwork-bgp-diagnostics is an affaan-m/ecc skill for safely diagnosing Border Gateway Protocol problems on routers and cloud network gateways. It helps operators inspect BGP neighbor state, advertised and received routes, and routing policy mismatches using non-disruptive diagnostic commands suited to production environments. Developers and SREs reach for network-bgp-diagnostics when hybrid cloud or on-prem BGP sessions flap, prefixes disappear, or asymmetric routing appears after policy changes. The skill emphasizes safe command selection so agents do not suggest clearing sessions or other destructive fixes during initial triage.1.4kinstalls222Openclaw Persona Forgeopenclaw-persona-forge is an ECC community skill that forges full OpenClaw lobster-agent personas from guided Q&A or random gacha mode. It outputs identity positioning, a SOUL.md soul description, character boundary rules, a chosen name, and an image-generation prompt for a unified-style avatar; when an approved image skill is available, it can produce the avatar file too. Developers reach for openclaw-persona-forge when bootstrapping a new OpenClaw agent that needs personality, not just tool wiring. The skill explicitly avoids fine-tuning existing SOUL.md files, non-OpenClaw frameworks, and purely utilitarian agents without character. Trigger phrases include lobster soul, OpenClaw SOUL, and gacha persona generation.1.4kinstalls223Returns Reverse Logisticsreturns-reverse-logistics is an ECC skill (version 1.0.0, Apache-2.0) encoding a senior returns operations manager playbook for retail, ecommerce, and omnichannel environments. It covers RMA approval, receiving and inspection, condition grading, disposition routing, refunds and credits, fraud detection, vendor return-to-vendor recovery, and warranty claims across OMS, WMS, RMS, CRM, and fraud platforms. The framework balances customer satisfaction with margin protection and inspection accuracy. Developers reach for it when designing return policies, automation rules, or support playbooks rather than hiring dedicated reverse-logistics staff.1.4kinstalls224Swift Protocol Di Testingswift-protocol-di-testing is an ECC-origin agent skill for protocol-based dependency injection in Swift codebases. The patterns abstract file system, network, external APIs, and iCloud access behind small focused protocols, enabling Swift Testing mocks that run deterministically across app, test, and SwiftUI preview targets. Reach for swift-protocol-di-testing when writing Swift that touches I/O, testing error paths without triggering real failures, or building modules that must behave identically in production, XCTest or Swift Testing, and preview environments. The skill emphasizes minimal protocol surface area so mocks stay maintainable as features grow.1.4kinstalls225Unified Notifications Opsunified-notifications-ops is an ECC-native workflow skill for developers drowning in fragmented alerts rather than missing notifications entirely. It merges GitHub Issues, PRs, reviews, comments, and CI events with Linear issue status changes, local hooks, desktop alerts, chat, and email into a single operator interface with explicit severity levels, owners, routing rules, and next actions. Developers reach for unified-notifications-ops when CI failures, review requests, and operator events scatter across channels and generate noise instead of actionable signal. The skill assumes hooks, MCP servers, or connected tools already exist but lack a consistent notification strategy. It prioritizes deduplication, escalation paths, and inbox collapse over adding yet another alert source.1.4kinstalls226Perl Patternsperl-patterns is an ECC skill documenting idiomatic Modern Perl 5.36+ patterns for robust, maintainable applications. A single use v5.36 pragma replaces older boilerplate by enabling strict, warnings, and subroutine signatures. The guide biases toward explicit modules, centralized error handling, and testable boundaries when writing new code, reviewing for idiomatic compliance, or migrating pre-5.36 legacy Perl. Developers reach for perl-patterns when authoring Perl modules, designing architecture, or refactoring legacy scripts that still use antiquated pragmas instead of signature-based Modern Perl defaults.1.4kinstalls227Perl Securityperl-security is an ECC comprehensive security guide for Perl applications handling user input, filesystem paths, shell commands, and databases. Coverage includes taint mode (-T) for tracking untrusted external data, validation and untainting at input boundaries, constrained filesystem and process execution, parameterized DBI queries, and web protections against XSS, SQLi, and CSRF across CGI, Mojolicious, Dancer2, and Catalyst stacks. perlcritic security policies supplement manual review. Developers reach for perl-security when building or auditing Perl web apps and CLI tools that touch user input and must ship with hardened defaults instead of ad-hoc escaping.1.4kinstalls228Perl Testingperl-testing is an ECC-origin agent skill for writing reliable Perl modules and applications through strict test-driven development. The workflow walks developers through Test2::V0 and Test::More harness setup, red-green-refactor cycles, and assertion patterns so CPAN-style modules and CLI tools ship with deterministic coverage. Reach for perl-testing when adding Perl features, fixing regressions, or refactoring legacy scripts where missing tests block safe changes. The skill assumes familiarity with Perl's testing ecosystem and focuses on module boundaries, mockable dependencies, and CI-friendly test layout rather than application scaffolding from scratch.1.4kinstalls229Visa Doc Translatevisa-doc-translate is an ECC agent skill that automates visa document localization from image inputs to submission-ready bilingual PDFs. When given an image path, the skill converts HEIC files to PNG with macOS sips, reads EXIF orientation and applies automatic rotation, then produces side-by-side original and English translation pages in a single PDF. The workflow runs without confirmation prompts so agents can batch embassy paperwork quickly. Developers reach for visa-doc-translate when supporting users who photograph foreign-language bank letters, employment certificates, or government forms and need consistent English translations packaged for consular review.1.4kinstalls230Quarkus Securityquarkus-security is an ECC-origin skill from affaan-m/ecc for securing Quarkus applications with authentication, authorization, and input validation best practices. It guides JWT and OIDC setup, @RolesAllowed and SecurityIdentity RBAC, Bean Validation and custom validators, CORS and security headers, and secrets handling through Vault, environment variables, and configuration sources. Developers reach for quarkus-security when adding auth to Quarkus services or auditing existing endpoints before production deploy. The skill focuses on Java microservice appsec patterns rather than generic OWASP checklists without framework context.1.4kinstalls231Ralphinho Rfc Pipelineralphinho-rfc-pipeline is an ECC-origin skill inspired by humanplane-style RFC decomposition for multi-agent software delivery. Its seven pipeline stages cover RFC intake, DAG decomposition, unit assignment, unit implementation, unit validation, merge queue integration, and final system verification. Each work unit includes id, depends_on, scope, acceptance_tests, risk_level, and rollback_plan, with three complexity tiers from isolated file edits to multi-file behavior changes. Developers reach for ralphinho-rfc-pipeline when a feature is too large for one agent path and needs independently testable units executed safely in sequence across multiple agents.1.4kinstalls232Quarkus Tddquarkus-tdd is an ECC-origin agent skill for test-driven development on Quarkus 3.x LTS event-driven microservices. The workflow sequences JUnit 5 unit tests, Mockito doubles, REST Assured HTTP checks, Apache Camel route tests, and JaCoCo coverage gates targeting 80%+ combined unit and integration coverage. Reach for quarkus-tdd when adding REST endpoints, fixing bugs, refactoring reactive or Camel-backed services, or validating security and data-access logic in Quarkus projects. The skill is optimized for event-driven architectures where Camel routes and async handlers need the same TDD rigor as synchronous REST layers.1.4kinstalls233Netmiko Ssh Automationnetmiko-ssh-automation is an ECC-origin agent skill for Python network automation with Netmiko. It guides Claude through SSH connection patterns, device-type selection, command execution, output parsing, and safe review of scripts targeting routers, switches, and similar gear. Developers reach for netmiko-ssh-automation when automating show commands, config pushes, or health checks across a fleet without hand-writing fragile Paramiko boilerplate. The skill emphasizes safe connection handling, credential hygiene, and script review before production runs. It fits network engineers and backend developers maintaining infrastructure-as-code or ops tooling in Python.1.4kinstalls234Quarkus Verificationquarkus-verification is an ECC-origin agent skill describing a Spanish-language verification loop for Quarkus microservice projects. Developers trigger it before opening pull requests, after major refactors or dependency upgrades, and before staging or production deploys. The pipeline order is build, lint static analysis, tests with coverage thresholds, security scanning, native compilation, and diff review against the target branch. The skill fits JVM teams shipping Quarkus REST or reactive services who want agents to run the same pre-PR checklist every time instead of skipping native builds or security scans under deadline pressure. It validates that coverage and compile targets pass before merge, reducing regressions on GraalVM native images.1.4kinstalls235Uspto Databaseuspto-database is a community-origin agent skill for querying United States Patent and Trademark Office systems from coding agents. The workflow prioritizes official USPTO surfaces—Open Data Portal datasets, Patent File Wrapper bibliographic records, PatentSearch API for granted patents and pre-grant publications, and TSDR for trademark status—then documents findings in reproducible investigation logs. Reach for uspto-database when searching granted patents, checking application status, reviewing assignment chains, or comparing USPTO records against Google Patents, Lens.org, or Semantic Scholar. The skill is for data collection and record verification only, not legal advice.1.4kinstalls236Unclouduncloud is an ECC-origin agent skill referencing the uc CLI for decentralized self-hosting on personal clusters. The workflow covers bootstrapping machines with `uc machine`, deploying services from Compose files via `uc deploy`, publishing HTTP, HTTPS, and TCP ports, configuring Caddy reverse proxy ingress, adding static proxy routes for non-cluster devices, scaling workloads, inspecting logs, and managing volumes across WireGuard mesh-linked nodes. Reach for uncloud when operating Uncloud clusters through natural language instead of memorizing uc subcommands. The platform combines Docker containers, WireGuard mesh networking, and Caddy ingress for self-hosted SaaS and API deployments.1.4kinstalls237Tinystruct Patternstinystruct-patterns is a development skill from the ECC harness for engineers building on the tinystruct Java framework—a lightweight runtime that treats CLI and HTTP as equal citizens with no main() boilerplate. The skill walks through creating Application modules extending AbstractApplication, mapping @Action endpoints for terminal and web, wiring ActionRegistry path injection, serializing JSON via Builder/Builders, persisting with AbstractData POJOs and XML mapping, and handling SSE, file uploads, events, and outbound HTTP. It bundles six reference guides covering architecture, routing, data handling, database persistence, system usage, and JUnit 5 unit plus HTTP integration testing. Reach for tinystruct-patterns when extending tinystruct itself or shipping hybrid CLI/web services that share one codebase. The skill does not replace tinystruct docs—it gives agents opinionated patterns aligned with zero-dependency JSON and dual-mode design.1.3kinstalls238Benchmark Optimization Loopbenchmark-optimization-loop is an ECC-origin Claude Code skill that replaces open-ended requests like make it 20x faster with structured, measured optimization cycles. Before any change, the skill requires a defined operation, a correctness gate that must stay green, and a chosen metric such as wall time, p95 latency, rows per second, cost per run, or memory usage. Developers reach for benchmark-optimization-loop when comparing implementation variants, running recursive optimization attempts, or choosing the best approach through repeated measured tests rather than intuition. The skill uses Read, Write, Edit, Bash, Grep, and Glob tools to iterate on code while holding benchmarks accountable. It fits backend services, data pipelines, and CLI tools where performance regressions are costly.1.3kinstalls239React Testingreact-testing is an ECC (affaan-m/ecc) agent skill for behavior-focused React testing with React Testing Library, Vitest or Jest, MSW network mocking, and axe accessibility assertions. It defines decision boundaries between component tests and Playwright or Cypress end-to-end runs, helping developers test custom hooks, legacy untested components, and pages migrated from Enzyme patterns. The skill activates on requests to write tests, fix failing specs, add coverage, or review Vitest and RTL conventions. Developers reach for react-testing when building React SaaS frontends that need user-centric assertions, mocked API layers, and accessible UI validation before release.1.3kinstalls240Parallel Execution Optimizerparallel-execution-optimizer is an ECC agent skill for safely speeding up large coding tasks by planning parallel execution lanes before any tool calls run. The workflow starts with goals and completion signals, splits work into channels labeled parallel, serial, or gated, batches independent reads and checks, and isolates writes by file, git worktree, branch, service, or dataset. Developers reach for parallel-execution-optimizer when repo scans, API checks, browser checks, build or test runs, and multi-worktree implementation batches can run at the same time without stepping on each other. The skill closes with a verification table that proves each lane succeeded instead of relying on a vague speed claim. It uses Read, Write, Edit, Bash, Grep, and Glob tools from the ECC toolkit.1.3kinstalls241Latency Critical Systemslatency-critical-systems is an ECC-origin skill from affaan-m/ecc for engineering latency-sensitive systems such as realtime dashboards, market data feeds, streaming agents, execution gateways, queues, caches, and HFT-like infrastructure. The skill instructs agents to split metrics instead of collapsing everything into fast, tracking p50, p95, and p99 latency alongside throughput and data freshness on hot paths. It explicitly focuses on engineering patterns and does not authorize live trading or financial advice. Developers reach for latency-critical-systems when users care about realtime behavior, streaming freshness, or execution speed in production services. Tooling access includes Read, Write, Edit, Bash, Grep, and Glob for profiling codepaths, queue backlogs, and cache invalidation strategies across backend services.1.3kinstalls242Prediction Market Oracle ResearchPrediction-market-oracle-research is an affaan-m ECC origin skill for source-grounded analysis of prediction markets as forecasting inputs, oracle-like signals, or decision-intelligence layers. It guides developers through evaluating market-implied probabilities while separating venue mechanics, liquidity constraints, and integration caveats from treating prices as objective truth. Explicit guardrails prohibit investment advice and trading recommendations. Reach for this skill when building agents, dashboards, or corporate decision systems that might ingest prediction-market data and need rigorous due diligence on signal quality, not speculative trading guidance. The research output covers integration patterns and documented limitations for engineering teams.1.3kinstalls243Social Publishersocial-publisher is a community-origin ECC skill that connects Claude Code and compatible agents to SocialClaw at getsocialclaw.com for agent-driven social media publishing. A single workspace API key enables scheduling and posting across 13 platforms: X, LinkedIn, Instagram, Facebook Pages, TikTok, Discord, Telegram, YouTube, Reddit, WordPress, and Pinterest. Developers use social-publisher to publish or schedule content, upload media, manage campaigns, and monitor post delivery status without leaving the agent chat. The skill activates when users want multi-platform distribution or campaign orchestration rather than drafting copy alone. It is an integration workflow over SocialClaw's workspace API rather than a standalone social network client.1.3kinstalls244Prediction Market Risk Reviewprediction-market-risk-review is an ECC-origin agent skill that gates prediction-market and trading automation workflows before they handle venue authentication, user portfolio data, API keys, or trade planning. Review gates cover advice boundaries—keeping outputs informational without buy/sell/hold sizing recommendations—and venue plus regulatory concerns alongside data-quality and privacy checks. Developers invoke prediction-market-risk-review when building agents that interact with prediction markets, oracle feeds, basket strategies, or execution-capable trading tools and need a structured preflight audit. The skill emphasizes explicit manual decision points and removal of direct trading recommendations from agent outputs before any workflow touches user financial context.1.3kinstalls245Data Throughput Acceleratordata-throughput-accelerator is an ECC-origin skill for when moving, transforming, or saving large datasets is the bottleneck in production pipelines. It forces an upfront split between source extraction, network transfer, warehouse load, transform, serving-table freshness, and proof of correct landing before applying parallelization or batching tactics.py The workflow targets backfills, exports, manifest catch-up, and table sync jobs where faster wrong data is unacceptable. Data engineers and backend developers reach for data-throughput-accelerator when ingestion lag, warehouse load queues, or sync freshness SLAs break and they need a structured acceleration plan with evidence that rows landed correctly.1.3kinstalls246Recursive Decision Ledgerrecursive-decision-ledger is a Claude Code skill from affaan-m/ecc for agents that must explore multiple options, run repeated trials, or perform recursive reasoning with a visible evidence trail. It preserves repeated rollouts, prior memory, fresh information, and explicit marks while avoiding false certainty from looping alone. The ledger contract records each roll's decisions and outcomes for stochastic optimization, local-optima exploration, ensemble comparison, and high-dimensional search tasks. Developers reach for recursive-decision-ledger when prompting agents through Prime Gauss-style recursive processes that need auditable marks instead of opaque iteration. Tools include Read, Write, Edit, Bash, Grep, and Glob.1.3kinstalls247Ito Market Intelligenceito-market-intelligence is an ECC-origin Claude Code skill for source-grounded prediction-market briefings without investment advice or live trading. It supports event discovery, venue comparison, basket theme exploration, and Itô API-backed market context when ITO_API_KEY is configured, while defaulting to public sources otherwise. Developers reach for it when scoping Itô integrations, comparing prediction-market venues and underliers, or producing liquidity-aware research before wiring basket workflows. Guardrails block live trading recommendations and require explicit API access for Itô-backed data calls.1.3kinstalls248Ito Trade Plannerito-trade-planner is an ECC-origin skill that produces neutral, structured worksheets for prediction-market ideas, basket adjustments, venue comparisons, and manual execution plans on Itô or compatible venues. The skill inspects venues, underliers, constraints, order prerequisites, and step-by-step manual execution checklists while explicitly avoiding trade recommendations or position sizing advice. Output includes parameter tables and reviewable checklists the user completes manually. Developers reach for ito-trade-planner when they need a disciplined planning artifact before touching live markets, especially after initial research but before order entry. Guardrails prohibit labeling trades good, bad, optimal, or recommended.1.2kinstalls249Ito Basket Compareito-basket-compare is an ECC-origin agent skill for read-only comparison of Itô prediction-market baskets, themes, or market sets against a user's knowledge base, portfolio notes, research memo, CRM context, or stated thesis. The skill inspects fit, exposure overlap, unstated assumptions, and missing context so a developer can decide next steps manually. It explicitly does not recommend trades, rank opportunities, or provide investment advice. Developers reach for ito-basket-compare when evaluating whether a published basket aligns with documented research before adjusting positions or building automation. Guardrails keep output analytical and non-executing, making the skill suitable for pre-decision diligence rather than live order placement.1.2kinstalls250Ito Data Atlas Agentito-data-atlas-agent is an ECC-origin skill for designing background Data Atlas-style agents that watch data sources, assemble candidate prediction-market baskets, draft parameter changes, and route output to a human reviewer. The skill covers workflow architecture and planning only—it does not run live trading or place orders. Guardrails require explicit human approval before any execution step and limit ITO_API_KEY usage to read-only Itô data access unless a separate approved execution path exists. Developers reach for ito-data-atlas-agent when scaffolding automated basket research pipelines that need review gates, source watchers, and draft parameter tables instead of one-off manual worksheets.1.2kinstalls251Team Agent Orchestrationteam-agent-orchestration is a Claude Code skill for managing multiple coding agents like a team rather than a single assistant. It uses work items, explicit ownership, an agent Kanban board, branch isolation, and merge gates to keep parallel agent work visible and mergeable. A developer uses it when a task spans multiple agents, harnesses, branches, or worktrees and existing fan-out produces output but not mergeable product. It matters because it prevents agent soup, invisible work, and overlapping writes.922installs252Dynamic Workflow Modedynamic-workflow-mode is a Claude Code skill for designing task-local agent harnesses instead of only following a static command flow. A developer uses it when a task needs a custom loop, evaluator, watcher, or local dashboard, and wants each harness to carry an objective, eval gate, and handoff artifact. It also defines when to promote a one-off harness into a shared reusable skill and how to expose workflow state through control-pane checkpoints.921installs253Agent Self Evaluationagent-self-evaluation is a Claude Code skill that makes an agent rate its own output after a non-trivial task. It scores five axes (accuracy, completeness, clarity, actionability, conciseness) on a 1-5 scale with concrete evidence per axis, then lists ranked improvements. A developer uses it as a reflection step to catch omissions and overconfidence before the user does. It ships an evaluation script, report template and examples.2installs254Benchmark Methodologybenchmark-methodology is a Claude Code skill that scores a scoped competitor set on nine weighted dimensions using explicit 1-5 rubrics. It produces comparable, evidence-anchored profile cards and a strategic-tension plot rather than gut-feel rankings. A developer or strategist uses it as the middle step of a competitive analysis pipeline, after scoping and before assembling the report.2installs255Brand Discoverybrand-discovery is a Claude Code skill that conducts a structured multi-session interview to articulate a brand's identity. It works through eight modules (purpose, positioning, audience, personality, voice, narrative, founder tension, synthesis) using laddering, 5 Whys and projective techniques. A founder or strategist uses it to produce a master brandbook. It persists session state to disk so interviews can span days and resume where they left off.2installs256Codehealth Mcpcodehealth-mcp is a Claude Code skill that connects the CodeScene Code Health MCP server to give design-level maintainability scores. It reviews a file before edits, checks the score delta after changes, and gates commits and pull requests against Code Health regressions. A developer uses it as a structural safeguard alongside lint and tests when refactoring or after large agent-written diffs. It runs the @codescene/codehealth-mcp server over stdio via npx and needs a CS_ACCESS_TOKEN.2installs257Competitive Platform Analysiscompetitive-platform-analysis is a Claude Code skill that decides who counts as a competitor and where to find them before any benchmarking begins. It sorts candidates along generic axes and groups them into Direct, Adjacent and Aspirational tiers, producing a defensible, pruned set rather than an exhaustive census. A strategist uses it as the first step of a three-skill competitive pipeline, before benchmark-methodology.2installs258Competitive Report Structurecompetitive-report-structure is a Claude Code skill that assembles scored competitor profile cards into a decision-grade report. It defines the sections (executive summary, landscape map, competitor tiers, benchmarking matrix, deep dives, white-space and threats, recommendations) so the report answers who to compete with, how, and where the defensible white-space is. A strategist uses it as the final step of a three-skill competitive pipeline.2installs259Config Gcconfig-gc is a Claude Code skill that garbage-collects a Claude Code configuration. It periodically scans ~/.claude for redundant, stale or orphaned skills, memory, hooks, permissions, MCP servers and caches, then walks the user through a confirm-each-deletion cleanup. A developer uses it to slim a bloated setup and speed up session startup. It soft-deletes first, keeps an undo path, and logs every run to gc_log.md.2installs260Generating Python Installergenerating-python-installer is a Claude Code skill for advanced Windows packaging of Python applications. A developer uses it to compile with Nuitka in folder (dist) mode, slim the dist folder, analyze DLL footprint, and package a residue-free installer with Inno Setup. It targets minimal installer size and fast startup, not basic script-to-exe conversion.2installs261Inherit Legacy Styleinherit-legacy-style is a Claude Code skill that prevents AI code-style drift in legacy projects. A developer uses it when onboarding an AI coding agent onto a hand-written codebase, so the model does not impose pretrained mainstream idioms. It scans the codebase across file anatomy, state and control flow, infrastructure, and error handling, resolves conflicts one at a time, and writes an enforceable .ai-style-rules.md.2installs262Intent Driven Developmentintent-driven-development is a Claude Code skill that produces verifiable acceptance criteria for ambiguous or high-impact changes. A developer uses it to clarify a feature, de-risk a security or migration change, or prepare a handoff artifact for another agent before or alongside implementation. It inspects repo context first, asks only unavoidable questions, and writes observable criteria instead of vague requirements.2installs263Kubernetes Patternskubernetes-patterns is a Claude Code skill that provides production-grade Kubernetes workload patterns and kubectl debugging commands. A developer uses it when writing manifests, configuring resource limits and probes, setting up RBAC, or debugging CrashLoopBackOff, OOMKilled, and pending pods. It supplies copy-pasteable YAML templates with security contexts, autoscaling, and an anti-patterns checklist.2installs264Ml Adoption Playbookml-adoption-playbook is a Claude Code skill with an end-to-end methodology for adding machine learning to an existing non-ML codebase. A developer uses it to frame the problem, audit data readiness, decouple inference behind an API boundary, build a baseline model, and hand off to MLOps. It stresses starting with a heuristic, preventing data leakage, and using feature flags and fallbacks for safe rollout.2installs265Orch Add Featureorch-add-feature is a Claude Code skill that orchestrates building a net-new feature end to end. A developer uses it when adding a capability that does not exist yet, delegating research, planning, TDD implementation, review, and gated commit to the matching ECC agents. It is a thin wrapper over the shared orch-pipeline engine and stops at a plan-approval gate and a pre-commit gate.2installs266Orch Build Mvporch-build-mvp is a Claude Code skill that orchestrates bootstrapping a working MVP from a design or spec document. A developer points it at an SDD or PRD, and it extracts scope and locked decisions, orders the work into thin vertical slices, scaffolds the first end-to-end slice, then TDD-implements, reviews, and commits behind two human gates. It is a thin wrapper over the shared orch-pipeline engine and reuses the GAN generator-to-evaluator harness.2installs267Orch Change Featureorch-change-feature is a Claude Code skill that orchestrates altering an existing, working feature to new desired behavior. A developer uses it when a feature is not broken but should behave differently, updating the existing tests to the new spec first and then changing the implementation to match. It is a thin wrapper over the shared orch-pipeline engine and commits only after plan and pre-commit gates.2installs268Orch Fix Defectorch-fix-defect is a Claude Code skill that orchestrates fixing a bug end to end. A developer uses it when existing behavior is broken or wrong, first reproducing the bug as a new failing regression test, then fixing to green, reviewing, and committing behind a gate. It is a thin wrapper over the shared orch-pipeline engine and can scope unclear root causes with code-explorer.2installs269Orch Pipelineorch-pipeline is a Claude Code skill that defines the shared orchestration engine for the orch-* skill family. It specifies the gated Research-Plan-TDD-Review-Commit pipeline, a size classifier that scales ceremony to blast radius, the agent and command map for each phase, and the two human gates. A developer reads it directly only when adding a new orch operation or tuning the shared phases, gates, or agent map.2installs270Orch Refine Codeorch-refine-code is a Claude Code skill that orchestrates a behavior-preserving refactor. A developer uses it when the structure should improve but behavior must not change, confirming the relevant tests are green first, then restructuring in small steps while keeping tests green. It is a thin wrapper over the shared orch-pipeline engine and can delegate dead-code and duplication sweeps to the refactor-cleaner agent.2installs271Tastetaste is a Claude Code skill that adds a creative-direction layer for music videos and short-form edits in the angelcore / cloud-trance / hyperpop visual family. It distills a named-genre aesthetic vocabulary, a mood plus color plus light system, and a beat-synced editing grammar. A developer uses it to pick a coherent visual direction before generating AI b-roll and to chain ECC video skills into one production pipeline. It matters because it decides what frames should look like and in what order, so the result reads as one intentional thing.2installs272Vue Patternsvue-patterns is a Claude Code skill that encodes Vue.js 3 Composition API patterns and best practices. It covers component architecture, reactivity, Pinia state management, Vue Router navigation, composables, testing, and Nuxt SSR patterns. A developer uses it when a project uses Vue, Nuxt, Vite plus Vue, or Pinia, or when reviewing Vue single-file components. It matters because it standardizes how Vue components, stores, and composables are structured across a codebase.2installs