PluginBench
Skill
Review
Audit score 70

ecc-guide

affaan-m/everything-claude-code

Navigate ECC's agents, skills, commands, hooks, and install profiles by reading live repository state.

What is ecc-guide?

Guide users through Everything Claude Code (ECC) by inspecting the current repository surface rather than relying on stale catalogs. Use this skill when someone needs help understanding ECC's structure, finding components, installing profiles, or onboarding a project.

  • Inspect live ECC repository files to answer questions about available skills, commands, agents, hooks, and rules
  • Recommend the right ECC component for a user's task by searching skills, commands, and agents
  • Generate install plans using managed profiles and selective install options for different harnesses
  • Guide new users through onboarding with short menus and next-action clarity
  • Troubleshoot install state, plugin conflicts, and harness configuration issues
  • Detect project stacks and suggest ECC components that fit the target repository

How to install ecc-guide

npx skills add https://github.com/affaan-m/everything-claude-code --skill ecc-guide
Claude Code
Cursor
Windsurf
Cline

How to use ecc-guide

  1. 1.Ask the skill a question about ECC (e.g., 'what skill should I use for X?' or 'how do I install ECC for Cursor?')
  2. 2.The skill inspects live repository files using scripts like catalog.js and install-plan.js to get current state
  3. 3.Review the recommendation, which includes the relevant file path and a concrete next action
  4. 4.For install guidance, run the suggested dry-run command to preview changes before applying
  5. 5.For new projects, use /project-init to detect your stack and generate a tailored onboarding plan

Use cases

Good for
  • A user asks 'what skills does ECC have for testing?' — search skills/ and recommend the best match with a dry-run install command
  • New user wants to install ECC but is unsure which profile fits their harness — run install-plan.js to show options and dry-run output
  • Developer is confused about commands vs. skills — explain the distinction and point to maintained skill-first workflows
  • User has a custom project and wants ECC configured for it — use /project-init to detect stack and generate a repo-specific plan
  • Someone reports a duplicate install or hook conflict — inspect plugin metadata and hooks.json to diagnose the issue
Who it's for
  • New ECC users seeking guided onboarding and component discovery
  • Developers choosing between ECC skills, commands, and agents for a specific task
  • Teams installing ECC across multiple harnesses (Claude, Cursor, Codex, etc.)
  • Contributors troubleshooting install state or hook behavior
  • Project leads configuring ECC for a target repository

ecc-guide FAQ

Should I use a command or a skill?

Prefer skills as the primary workflow surface. Use commands only when they are a maintained compatibility shim or you explicitly want slash-command behavior. The skill will recommend the skill-first path.

How do I avoid duplicate installs?

Use managed install paths (install-plan.js and install-apply.js) rather than stacking plugin installs with full profile installs. The skill will warn you if a conflict is detected.

What if ECC changes and my install is stale?

This skill always reads the live repository before answering, so it reflects current state. Run the suggested dry-run command to see what would change, then apply only what you need.

How do I onboard ECC for my specific project?

Use /project-init, which detects your project stack, resolves an install plan, and generates repo-specific guidance. The skill can help you interpret the results.

Where do I find the full list of ECC skills and commands?

Run 'node scripts/ci/catalog.js --json' or 'find skills -maxdepth 2 -name SKILL.md | sort' to see current offerings. The skill will search these for you based on your question.

Full instructions (SKILL.md)

Source of truth, from affaan-m/everything-claude-code.


name: ecc-guide description: Guide users through ECC's current agents, skills, commands, hooks, rules, install profiles, and project onboarding by reading the live repository surface before answering. metadata: origin: community

ECC Guide

Use this skill when a user needs help understanding, navigating, installing, or choosing parts of Everything Claude Code.

When To Use

Use this skill when the user:

  • asks what ECC includes
  • wants help finding a skill, command, agent, hook, rule, or install profile
  • is new to the repository and needs a guided path
  • asks "how do I do X with ECC?"
  • asks which ECC components fit a project
  • needs a lightweight explanation of how commands, skills, agents, hooks, and rules relate
  • is confused by install paths, duplicate installs, reset/uninstall, or selective install options

Core Principle

