Proven engineering practices, enforced through skills.

Ring 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 9 active plugins (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.

Without Ring, AI assistants often:

• Skip tests and jump straight to implementation
• Make changes without understanding root causes
• Claim tasks are complete without verification
• Forget to check for existing solutions
• Repeat known mistakes

Ring solves this by:

• Enforcing proven workflows - Test-driven development, systematic debugging, proper planning
• Providing 90 specialized skills - Complete coverage from finance to operations (26 core + 9 dev-team + 10 product planning + 6 FinOps regulatory + 8 finance ops + 8 production ops + 8 product marketing + 8 PMO + 7 technical writing)
• 44 specialized agents - 5 review/planning + 9 developer + 3 product research + 2 FinOps regulatory + 6 finance + 5 operations + 6 product marketing + 5 PMO + 3 technical writing
• Automating skill discovery - Skills load automatically at session start
• Preventing common failures - Built-in anti-patterns and mandatory checklists

Review & Planning Agents (default plugin):

• code-reviewer - Foundation review (architecture, code quality, design patterns)
• business-logic-reviewer - Correctness review (domain logic, requirements, edge cases)
• security-reviewer - Safety review (vulnerabilities, OWASP, authentication)
• write-plan - Implementation planning agent
• codebase-explorer - Deep architecture analysis (Opus-powered, complements built-in Explore)
• Use /codereview command to orchestrate parallel review workflow

Developer Agents (dev-team plugin):

• backend-engineer-golang - Go backend specialist for financial systems
• backend-engineer-typescript - TypeScript/Node.js backend specialist (Express, NestJS, Fastify)
• devops-engineer - DevOps infrastructure specialist
• frontend-bff-engineer-typescript - BFF & React/Next.js frontend with Clean Architecture
• frontend-designer - Visual design specialist
• qa-analyst - Quality assurance specialist
• sre - Site reliability engineer
• frontend-engineer - Senior Frontend Engineer (React/Next.js)
• prompt-quality-reviewer - Agent Quality Analyst

Standards Compliance: All dev-team agents include a ## Standards Compliance output section with conditional requirement:

• Optional when invoked directly or via dev-cycle
• MANDATORY when invoked from dev-refactor (triggered by **MODE: ANALYSIS ONLY** in prompt)

When mandatory, agents load Ring standards via WebFetch and produce comparison tables with:

• Current Pattern vs Expected Pattern
• Severity classification (Critical/High/Medium/Low)
• File locations and migration recommendations

See dev-team/docs/standards/*.md for standards source. Cross-references: CLAUDE.md (Standards Compliance section), dev-team/skills/dev-refactor/SKILL.md

FinOps Agents (ring-finops-team plugin):

• finops-analyzer - Financial operations analysis
• finops-automation - FinOps template creation and automation

Technical Writing Agents (ring-tw-team plugin):

• functional-writer - Functional documentation (guides, tutorials, conceptual docs)
• api-writer - API reference documentation (endpoints, schemas, examples)
• docs-reviewer - Documentation quality review (voice, tone, structure, completeness)

Financial Operations Agents (ring-finance-team plugin):

• financial-analyst - Financial statement analysis, ratio analysis, trend analysis
• budget-planner - Annual budgets, rolling forecasts, variance analysis
• financial-modeler - DCF valuation, LBO models, M&A models, scenario analysis
• treasury-specialist - Cash flow forecasting, liquidity management, working capital
• accounting-specialist - Journal entries, reconciliations, month-end close
• metrics-analyst - KPI definition, dashboard design, anomaly detection

Production Operations Agents (ring-ops-team plugin):

• platform-engineer - Service mesh, API gateways, developer platforms
• incident-responder - Production incidents, RCA, post-mortems
• cloud-cost-optimizer - Cost analysis, reserved instances, FinOps practices
• infrastructure-architect - Multi-region architecture, DR, capacity planning
• security-operations - Security audits, compliance, vulnerability management

Product Marketing Agents (ring-pmm-team plugin):

• market-researcher - TAM/SAM/SOM analysis, market segmentation, trend analysis
• positioning-strategist - Differentiation strategy, category design, positioning
• messaging-specialist - Value propositions, messaging frameworks, proof points
• gtm-planner - Go-to-market strategy, channel selection, campaign planning
• launch-coordinator - Launch checklists, stakeholder coordination, day-of execution
• pricing-analyst - Pricing models, competitive pricing, value-based pricing

Portfolio Management Agents (ring-pmo-team plugin):

• portfolio-manager - Multi-project coordination, strategic alignment, portfolio optimization
• resource-planner - Capacity planning, allocation optimization, conflict resolution
• governance-specialist - Gate reviews, process compliance, audit readiness
• risk-analyst - Risk identification, RAID logs, mitigation planning
• executive-reporter - Executive dashboards, board packages, stakeholder communication

Plugin versions are managed in .claude-plugin/marketplace.json

Ring works across multiple AI development platforms:

Transformation Notes:

• Claude Code receives Ring content in its native format
• Factory AI: agents → droids terminology
• Cursor: Skills/agents → .cursorrules and workflows
• Cline: All content → structured prompts

Platform-Specific Guides:

• Claude Code Installation Guide - Native format setup and usage
• Factory AI Installation Guide - Droids transformation and configuration
• Cursor Installation Guide - Rules and workflow setup
• Cline Installation Guide - Prompt-based configuration
• Migration Guide - Moving between platforms or upgrading

The Ring installer automatically detects installed platforms and transforms content appropriately.

Linux/macOS/Git Bash:

# Interactive installer (auto-detects platforms)
curl -fsSL https://raw.githubusercontent.com/lerianstudio/ring/main/install-ring.sh | bash

# Or clone and run locally
git clone https://github.com/lerianstudio/ring.git ~/ring
cd ~/ring
./installer/install-ring.sh

Windows PowerShell:

# Interactive installer (auto-detects platforms)
irm https://raw.githubusercontent.com/lerianstudio/ring/main/install-ring.ps1 | iex

# Or clone and run locally
git clone https://github.com/lerianstudio/ring.git $HOME\ring
cd $HOME\ring
.\installer\install-ring.ps1

Install to specific platforms without the interactive menu:

# Install to Claude Code only (native format)
./installer/install-ring.sh install --platforms claude

# Install to Factory AI only (droids format)
./installer/install-ring.sh install --platforms factory

# Install to multiple platforms
./installer/install-ring.sh install --platforms claude,cursor,cline

# Install to all detected platforms
./installer/install-ring.sh install --platforms auto

# Dry run (preview changes without installing)
./installer/install-ring.sh install --platforms auto --dry-run

# List installed platforms and versions
./installer/install-ring.sh list

# Update existing installation
./installer/install-ring.sh update

# Check for available updates
./installer/install-ring.sh check

# Sync (update only changed files)
./installer/install-ring.sh sync

# Uninstall from specific platform
./installer/install-ring.sh uninstall --platforms cursor

# Detect available platforms
./installer/install-ring.sh detect

For Claude Code users, you can also install from the marketplace:

• Open Claude Code
• Go to Settings → Plugins
• Search for "ring"
• Click Install

# Clone the marketplace repository
git clone https://github.com/lerianstudio/ring.git ~/ring

# Skills auto-load at session start via hooks
# No additional configuration needed for Claude Code

When you start a new Claude Code session with Ring installed, you'll see:

## Available Skills:
- using-ring (Check for skills BEFORE any task)
- test-driven-development (RED-GREEN-REFACTOR cycle)
- systematic-debugging (4-phase root cause analysis)
- verification-before-completion (Evidence before claims)
... and 50 more skills

Before ANY action → Check skills
Before ANY tool → Check skills
Before ANY code → Check skills

RED → Write failing test → Watch it fail
GREEN → Minimal code → Watch it pass
REFACTOR → Clean up → Stay green

Phase 1: Investigate (gather ALL evidence)
Phase 2: Analyze patterns
Phase 3: Test hypothesis (one at a time)
Phase 4: Implement fix (with test)

Run command → Paste output → Then claim
No "should work" → Only "does work" with proof

Testing & Debugging (7):

• test-driven-development - Write test first, watch fail, minimal code
• systematic-debugging - 4-phase root cause investigation
• verification-before-completion - Evidence before claims
• testing-anti-patterns - Common test pitfalls to avoid
• condition-based-waiting - Replace timeouts with conditions
• defense-in-depth - Multi-layer validation
• linting-codebase - Parallel lint fixing with agent dispatch

Collaboration & Planning (11):

• brainstorming - Structured design refinement
• interviewing-user - Proactive requirements gathering through structured interview
• writing-plans - Zero-context implementation plans
• executing-plans - Batch execution with checkpoints
• requesting-code-review - Parallel 3-reviewer dispatch with severity-based handling
• receiving-code-review - Responding to feedback
• dispatching-parallel-agents - Concurrent workflows
• subagent-driven-development - Fast iteration with parallel reviews
• using-git-worktrees - Isolated development
• finishing-a-development-branch - Merge/PR decisions
• root-cause-tracing - Backward bug tracking

Meta Skills (4):

• using-ring - Mandatory skill discovery
• writing-skills - TDD for documentation
• testing-skills-with-subagents - Skill validation
• testing-agents-with-subagents - Subagent-specific testing

Session & Learning (5):

• handoff-tracking - Task handoff management and session continuity
• compound-learnings - Pattern detection from session history
• artifact-query - Semantic search over past artifacts
• exploring-codebase - Two-phase codebase exploration
• doubt-triggered-questions - Decision hierarchy for asking vs proceeding

Code Development:

• using-dev-team - Introduction to developer specialist agents
• dev-refactor - Codebase analysis against standards
• dev-cycle - 6-gate development workflow orchestrator

6-Gate Workflow Skills:

• dev-implementation - Gate 0: TDD implementation
• dev-devops - Gate 1: DevOps setup (Docker, compose)
• dev-sre - Gate 2: Observability setup
• dev-testing - Gate 3: Test coverage
• requesting-code-review - Gate 4: Parallel code review (3 reviewers)
• dev-validation - Gate 5: User approval
• dev-feedback-loop - Assertiveness scoring and metrics

Pre-Development Workflow (includes using-pm-team + 9 gates):

• using-pm-team - Introduction to product planning workflow

0. pre-dev-research - Research phase (parallel agents)
1. pre-dev-prd-creation - Business requirements (WHAT/WHY)
2. pre-dev-feature-map - Feature relationships
3. pre-dev-trd-creation - Technical architecture (HOW)
4. pre-dev-api-design - Component contracts
5. pre-dev-data-model - Entity relationships
6. pre-dev-dependency-map - Technology selection
7. pre-dev-task-breakdown - Work increments
8. pre-dev-subtask-creation - Atomic units

Regulatory Templates (6):

• using-finops-team - Introduction to FinOps team workflow
• regulatory-templates - Brazilian regulatory orchestration (BACEN, RFB)
• regulatory-templates-setup - Template selection initialization
• regulatory-templates-gate1 - Compliance analysis and field mapping
• regulatory-templates-gate2 - Field mapping validation
• regulatory-templates-gate3 - Template file generation

Documentation Creation:

• using-tw-team - Introduction to technical writing specialists
• writing-functional-docs - Patterns for guides, tutorials, conceptual docs
• writing-api-docs - API reference documentation patterns
• documentation-structure - Document hierarchy and organization
• voice-and-tone - Voice and tone guidelines (assertive, encouraging, human)
• documentation-review - Quality checklist and review process
• api-field-descriptions - Field description patterns by type

Ring provides 35 slash commands across 9 plugins for common workflows.

• /codereview [files-or-paths] - Dispatch 3 parallel code reviewers for comprehensive review
• /commit [message] - Create git commit with AI identification via Git trailers
• /worktree [branch-name] - Create isolated git workspace for parallel development
• /brainstorm [topic] - Interactive design refinement using Socratic method
• /write-plan [feature] - Create detailed implementation plan with bite-sized tasks
• /execute-plan [path] - Execute plan in batches with review checkpoints
• /lint [path] - Run lint checks and dispatch parallel agents to fix all issues
• /explore-codebase [path] - Deep codebase exploration using Opus-powered agent
• /create-handoff [task] - Create task handoff document for session continuity
• /resume-handoff [path] - Resume work from a previous handoff
• /query-artifacts [query] - Search indexed artifacts for precedent
• /compound-learnings - Extract learnings from session history

• /pre-dev-feature [feature-name] - Lightweight 4-gate pre-dev workflow for small features (<2 days)
• /pre-dev-full [feature-name] - Complete 9-gate pre-dev workflow for large features (>=2 days)

• /dev-cycle [task] - Start 6-gate development workflow (implementation→devops→SRE→testing→review→validation)
• /dev-refactor [path] - Analyze codebase against standards
• /dev-status - Show current gate progress
• /dev-report - Generate development cycle report
• /dev-cancel - Cancel active development cycle

• /write-guide [topic] - Start writing a functional guide with voice/tone guidance
• /write-api [endpoint] - Start writing API reference documentation
• /review-docs [file] - Review existing documentation for quality

User: "Add user authentication to the app"
Claude: I'm using the brainstorming skill to design this feature...
        [Structured exploration of requirements]
Claude: I'm using test-driven-development to implement...
        [RED-GREEN-REFACTOR cycle for each component]
Claude: I'm using verification-before-completion to confirm...
        [Runs tests, shows actual output]

User: "The app crashes when clicking submit"
Claude: I'm using systematic-debugging to investigate...
        Phase 1: [Gathering evidence]
        Phase 2: [Pattern analysis]
        Phase 3: [Hypothesis testing]
        Phase 4: [Implementing fix with test]

User: "Plan an e-commerce platform"
Claude: I'll use the pre-dev workflow to plan this systematically...
        Gate 1: PRD Creation [Business requirements]
        Gate 2: Feature Map [Domain groupings]
        Gate 3: TRD Creation [Architecture patterns]
        ... [Through all 8 gates]

User: "Review my authentication implementation"
Claude: Dispatching all 3 reviewers in parallel...
        [Launches code-reviewer, business-logic-reviewer, security-reviewer simultaneously]

        Code reviewer: PASS. Clean architecture, good tests.
        Business reviewer: FAIL. Missing password reset flow (HIGH severity).
        Security reviewer: FAIL. JWT secret hardcoded (CRITICAL severity).

        Aggregating issues by severity:
        - CRITICAL: JWT secret hardcoded in auth.ts:42
        - HIGH: Password reset flow missing from requirements

        Dispatching fix subagent to address Critical/High issues...
        [Fixes applied]

        Re-running all 3 reviewers in parallel...
        All reviewers: PASS. Ready for production.

Key benefits:

• 3x faster - All reviewers run simultaneously (not sequential)
• Comprehensive - Get all feedback at once, easier to prioritize
• Tech debt tracking - Low/Cosmetic issues tracked with TODO/FIXME comments in code
• Model-specific - All reviewers run on Opus for deep analysis

Monorepo Marketplace - Multiple specialized plugin collections:

ring/                                  # Monorepo root
├── .claude-plugin/
│   └── marketplace.json              # Multi-plugin marketplace config (9 active plugins)
├── default/                          # Core Ring plugin (ring-default)
│   ├── skills/                       # 26 core skills
│   │   ├── skill-name/
│   │   │   └── SKILL.md             # Skill definition with frontmatter
│   │   └── shared-patterns/         # Universal patterns (6 patterns)
│   ├── commands/                    # 12 slash command definitions
│   ├── hooks/                       # Session initialization
│   │   ├── hooks.json              # Hook configuration
│   │   ├── session-start.sh        # Loads skills at startup
│   │   └── generate-skills-ref.py  # Auto-generates quick reference
│   ├── agents/                      # 5 specialized agents
│   │   ├── code-reviewer.md        # Foundation review (parallel)
│   │   ├── business-logic-reviewer.md  # Correctness review (parallel)
│   │   ├── security-reviewer.md    # Safety review (parallel)
│   │   ├── write-plan.md           # Implementation planning
│   │   └── codebase-explorer.md    # Deep architecture analysis (Opus)
│   └── docs/                       # Documentation
├── dev-team/                      # Developer Agents plugin (ring-dev-team)
│   └── agents/                      # 7 specialized developer agents
│       ├── backend-engineer-golang.md  # Go backend specialist
│       ├── backend-engineer-typescript.md # TypeScript/Node.js backend specialist
│       ├── devops-engineer.md          # DevOps infrastructure
│       ├── frontend-bff-engineer-typescript.md # BFF & React/Next.js frontend specialist
│       ├── frontend-designer.md        # Visual design specialist
│       ├── qa-analyst.md               # Quality assurance
│       └── sre.md                      # Site reliability engineer
├── finops-team/                     # FinOps plugin (ring-finops-team)
│   ├── skills/                      # 6 regulatory compliance skills
│   │   └── regulatory-templates*/   # Brazilian regulatory compliance
│   ├── agents/                      # 2 FinOps agents
│   │   ├── finops-analyzer.md      # FinOps analysis
│   │   └── finops-automation.md    # FinOps automation
│   └── docs/
│       └── regulatory/             # Brazilian regulatory documentation
├── pm-team/                    # Product Planning plugin (ring-pm-team)
│   └── skills/                      # 10 pre-dev workflow skills
│       └── pre-dev-*/              # PRD, TRD, API, Data, Tasks
├── tw-team/                         # Technical Writing plugin (ring-tw-team)
│   ├── skills/                      # 7 documentation skills
│   ├── agents/                      # 3 technical writing agents
│   ├── commands/                    # 3 slash commands
│   └── hooks/                       # SessionStart hook
├── ops-team/                        # Production operations (8 skills, 5 agents, 4 commands)
└── pmm-team/                        # Product marketing (8 skills, 6 agents, 3 commands)

For core Ring skills:

1. Create the skill directory

   mkdir default/skills/your-skill-name

2. Write SKILL.md with frontmatter

   ---
   name: your-skill-name
   description: |
     Brief description of WHAT this skill does (the method/technique).
     1-2 sentences maximum.
   
   trigger: |
     - Specific condition that mandates using this skill
     - Another trigger condition
     - Use quantifiable criteria when possible
   
   skip_when: |
     - When NOT to use this skill → alternative
     - Another exclusion condition
   
   sequence:
     after: [prerequisite-skill]   # Skills that should come before
     before: [following-skill]     # Skills that typically follow
   
   related:
     similar: [skill-that-seems-similar]      # Differentiate from these
     complementary: [skill-that-pairs-well]   # Use together with these
   ---
   
   # Skill content here...

   Schema fields explained:

   • name: Skill identifier (matches directory name)
   • description: WHAT the skill does (method/technique)
   • trigger: WHEN to use - specific, quantifiable conditions
   • skip_when: WHEN NOT to use - differentiates from similar skills
   • sequence: Workflow ordering (optional)
   • related: Similar/complementary skills for disambiguation (optional)

3. Update documentation

   • Skills auto-load via default/hooks/generate-skills-ref.py
   • Test with session start hook

4. Submit PR

   git checkout -b feat/your-skill-name
   git add default/skills/your-skill-name
   git commit -m "feat(skills): add your-skill-name for X"
   gh pr create

For product/team-specific skills:

1. Create plugin structure

   mkdir -p product-xyz/{skills,agents,commands,hooks,lib}

2. Register in marketplace Edit .claude-plugin/marketplace.json:

   {
     "name": "ring-product-xyz",
     "description": "Product XYZ specific skills",
     "version": "0.1.0",
     "source": "./product-xyz",
     "homepage": "https://github.com/lerianstudio/ring/tree/product-xyz"
   }

3. Follow core plugin structure

   • Use same layout as default/
   • Create product-xyz/hooks/hooks.json for initialization
   • Add skills to product-xyz/skills/

• Mandatory sections: When to use, How to use, Anti-patterns
• Include checklists: TodoWrite-compatible task lists
• Evidence-based: Require verification before claims
• Battle-tested: Based on real-world experience
• Clear triggers: Unambiguous "when to use" conditions

• Skills Quick Reference - Auto-generated at session start from skill frontmatter
• CLAUDE.md - Repository guide for Claude Code
• MANUAL.md - Quick reference for all commands, agents, and workflows
• Design Documents - Implementation plans and architecture decisions
• Platform Guides:
  • Claude Code - Native format setup
  • Factory AI - Droids transformation
  • Cursor - Rules and workflows
  • Cline - Prompt-based setup
  • Migration - Platform switching and upgrades

Ring embodies these principles:

1. Skills are mandatory, not optional - If a skill applies, it MUST be used
2. Evidence over assumptions - Prove it works, don't assume
3. Process prevents problems - Following workflows prevents known failures
4. Small steps, verified often - Incremental progress with continuous validation
5. Learn from failure - Anti-patterns document what doesn't work

Teams using Ring report:

• 90% reduction in "works on my machine" issues
• 75% fewer bugs reaching production
• 60% faster debugging cycles
• 100% of code covered by tests (enforced by TDD)

Ring is built on decades of collective software engineering wisdom, incorporating patterns from:

• Extreme Programming (XP)
• Test-Driven Development (TDD)
• Domain-Driven Design (DDD)
• Agile methodologies
• DevOps practices

Special thanks to the Lerian Team for battle-testing these skills in production.

MIT - See LICENSE file

• GitHub Repository
• Issue Tracker
• Plugin Marketplace

Remember: If a skill applies to your task, you MUST use it. This is not optional.