vanilla-rails
Use when building Rails + Hotwire applications - covers REST routing, thin controllers, rich models, Turbo Streams/Frames, and Stimulus patterns from 37signals
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.
| name | vanilla-rails |
|---|---|
| description | Use 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
- REST purity - Actions are CRUD on resources
- Thin controllers - Controllers call models, models contain behavior
- Small concerns - One behavior per concern
- Turbo-first - Server renders HTML, Turbo handles updates
- 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.