vanilla-rails

Use when building Rails + Hotwire applications - covers REST routing, thin controllers, rich models, Turbo Streams/Frames, and Stimulus patterns from 37signals

⭐5stars🔀1forks📁View on GitHub🕐Updated Jan 11, 2026

When & Why to Use This Skill

This Claude skill streamlines Ruby on Rails development by implementing the 'vanilla' architectural patterns championed by 37signals. It focuses on building high-performance, maintainable applications using Hotwire (Turbo and Stimulus), emphasizing RESTful purity, thin controllers, and rich domain models to reduce code complexity and eliminate the need for heavy frontend frameworks.

Use Cases

  • Architecting RESTful routing and nested resources to ensure a clean and predictable URL structure.
  • Refactoring 'fat' controllers by delegating business logic to rich models and focused concerns.
  • Implementing reactive UI components using Turbo Streams and Turbo Frames for seamless, partial page updates.
  • Developing lightweight Stimulus controllers to add interactive client-side behavior without full-page reloads.
  • Organizing complex model logic into small, reusable concerns to improve code readability and testability.
namevanilla-rails
descriptionUse when building Rails + Hotwire applications - covers REST routing, thin controllers, rich models, Turbo Streams/Frames, and Stimulus patterns from 37signals

Rails + Hotwire Patterns

Overview

Patterns from 37signals' approach to Rails development. Emphasizes REST purity, thin controllers calling rich models, and Hotwire for dynamic interfaces without heavy JavaScript.

Read vanilla-rails.md for complete patterns and examples (~3000 tokens).

When to Use This Skill

Use when working on Rails applications with Hotwire:

  • Adding new routes, controllers, or actions
  • Implementing Turbo Streams or Turbo Frames
  • Writing Stimulus controllers
  • Organizing model concerns
  • Building real-time features with broadcasts

Quick Reference

Routing

Model actions as resources. Custom actions become nested resources:

# Instead of: post :close, :reopen on cards
resources :cards do
  resource :closure  # create = close, destroy = reopen
end

Controllers

Thin controllers call rich model methods:

class Cards::ClosuresController < ApplicationController
  def create
    @card.close(user: Current.user)
  end

  def destroy
    @card.reopen(user: Current.user)
  end
end

Models

Small, focused concerns. One behavior per concern:

class Card < ApplicationRecord
  include Closeable, Watchable, Pinnable
end

Turbo Streams

Array-based DOM IDs for scoped targets:

<%= turbo_stream.replace [@card, :container], partial: "cards/container" %>

Stimulus

Private methods with #, dispatch events for coordination:

export default class extends Controller {
  #timer

  open() {
    this.dispatch("show")
  }
}

Core Principles

  1. REST purity - Actions are CRUD on resources
  2. Thin controllers - Controllers call models, models contain behavior
  3. Small concerns - One behavior per concern
  4. Turbo-first - Server renders HTML, Turbo handles updates
  5. Stimulus for sprinkles - JavaScript enhances, doesn't replace

Bottom Line

Read vanilla-rails.md for the complete guide. These patterns work together - routing informs controller design, controllers return Turbo Streams, Stimulus coordinates the UI.