{"id":51215843,"url":"https://github.com/LerianStudio/ring","last_synced_at":"2026-07-16T14:01:13.102Z","repository":{"id":322015088,"uuid":"1086726454","full_name":"LerianStudio/ring","owner":"LerianStudio","description":"89 skills and 38 specialized agents that enforce proven engineering practices for AI-assisted development. TDD, systematic debugging, parallel code review, and 10-gate development cycles — as a Claude Code plugin marketplace.","archived":false,"fork":false,"pushed_at":"2026-07-13T21:28:52.000Z","size":96551,"stargazers_count":203,"open_issues_count":10,"forks_count":24,"subscribers_count":2,"default_branch":"main","last_synced_at":"2026-07-13T22:21:35.612Z","etag":null,"topics":["ai-agents","ai-coding","claude-code","code-quality","code-review","developer-tools","devops","finops","plugin","prompt-engineering","skills-library","software-engineering","tdd","technical-writing","workflow-automation"],"latest_commit_sha":null,"homepage":"https://lerian.studio","language":"HTML","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/LerianStudio.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":"AGENTS.md","dco":null,"cla":null}},"created_at":"2025-10-30T20:18:13.000Z","updated_at":"2026-07-13T14:19:16.000Z","dependencies_parsed_at":"2025-11-02T03:07:12.173Z","dependency_job_id":null,"html_url":"https://github.com/LerianStudio/ring","commit_stats":null,"previous_names":["lerianstudio/ring"],"tags_count":1020,"template":false,"template_full_name":null,"purl":"pkg:github/LerianStudio/ring","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/LerianStudio%2Fring","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/LerianStudio%2Fring/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/LerianStudio%2Fring/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/LerianStudio%2Fring/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/LerianStudio","download_url":"https://codeload.github.com/LerianStudio/ring/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/LerianStudio%2Fring/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":35546267,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-07-16T02:00:06.687Z","response_time":83,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["ai-agents","ai-coding","claude-code","code-quality","code-review","developer-tools","devops","finops","plugin","prompt-engineering","skills-library","software-engineering","tdd","technical-writing","workflow-automation"],"created_at":"2026-06-28T04:01:00.196Z","updated_at":"2026-07-16T14:01:13.085Z","avatar_url":"https://github.com/LerianStudio.png","language":"HTML","funding_links":[],"categories":["⭐ 精选第三方技能"],"sub_categories":["💻 开发效率"],"readme":"\u003cp align=\"center\"\u003e\n  \u003cimg src=\"assets/ring-banner.png\" alt=\"Ring by Lerian\" width=\"100%\" /\u003e\n\u003c/p\u003e\n\n# 💍 The Ring - Skills Library for AI Agents\n\n**Proven engineering practices, enforced through skills.**\n\nRing is a comprehensive skills library and workflow system for AI agents that transforms how AI assistants approach software development. Currently implemented as a **Claude Code plugin marketplace** with **4 active plugins**, **76 skills**, and **33 agents** (see `.claude-plugin/marketplace.json` for current versions), the skills themselves are agent-agnostic and can be used with any AI agent system. Ring provides battle-tested patterns, mandatory workflows, and systematic approaches across the entire software delivery value chain.\n\n## ✨ Why Ring?\n\nWithout Ring, AI assistants often:\n\n- Skip tests and jump straight to implementation\n- Make changes without understanding root causes\n- Claim tasks are complete without verification\n- Forget to check for existing solutions\n- Repeat known mistakes\n\nRing solves this by:\n\n- **Enforcing proven workflows** - Test-driven development, systematic debugging, proper planning\n- **Providing 76 specialized skills** (23 core + 35 dev-team + 14 product planning + 4 technical writing)\n- **33 specialized agents** - 2 planning/analysis + 24 developer/reviewer + 4 product research + 3 technical writing\n- **Automating skill discovery** - Skills load automatically at session start\n- **Preventing common failures** - Built-in anti-patterns and mandatory checklists\n\n## 🧭 Project Identity\n\n**Ring is Lerian-first, open-source-friendly.** Design decisions prioritize the Lerian engineering team's daily needs while keeping the architecture clean and reusable for external adoption. This means:\n\n- **Lerian-specific skills stay active** — Internal integrations and domain-specific workflows remain in the marketplace because the team uses them\n- **The architecture is universal** — Skills, agents, and the plugin system work with any codebase or team\n- **Archival is usage-driven** — Skills are archived when they stop being used, not because they're \"too specific\"\n\n## 🤖 Specialized Agents\n\n**Planning \u0026 Analysis Agents (default plugin):**\n\n- `ring:review-slicer` - Review slicer (groups large multi-themed PRs into thematic slices for focused parallel review)\n- `ring:codebase-explorer` - Deep architecture analysis (deep-analysis, complements built-in Explore)\n- Use `ring:reviewing-code` skill to orchestrate parallel review workflow\n\n**Developer Agents (dev-team plugin):**\n\n- `ring:backend-go` - Go backend specialist for financial systems\n- `ring:backend-ts` - TypeScript/Node.js backend specialist (Express, NestJS, Fastify)\n- `ring:bff-ts` - BFF \u0026 React/Next.js frontend with Clean Architecture\n- `ring:ui-designer` - Visual design specialist\n- `ring:frontend` - Senior Frontend Engineer (React/Next.js)\n- `ring:devops` - DevOps and infrastructure specialist\n- `ring:prompt-reviewer` - Agent Quality Analyst\n- `ring:qa` - Backend QA specialist (unit, integration, load, chaos)\n- `ring:qa-frontend` - Frontend QA specialist (accessibility, visual, E2E, performance)\n- `ring:sre` - Observability and reliability specialist\n- `ring:ui-engineer` - UI component specialist (design systems, accessibility)\n- `ring:helm` - Helm chart specialist (chart structure, security, Lerian conventions)\n- `ring:code-reviewer` - Foundation review (architecture, code quality, design patterns)\n- `ring:logic-reviewer` - Correctness review (domain logic, requirements, edge cases)\n- `ring:security-reviewer` - Safety review (vulnerabilities, OWASP, authentication)\n- `ring:test-reviewer` - Test quality review (coverage, edge cases, assertions, test anti-patterns)\n- `ring:nil-reviewer` - Nil/null safety review (traces pointer risks, missing guards, panic paths)\n- `ring:dead-code-reviewer` - Dead code review (orphaned code detection, reachability analysis, dead dependency chains)\n- `ring:commons-reviewer` - lib-commons package usage review (lifecycle, tenancy, http, idempotency, security, database, messaging, outbox; reinvented-wheel opportunities)\n- `ring:obs-reviewer` - Conditional specialist for tracing, metrics, logging, runtime recovery, redaction, constants, and SafeGo implications\n- `ring:systemplane-reviewer` - Conditional specialist for runtime config, hot-reload knobs, admin config, tenant-scoped settings, and systemplane imports\n- `ring:streaming-reviewer` - Conditional specialist for business events, outbox, producers, broker publishing, CloudEvents, manifests, and catalogs\n- `ring:tenancy-reviewer` - Multi-tenant usage review (lib-commons/multitenancy patterns, tenant isolation, JWT tenantId propagation)\n- `ring:perf-reviewer` - Performance review (code hotspots, infra misconfigurations, Go/TypeScript/Python)\n\n\u003e **Standards Compliance:** Refactor-capable dev-team agents produce a `## Standards Compliance` output section with conditional requirement:\n\u003e\n\u003e - **Optional** when invoked directly or via `ring:running-dev-cycle`\n\u003e - **MANDATORY** when invoked from `ring:planning-backend-refactor` (triggered by `**MODE: ANALYSIS ONLY**` in prompt)\n\u003e\n\u003e When mandatory, agents load Ring standards via WebFetch and produce comparison tables with:\n\u003e\n\u003e - Current Pattern vs Expected Pattern\n\u003e - Severity classification (Critical/High/Medium/Low)\n\u003e - File locations and migration recommendations\n\u003e\n\u003e See `dev-team/docs/standards/*.md` for standards source. Cross-references: CLAUDE.md (Standards Compliance section), `dev-team/skills/planning-backend-refactor/SKILL.md`\n\n**Product Research Agents (ring-pm-team plugin):**\n\n- `ring:repo-researcher` - Repository structure and codebase analysis\n- `ring:web-researcher` - Industry best practices research\n- `ring:docs-researcher` - Framework documentation research\n- `ring:product-designer` - Product design and UX research\n\n**Technical Writing Agents (ring-tw-team plugin):**\n\n- `ring:guide-writer` - Functional documentation (guides, tutorials, conceptual docs)\n- `ring:api-writer` - API reference documentation (endpoints, schemas, examples)\n- `ring:docs-reviewer` - Documentation quality review (voice, tone, structure, completeness)\n\n_Plugin versions are managed in `.claude-plugin/marketplace.json`_\n\n### 📦 Archived Plugins\n\nThe following plugins have been archived and are not actively maintained. They remain available in `.archive/` for reference:\n\n| Plugin         | Description                                             | Status                                                   |\n| -------------- | ------------------------------------------------------- | -------------------------------------------------------- |\n| `pmm-team`     | Product Marketing (GTM, positioning, competitive intel) | Archived - functionality may be restored based on demand |\n| `finance-team` | Financial planning and analysis                         | Archived - under evaluation                              |\n| `ops-team`     | Operations management                                   | Archived - under evaluation                              |\n\n_To restore an archived plugin, move its folder from `.archive/` to the root directory and register it in `marketplace.json`._\n\n## 🖥️ Supported Platforms\n\nRing works across multiple AI development platforms:\n\n| Platform        | Native manifest        | Symlink installer       | Status             |\n| --------------- | ---------------------- | ----------------------- | ------------------ |\n| **Claude Code** | ✅ marketplace.json    | ✅ `--claude`           | Source of truth    |\n| **Codex**       | ✅ `.codex-plugin/`    | ✅ `--codex` (built)    | Both paths work    |\n| **OpenCode**    | ✅ `.opencode/`        | ✅ `--opencode` (built) | Both paths work    |\n| **Cursor**      | ✅ `.cursor-plugin/`   | ❌ not in installer     | Native only        |\n| **Factory AI**  | ❌                     | ✅ `--factory`          | Installer only     |\n\n**Two install mechanisms:**\n\n- **Native manifest** — the harness installs Ring directly from this repo via its own package manager (`opencode.json`, Cursor plugin marketplace, Codex plugin manifest). No local build step, no manual symlink work. Best for end users and CI.\n- **Symlink installer** (`ring-install.sh`) — symlinks from your local harness config dir into a cloned Ring repo. For Codex/OpenCode, the installer builds a transformed tree at `.ring-build/` first (namespace + frontmatter rewrites). Best for local development with hot-reload against the source tree.\n\nSee the [`Native plugin install`](#native-plugin-install-per-harness) and [`Symlink installer`](#symlink-installer-local-dev) sub-sections below for usage.\n\n## 🚀 Quick Start\n\n### Native plugin install (per harness)\n\nEach Ring plugin ships native manifests for Claude Code, Codex, Cursor, and OpenCode. The harness installs the plugin directly from this repo via its own package manager — no transformation step, no local installer.\n\n| Harness         | Mechanism                                | Per-plugin entry points |\n| --------------- | ---------------------------------------- | ----------------------- |\n| **Claude Code** | `.claude-plugin/marketplace.json` (root) | All 4 plugins enumerated in one marketplace file |\n| **Codex**       | `\u003cplugin\u003e/.codex-plugin/plugin.json`     | [default](default/.codex-plugin/plugin.json) · [dev-team](dev-team/.codex-plugin/plugin.json) · [pm-team](pm-team/.codex-plugin/plugin.json) · [tw-team](tw-team/.codex-plugin/plugin.json) |\n| **Cursor**      | `\u003cplugin\u003e/.cursor-plugin/plugin.json`    | [default](default/.cursor-plugin/plugin.json) · [dev-team](dev-team/.cursor-plugin/plugin.json) · [pm-team](pm-team/.cursor-plugin/plugin.json) · [tw-team](tw-team/.cursor-plugin/plugin.json) |\n| **OpenCode**    | `\u003cplugin\u003e/.opencode/` (INSTALL + JS plugin) | [default](default/.opencode/INSTALL.md) · [dev-team](dev-team/.opencode/INSTALL.md) · [pm-team](pm-team/.opencode/INSTALL.md) · [tw-team](tw-team/.opencode/INSTALL.md) |\n\n**`ring-default` is the foundation plugin** — install it alongside any other Ring plugin since it provides the `using-ring` bootstrap that orients agent behavior. Example for OpenCode:\n\n```json\n{\n  \"plugin\": [\n    \"ring-default@git+https://github.com/lerianstudio/ring.git#main\",\n    \"ring-dev-team@git+https://github.com/lerianstudio/ring.git#main\"\n  ]\n}\n```\n\nEach harness's INSTALL.md (for OpenCode) or `plugin.json` (for Codex/Cursor) carries the exact install command for that platform.\n\n### Symlink installer (local dev)\n\n`ring-install.sh` symlinks your harness's local config dir into this cloned Ring repo. For Codex and OpenCode, it first builds a transformed tree at `.ring-build/` (namespace + frontmatter rewrites required by those tools).\n\n**Supported targets:** Claude Code, Factory AI, OpenCode, Codex.\n**Not supported by the installer:** Cursor (use the [native plugin install above](#native-plugin-install-per-harness)).\n\n```bash\n# Clone the repo\ngit clone https://github.com/lerianstudio/ring.git ~/ring\ncd ~/ring\n\n# Interactive menu (lets you pick targets)\nbash ring-install.sh\n\n# Or target specific harnesses without the prompt:\nbash ring-install.sh --claude               # Claude Code (per-file symlinks)\nbash ring-install.sh --factory              # Factory AI (per-file symlinks)\nbash ring-install.sh --opencode             # OpenCode (builds .ring-build/opencode/ first)\nbash ring-install.sh --codex                # Codex    (builds .ring-build/codex/ first)\nbash ring-install.sh --all                  # All four supported targets\n```\n\n#### Installer subcommands\n\n```bash\nbash ring-install.sh install --opencode --codex   # install symlinks for selected targets\nbash ring-install.sh remove                        # remove all Ring symlinks\nbash ring-install.sh build                         # rebuild .ring-build/{opencode,codex} only\nbash ring-install.sh clean                         # remove .ring-build/ outputs\nbash ring-install.sh doctor                        # verify install + build outputs\nbash ring-install.sh all --all -y                  # clean + build + install for all targets, no prompt\n```\n\n**Flags:** `--yes` / `-y` (skip confirmation), `--dry-run` (preview without changes), `--force` (back up non-symlink collisions), `--verbose`.\n\n### Claude Code Plugin Marketplace\n\nFor Claude Code users, you can also install from the marketplace:\n\n- Open Claude Code\n- Go to Settings → Plugins\n- Search for \"ring\"\n- Click Install\n\n### Manual Installation (Claude Code only)\n\n```bash\n# Clone the marketplace repository\ngit clone https://github.com/lerianstudio/ring.git ~/ring\n\n# Skills auto-load at session start via hooks\n# No additional configuration needed for Claude Code\n```\n\n### Code Analysis Pipeline\n\nThe `ring:reviewing-code` pipeline uses [Mithril](https://github.com/LerianStudio/mithril), an external code analysis tool installed via `go install`. Mithril performs static analysis, AST extraction, call graph generation, and context compilation for AI-assisted code review.\n\nInstall via `go install github.com/lerianstudio/mithril@latest`. See the [Mithril repository](https://github.com/LerianStudio/mithril) for full installation details and release notes.\n\n### First Session\n\nWhen you start a new Claude Code session with Ring installed, you'll see:\n\n```\n## Available Skills:\n- ring:using-ring (Check for skills BEFORE any task)\n- ring:test-driven-development (RED-GREEN-REFACTOR cycle)\n- ring:reviewing-code (9 defaults + conditional specialist dispatch)\n- ring:exploring-codebases (Two-phase codebase exploration)\n... and 71 more skills\n```\n\n## 🎯 Core Skills\n\n### Start Here\n\n#### 1. **ring:using-ring** - Mandatory Skill Discovery\n\n```\nBefore ANY action → Check skills\nBefore ANY tool → Check skills\nBefore ANY code → Check skills\n```\n\n#### 2. **ring:test-driven-development** - Test First, Always\n\n```\nRED → Write failing test → Watch it fail\nGREEN → Minimal code → Watch it pass\nREFACTOR → Clean up → Stay green\n```\n\n## 📚 All 76 Skills (Across 4 Plugins)\n\n### Core Skills (ring-default plugin - 23 skills)\n\n**Testing \u0026 Quality (3):**\n\n- `ring:test-driven-development` - Write test first, watch fail, minimal code\n- `ring:fixing-lint` - Parallel lint fixing with agent dispatch\n- `ring:cleaning-comments` - Remove redundant, stale, or low-value comments while preserving intent-revealing ones\n\n**Collaboration \u0026 Planning (10):**\n\n- `ring:reviewing-code` - **Parallel 9 defaults + conditional specialist dispatch** with severity-based handling\n- `ring:creating-worktrees` - Isolated development\n- `ring:committing-changes` - Smart commit organization with atomic grouping, conventional commits, and trailers\n- `ring:opening-pull-requests` - Open a PR with base-branch detection, scope allowlist enforcement, and template filling\n- `ring:shipping-changes` - End-to-end commit-and-ship flow from working tree to open PR\n- `ring:writing-plans` - Author phased implementation plans (phase → epic → task) from a spec; first phase detailed into dispatch-ready tasks, later phases epic-level for rolling-wave elaboration\n- `ring:executing-plans` - Rolling-wave execution of a phased plan: implement the detailed phase, checkpoint with the user, elaborate the next phase against the real codebase, repeat\n- `ring:dispatching-workflows` - Rolling-wave execution where each phase runs as a reviewed multi-agent workflow harness (mandatory in-harness review + adversarial contrarian pass) before returning verified work\n- `ring:analyzing-options` - Structured comparison of approaches with effort estimates and a recommendation\n- `ring:generating-pr-descriptions` - Generate PR descriptions from branch diff analysis\n\n**Meta Skills (4):**\n\n- `ring:using-ring` - Mandatory skill discovery\n- `ring:writing-skills` - TDD for documentation\n- `ring:testing-skills-with-subagents` - Skill validation\n- `ring:engineering-prompts` - Engineer and refine prompts for skills and agents\n\n**Session \u0026 Learning (5):**\n\n- `ring:exploring-codebases` - Two-phase codebase exploration\n- `ring:generating-release-guides` - Generate Ops Update Guide from git diff analysis\n- `ring:visualizing` - Generate self-contained HTML pages to visually explain systems, code changes, and data\n- `ring:creating-handoffs` - Create handoff documents capturing session state for seamless context-clear and resume\n- `ring:searching-code` - Targeted code search patterns and dispatch strategies\n\n**Audit \u0026 Readiness (1):**\n\n- `ring:auditing-production-readiness` - 44-dimension production readiness audit; runs explorers in batches of up to 10, appends incrementally to a single report; output: scored report (0-430, max 440 with multi-tenant) with severity ratings. See [default/skills/auditing-production-readiness/SKILL.md](default/skills/auditing-production-readiness/SKILL.md) for invocation and implementation details.\n\n### Developer Skills (ring-dev-team plugin - 35 skills)\n\n**Orchestration \u0026 Refactoring (7):**\n\n- `ring:using-dev-team` - Introduction to developer specialist agents\n- `ring:running-dev-cycle` - Lean backend development cycle orchestrator driven by a rolling-wave phased plan (phases → epics `Epic N.M` → tasks `Task N.M.T`): Gate 0 implementation-owned TDD/coverage/docker-compose/runtime/delivery verification per task, Gate 8 review + Gate 9 validation per epic, phase boundary (Step 11.5) closes each phase and elaborates the next against the real codebase\n- `ring:running-dev-cycle-frontend` - Lean frontend development cycle orchestrator on the same rolling-wave phased plan (Gate 0 per task, Gate 7 review per epic, Gate 8 validation per task, phase boundary per phase)\n- `ring:planning-backend-refactor` - Backend/codebase standards analysis\n- `ring:planning-frontend-refactor` - Frontend standards analysis and task generation\n- `ring:planning-codebase-simplification` - Whole-codebase structural simplification sweep (hunts unjustified abstractions, adapters, shims; KILL/REVIEW/KEEP output; DELETE-by-default burden of proof for pre-public applications)\n- `ring:managing-dev-cycle` - Development cycle state management (phase/epic status reporting and cancellation)\n\n**Backend Gate Skills:**\n\n- `ring:implementing-tasks` - Gate 0: TDD implementation\n- `ring:adding-multi-tenancy` - Multi-tenant adaptation (database-per-tenant isolation, integrated into Gate 0)\n- `ring:hardening-dockerfiles` - Docker image security audit for Docker Hub Health Score grade A\n- `ring:creating-helm-charts` - Helm chart creation and maintenance following Lerian conventions\n- `ring:mapping-service-resources` - Service/module/resource hierarchy scanner for dispatch layer\n- `ring:implementing-readyz` - Comprehensive readiness probes (/readyz) with per-dependency status and TLS validation\n- `ring:instrumenting-streaming-events` - Wire lib-streaming event emission from a validated instrumentation map\n\n**Testing \u0026 Validation:**\n\n- `ring:detecting-goroutine-leaks` - Goroutine leak detection and regression testing\n- `ring:validating-acceptance-criteria` - Gate 9: User approval\n- `ring:writing-dev-reports` - Assertiveness scoring and metrics\n- `ring:verifying-code` - Atomic Go code verification with MERGE_READY/NEEDS_FIX verdict\n\n**Migration \u0026 Reference (14):**\n\n- `ring:using-lib-commons` - Comprehensive reference for lib-commons v5.0.2 (Lerian's shared Go library with 30+ packages)\n- `ring:using-runtime` - Deep reference and 6-angle audit for lib-observability/runtime: SafeGo, panic recovery, observability trident, policy selection, framework integration. Catches naked goroutine launches that cause silent production failures.\n- `ring:using-assert` - Deep reference and 6-angle audit for lib-observability/assert: production runtime assertions with observability trident, full domain predicate catalog (double-entry, transaction state machine, financial validations), AssertionError unwrapping patterns. Converts financial invariants into production-enforced rules.\n- `ring:migrating-to-lib-systemplane` - Migrate Lerian Go services from .env/YAML config to systemplane (database-backed hot-reloadable config)\n- `ring:generating-llms-txt` - Generate or audit llms.txt files following llmstxt.org spec for AI-friendly repository entry points\n- `ring:applying-licenses` - Repository license management (Apache 2.0, Elastic v2, Proprietary)\n- `ring:adopting-lib-commons-huma-wrapper` - Adopt the lib-commons/v5 shared Huma (OAS 3.1) OpenAPI wrapper + RFC 9457 problem model\n- `ring:applying-composition-patterns` - Apply Go composition patterns (interfaces, embedding, functional options)\n- `ring:migrating-to-lib-observability` - Migrate off deprecated lib-commons observability imports to lib-observability\n- `ring:using-lib-observability` - Reference + sweep for lib-observability (log, metrics, zap, redaction, constants)\n- `ring:using-lib-streaming` - Reference + sweep for lib-streaming (business events, outbox, producers, CloudEvents)\n- `ring:using-lib-systemplane` - Reference + sweep for lib-systemplane (runtime config, hot-reloadable knobs)\n- `ring:using-outbox` - Transactional outbox pattern via lib-commons for reliable event publishing\n- `ring:using-tracing` - Reference + sweep for lib-observability tracing (spans, context propagation, OTel)\n\n**Security (2):**\n\n- `ring:auditing-dependency-security` - Supply-chain gate for dependency installations (validates identity, vulnerabilities, suspicious signals)\n- `ring:reviewing-operational-risk` - Reviews built flows for operational recovery gaps and resilience risks\n\n**Frontend Quality Skills (1):**\n\n- `ring:checking-frontend-quality` - Frontend quality checks in modes `accessibility` (axe-core/WCAG), `visual` (snapshots/viewports), `e2e` (Playwright 3-browser), `performance` (Lighthouse/Core Web Vitals), or `all`; dispatches `ring:qa-frontend`\n\n\u003e Frontend and backend dev-cycle workflows both use `ring:reviewing-code` (core plugin) as the review gate.\n\n### Product Planning Skills (ring-pm-team plugin - 14 skills)\n\n**Pre-Development Workflow (includes ring:using-pm-team + 7 gate skills; Large track gate numbers shown):**\n\n- `ring:using-pm-team` - Introduction to product planning workflow\n\n0. `ring:researching-features` - Deep technical/product research (parallel agents)\n1. `ring:writing-prds` - Squad-facing product requirements (WHAT/WHY)\n2. `ring:mapping-feature-relationships` - Feature relationships and phasing (Large only)\n3. `ring:writing-trds` - Technical architecture (HOW)\n4. `ring:designing-api-contracts` - OpenAPI 3.1 contract (openapi.yaml)\n5. `ring:designing-data-model` - Stack-native schema (schema.sql / schema.prisma)\n6. `ring:pinning-dependency-versions` - Technology selection\n7. `ring:writing-plans` (ring-default) - Single execution plan (plan.md), invoked by the orchestrator\n\n**Workflow Orchestrators:**\n\n- `ring:planning-small-features` - 4-gate orchestrator for small features (\u003c2 days)\n- `ring:planning-large-features` - 8-gate orchestrator for large features (\u003e=2 days)\n\n**Additional Planning Skills:**\n\n- `ring:validating-ux-completeness` - Standalone UX validation for UI features (run before the TRD)\n- `ring:reconciling-predev-docs` - Deep cross-reference review of pre-dev documentation artifacts\n- `ring:mapping-streaming-events` - Standalone streaming-event discovery (event catalog + instrumentation map)\n- `ring:creating-grafana-dashboards` - Grafana dashboard generation for instrumented services\n\n### Technical Writing Skills (ring-tw-team plugin - 4 skills)\n\n**Documentation Creation:**\n\n- `ring:using-tw-team` - Introduction to technical writing specialists\n- `ring:structuring-documentation` - Document hierarchy and organization\n- `ring:applying-voice-and-tone` - Voice and tone guidelines (assertive, encouraging, human)\n- `ring:reviewing-docs` - Quality checklist and review process\n\n## 💡 Usage Examples\n\n### Building a Feature\n\n```\nUser: \"Add user authentication to the app\"\nClaude: I'm using ring:planning-small-features to scope this feature...\n        [Pre-dev workflow: PRD, TRD, plan]\nClaude: I'm using ring:test-driven-development to implement...\n        [RED-GREEN-REFACTOR cycle for each component]\nClaude: I'm using ring:reviewing-code to validate...\n        [9 defaults + conditional specialist parallel dispatch]\n```\n\n### Fixing a Bug\n\n```\nUser: \"The app crashes when clicking submit\"\nClaude: Investigating the crash:\n        Phase 1: [Gathering evidence]\n        Phase 2: [Pattern analysis]\n        Phase 3: [Hypothesis testing]\n        Phase 4: [Implementing fix with test]\n```\n\n### Planning a Project\n\n```\nUser: \"Plan an e-commerce platform\"\nClaude: I'll use the pre-dev workflow to plan this systematically...\n        Gate 1: PRD Creation [Business requirements]\n        Gate 2: Feature Map [Domain groupings]\n        Gate 3: TRD Creation [Architecture patterns]\n        ... [Through all 8 gates]\n```\n\n### Code Review (Parallel, 9 Defaults + Conditional Specialists)\n\n```\nUser: \"Review my authentication implementation\"\nClaude: Dispatching all 9 default reviewers plus triggered conditional specialists in parallel...\n        [Launches ring:code-reviewer, ring:logic-reviewer, ring:security-reviewer,\n         ring:test-reviewer, ring:nil-reviewer,\n         ring:dead-code-reviewer, ring:perf-reviewer, ring:tenancy-reviewer,\n         ring:commons-reviewer simultaneously]\n        Conditional specialists trigger only when the diff touches their stack:\n        lib-observability, lib-systemplane, or lib-streaming.\n\n        Code reviewer: PASS. Clean architecture, good tests.\n        Business reviewer: FAIL. Missing password reset flow (HIGH severity).\n        Security reviewer: FAIL. JWT secret hardcoded (CRITICAL severity).\n        Test reviewer: PASS. Good coverage, assertions well-structured.\n        Nil-safety reviewer: PASS. No unguarded nil dereferences found.\n        Performance reviewer: PASS. No hotspots or goroutine leaks found.\n        Multi-tenant reviewer: PASS. No multi-tenant code in scope.\n        lib-commons reviewer: PASS. Correct shared-library usage, no reinvented wheels detected.\n\n        Aggregating issues by severity:\n        - CRITICAL: JWT secret hardcoded in auth.ts:42\n        - HIGH: Password reset flow missing from requirements\n\n        Review report complete. No files changed by reviewers.\n        Fixes require a separate implementation step, then a new review run.\n```\n\n**Key benefits:**\n\n- **All reviewers run simultaneously** (not sequential)\n- **Comprehensive** - Get all feedback at once, easier to prioritize\n- **Report-only boundary** - Reviewers report findings; remediation is a separate step\n- **Specialized lanes** - Each reviewer owns a clear domain to avoid duplicate slop\n\n## 🏗️ Architecture\n\n**Monorepo Marketplace** - Multiple specialized plugin collections:\n\n```\nring/                                  # Monorepo root\n├── .claude-plugin/\n│   └── marketplace.json              # Multi-plugin marketplace config (4 active plugins)\n├── default/                          # Core Ring plugin (ring-default)\n│   ├── skills/                       # 23 core skills\n│   │   ├── skill-name/\n│   │   │   └── SKILL.md             # Skill definition with frontmatter\n│   │   └── shared-patterns/         # Universal patterns (10 patterns)\n│   ├── hooks/                       # Session initialization\n│   │   ├── hooks.json              # Hook configuration\n│   │   ├── session-start.sh        # Loads skills at startup\n│   │   └── generate-skills-ref.py  # Auto-generates quick reference\n│   ├── agents/                      # 2 planning/analysis agents\n│   │   ├── review-slicer.md             # Review slicing for large PRs (`ring:review-slicer`)\n│   │   └── codebase-explorer.md         # Deep architecture analysis (`ring:codebase-explorer`)\n│   └── docs/                       # Documentation\n├── dev-team/                      # Developer Agents plugin (ring-dev-team) - 35 skills, 24 agents\n│   └── agents/                      # 24 specialized developer/reviewer agents\n│       ├── backend-go.md       # Go backend specialist (`ring:backend-go`)\n│       ├── backend-ts.md   # TypeScript/Node.js backend specialist (`ring:backend-ts`)\n│       ├── bff-ts.md # BFF \u0026 React/Next.js specialist (`ring:bff-ts`)\n│       ├── devops.md              # DevOps and infrastructure specialist (`ring:devops`)\n│       ├── ui-designer.md             # Visual design specialist (`ring:ui-designer`)\n│       ├── frontend.md             # Frontend engineer (`ring:frontend`)\n│       ├── helm.md                 # Helm chart specialist (`ring:helm`)\n│       ├── code-reviewer.md                 # Foundation review (`ring:code-reviewer`)\n│       ├── logic-reviewer.md       # Correctness review (`ring:logic-reviewer`)\n│       ├── security-reviewer.md             # Safety review (`ring:security-reviewer`)\n│       ├── test-reviewer.md                 # Test quality review (`ring:test-reviewer`)\n│       ├── nil-reviewer.md           # Nil/null safety review (`ring:nil-reviewer`)\n│       ├── dead-code-reviewer.md            # Dead code analysis (`ring:dead-code-reviewer`)\n│       ├── commons-reviewer.md          # lib-commons usage review (`ring:commons-reviewer`)\n│       ├── obs-reviewer.md    # Conditional observability review (`ring:obs-reviewer`)\n│       ├── systemplane-reviewer.md      # Conditional runtime-config review (`ring:systemplane-reviewer`)\n│       ├── streaming-reviewer.md        # Conditional event producer review (`ring:streaming-reviewer`)\n│       ├── tenancy-reviewer.md         # Multi-tenant usage review (`ring:tenancy-reviewer`)\n│       ├── perf-reviewer.md          # Performance review (`ring:perf-reviewer`)\n│       ├── prompt-reviewer.md       # Agent quality reviewer (`ring:prompt-reviewer`)\n│       ├── qa.md                    # Backend QA specialist (`ring:qa`)\n│       ├── qa-frontend.md           # Frontend QA specialist (`ring:qa-frontend`)\n│       ├── sre.md                           # Observability and reliability specialist (`ring:sre`)\n│       └── ui-engineer.md                   # UI component specialist (`ring:ui-engineer`)\n├── pm-team/                    # Product Planning plugin (ring-pm-team)\n│   └── skills/                      # 14 product planning skills\n│       ├── writing-prds/          # PRD authoring\n│       ├── writing-trds/          # TRD authoring\n│       ├── designing-api-contracts/ # OpenAPI contract design\n│       ├── designing-data-model/   # Stack-native schema design\n│       └── pinning-dependency-versions/ # Dependency pinning\n└── tw-team/                         # Technical Writing plugin (ring-tw-team)\n    ├── skills/                      # 4 documentation skills\n    ├── agents/                      # 3 technical writing agents\n    └── hooks/                       # SessionStart hook\n```\n\n## 🤝 Contributing\n\n### Adding a New Skill\n\n**For core Ring skills:**\n\n1. **Create the skill directory**\n\n   ```bash\n   mkdir default/skills/your-skill-name\n   ```\n\n2. **Write SKILL.md with frontmatter**\n\n   ```yaml\n   ---\n   name: ring:your-skill-name\n   description: Single paragraph (≤500 chars target, 1,536 cap). States WHAT the skill does, WHEN to invoke, and WHEN to skip.\n   ---\n\n   # Your Skill Name\n\n   ## When to use\n   - Specific condition that mandates this skill\n   - Another trigger condition\n\n   ## Skip when\n   - When NOT to use → alternative skill\n   - Another exclusion\n   ```\n\n   **Schema fields:**\n\n   - **Required:** `name` (must use `ring:` prefix), `description`\n   - **Optional:** `argument-hint`, `allowed-tools`, `model`, `disable-model-invocation`, `user-invocable`, `paths`\n   - Trigger / skip / sequence / related content lives in body H2 sections (`## When to use`, `## Skip when`, `## Sequence`, `## Related`). See [docs/FRONTMATTER_SCHEMA.md](docs/FRONTMATTER_SCHEMA.md) for the canonical schema.\n\n3. **Update documentation**\n\n   - Skills auto-load via `default/hooks/generate-skills-ref.py`\n   - Test with session start hook\n\n4. **Submit PR**\n   ```bash\n   git checkout -b feat/your-skill-name\n   git add default/skills/your-skill-name\n   git commit -m \"feat(skills): add your-skill-name for X\"\n   gh pr create\n   ```\n\n**For product/team-specific skills:**\n\n1. **Create plugin structure**\n\n   ```bash\n   mkdir -p product-xyz/{skills,agents,hooks,lib}\n   ```\n\n2. **Register in marketplace**\n   Edit `.claude-plugin/marketplace.json`:\n\n   ```json\n   {\n     \"name\": \"ring-product-xyz\",\n     \"description\": \"Product XYZ specific skills\",\n     \"version\": \"0.1.0\",\n     \"source\": \"./product-xyz\",\n     \"homepage\": \"https://github.com/lerianstudio/ring/tree/product-xyz\"\n   }\n   ```\n\n3. **Follow core plugin structure**\n   - Use same layout as `default/`\n   - Create `product-xyz/hooks/hooks.json` for initialization\n   - Add skills to `product-xyz/skills/`\n\n### Skill Quality Standards\n\n- **Mandatory sections**: When to use, How to use, Anti-patterns\n- **Include checklists**: TodoWrite-compatible task lists\n- **Evidence-based**: Require verification before claims\n- **Battle-tested**: Based on real-world experience\n- **Clear triggers**: Unambiguous \"when to use\" conditions\n\n## 📖 Documentation\n\n- **Skills Quick Reference** - Auto-generated at session start from skill frontmatter\n- [CLAUDE.md](CLAUDE.md) - Repository guide for Claude Code\n- [MANUAL.md](MANUAL.md) - Quick reference for all skills, agents, and workflows\n- [ARCHITECTURE.md](ARCHITECTURE.md) - Architecture diagrams and component relationships\n- [Installer](installer/) - Multi-platform installation and migration\n\n## 🎯 Philosophy\n\nRing embodies these principles:\n\n1. **Skills are mandatory, not optional** - If a skill applies, it MUST be used\n2. **Evidence over assumptions** - Prove it works, don't assume\n3. **Process prevents problems** - Following workflows prevents known failures\n4. **Small steps, verified often** - Incremental progress with continuous validation\n5. **Learn from failure** - Anti-patterns document what doesn't work\n\n## 📊 Success Metrics\n\nTeams using Ring report:\n\n- 90% reduction in \"works on my machine\" issues\n- 75% fewer bugs reaching production\n- 60% faster debugging cycles\n- 100% of code covered by tests (enforced by TDD)\n\n## 🙏 Acknowledgments\n\nRing is built on decades of collective software engineering wisdom, incorporating patterns from:\n\n- Extreme Programming (XP)\n- Test-Driven Development (TDD)\n- Domain-Driven Design (DDD)\n- Agile methodologies\n- DevOps practices\n\nSpecial thanks to the Lerian Team for battle-testing these skills in production.\n\n## 📄 License\n\nMIT - See [LICENSE](LICENSE) file\n\n## 🔗 Links\n\n- [GitHub Repository](https://github.com/lerianstudio/ring)\n- [Issue Tracker](https://github.com/lerianstudio/ring/issues)\n- [Plugin Marketplace](https://claude.ai/marketplace/ring)\n\n---\n\n**Remember: If a skill applies to your task, you MUST use it. This is not optional.**\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2FLerianStudio%2Fring","html_url":"https://awesome.ecosyste.ms/projects/github.com%2FLerianStudio%2Fring","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2FLerianStudio%2Fring/lists"}