Answer from current files, not memory. ECC changes quickly, so hard-coded catalog counts, feature lists, and install instructions go stale.

When the ECC repository is available, inspect the relevant files before giving a concrete answer:

node scripts/ci/catalog.js --json
find skills -maxdepth 2 -name SKILL.md | sort
find commands -maxdepth 1 -name '*.md' | sort
find agents -maxdepth 1 -name '*.md' | sort
node scripts/install-plan.js --list-profiles
node scripts/install-plan.js --list-components --json

Use the smallest set of reads needed for the user's question.

Repository Map

  • README.md: install paths, uninstall/reset guidance, public positioning, FAQs
  • AGENTS.md: contributor guidance and project structure
  • agent.yaml: exported gitagent surface and command list
  • commands/: maintained slash-command compatibility shims
  • skills/*/SKILL.md: reusable workflows and domain playbooks
  • agents/*.md: delegated subagent role prompts
  • rules/: language and harness rules
  • hooks/README.md, hooks/hooks.json, scripts/hooks/: hook behavior and safety gates
  • manifests/install-*.json: selective install modules, components, profiles, and target support
  • docs/: harness guides, architecture notes, translated docs, release docs

Response Style

Lead with the answer, then give the next action. Most users do not need a full catalog dump.

Good first response shape:

  1. what to use
  2. why it fits
  3. exact file or command to inspect
  4. one next command or question

Avoid:

  • listing every skill or command by default
  • repeating large README sections
  • recommending retired command shims when a skill-first path exists
  • claiming a component exists without checking the filesystem
  • replacing install guidance with manual copy commands when the managed installer supports the target

Common Tasks

New User Onboarding

Give a short menu:

  • install or reset ECC
  • pick skills for a project
  • understand commands vs skills
  • inspect hooks and safety behavior
  • run a harness audit
  • find a specific workflow

Point to README.md for install/reset and /project-init for project-specific onboarding.

Feature Discovery

For "what should I use for X?":

  1. Search skills/, commands/, and agents/.
  2. Prefer skills as the primary workflow surface.
  3. Use commands only when they are a maintained compatibility shim or a user explicitly wants slash-command behavior.
  4. Mention agents when delegation is useful.

Useful searches:

rg -n "<query>" skills commands agents docs
find skills -maxdepth 2 -name SKILL.md | sort

Install Guidance

Use managed install paths:

node scripts/install-plan.js --list-profiles
node scripts/install-plan.js --profile minimal --target claude --json
node scripts/install-apply.js --profile minimal --target claude --dry-run

For specific skill installs:

node scripts/install-plan.js --skills <skill-id> --target claude --json
node scripts/install-apply.js --skills <skill-id> --target claude --dry-run

Warn users not to stack plugin installs and full manual/profile installs unless they intentionally want duplicate surfaces.

Project Onboarding

Use /project-init when the user wants ECC configured for a target repo. The expected sequence is:

  1. detect the stack from project files
  2. resolve a dry-run install plan
  3. inspect existing CLAUDE.md and settings files
  4. ask before applying changes
  5. keep generated guidance minimal and repo-specific

Troubleshooting

Ask for the target harness and install path first, then inspect:

  • plugin install metadata
  • .claude/, .cursor/, .codex/, .gemini/, .opencode/, .codebuddy/, .joycode/, or .qwen/
  • hooks/hooks.json
  • install-state files
  • relevant command/skill files

For repo health, suggest:

npm run harness:audit -- --format text
npm run observability:ready
npm test

Output Templates

Short Recommendation

Use <skill-or-command>. It fits because <reason>.

Canonical file: <path>
Verify with: <command>
Next: <one concrete action>

Search Results

Best matches:
- <path>: <why it matters>
- <path>: <why it matters>

Recommendation: <which one to use first and why>

Install Plan Summary

Detected: <stack evidence>
Target: <harness>
Plan: <profile/modules/skills>
Dry run: <command>
Would change: <paths>
Needs approval before apply: <yes/no>

Related Surfaces

  • /project-init: stack-aware onboarding plan for a target repo
  • /harness-audit: deterministic readiness scorecard
  • /skill-health: skill quality review
  • /skill-create: generate a new skill from local git history
  • /security-scan: inspect Claude/OpenCode configuration security