AI Coding with Ruby on Rails

AI Tool Ecosystem for Ruby on Rails

Ruby on Rails has one of the most mature AI coding ecosystems, benefiting from nearly two decades of community-generated code in training data. AI tools understand Rails conventions at a deep level, from naming conventions (pluralization, inflections) to the standard MVC architecture and the directory structure that every Rails app follows. The framework's strong opinions about how code should be organized mean AI-generated code typically integrates seamlessly into existing projects. ActiveRecord, Action Mailer, Action Cable, and Active Job are all well-represented in AI training data. The modern Rails stack with Hotwire (Turbo + Stimulus) is increasingly understood, though AI tools still default to API-style JSON responses in some cases. RSpec and the Rails testing ecosystem are deeply known by AI tools.

What AI Does Well with Ruby on Rails

• Generates ActiveRecord models with validations, associations (has_many through, polymorphic), scopes, and callback patterns
• Creates Rails migrations with proper column types, indexes, foreign keys, and reversible change methods
• Produces RESTful controller actions with strong parameters, proper response formats, and before_action filters
• Builds RSpec test suites with FactoryBot factories, shared examples, request specs, and proper let/before usage
• Scaffolds Stimulus controllers with proper target definitions, action descriptors, and lifecycle callbacks
• Generates Active Job classes with retry logic, error handling, and proper queue assignment

Tips for AI-Assisted Ruby on Rails Development

• AI tools understand Rails conventions deeply - follow naming conventions for best results
• Use AI to generate Rails migrations, models with validations, and associations
• AI handles Rails controller actions with proper strong parameters
• Leverage AI for generating RSpec/Minitest tests with factory patterns
• AI understands Turbo and Stimulus patterns for Hotwire-based development

Prompting Tips for Ruby on Rails

Where AI Struggles with Ruby on Rails

• AI-generated ActiveRecord queries frequently create N+1 problems, missing includes(), eager_load(), or preload() calls
• Complex ActiveRecord scopes with joins, subqueries, and Arel nodes are often syntactically incorrect in AI output
• AI struggles with Hotwire Turbo Stream patterns, especially broadcasting from models and complex frame navigation
• Generated Rails concern modules sometimes create unclear inheritance chains and method collision issues

RESTful Controller with Service Object

A Rails controller with proper strong parameters, service object delegation, and Turbo Stream responses.

# app/controllers/articles_controller.rb
class ArticlesController < ApplicationController
  before_action :authenticate_user!
  before_action :set_article, only: %i[show edit update destroy]
  before_action :authorize_article, only: %i[edit update destroy]

  def index
    @articles = Article.includes(:author, :tags)
                       .published
                       .order(created_at: :desc)
                       .page(params[:page])
  end

  def create
    result = Articles::CreateService.call(
      params: article_params,
      author: current_user
    )

    if result.success?
      redirect_to result.article, notice: "Article published."
    else
      @article = result.article
      render :new, status: :unprocessable_entity
    end
  end

  def destroy
    @article.destroy!
    respond_to do |format|
      format.html { redirect_to articles_path, notice: "Article deleted." }
      format.turbo_stream
    end
  end

  private

  def set_article
    @article = Article.find(params[:id])
  end

  def authorize_article
    redirect_to articles_path unless @article.author == current_user
  end

  def article_params
    params.require(:article).permit(:title, :content, :status, tag_ids: [])
  end
end

Common Use Cases

• Full-stack web applications
• API-only backends
• Rapid prototyping and MVPs
• E-commerce and marketplace platforms

Common Patterns AI Generates Well

• ActiveRecord models with validations, associations, scopes, and enum definitions for domain logic
• RESTful controllers with before_action filters, strong parameters, and respond_to blocks
• Service objects (POROs) for complex business logic extracted from controllers
• Concerns for shared model behavior (Searchable, Sluggable) and controller functionality
• RSpec request specs with FactoryBot factories and shared contexts for comprehensive API testing
• Background jobs with Active Job for email delivery, data processing, and third-party API calls

Best Practices

Rails' conventions are AI's best guide. Never fight the conventions. Use standard Rails directory structure and naming. AI tools generate excellent ActiveRecord queries, but review N+1 queries. For API-only apps, use Rails' API mode. AI understands both traditional Rails views and modern Hotwire patterns.

Setting Up Your AI Environment

Follow Rails conventions strictly - use standard directory structure, naming, and pluralization rules. Install Solargraph or Ruby LSP alongside your AI tool for type inference and autocompletion. Add a .cursorrules file listing your Rails version, key gems (Devise, Pundit, Sidekiq), testing framework (RSpec vs Minitest), and whether you use Hotwire or API-only mode so AI generates compatible code.

Recommended Tools for Ruby on Rails

The following AI coding tools offer the best support for Ruby on Rails development:

• Cursor - AI-first code editor built as a fork of VS Code with deep AI integration for code generation, editing, and chat.
• GitHub Copilot - AI pair programmer by GitHub and Microsoft that provides code suggestions, chat, and autonomous coding agents directly in your editor.
• Claude Code - Anthropic's agentic CLI coding tool that operates directly in your terminal, capable of editing files, running commands, and managing entire coding workflows.
• Cody - AI coding assistant by Sourcegraph that leverages deep codebase understanding and code search to provide context-aware assistance.

FAQ