
Analyzes a Go service using lib-commons v2/v3 and generates a visual migration report showing every change needed to upgrade to lib-commons v4. Produces an interactive HTML page (via ring:visualize) and optionally generates refactoring tasks for ring:dev-cycle.
Complete budgeting and forecasting workflow covering annual budgets, departmental budgets, rolling forecasts, and variance analysis. Delivers documented budgets with approval trails.
Cash flow analysis and treasury management workflow covering liquidity assessment, cash forecasting, working capital optimization, and treasury operations.
Competitive intelligence skill for analyzing competitive landscape, creating battlecards, and tracking competitor movements.
Gate 7 of development cycle - ensures chaos tests exist using Toxiproxy to verify graceful degradation under connection loss, latency, and partitions.
Delivery Verification Gate — verifies that what was requested is actually delivered as reachable, integrated code. Not quality review (Gate 8), not test verification (Gate 9) — this gate answers: "Is every requirement from the original task actually functioning in the running application?" Applies to ANY task type: features, refactors, fixes, infrastructure, API endpoints, middleware, business logic, integrations.
Creates or audits Dockerfiles and Docker image configurations to achieve Docker Hub Health Score grade A. Enforces all evaluable security policies and supply chain best practices.
Gate 2 of frontend development cycle - ensures all components pass axe-core automated accessibility scans with zero WCAG 2.1 AA violations.
Implements comprehensive readiness probes (/readyz) and startup self-probes for Lerian services. Goes beyond basic K8s liveness: validates every external dependency (database, cache, queue, TLS handshakes) and exposes per-dependency status with latency and TLS info. Designed to be consumed by Tenant Manager post-provisioning. Origin: Monetarie SaaS incident — product-console started successfully but MongoDB was silently unreachable (TLS mismatch with DocumentDB). K8s liveness passed, traffic routed, client hit errors. This skill ensures that never happens again.
Gate 6 of frontend development cycle - ensures Core Web Vitals compliance, Lighthouse performance score > 90, and bundle size within budget.
Gate 4 of development cycle - ensures fuzz tests exist with proper seed corpus to discover edge cases, crashes, and unexpected input handling.
Gate 6 of development cycle - ensures integration tests pass for all external dependency interactions using real containers via testcontainers.
Generates or audits llms.txt files for Lerian repositories following the llmstxt.org specification. Creates LLM-friendly entry points that help AI agents, coding assistants, and chat models understand a project quickly without parsing full HTML docs. Also generates CLAUDE.md / AGENTS.md when missing.
Analyzes frontend codebase against Ring standards and generates refactoring tasks for ring:dev-cycle-frontend. Dispatches frontend-specific agents in ANALYSIS mode.
Gate 2 of the development cycle. VALIDATES that observability was correctly implemented by developers. Does not implement observability code - only validates it.
Patterns for organizing and structuring documentation including hierarchy, navigation, and information architecture.
Initial setup sub-skill - handles template selection and context initialization for the 5-stage regulatory workflow. Supports any regulatory template (pre-defined or new) via official spec intake (URL/XSD/PDF).
Comprehensive financial analysis workflow covering ratio analysis, trend analysis, benchmarking, and variance analysis. Delivers documented, audit-ready insights.
Month-end and year-end close workflow covering journal entries, reconciliations, close procedures, and audit preparation. Delivers accurate, timely close with full audit trail.
Send tasks to Gandalf (AI team member) via webhook and get responses back. Publish to Alfarrábio, send Slack notifications, ask for business context, and more.
Orchestrates infrastructure cost estimation with tier-based or custom TPS sizing. Offers pre-configured tiers (Starter/Growth/Business/Enterprise) or custom TPS input. Skill discovers components, asks shared/dedicated for EACH, selects environment(s), reads actual Helm chart configs, then dispatches agent for accurate calculations.
KPI and metrics dashboard workflow covering metric definition, data sourcing, visualization design, and anomaly detection. Delivers actionable dashboards.
Structured workflow for infrastructure capacity planning including growth forecasting, scaling strategy, and resource provisioning decisions.
Structured workflow for disaster recovery planning, implementation, and testing including RTO/RPO definition, DR strategy selection, and failover procedures.
Structured workflow for infrastructure migration planning including cloud migrations, technology upgrades, and data center transitions.
Structured workflow for onboarding new services to the internal platform including infrastructure provisioning, observability setup, and documentation.
Portfolio retrospective skill for capturing lessons learned, process improvements, and organizational learning across completed projects.
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.
Lightweight 5-gate pre-dev workflow for small features (<2 days). Orchestrates topology discovery, research, PRD with UX validation, design validation, TRD, task breakdown, and delivery planning in a sequential gated process with human approval at each gate.
Gate 1: Business requirements document - defines WHAT/WHY before HOW. Creates PRD with problem definition, user stories, success metrics.
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.
Pricing analysis skill for developing pricing models, competitive pricing analysis, and pricing recommendations for products and features.
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.
Individual project health assessment skill for evaluating project status across multiple dimensions. Provides early warning of troubled projects.
5-stage regulatory template orchestrator - manages setup, Gate 1 (analysis + auto-save), Gate 2 (validation), Gate 3 (generation), optional Test Gate, optional Contribution Gate. Supports any regulatory template (BACEN, RFB, CVM, SUSEP, COAF, or other).
Portfolio-level risk management skill for identifying, assessing, and mitigating risks across multiple projects. Maintains RAID logs and tracks risk responses.
Four-phase debugging framework - root cause investigation, pattern analysis, hypothesis testing, implementation. Ensures understanding before attempting fixes.
RED-GREEN-REFACTOR implementation methodology - write failing test first, minimal implementation to pass, then refactor. Ensures tests verify behavior.
Agent testing methodology - run agents with test inputs, observe outputs, iterate until outputs are accurate and well-structured.
Skill testing methodology - run scenarios without skill (RED), observe failures, write skill (GREEN), close loopholes (REFACTOR).
9 specialist developer agents for backend (Go/TypeScript), DevOps, frontend, design, UI implementation, QA (backend + frontend), and SRE. Dispatch when you need deep technology expertise.
3 FinOps agents: 2 for Brazilian financial regulatory compliance (BACEN, RFB, Open Banking), 1 for infrastructure cost estimation when onboarding customers. Supports any regulatory template via open intake system.
5 specialist operations agents for platform engineering, incident response, cloud cost optimization, infrastructure architecture, and security operations. Dispatch when you need production operations expertise.
12 pre-dev workflow skills + 4 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.
Mandatory orchestrator protocol - establishes ORCHESTRATOR principle (dispatch agents, don't operate directly) and skill discovery workflow for every conversation.
Technical writing specialists for functional and API documentation. Dispatch when you need to create guides, conceptual docs, or API references following established documentation standards.
Financial modeling workflow for DCF, LBO, merger, and operating models. Delivers validated, documented models with sensitivity and scenario analysis.
Financial reporting workflow covering report preparation, management reporting, board presentations, and investor communications. Delivers polished, accurate reports.
6 specialist financial agents for analysis, budgeting, modeling, treasury, accounting, and metrics. Dispatch when you need deep financial expertise.
Structured workflow for cloud cost analysis and optimization including rightsizing, reserved capacity planning, and FinOps practices.
Structured workflow for production incident management following SRE best practices. Covers incident declaration, triage, coordination, resolution, and post-mortem.
Structured workflow for infrastructure security audits including compliance validation, vulnerability assessment, and security posture review.
Go-to-market planning skill for developing channel strategy, tactics, timeline, and budget allocation for product launches.
Launch coordination skill for managing launch checklists, stakeholder alignment, and day-of execution for product and feature launches.
Systematic market analysis skill for understanding market size, segmentation, trends, and opportunities. Produces quantified market intelligence.
Messaging framework skill for developing value propositions, proof points, and consistent messaging across audiences and channels.
Strategic positioning skill for developing differentiated market position, positioning statements, and competitive framing.
7 product marketing skills + 6 specialist agents for go-to-market strategy, positioning, messaging, competitive intelligence, and launch coordination.
Socratic design refinement - transforms rough ideas into validated designs through structured questioning, alternative exploration, and incremental validation.
Generate Mermaid diagrams from context and open them in mermaid.live in the browser. Use when the user asks for a diagram, visualization, flowchart, sequence diagram, ER diagram, or any visual representation of code, architecture, or processes. Produces lightweight, shareable mermaid.live URLs that open in the browser for interactive editing.
Controlled plan execution with human review checkpoints - loads plan, executes in batches, pauses for feedback. Supports one-go (autonomous) or batch modes.
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.
Smart commit organization with atomic grouping, conventional commits, and trailer management
Proactive requirements gathering - systematically interviews the user to uncover ambiguities, preferences, and constraints BEFORE implementation begins.
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.
Generate Ops Update Guide from Git Diff. Produces internal Operations-facing update/migration guides based on git diff analysis. Supports STRICT_NO_TOUCH (default) and TEMP_CLONE_FOR_FRESH_REFS modes. Includes tag auto-detection and commit log analysis.
Gate 4 of development cycle - dispatches 7 specialized reviewers (code, business-logic, security, test, nil-safety, consequences, dead-code) in parallel for comprehensive code review feedback.
Create handoff documents capturing session state for seamless context-clear and resume
Test quality guard - prevents testing mock behavior, production pollution with test-only methods, and mocking without understanding dependencies.
Isolated workspace creation - creates git worktrees with smart directory selection and safety verification for parallel feature development.
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.
Creates comprehensive implementation plans with exact file paths, complete code examples, and verification steps for engineers with zero codebase context.
TDD for process documentation - write test cases (pressure scenarios), watch baseline fail, write skill, iterate until bulletproof against rationalization.
Development cycle state management — status reporting and cycle cancellation
Frontend development cycle orchestrator with 9 gates. Loads tasks from PM team output or backend handoff and executes through implementation → devops → accessibility → unit testing → visual testing → E2E testing → performance testing → review → validation.
Main orchestrator for the 10-gate development cycle system. Loads tasks/subtasks from PM team output and executes through implementation → devops → SRE → unit testing → fuzz testing → property testing → integration testing (write) → chaos testing (write) → review → validation gates (Gates 0-9), with state persistence and metrics collection. Gates 6-7 (integration/chaos) write and update test code per unit but only execute tests at end of cycle (deferred execution). Multi-tenant dual-mode is implemented during Gate 0 and verified at Gate 0.5G (no separate post-cycle step).
Intercepts and audits dependency installations (pip, npm, go) before they execute. Validates package identity, checks for known vulnerabilities, flags suspicious signals (new package, single maintainer, recent name change), and enforces hash pinning in lockfiles. Acts as a supply-chain gate for every `install` command in a Lerian codebase.
Gate 1 of the development cycle. Creates/updates Docker configuration, docker-compose setup, and environment variables for local development and deployment readiness.
Development cycle feedback system - calculates assertiveness scores, analyzes prompt quality for all agents executed, aggregates cycle metrics, performs root cause analysis on failures, and generates improvement reports to docs/feedbacks/cycle-{date}/.
Gate 5 of frontend development cycle - ensures all user flows from product-designer have passing E2E tests with Playwright across browsers.
Goroutine leak detection skill - detects goroutine usage in Go code, runs goleak to identify memory leaks, and dispatches ring:backend-engineer-golang to fix leaks and create regression tests using the goleak framework.
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 a Go service using lib-commons v2/v3 and generates a visual migration report showing every change needed to upgrade to lib-commons v4. Produces an interactive HTML page (via ring:visual-explainer) and optionally generates refactoring tasks for ring:dev-cycle.
Multi-tenant development cycle orchestrator following Ring Standards. Auto-detects the service stack (PostgreSQL, MongoDB, Redis, RabbitMQ, S3) and whether the service has targetServices declared, then executes a gate-based implementation using tenantId from JWT for database-per-tenant isolation via lib-commons v4 tenant-manager sub-packages (postgres.Manager, mongo.Manager). Uses event-driven tenant discovery (Redis Pub/Sub via EventListener, TenantCache, TenantLoader) instead of polling-based discovery. TenantMiddleware with WithPG/WithMB variadic options handles both single-module and multi-module services. For services with targetServices: includes mandatory M2M credential retrieval from AWS Secrets Manager via lib-commons v4 secretsmanager package (per-tenant authentication with target service APIs). MUST update lib-commons v4 first; lib-auth v2 depends on it. Both are required dependencies. Each gate dispatches ring:backend-engineer-golang with context and section references. The agent loads multi-tenant.md via WebFetch and has all code examples.
Gate 5 of development cycle - ensures property-based tests exist to verify domain invariants hold for all randomly generated inputs.
Analyzes backend codebase (Go/TypeScript) against standards and generates refactoring tasks for ring:dev-cycle. For frontend projects, use ring:dev-refactor-frontend instead.
Scans the current Go project and identifies the Service → Module → Resource hierarchy for tenant-manager registration. Detects service name and type, modules (via WithModule or component structure), resources per module (PostgreSQL, MongoDB, RabbitMQ), and database names for each resource. Redis is excluded (managed via key prefixing). Produces a visual HTML report for human decision-making. Additionally detects MongoDB index definitions (both in-code EnsureIndexes and scripts/mongodb/*.js files), generates index creation scripts for any gaps, and uploads them to S3 for use during dedicated tenant database provisioning. Also detects database names per module, cross-references them across modules to find shared databases, and flags them for single-provision in tenant-manager.
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.
Gate-based systemplane migration orchestrator. Migrates Lerian Go services from .env/YAML-based configuration to the systemplane — a database-backed, hot-reloadable runtime configuration and settings management plane with full audit history, optimistic concurrency, change feeds, component-granular bundle rebuilds, and atomic infrastructure replacement. Requires lib-commons v4.3.0+.
Comprehensive reference for lib-commons v4.6.0 — Lerian's shared Go library providing 35+ packages across database connections, messaging, multi-tenancy, runtime configuration, observability, security, resilience, HTTP tooling, and event-driven tenant discovery. Load this skill to discover available APIs, find the right package, and learn correct initialization patterns.
Gate 1 sub-skill - performs regulatory compliance analysis, field mapping, batch approval by confidence level, and auto-saves dictionary after approval. Supports both pre-defined templates (dictionary exists) and new templates (any spec).
Gate 2 sub-skill - validates uncertain mappings from Gate 1 and confirms all field specifications through testing.
Gate 3 sub-skill - generates complete .tpl template file with all validated mappings from Gates 1-2.
<!-- NOTE: This fixture intentionally uses ambiguous ring: shorthand to test the adapter transformation logic. DO NOT change to format. See installer/ring_installer/adapters/factory.py for transformation tests. --> --- name: sample-skill description: | A sample skill for testing the Ring multi-platform installer. This skill demonstrates the full frontmatter structure. trigger: | - When testing transformer functionality - When validating platform-specific conversions - When running in
Delivery status tracking and progress reporting. Analyzes repository against delivery roadmap to calculate actual vs planned progress, identify delays, and provide insights on velocity and risk trends.
Manage the Lerian Map platform — maintain products, features, iterations, and delivery roadmaps via REST API. Enforces Lerian naming/tagging standards, keeps map data in sync with repository activity, and supports TPMs/PMs in keeping the map 100% accurate.
Gate 4: API contracts document - defines component interfaces and data contracts before protocol/technology selection. Large Track only.
Gate 9 (Full Track) / Gate 4 (Small Track): Delivery roadmap and timeline planning. Transforms tasks into realistic delivery schedule with critical path analysis, resource allocation, and delivery breakdown. MANDATORY gate for both workflows.
Gate 1.5/2.5: Design Validation - verifies UX specifications are complete before proceeding to technical architecture. Checklist-based validation that prevents incomplete designs from reaching implementation.
Gate 2: Feature relationship map - visualizes feature landscape, groupings, and interactions at business level before technical architecture.
Complete 10-gate pre-dev workflow for large features (>=2 days). Orchestrates topology discovery, research, PRD, feature map, design validation, TRD, API design, data model, dependency map, task breakdown, subtask creation, and delivery planning in a sequential gated process with human approval at each gate.
Mandatory skill for creating and maintaining Helm charts following Lerian conventions. Enforces standardized chart structure, values organization, template patterns, security defaults, and dependency management.
Delivery reporting skill for creating visual executive presentations of squad deliveries (engineering, product, design). Analyzes Git repositories to extract business value from technical changes and generates HTML slide presentations with customizable visual identity.
Cross-project dependency mapping and analysis skill for identifying, tracking, and managing dependencies across portfolio projects.
Executive communication and reporting skill for creating dashboards, status summaries, and board packages. Focuses on actionable insights for leadership.
Strategic portfolio planning skill for multi-project coordination, capacity assessment, and portfolio optimization. Provides framework for portfolio-level decision making.
Resource capacity planning and allocation skill for managing people and skills across multiple projects. Identifies conflicts, gaps, and optimization opportunities.
6 specialist PMO agents for portfolio management, resource planning, governance, risk analysis, executive reporting, and delivery reporting. Dispatch when you need portfolio-level oversight.
Patterns for writing clear, consistent API field descriptions including types, constraints, examples, and edge cases.
Patterns and structure for writing functional documentation including guides, conceptual explanations, tutorials, and best practices documentation.
Gate 4 of frontend development cycle - ensures all components have snapshot tests covering all states, viewports, and edge cases.
Comprehensive checklist and process for reviewing documentation quality including voice, tone, structure, completeness, and technical accuracy.
Gate 0 research phase for pre-dev workflow. Dispatches 4 parallel research agents to gather codebase patterns, external best practices, framework documentation, and UX/product research BEFORE creating PRD/TRD. Outputs research.md with file:line references and user research findings.
Patterns and structure for writing API reference documentation including endpoint descriptions, request/response schemas, and error documentation.
Voice and tone guidelines for technical documentation. Ensures consistent, clear, and human writing across all documentation.
Gate 3: Technical architecture document - defines HOW/WHERE with technology-agnostic patterns before concrete implementation choices.