ring-for-opencode

Orchestrates the 6-gate development workflow for implementing tasks. Manages state, dispatches specialist agents, and enforces gate requirements.

Captures metrics and learnings from completed development cycles. Enables continuous improvement by analyzing patterns across cycles.

Controlled plan execution with human review checkpoints - loads plan, executes in batches, pauses for feedback. Supports one-go (autonomous) or batch modes.

Gate 4 of development cycle - dispatches 6 specialized reviewers (code, business-logic, security, test, nil-safety, consequences) in parallel for comprehensive code review feedback.

Guide to the dev-team skills - specialist developer agents and 6-gate development cycle. Provides backend engineers (Go/TypeScript), frontend engineers, DevOps, SRE, and QA agents.

Skill discovery workflow and agent dispatch patterns for every conversation.

Generate beautiful, self-contained HTML pages that visually explain systems, code changes, plans, and data. Use when the user asks for a diagram, architecture overview, diff review, plan review, project recap, comparison table, or any visual explanation of technical concepts. Also use proactively when you are about to render a complex ASCII table (4+ rows or 3+ columns) — present it as a styled HTML page instead.

Socratic design refinement - transforms rough ideas into validated designs through structured questioning, alternative exploration, and incremental validation.

Gate 0 of the development cycle. Executes code implementation using the appropriate specialized agent based on task content and project language. Handles TDD workflow with RED-GREEN phases. Follows project standards defined in docs/PROJECT_RULES.md.

Analyzes codebase against standards and generates refactoring tasks for ring:dev-cycle.

Parallel lint fixing pattern - runs lint checks, groups issues into independent streams, and dispatches AI agents to fix all issues until the codebase is clean.

Comprehensive Ring-standards-aligned 44-dimension production readiness audit. Detects project stack, loads Ring standards via WebFetch, and runs in batches of 10 explorers appending incrementally to a single report file. Categories - Structure (pagination, errors, routes, bootstrap, runtime, core deps, naming, domain modeling, nil-safety, api-versioning, resource-leaks), Security (auth, IDOR, SQL, validation, secret-scanning, data-encryption, multi-tenant, rate-limiting, cors), Operations (telemetry, health, config, connections, logging, resilience, graceful-degradation), Quality (idempotency, docs, debt, testing, dependencies, performance, concurrency, migrations, linting, caching), Infrastructure (containers, hardening, cicd, async, makefile, license). Produces scored report (0-430, max 440 with multi-tenant) with severity ratings and standards cross-reference.

TDD for process documentation - write test cases (pressure scenarios), watch baseline fail, write skill, iterate until bulletproof against rationalization.

Gate 1 of the development cycle. Creates containerization, local development setup, and CI/CD configuration using the ring:devops-engineer agent.

Gate 2 of the development cycle. VALIDATES that observability was correctly implemented by developers. Does NOT implement observability code - only validates it.

Gate 3 of development cycle - ensures unit test coverage meets threshold (85%+) for all acceptance criteria using TDD methodology.

Development cycle validation gate (Gate 5) - validates all acceptance criteria are met and requires explicit user approval before completion.

Autonomous two-phase codebase exploration - first discovers natural perspectives (layers, components, boundaries), then dispatches adaptive deep-dive explorers based on what was discovered. Synthesizes findings into actionable insights.

Proactive requirements gathering - systematically interviews the user to uncover ambiguities, preferences, and constraints BEFORE implementation begins.

Gate 4: API contracts document - defines component interfaces and data contracts before protocol/technology selection. Large Track only.

Gate 5: Data structures document - defines entities, relationships, and ownership before database technology selection. Large Track only.

Gate 6: Technology choices document - explicit, versioned, validated technology selections with justifications. Large Track only. HARD BLOCK: Must load Ring Standards and PROJECT_RULES.md before proceeding.

Gate 2: Feature relationship map - visualizes feature landscape, groupings, and interactions at business level before technical architecture.

Gate 1: Business requirements document - defines WHAT/WHY before HOW. Creates PRD with problem definition, user stories, success metrics.

Gate 0 research phase for pre-dev workflow. Dispatches 3 parallel research agents to gather codebase patterns, external best practices, and framework documentation BEFORE creating PRD/TRD. Outputs research.md with file:line references.

Gate 8: Zero-context implementation steps - 2-5 minute atomic subtasks with complete code, exact commands, TDD pattern. Large Track only.

Gate 7: Implementation tasks - value-driven decomposition into working increments that deliver measurable user value.

Gate 3: Technical architecture document - defines HOW/WHERE with technology-agnostic patterns before concrete implementation choices.

Review reception protocol - requires technical verification before implementing suggestions. Prevents performative agreement and blind implementation.

RED-GREEN-REFACTOR implementation methodology - write failing test first, minimal implementation to pass, then refactor. Ensures tests verify behavior.

Isolated workspace creation - creates git worktrees with smart directory selection and safety verification for parallel feature development.

10 pre-dev workflow skills + 3 research agents organized into Small Track (4 gates, <2 days) and Large Track (9 gates, 2+ days) for systematic feature planning with research-first approach.

Creates comprehensive implementation plans with exact file paths, complete code examples, and verification steps for engineers with zero codebase context.

Create detailed handoff documents for session transitions. Captures task status, learnings, decisions, and next steps in a structured format.

Lightweight 4-gate pre-dev workflow for small features (<2 days)

Complete 9-gate pre-dev workflow for large features (≥2 days)