igmarin/rails-agent-skills
Curated library of AI agent skills for Ruby on Rails development. Covers code review, architecture, security, testing (RSpec), engines, service objects, DDD patterns, and workflow automation.
73
91%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
86%
Use when creating or modifying REST API endpoints (Rails controllers, engine routes, API actions). Requires generating or updating an API Collection file (e.g., Postman Collection v2.1) so the new or changed endpoints can be tested. Trigger words: endpoint, API route, controller action, API collection, request collection.
94%
Generates a clear, actionable Product Requirements Document (PRD) in Markdown from a feature description. Use when a user asks to plan a feature, define requirements, or create a PRD. Covers goals, user stories, requirements, and non-goals for Rails-oriented workflows.
90%
Use when reviewing a Ruby on Rails app for Domain-Driven Design boundaries, bounded contexts, language leakage, cross-context orchestration, or unclear ownership. Covers context mapping, leakage detection, and smallest credible boundary improvements.
100%
Use when modeling Domain-Driven Design concepts in a Ruby on Rails codebase. Covers Rails-first mapping of entities, aggregates, value objects, domain services, application services, repositories, and domain events without over-engineering or fighting Rails conventions.
94%
Use when a Ruby on Rails feature, bug, or architecture discussion has fuzzy business terminology and you need shared vocabulary. Identifies canonical terms, resolves naming conflicts, maps synonyms to one concept, and generates a glossary for Rails-first workflows. Trigger words: DDD, shared vocabulary, define terms, bounded context naming, what should we call this, terminology alignment, DDD glossary, naming inconsistency.
78%
Generates phased plans or step-by-step task lists in Markdown from a PRD or feature description. Tasks include checkboxes, relevant file paths, test commands, YARD documentation, and code-review gates for Rails-oriented workflows.
70%
This skill is the starting point for all Rails tasks. It identifies the correct, more specialized skill to use for a given task, like code reviews, TDD, or documentation, and enforces the 'Tests Gate Implementation' mandate.
93%
Use when reviewing Rails application structure, identifying fat models or controllers, auditing callbacks, concerns, service extraction, domain boundaries, or general Rails architecture decisions. Covers controller orchestration, model responsibilities, and abstraction quality.
82%
Use when adding or reviewing background jobs in Rails. Covers Active Job, Solid Queue (Rails 8+), Sidekiq, recurring jobs, idempotency, retry/discard strategies, and queue selection.
78%
Use when investigating a bug in a Ruby on Rails codebase and you need to turn the report into a reproducible failing spec and fix plan. Covers reproduction, scope narrowing, boundary selection, and TDD-first handoff.
76%
A daily checklist for writing clean Rails code, covering design principles (DRY, YAGNI, PORO, CoC, KISS), per-path rules (models, services, workers, controllers), structured logging, and comment discipline. Defers style and formatting to the project's configured linter(s).
79%
Reviews Rails pull requests, focusing on controller/model conventions, migration safety, query performance, and Rails Way compliance. Covers routing, ActiveRecord, security, caching, and background jobs. Use when reviewing existing Rails code for quality.
64%
Use when maintaining compatibility for Rails engines across Rails and Ruby versions. Trigger words: Zeitwerk, autoloading, Rails upgrade, dependency bounds, gemspec, feature detection, CI matrix, reload safety, deprecated APIs, cross-version support.
75%
Use when writing or maintaining documentation for Rails engines. Trigger words: engine README, installation guide, configuration docs, mount instructions, migration notes, extension points, host integration examples, setup documentation.
77%
Use when extracting existing Rails app code into a reusable engine. Trigger words: extract to engine, move feature to engine, host coupling, adapters, extraction slices, preserve behavior, incremental extraction, bounded feature.
97%
Use when creating install generators, copied migrations, or initializer installers for Rails engines. Covers idempotent setup tasks, host-app onboarding, and route mount setup. Trigger words: install generator, mountable engine setup, gem installation, engine onboarding, rails plugin installer, copy migrations, initializer generator, route mount setup, engine configuration generator.
79%
Use when preparing a release, updating gemspec, writing changelog, handling deprecations, setting semantic version, planning upgrade notes, migration guide, or shipping a Rails engine as a gem. Trigger words: version bump, changelog, deprecation, gemspec, upgrade, migration guide, release.
90%
Use when reviewing a Rails engine, mountable engine, or Railtie. Covers namespace boundaries, host-app integration, safe initialization, migrations, generators, and dummy app test coverage. Prioritizes architectural risks.
80%
Use when creating or improving RSpec test coverage for Rails engines. Covers dummy app setup, request, routing, generator, and configuration specs for proving engine behavior within a host application.
90%
Use when building or reviewing GraphQL APIs in Rails with the graphql-ruby gem. Covers schema design, N+1 prevention with dataloaders, field-level auth, query limits, error handling, and testing resolvers/mutations with RSpec.
97%
Use when planning or reviewing production database migrations, adding columns, indexes, constraints, backfills, renames, table rewrites, or concurrent operations. Covers phased rollouts, lock behavior, rollback strategy, strong_migrations compliance, and deployment ordering for schema changes.
100%
Use when you have received code review feedback on Rails code and need to decide what to implement, how to respond, and in what order. Covers evaluating reviewer suggestions, pushing back with technical reasoning, avoiding performative agreement, implementing feedback safely one item at a time, and triggering a re-review when needed.
84%
Use when reviewing Rails code for security risks, assessing authentication or authorization, auditing parameter handling, redirects, file uploads, secrets management, or checking for XSS, CSRF, SSRF, SQL injection, and other common vulnerabilities.
100%
Use when writing new Rails code for a project using PostgreSQL, Hotwire, and Tailwind CSS. Covers MVC structure, query patterns, Turbo Frames/Streams, Stimulus controllers, and Tailwind components. For design principles, use rails-code-conventions.
88%
Use when choosing the best first failing spec or vertical slice for a Ruby on Rails change. Covers request vs model vs service vs job vs engine spec selection, system spec escalation, smallest safe slice planning, and Rails-first TDD sequencing.
97%
Use when the goal is to change code structure without changing behavior — this includes extracting a service object from a fat controller or model, splitting a large class, renaming abstractions, reducing duplication, or reorganizing modules. Covers characterization tests (write tests that document current behavior before touching the code), safe extraction in small steps, and verification after every step. Do NOT use for bug fixes or new features — those follow the TDD gate in rspec-best-practices. Do NOT mix structural changes with behavior changes in the same step.
88%
Use when writing, reviewing, or cleaning up RSpec tests for Ruby and Rails codebases. Covers spec type selection, factory design, flaky test fixes, shared examples, deterministic assertions, test-driven development discipline, and choosing the best first failing spec for Rails changes. Also applies when choosing between model, request, system, and job specs.
90%
Use when writing RSpec tests for service objects, API clients, orchestrators, or business logic in spec/services/. Covers instance_double, FactoryBot hash factories, shared_examples, subject/let blocks, context/describe structure, aggregate_failures, change matchers, travel_to, and error scenario testing.
85%
Use when integrating with external APIs in Ruby, creating HTTP clients, or building data pipelines. Covers the layered Auth, Client, Fetcher, Builder, and Domain Entity pattern with token caching, retry logic, and FactoryBot hash factories for test data.
90%
Use when creating or refactoring Ruby service classes in Rails. Covers the .call pattern, module namespacing, YARD documentation, standardized responses, orchestrator delegation, transaction wrapping, and error handling conventions.
84%
Use when building variant-based calculators with a single entry point that picks the right implementation (Strategy + Factory), or when adding a no-op fallback (Null Object). Covers SERVICE_MAP routing and RSpec testing.
85%
Drafts, classifies, and optionally creates tickets from an initiative plan. Use when the user provides a plan and wants ticket drafts, wants help shaping a plan into tickets, wants sprint-placement guidance, or wants tickets created in an issue tracker after the plan is approved.
90%
Use when writing or reviewing inline documentation for Ruby code. Covers YARD tags for classes and public methods (param, option, return, raise, example tags). Trigger words: YARD, inline docs, method documentation, API docs, public interface, rdoc.
Quality
Discovery
100%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
This is a strong skill description that clearly defines its scope (Ruby YARD documentation), lists specific capabilities (param, option, return, raise, example tags), and provides explicit trigger guidance. It uses proper third-person voice and includes a comprehensive set of natural trigger terms that Ruby developers would use.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions: 'writing or reviewing inline documentation', 'YARD tags for classes and public methods', and enumerates specific tags (param, option, return, raise, example tags). | 3 / 3 |
Completeness | Clearly answers both 'what' (writing/reviewing inline documentation for Ruby code, covering YARD tags for classes and public methods) and 'when' (explicit 'Use when' clause with trigger words listed). | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural trigger terms users would say: 'YARD', 'inline docs', 'method documentation', 'API docs', 'public interface', 'rdoc'. These are terms Ruby developers naturally use when seeking documentation help. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive — targets a specific niche (Ruby YARD documentation) with domain-specific trigger terms like 'YARD', 'rdoc', and 'param/option/return tags' that are unlikely to conflict with other skills. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
77%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a solid, actionable YARD documentation skill with excellent concrete examples and clear enforcement gates. Its main weakness is redundancy — the English language requirement and documentation-before-merge rule are each stated multiple times, and the Common Mistakes and Red Flags sections substantially overlap. Consolidating these would improve token efficiency without losing any information.
Suggestions
Consolidate the three separate English-language enforcement points (core principle, quick reference row, HARD-GATE: Language) into a single prominent statement to reduce redundancy.
Merge 'Common Mistakes' and 'Red Flags' into a single section, as most items appear in both (e.g., missing @raise, missing @option, non-English docs, merging without YARD).
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is mostly efficient but has some redundancy — the language requirement is stated three times (core principle, quick reference table, and a dedicated HARD-GATE section), and the 'Common Mistakes' and 'Red Flags' sections overlap significantly. The content could be tightened by consolidating these. | 2 / 3 |
Actionability | Provides fully concrete, copy-paste-ready Ruby code examples for every tag type (class-level, params, return, raise, option, example). The good-vs-bad comparison gives clear executable patterns, and the tag usage is specific and unambiguous. | 3 / 3 |
Workflow Clarity | The workflow is clear: implement code → add/update YARD on public surfaces → verify before PR. The HARD-GATE sections establish explicit checkpoints, and the 'When to Document' section provides an unambiguous decision framework. For a documentation skill (not a destructive/batch operation), this level of workflow guidance is appropriate. | 3 / 3 |
Progressive Disclosure | The skill is well-structured with clear sections and tables, but it's somewhat long (~120 lines of content) with overlapping sections (Common Mistakes vs Red Flags, multiple language enforcement blocks) that could be consolidated or split. The Integration table references other skills nicely, but no content is offloaded to separate files despite the length. | 2 / 3 |
Total | 10 / 12 Passed |
Validation
100%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 11 / 11 Passed
Validation for skill structure
No warnings or errors.
Reviewed
Table of Contents