Named workflows that only fire when the task matches

A skill in ECC is not a general capability boost — it is a narrow, named workflow the agent activates only when a task matches its description. That distinction matters when you are evaluating 292 of them, because the count is not 292 improvements to every response. The repository groups them into real categories: security and auditing skills such as agent-architecture-audit, django-security and canary-watch; testing and QA skills including agent-eval, browser-qa and e2e-testing; framework-specific ones like angular-developer, django-patterns and clickhouse-io; business and content skills such as brand-voice and article-writing; and agent architecture skills including autonomous-agent-harness and continuous-agent-loop. Grouping them this way is far more useful than repeating the total, because it tells you where the bundle is deep and where it is thin.

Workflow outcome: a reviewer can point at a named skill instead of describing a process in a prompt every time.

Repeatable processes for review, security and planning

The 68 agents are the heavier half of the toolkit. The project's own examples include an Agent for reviewing a change with a repeatable process, and a Skill for checking the security surface across permissions, inputs and exposed secrets. In practice this is what turns an agent from a fast autocomplete into something a team can hand a defined responsibility. The value is not that the agent is smarter — it is that the same review process runs whether the change came from a senior engineer or someone in their first month.

Workflow outcome: review quality stops depending on which developer happened to open the pull request.

Handoffs that survive a change of harness

Unified Memory lets one agent pick up a thread another started. The documented commands are concrete: ecc memory init --scope project, ecc memory handoff --from codex --target claude, and ecc memory search with a target harness. It is available through the CLI and MCP. For teams running more than one coding agent, this is the feature that stops context from dying at the end of a session, and it is the clearest answer to why a shared operating layer is worth more than five individually well-configured machines.

Workflow outcome: a rollout started in one harness continues in another without a re-briefing.

Plan Canvas and a view across sessions

Plan Canvas lets you annotate a plan in a browser, point at the specific part you mean, and send feedback to your agent before reviewing the revision in place. Control Pane is a local operator interface for inspecting sessions, worktrees and overlapping work. Together they address a real failure mode in agentic development: two developers unknowingly working the same problem, or a plan drifting because feedback was too vague to act on.

Workflow outcome: overlapping work and vague feedback get caught before they turn into merge conflicts.

AgentShield inspects what your agent can actually reach

AgentShield is the security layer, and it is available as its own npm package as well as inside the GitHub App path. It inspects configurations, permissions, hooks and MCP connections, then surfaces findings so you can decide what to change. This is the part of ECC that is hardest to replicate by hand, because it is a moving target — every new MCP connection changes the surface. Teams that give agents repository access should treat this as the reason to adopt rather than the reason to wait.

Workflow outcome: permission and hook exposure gets reviewed as a routine step, not after an incident.

Repository history turned into guidance

The hosted GitHub App connects a repository, reviews the practices it finds, and keeps useful guidance with the code. On the free tier this covers public repositories with 10 analyses per month and 200 commits per run. Pro raises that to 50 analyses per active seat pooled on the installation, 1,000 commits per run, PR-triggered config audits, auto-triggers on large pushes, and AgentShield-backed scanning. This is the layer that keeps working after day one, which is exactly where a manual install tends to decay.

Workflow outcome: the practices stay current with the repository instead of drifting after the initial setup.

Standardising review across a growing team

A team of eight engineers using three different coding agents has no shared definition of a good review. Adopting ECC gives them the Agent review process and the security Skill as common reference points, so a pull request gets the same scrutiny regardless of which harness produced it. The measurable effect is fewer review comments that amount to personal preference, and more that point at a named practice.

Onboarding without a six-week ramp

New engineers typically absorb team conventions slowly and inconsistently. With ECC installed, the conventions are encoded — install profiles, skills and commands are present from day one, and the agent's behaviour reflects them. Platform teams report that this shortens the period where a new hire's output needs heavy correction, because the process is enforced by the tooling rather than remembered by the person.

Auditing agent permissions before a security review

Before an internal security review, a team needs to know exactly what their agents can reach. Running AgentShield surfaces configurations, permissions, hooks and MCP connections in one pass, and the findings are concrete enough to act on. This turns a vague question about agent risk into a list of specific changes, which is usually what a security reviewer actually wants.

Carrying work across multiple harnesses

Teams that use Claude Code for some work and Codex or Cursor for others lose context at every switch. Unified Memory lets a handoff be saved and read from another harness, so a rollout started in one tool continues in another without rebuilding the brief. The documented CLI commands make this scriptable, which means it can become part of a workflow rather than a manual step someone remembers to do.

• The free tier is the actual product, not a teaserThe MIT-licensed repository contains all 292 skills, 68 agents and 94 commands — the paid layer adds hosted repository automation, not the toolkit itself.
• Breadth that covers real categories, not fillerSecurity, testing, framework-specific, business and agent-architecture skills are all genuinely represented, so most teams find their stack already covered.
• Cross-harness by designMemory handoffs and a shared operating layer work across Claude Code, Codex, Cursor, OpenCode and Kimi Code, which is rare in a space where most tooling is single-vendor.
• Security scanning that is hard to build yourselfAgentShield inspecting permissions, hooks and MCP connections addresses a moving target that most teams have no process for at all.
• Pro pricing is per active seat, pooledAt $19 per seat with usage pooled across the installation, a small team can pilot without committing to an organisation-wide contract.

• You are adopting someone else's opinions at scale292 skills encode a lot of decisions about how work should be done, and reconciling them with your team's existing conventions takes real time.
• Single-maintainer bus factor is realThe project ships weekly across seven harnesses, which is impressive velocity and also means one person is the dependency for a layer your team may come to rely on.
• Context cost is not zeroA large, fast-changing configuration bundle consumes agent context and attention, and independent reviewers have flagged this as a genuine trade-off against a smaller custom setup.
• The free GitHub App tier is public-repo onlyTeams working entirely in private repositories get no repository analysis at all until they move to Pro, which changes the calculus for anyone evaluating the hosted layer first.
• The DealbreakerThe project's own repository carries an explicit security warning: install only from official channels — the GitHub repository, the npm packages ecc-universal and ecc-agentshield, the GitHub App, or ecc.tools — because third-party re-uploads and unofficial mirrors are not maintained or reviewed by the project and may contain malware. If your team's install process cannot enforce an approved source list, that risk sits with you, not the maintainer.

Read the repository before installing anything. The README documents the skills, agents and commands, and it is where the official install channels and the security warning are stated. Confirm your team can enforce those channels before you roll anything out.

Run the guided install on one machine first. The documented command is npx ecc-universal install --guided, which walks through setup for Claude Code, Codex, Cursor, OpenCode and Kimi Code. Doing this on a single developer's machine surfaces friction before it becomes a team-wide problem.

Pick an install profile rather than taking everything. Core and developer profiles are available on the free tier; security and research profiles sit behind Pro. Starting narrow keeps context cost down and makes it obvious which additions are actually earning their place.

Initialise project memory and run one real handoff. The commands are ecc memory init --scope project, then ecc memory handoff with a source and target harness, then ecc memory search to confirm it reads back. This is the fastest way to see whether the cross-harness promise holds for your setup.

Run AgentShield against your current configuration. Inspect permissions, hooks and MCP connections, and read the findings before deciding what to change. Expect this step to produce a short list of specific, actionable items rather than a clean bill of health.

Connect the GitHub App on a single repository and review what it surfaces. On the free tier this means a public repository with 10 analyses per month. Review the practices it finds, keep the ones that match how your team actually works, and only then decide whether Pro's private-repo coverage is worth the per-seat cost.