vep-rails-agents

Create new Rails skills, modify and improve existing ones. Use when the user wants to build a new skill from scratch, improve an existing skill, capture a workflow as a reusable skill, or turn a repeated Rails pattern into a skill. Triggers on: "create a skill", "new skill for", "turn this into a skill", "skill for X", "add a skill", "improve this skill".

Bulk insert, upsert, and update operations in Rails - insert_all, upsert_all, update_all, find_in_batches, and activerecord-import. Use when processing large datasets, imports, or batch writes that would be too slow with individual ActiveRecord saves.

Fan-out scheduler pattern - one orchestrator job dispatches many worker jobs efficiently using perform_all_later and Set-based filtering. Use when processing large external datasets, scheduled syncs, or any operation that reads N records and needs to dispatch N background jobs without blocking.

Queue-level concurrency controls in Solid Queue to respect external API rate limits. Use when a job calls a third-party API with burst or concurrency limits, or when you need to cap how many instances of a job type run in parallel across all workers.

Configures Solid Queue for background jobs in Rails 8. Use when setting up background processing, creating background jobs, configuring job queues, or migrating from Sidekiq to Solid Queue.

Rails error handling - custom exception hierarchy, rescue_from in controllers, consistent API error responses, Sentry integration, and the bridge between dry-monads Failure() and HTTP status codes.

Structuring Rails services that call external APIs — gateway layer separation, response normalization, error message extraction with dig fallback chains, token refresh management, and transaction coordination with external cleanup on DB failure.

How to compose multiple service objects — Leaf vs Orchestrator distinction, self.build() DI factory, Failure propagation with do-notation yield, side effect placement rules, and transaction coordination with external cleanup.

Implements transactional emails with Action Mailer and TDD. Use when creating email templates, notification emails, password resets, email previews, or when user mentions mailer, email, notifications, or transactional emails.

Implements RESTful API design with versioning and request specs. Use when building APIs, adding API endpoints, versioning APIs, or when user mentions REST, JSON API, or API design.

Implements authentication using Rails 8 built-in generator. Use when setting up user authentication, login/logout, session management, password reset flows, or securing controllers.

Implements policy-based authorization with Pundit for resource access control. Use when adding authorization rules, checking permissions, restricting actions, role-based access, or when user mentions Pundit, policies, authorization, or permissions.

Passes requests along handler chain with Chain of Responsibility Pattern. Use for approval workflows, validation chains, error handling, or when multiple objects can handle a request.

Implements Command Pattern in Rails for operations with undo/redo, audit trails, or queuing. Use when building CMS editors, project management tools, e-commerce order flows, or any operation that needs reversibility and history tracking.

Creates objects through factory methods with Factory Method Pattern. Use for polymorphic object creation, notification systems, report generators, authentication providers, or when you need framework extensibility.

Creates form objects for complex form handling with TDD. Use when building multi-model forms, search forms, wizard forms, or when user mentions form objects, complex forms, virtual models, or non-persisted forms.

Implements Hotwire patterns with Turbo Frames, Turbo Streams, and Stimulus controllers. Use when building interactive UIs, real-time updates, form handling, partial page updates, or when user mentions Turbo, Stimulus, or Hotwire.

Pagination in Rails using will_paginate. Use when adding page navigation to index actions or API endpoints.

Guides modern Rails 8 code architecture decisions and patterns. Use when deciding where to put code, choosing between patterns (service objects vs concerns vs query objects), designing feature architecture, refactoring for better organization, or when user mentions architecture, code organization, design patterns, or layered design.

Creates Rails models using TDD approach - spec first, then migration, then model. Use when creating new models, adding model validations, defining associations, or setting up database tables.

Creates service objects following single-responsibility principle with comprehensive specs. Use when extracting business logic from controllers, creating complex operations, implementing interactors, or when user mentions service objects or POROs.

