Ring — Skills Library for AI Agents
A plugin-based skills library and specialist agents that enforce TDD, systematic debugging, and parallel code review in AI-assisted development.
- Source repo
- LerianStudio/ring
- Stars
- ★ 218
- Last updated
- 5d ago
- License
- Apache-2.0
- Primary language
- HTML
- FA score
- 72/100 · Some gaps
At a glance
- How it runs
- Works with
- Portable with changesCodex · Claude Code
- Cost
- Free software; you pay for model usage
- Setup effort
- Medium · a few setup steps
- You'll need
- Typical use
- A backend team on Claude Code that wants AI assistants to write tests before implementation instead of jumping straight to code
- Not a fit if
- Teams not using Claude Code, Codex, OpenCode, or Cursor
- Teams outside Lerian's internal library ecosystem (lib-commons, lib-observability, lib-systemplane, lib-streaming)
- Solo prototypers who want speed without mandatory gates and phased planning
- Source review
- 72/100 · Some gaps
What does this agent do, and when should you use it?
Ring is an open-source skills library and workflow system from LerianStudio, distributed as a Claude Code plugin marketplace with 4 active plugins (ring-default, ring-dev-team, ring-pm-team, ring-tw-team), 76 skills, and 33 specialist agents. A session-start hook auto-loads a skill index and mandates that the agent check for a matching skill before any action, enforcing test-first development, evidence-driven debugging, and phased plan execution. Core workflows include parallel code review with 9 default reviewers plus conditional specialists, gate-based rolling-wave dev cycles (Gate 0 per task, Gate 8 review, Gate 9 acceptance), and product-planning pipelines for small (4-gate) and large (8-gate) features. The skills are agent-agnostic; beyond Claude Code, Ring ships native manifests for Codex, OpenCode, and Cursor plus a symlink installer covering Factory AI. The project is Lerian-first but open-source-friendly: internal skills stay in the marketplace while unused plugins are archived under .archive/.
Ring defines skills as SKILL.md files with frontmatter (e.g., ring:test-driven-development, ring:reviewing-code, ring:running-dev-cycle) and auto-loads them via default/hooks/session-start.sh, which generates a skills quick reference at startup. At runtime, agents follow skill instructions: the TDD skill enforces RED-GREEN-REFACTOR cycles; ring:reviewing-code dispatches 9 default reviewers (code-reviewer, logic-reviewer, security-reviewer, test-reviewer, nil-reviewer, dead-code-reviewer, perf-reviewer, tenancy-reviewer, commons-reviewer) plus diff-triggered conditional specialists (obs-reviewer, systemplane-reviewer, streaming-reviewer), aggregating findings by severity without modifying files; ring:running-dev-cycle executes a rolling-wave phased plan through Gate 0 (per-task TDD/coverage verification) to Gate 8 review and Gate 9 user acceptance. The pm-team plugin runs gated workflows through researching-features, writing-prds, writing-trds, and designing-api-contracts to produce PRDs, TRDs, OpenAPI 3.1 contracts, and data models. The review pipeline can invoke the external Mithril tool (go install github.com/lerianstudio/mithril@latest) for static analysis and AST extraction. Installation is via the ring-install.sh symlink script or native per-harness plugin manifests.
- A backend team on Claude Code that wants AI assistants to write tests before implementation instead of jumping straight to code
- Engineering teams needing multi-lens code review where security, performance, nil-safety, and multi-tenancy reviewers run in parallel and findings are aggregated by severity
- Go/TypeScript engineers planning a large refactor, using planning-backend-refactor with Standards Compliance comparison tables against team conventions
- Product-engineering collaboration on feature scoping, producing PRD, TRD, OpenAPI contract, data model, and execution plan through 4- or 8-gate workflows
- Teams needing API reference or guide documentation, generated and quality-reviewed by the ring-tw-team agents (guide-writer, api-writer, docs-reviewer)
- Teams running a production-readiness audit via the 44-dimension auditing-production-readiness skill, producing a scored 0-430 report
How do you install or deploy this agent?
Option 1 (symlink installer, local dev): git clone https://github.com/lerianstudio/ring.git ~/ring && cd ~/ring, then run bash ring-install.sh for an interactive target menu, or target a harness directly: bash ring-install.sh --claude (Claude Code), --factory (Factory AI), --opencode, --codex, or --all. Subcommands: install, remove, build, clean, doctor, all; flags: --yes/-y, --dry-run, --force, --verbose. Option 2 (native manifests per harness): Claude Code uses .claude-plugin/marketplace.json at the repo root (Settings → Plugins, search "ring"); Codex uses each plugin's .codex-plugin/plugin.; Cursor uses .cursor-plugin/plugin. (native only — the installer does not support Cursor); OpenCode uses each plugin's .opencode/INSTALL.md, e.g., declaring "ring-default@git+https://github.com/lerianstudio/ring.git#main" in the plugin list. ring-default is the foundation plugin and should be installed alongside any other Ring plugin because it provides the using-ring bootstrap. Optional dependency: go install github.com/lerianstudio/mithril@latest for the Mithril code-analysis pipeline.
How do you use this agent?
After installation, start a new Claude Code session; the hook auto-loads the skill index (ring:using-ring, ring:test-driven-development, etc.). Always route through ring:using-ring first: before any action, tool call, or code, check for a matching skill. Typical flows: saying "add user authentication" triggers ring:planning-small-features for scoping, then TDD-driven implementation per component, then parallel review via ring:reviewing-code; a bug report triggers the four-phase debug flow (evidence gathering → pattern analysis → hypothesis testing → fix with test). Reviews are report-only; fixes require a separate implementation step followed by a new review run. Skills can be invoked explicitly by name, and dev-cycle skills (e.g., ring:running-dev-cycle) progress through a phased plan's Epic/Task structure with mandatory gate checkpoints.
What are this agent's strengths and limitations?
- Parallel review runs 9 default reviewers plus conditional specialists at once, returning severity-aggregated (Critical/High/Medium/Low) findings in a single pass, with a clean report-only boundary — reviewers never change files
- Mandatory skill triggers ("if a skill applies, it MUST be used") plus documented anti-patterns and checklists systematically prevent common AI failures like skipping tests or fixing symptoms without root-cause analysis
- Multi-platform delivery: native manifests for Claude Code, Codex, OpenCode, and Cursor, an installer for Factory AI, with the skills themselves agent-agnostic
- Covers the full delivery chain: core quality, 35 developer skills, 14 product-planning skills, and 4 technical-writing skills, including a 44-dimension production-readiness audit and gate-based dev cycles
- Headline metrics in the README (90% fewer works-on-my-machine issues, 100% test coverage) are team-reported claims without an independently verifiable methodology
- Deep coupling to Lerian's internal library ecosystem (lib-commons, lib-observability, lib-systemplane, lib-streaming); teams outside that stack can only leverage the generic skills, and many specialized skills/reviewers offer little value
- The full code-analysis pipeline depends on the external Go tool Mithril, requiring an extra Go toolchain install; Cursor is native-manifest only, not covered by the symlink installer
- High process overhead: mandatory gates and rolling-wave phased planning can feel heavy for lightweight tasks or solo prototyping
- License inconsistency: repository metadata says Apache-2.0 while the README license section says MIT — verify before adopting
How does this agent compare with similar options?
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| Ring — Skills Library for AI Agents This agent | 72 · Some gaps | Agent plugin / skillFree + model costs | ★ 218 | 5d ago | HTML | Codex · Claude Code |
| CC10x Workflow Engine | 54 · Major gaps | Agent plugin / skillFree + model costs | ★ 166 | 5d ago | Python | Claude Code |
| oh-my-agent | 48 · Major gaps | CLIFree + model costs | ★ 1.4k | today | TypeScript | Codex · Claude Code |
| Pi Subagents | 77 · Good | Agent plugin / skill | ★ 4.1k | today | TypeScript | — |
How does FollowAgents rate this agent?
Why each dimension lost points
Evidence shows: CI workflow declares explicit minimal permissions, installer offers --dry-run/--force backups, commit/PR skills have checkpoint gates, and a dependency-audit skill exists. Deductions: skills auto-load via session-start hooks with limited informed consent; Mithril is installed via unpinned 'go install @latest', a supply-chain weakness; skills drive git commit/push/PR external effects whose guards live only in prompt text, unverified by execution.
Evidence shows: hook logic has thorough unit tests, failure messages and exit codes are explicit (--strict, ERROR/WARNING levels), and the installer has a doctor subcommand. Deduction: internal inconsistency — README states 76 skills/33 agents while the object description claims 89/38; conflicting counts in one repo cap this at 1. Availability of Mithril and Lerian-private library dependencies cannot be statically confirmed.
Evidence shows: a clear multi-platform matrix (Claude Code/Codex/OpenCode/Cursor/Factory AI), two install mechanisms, and a Lerian-first but externally adoptable design — audience/scenarios earn 3. Deductions: runtime trigger precision cannot be verified statically (relies on frontmatter description quality); deep coupling to Lerian-internal libraries (lib-commons, systemplane) limits full applicability outside Lerian environments.
Evidence shows: clean information architecture (4-plugin layering, .archive, marketplace. as source of truth), detailed install docs with subcommands and platform matrix, naming stability enforced by a validator requiring the ring: prefix, full Apache-2.0 text, and an automated semver workflow with tags and lockstep manifest updates — all earn 3. Deductions: no standalone CHANGELOG file in evidence; maintenance commitment is Lerian-internal first with limited external-user guarantees; usage examples are truncated in the README and no FAQ exists.
Evidence shows: 76+ skills spanning the full delivery chain with mandatory workflows (TDD, 10-gate cycles, parallel review) — clear marginal value, earning 3. Deductions: auto-loading all skills at session start may impose context cost; ~14 migration/reference skills target Lerian-proprietary libraries and are dead weight for external users; output usability (Standards Compliance tables, scored reports) is described but quality is unverifiable statically.
Evidence shows: README cross-references concrete file paths (SKILL.md, marketplace., standards docs), and test code exists as checkable evidence. Deductions: strong claims like 'battle-tested' carry no attached evidence; cross-source corroboration is absent — skill/agent counts conflict between description and README with no third-party source; fact/inference separation is generally acceptable but marketing language (proven, battle-tested) is mixed with verifiable facts.
- Skill/agent counts conflict between the README (76/33) and the object description (89/38); verify against marketplace. before relying on them.
- Mithril is installed via 'go install @latest' with no version pinning — a supply-chain risk; pin to a specific release.
- Skills auto-load via session-start hooks and impose mandatory behavioral constraints, constituting a high-privilege prompt-injection surface; review hook and skill contents before deployment.
- Commit/push/PR skills drive real external effects whose guards exist only at the prompt level and are unverified by execution; use with caution in production.
- Publisher identity is unverified by the curated registry; documentation is deeply coupled to Lerian-internal libraries, limiting value of some skills for external teams.