Zenable Skills

Zenable enforces your organization's coding standards — the requirements your team decided on — against the code AI agents write, as they write it. Teams adopt AI coding agents at full speed and stay audit-ready, and developers keep whatever IDE or agent they already use.

You describe a standard once as a plain-English requirement. Zenable enforces it with a mix of deterministic static analysis and AI review, and records every finding — a durable account of what was actually checked, not a claim that an agent looked.

This repository is the home for Zenable's developer-side integrations: the agent plugin — which ships as both a Claude Code plugin and a portable Agent Plugins 1.0 package — plus a pre-commit hook and drop-in configuration for plenty of different agentic IDEs. Your requirements travel with you across all of them.

This README is the quick, self-contained tour. Full product documentation lives at zenable.app/docs — each section below links to the relevant deep dive.

How it works

You describe a standard once in plain English; Zenable turns it into automated guardrails — a mix of deterministic static analysis and AI review — that enforce it everywhere your code moves: in the editor as your agent writes, and again in pre-commit and CI. The payoff:

• Adopt AI at full speed, stay audit-ready — every finding is recorded on the exact file and line and attributed to the requirement behind it: the evidence an audit asks for, not a claim that an agent looked.
• Fixed in the same turn — violations feed straight back to the coding agent as it works, so they're resolved before they land.
• No cost, no friction — deterministic checks are pre-fetched and run locally, adding effectively no wall-clock time and no inference cost, with no change to the IDE or agent your developers already use.

Over time Zenable learns from the signals your team already produces — fixes, PR activity, agent and human feedback, false positives — and proposes improvements to the requirements and guardrails themselves. Those proposals are governed by policies you set, with a human kept in the loop wherever you require one.

Deep dive: How Zenable works · Requirements & guardrails

Integrations

Each integration below is a self-contained setup. Pick the ones that match your workflow — they layer cleanly (in-editor + pre-commit + CI is a common combo) and enforce the same requirements no matter which you use, with nothing to reconfigure when your team adopts a new tool.

Claude Code plugin

Install the plugin from this repo's marketplace:

/plugin marketplace add Zenable-io/skills
/plugin install z@zenable

Team setup — commit this to .claude/settings.json so everyone gets it:

{
  "extraKnownMarketplaces": {
    "zenable": {
      "source": {"source": "github", "repo": "Zenable-io/skills"}
    }
  },
  "enabledPlugins": {"z@zenable": true}
}

On first session the plugin sets itself up — it installs the zenable CLI and wires the post-edit hooks for you, so guardrail review starts running on every edit with nothing else to configure. What you get:

• Hooks — automatic guardrail review after each file edit. Violations are returned to the agent to fix in place.

• Skills — twelve of them, all invocable as /z:<name>. /z:review for autonomous, requirement-aware code review; /z:setup to onboard a codebase by turning the standards you've already written down into scoped Zenable requirements; /z:assessment to run a full assessment on top of those requirements and produce a deliverable report; /z:triage to address unresolved Zenable review comments on the current PR/MR; /z:pr-metrics to render your organization's PR delivery history before and after Zenable as a local report; plus /z:feat, /z:debug, /z:addtests, /z:doublecheck, /z:rebase, /z:prfeedback, and /z:researchbranch.

• CLI — the local engine behind the hooks and skills, running deterministic, token-free guardrail checks.

• MCP — full platform access for your agent: your requirements, guardrails, and findings, agent observability, how your requirements and guardrails improve over time, and configuring the platform itself. Connect it with one command:

  zenable install mcp claude-code

Deep dive: Claude Code integration

Agent Plugins

The same package is also a portable Agent Plugins 1.0 plugin, so clients that implement the spec load the identical twelve skills with no Zenable-specific glue. Install it through the client's own plugin flow, adding Zenable-io/skills as a marketplace and then installing z@zenable.

Skills CLI

To drop just the skills into any agent the skills CLI supports — Claude Code, Cursor, Codex, OpenCode, and dozens more — point it at this repo:

npx skills add Zenable-io/skills                    # pick skills and agents interactively
npx skills add Zenable-io/skills --skill triage     # install one skill
npx skills add Zenable-io/skills --list             # see what's available

Skills installed this way are invoked by their bare name (/triage rather than /z:triage) and don't include the plugin's post-edit hooks — use the plugin, or zenable install, for automatic review on every edit.

Other AI editors

The same guardrails — remote MCP plus an automatic post-edit review — work across Cursor, VS Code, Codex, GitHub Copilot CLI, and many more. Install the Zenable CLI, then let it write each editor's config:

curl -fsSL https://cli.zenable.app/install.sh | bash

zenable install cursor      # or: codex, vscode, copilot, amp, auggie,
zenable install codex        # antigravity, kiro, goose, devin-desktop, …
zenable install              # auto-detect every installed editor

The CLI writes the MCP server config — handling the required out-of-band login — and, where the editor supports it, the post-edit hook into that editor's own config files. Add --project to scope it to the current repo or --dry-run to preview. Run zenable install --help for the full list of supported editors.

Deep dive: MCP getting started · Zenable CLI reference

Pre-commit

Catch violations before they're committed. Install the Zenable CLI first:

curl -fsSL https://cli.zenable.app/install.sh | bash

Then add the hook to .pre-commit-config.yaml:

repos:
  - repo: https://github.com/Zenable-io/skills
    rev: v3 # Consider `pre-commit autoupdate --freeze` to safely lock and maintain this
    hooks:
      - id: zenable-check

Deep dive: Pre-commit setup

Documentation

Everything below redirects to docs.zenable.io:

• Zenable docs home
• How it works
• Requirements & guardrails
• MCP getting started
• Claude Code integration
• Pre-commit setup
• GitLab reviewer · GitHub reviewer
• Zenable CLI reference

Contributing

See CONTRIBUTING.md for development setup, commit conventions, and release process.

This project uses Conventional Commits and automated semantic versioning.

Support

• Issues: GitHub Issues
• Website: zenable.io