How to use Rails Expert skill in Claude Code for backend development

Feb 14, 2026

Cowrie

Dev @ Bswen

Purpose

This post demonstrates how to use the Rails Expert skill in Claude Code to accelerate Ruby on Rails development.

Environment

Claude Code (latest version)
Ruby on Rails 7.x
claude-skills plugin
macOS/Linux terminal

What is Rails Expert?

Rails Expert is a skill in the claude-skills ecosystem that provides specialized knowledge for Ruby on Rails development. It covers Rails conventions, best practices, ActiveRecord patterns, controller design, and common architectural patterns.

The skill activates when you’re working on Rails projects and need guidance on:

Model associations and validations
Controller design and RESTful patterns
Rails routing and namespacing
Background jobs with ActiveJob
Testing with RSpec or Minitest
Database migrations and schema design
Performance optimization
Security best practices

When you use Rails Expert, you get responses that follow Rails conventions (“the Rails way”) instead of generic Ruby advice.

Installation

First, ensure you have the claude-skills plugin installed:

# Navigate to your Claude skills directory
cd ~/.claude/skills

# Clone or update the skills repository
git clone https://github.com/jeffallan/claude-skills.git

# Verify Rails Expert skill exists
ls claude-skills/rails-patterns/

The Rails Expert skill should be available as rails-patterns in your skills directory.

Core Usage Patterns

The Rails Expert skill activates automatically when you’re working in a Rails project. Here are common ways to invoke it:

Pattern 1: Direct Invocation

# Use the skill command directly
/skill rails-patterns

# Then ask your question
"How do I implement a polymorphic association between Comments and Posts/Videos?"

Pattern 2: Context-Aware Invocation

When you’re in a Rails project directory, simply ask Rails-related questions:

# In your Rails project root
cd ~/projects/my-rails-app

# Ask Claude directly
"How should I structure my API serializers for these models?"

Claude will detect the Rails environment and use Rails Expert automatically.

Pattern 3: Specific Triggers

Certain phrases trigger Rails Expert:

“What’s the Rails way to…”
“How do I implement [feature] following Rails conventions…”
“Help me refactor this Rails controller…”
“Is this following Rails best practices…”

Practical Examples

Example 1: Building a Feature

When I needed to add user authentication to a Rails API, I used Rails Expert like this:

/skill rails-patterns
"I need to add JWT authentication to my Rails API. What's the Rails way?"

The response guided me through:

Installing the jwt gem
Creating an AuthenticationController
Using before_action callbacks
Implementing the authenticate_user! method
Securing the token with Rails secrets

I got code that followed Rails conventions instead of generic Ruby patterns.

Example 2: Refactoring Controllers

I had a bloated controller with too much logic:

class OrdersController < ApplicationController
  def create
    @order = Order.new(order_params)
    @order.user = current_user
    @order.calculate_discount
    @order.apply_tax
    @order.process_payment
    @order.send_confirmation_email

    if @order.save
      render json: @order, status: :created
    else
      render json: { errors: @order.errors }, status: :unprocessable_entity
    end
  end
end

I asked Rails Expert:

"This controller has too much logic. How should I refactor it?"

The skill suggested:

Move business logic to a service object (Orders::CreateOrderService)
Use form objects for parameter handling
Implement a before_action for user loading
Extract email sending to an ActiveJob

Example 3: Database Design

When I needed to design a multi-tenant system:

/skill rails-patterns
"How do I implement multi-tenancy in Rails? Should I use database schemas or row-level tenancy?"

Rails Expert explained:

The pros and cons of each approach
How to use the apartment gem for schema-based tenancy
How to implement current_tenant with around_action
Scoping models with default scopes
Security considerations for tenant isolation

Best Practices

DO

Use Rails Expert for architectural decisions

When you’re unsure how to structure features, ask the skill:

"I have Users, Organizations, and Subscriptions. How should I model these relationships?"

Follow the Rails way

The skill emphasizes convention over configuration. Trust its guidance on:

RESTful controller actions
Model associations
Routing conventions
Testing organization

Ask for explanations

"Why does Rails recommend strong parameters over mass assignment?"

This helps you understand the reasoning behind conventions.

Use it for code reviews

"Does this controller follow Rails best practices?"

Then paste your code for review.

DON’T

Don’t ignore Rails conventions

When the skill suggests a “Rails way” approach that feels different from your experience, give it a try. Rails conventions exist for good reasons.

Don’t use generic Ruby patterns

# Generic Ruby pattern (not recommended in Rails)
class User
  attr_accessor :name, :email

  def initialize(name, email)
    @name = name
    @email = email
  end
end

# Rails way (recommended)
class User < ApplicationRecord
  validates :name, presence: true
  validates :email, presence: true, uniqueness: true
end

Don’t skip testing guidance

Rails Expert includes knowledge about RSpec and Minitest. Use it for:

Writing model specs
Testing controller actions
Feature testing with Capybara
Factory patterns with FactoryBot

Don’t forget security

Always ask about security implications:

"How do I prevent SQL injection in this query?"
"How do I secure this API endpoint?"

Common Scenarios

Scenario 1: Adding a New Resource

When I needed to add a Comment system:

/skill rails-patterns
"I want to add comments to Posts. What's the Rails way?"

The skill provided:

Migration for comments table
Comment model with associations
CommentsController with RESTful actions
Routes for nested resources
Strong parameters setup
Testing structure

Scenario 2: Background Jobs

I needed to process image uploads in the background:

/skill rails-patterns
"How do I process image uploads with ActiveJob?"

Guidance included:

Creating the job with rails generate job
Using ActiveStorage for file handling
Implementing perform_later in the controller
Setting up Sidekiq or Resque
Error handling and retries
Testing strategies

Scenario 3: API Versioning

When my API needed versioning:

/skill rails-patterns
"What's the best way to version my Rails API?"

The skill explained:

Namespace-based versioning (Api::V1::UsersController)
Route constraints for version detection
Media type-based versioning
Maintaining backward compatibility
Deprecation strategies

Rails Expert works well with other claude-skills:

backend-patterns: General backend architecture and API design
security-review: Security best practices for authentication and authorization
testing-patterns: RSpec and Minitest best practices
tdd-workflow: Test-driven development workflow for Rails

Tips for Maximum Effectiveness

1. Provide context

When asking questions, share:

Your Rails version
Relevant model code
Current controller structure
Error messages or stack traces

2. Show your code

"Here's my User model. How can I optimize this query?"
[Paste your code]

3. Ask for alternatives

"What are two ways to implement this? Which is more Rails-like?"

4. Test the suggestions

Always verify the skill’s suggestions in your development environment. The skill provides guidance, but you should confirm it works in your specific context.

5. Learn from the explanations

Don’t just copy the code. Read the explanations to understand why Rails recommends certain patterns. This knowledge compounds over time.

Summary

In this post, I showed how to use the Rails Expert skill in Claude Code for Rails development. The key point is knowing when to invoke the skill (architectural decisions, refactoring, feature implementation) and how to ask effective questions that provide context and code.

The Rails Expert skill accelerates development by:

Enforcing Rails conventions
Suggesting best practices
Explaining the “why” behind patterns
Providing security-conscious solutions
Aligning with the Rails ecosystem

Use it alongside the official Rails guides and the Rails source code to deepen your understanding of the framework.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!