Implements interchangeable algorithms with Strategy Pattern. Use when implementing payment gateways, notification channels, export formats, authentication methods, or any scenario requiring runtime algorithm selection.

Money and currency handling in Rails - integer cents storage, money-rails gem, BigDecimal arithmetic, formatting, and multi-currency. Use whenever amounts, prices, balances, or currencies are involved.

Data migrations separate from schema migrations - data_migrate gem, safe backfills with find_in_batches, zero-downtime strategies, and when NOT to use schema migrations for data transformations.

Soft delete with the Discard gem - discarded_at column, kept/discarded scopes, cascade, and Pundit integration. Use when records must be deactivated without permanent deletion (audit trail, referential integrity, recovery).

JSON serialization for Rails APIs using Blueprinter (preferred) or ActiveModel::Serializers. Use when building API endpoints that need consistent JSON output, field selection, nested associations, and versioning.

Feature flags in Rails using the Flipper gem — boolean flags, percentage rollouts, per-user/group enablement, and UI. Use when doing canary releases, A/B testing, or gating features behind a flag.

In-process memoization patterns for Rails — instance variable ||=, nil/false-safe memoization, multi-argument caching, request-scoped CurrentAttributes, and the memo_wise gem. Use when avoiding repeated expensive computations within a single object or request lifecycle.

Full-text and filtered search in Rails using pg_search (PostgreSQL native), ransack (filter forms), and searchkick (Elasticsearch). Use when adding search bars, filter UIs, or autocomplete to Rails apps.

Receiving and processing webhooks from third-party services (Stripe, GitHub, etc.) — signature verification, raw body preservation, idempotent processing, async handling with jobs. Use when integrating any service that sends HTTP callbacks.

PostgreSQL locking patterns in Rails - pessimistic row locks, SELECT FOR UPDATE SKIP LOCKED, advisory locks, serializable isolation, and optimistic locking. Use inside service objects when concurrent writes risk race conditions or double-processing.

Event Sourcing with RailsEventStore - immutable event streams, AggregateRoot, projections, and subscribers. Use when domain state must be derived from an append-only event log (financial ledgers, audit trails, inventory).

Idempotency key pattern - deduplicate requests via DB-persisted keys and Redis locks so payments, webhooks, and Kafka consumers are safe to retry. Use when an operation must execute exactly once regardless of retries.

Kafka integration for Rails via Karafka - producers, consumers, dead letter queues, consumer groups, and testing. Use when building event-driven Rails services that publish or consume Kafka topics.

Transactional Outbox Pattern - atomic event persistence alongside domain writes, with a polling relay job. Use when publishing to Kafka, webhooks, or external systems must be guaranteed even on process crash.

Read Model and CQRS patterns - PostgreSQL materialized views, read replicas, and projection models that separate read concerns from writes. Use for expensive aggregation queries, financial summaries, and dashboards.

End-to-end testing for Rails with Playwright. Use when writing system tests that require reliable JavaScript execution, network interception, multi-tab scenarios, or when Capybara's Selenium/Chrome driver is flaky. Also use when the user mentions Playwright, wants fast parallel E2E tests, needs to test complex Hotwire/Turbo flows, or wants to migrate from Capybara system specs to Playwright. Covers both the capybara-playwright driver (drop-in for spec/system/) and standalone playwright-ruby-client tests.

Guides Test-Driven Development workflow with Red-Green-Refactor cycle. Use when the user wants to implement a feature using TDD, write tests first, follow test-driven practices, or mentions red-green-refactor.

Audits and improves Rails skill files in a project. Use when reviewing a SKILL.md file for correctness, completeness, and best practices. Triggers on: "audit skill", "review skill", "check skill", "improve skill", "verify skill", or when asked to verify that skill code examples are correct.

Implements Rails caching patterns for performance optimization. Use when adding fragment caching, Russian doll caching, low-level caching, cache invalidation, or when user mentions caching, performance, cache keys, or memoization.