Agent skill

dhh-ruby-style

This skill should be used when writing Ruby and Rails code in DHH's distinctive 37signals style. It applies when writing Ruby code, Rails applications, creating models, controllers, or any Ruby file. Triggers on Ruby/Rails code generation, refactoring requests, code review, or when the user mentions DHH, 37signals, Basecamp, HEY, or Campfire style. Embodies REST purity, fat models, thin controllers, Current attributes, Hotwire patterns, and the "clarity over cleverness" philosophy.

View SKILL.md on GitHub Repository
Stars 1
Forks 1

Install this agent skill to your Project

npx add-skill https://github.com/nbbaier/compound-engineering-amp/tree/main/skills/dhh-ruby-style

SKILL.md

DHH Ruby/Rails Style Guide

Write Ruby and Rails code following DHH's philosophy: clarity over cleverness, convention over configuration, developer happiness above all.

Quick Reference

Controller Actions

  • Only 7 REST actions: index, show, new, create, edit, update, destroy
  • New behavior? Create a new controller, not a custom action
  • Action length: 1-5 lines maximum
  • Empty actions are fine: Let Rails convention handle rendering
ruby
class MessagesController < ApplicationController
  before_action :set_message, only: %i[ show edit update destroy ]

  def index
    @messages = @room.messages.with_creator.last_page
    fresh_when @messages
  end

  def show
  end

  def create
    @message = @room.messages.create_with_attachment!(message_params)
    @message.broadcast_create
  end

  private
    def set_message
      @message = @room.messages.find(params[:id])
    end

    def message_params
      params.require(:message).permit(:body, :attachment)
    end
end

Private Method Indentation

Indent private methods one level under private keyword:

ruby
  private
    def set_message
      @message = Message.find(params[:id])
    end

    def message_params
      params.require(:message).permit(:body)
    end

Model Design (Fat Models)

Models own business logic, authorization, and broadcasting:

ruby
class Message < ApplicationRecord
  belongs_to :room
  belongs_to :creator, class_name: "User"
  has_many :mentions

  scope :with_creator, -> { includes(:creator) }
  scope :page_before, ->(cursor) { where("id < ?", cursor.id).order(id: :desc).limit(50) }

  def broadcast_create
    broadcast_append_to room, :messages, target: "messages"
  end

  def mentionees
    mentions.includes(:user).map(&:user)
  end
end

class User < ApplicationRecord
  def can_administer?(message)
    message.creator == self || admin?
  end
end

Current Attributes

Use Current for request context, never pass current_user everywhere:

ruby
class Current < ActiveSupport::CurrentAttributes
  attribute :user, :session
end

# Usage anywhere in app
Current.user.can_administer?(@message)

Ruby Syntax Preferences

ruby
# Symbol arrays with spaces inside brackets
before_action :set_message, only: %i[ show edit update destroy ]

# Modern hash syntax exclusively
params.require(:message).permit(:body, :attachment)

# Single-line blocks with braces
users.each { |user| user.notify }

# Ternaries for simple conditionals
@room.direct? ? @room.users : @message.mentionees

# Bang methods for fail-fast
@message = Message.create!(params)
@message.update!(message_params)

# Predicate methods with question marks
@room.direct?
user.can_administer?(@message)
@messages.any?

# Expression-less case for cleaner conditionals
case
when params[:before].present?
  @room.messages.page_before(params[:before])
when params[:after].present?
  @room.messages.page_after(params[:after])
else
  @room.messages.last_page
end

Naming Conventions

Element Convention Example
Setter methods set_ prefix set_message, set_room
Parameter methods {model}_params message_params
Association names Semantic, not generic creator not user
Scopes Chainable, descriptive with_creator, page_before
Predicates End with ? direct?, can_administer?

Hotwire/Turbo Patterns

Broadcasting is model responsibility:

ruby
# In model
def broadcast_create
  broadcast_append_to room, :messages, target: "messages"
end

# In controller
@message.broadcast_replace_to @room, :messages,
  target: [ @message, :presentation ],
  partial: "messages/presentation",
  attributes: { maintain_scroll: true }

Error Handling

Rescue specific exceptions, fail fast with bang methods:

ruby
def create
  @message = @room.messages.create_with_attachment!(message_params)
  @message.broadcast_create
rescue ActiveRecord::RecordNotFound
  render action: :room_not_found
end

Architecture Preferences

Traditional DHH Way
PostgreSQL SQLite (for single-tenant)
Redis + Sidekiq Solid Queue
Redis cache Solid Cache
Kubernetes Single Docker container
Service objects Fat models
Policy objects (Pundit) Authorization on User model
FactoryBot Fixtures

Detailed References

For comprehensive patterns and examples, see:

  • patterns.md - Complete code patterns with explanations
  • resources.md - Links to source material and further reading

Philosophy Summary

  1. REST purity: 7 actions only; new controllers for variations
  2. Fat models: Authorization, broadcasting, business logic in models
  3. Thin controllers: 1-5 line actions; extract complexity
  4. Convention over configuration: Empty methods, implicit rendering
  5. Minimal abstractions: No service objects for simple cases
  6. Current attributes: Thread-local request context everywhere
  7. Hotwire-first: Model-level broadcasting, Turbo Streams, Stimulus
  8. Readable code: Semantic naming, small methods, no comments needed
  9. Pragmatic testing: System tests over unit tests, real integrations

Recommended Agent Skills

Expand your agent's capabilities with these related and highly-rated skills.

nbbaier/compound-engineering-amp

every-style-editor

This skill should be used when reviewing or editing copy to ensure adherence to Every's style guide. It provides a systematic line-by-line review process for grammar, punctuation, mechanics, and style guide compliance.

1 1
Explore
nbbaier/compound-engineering-amp

compound-docs

Capture solved problems as categorized documentation with YAML frontmatter for fast lookup

1 1
Explore
nbbaier/compound-engineering-amp

file-todos

This skill should be used when managing the file-based todo tracking system in the todos/ directory. It provides workflows for creating todos, managing status and dependencies, conducting triage, and integrating with slash commands and code review processes.

1 1
Explore
nbbaier/compound-engineering-amp

dspy-ruby

This skill should be used when working with DSPy.rb, a Ruby framework for building type-safe, composable LLM applications. Use this when implementing predictable AI features, creating LLM signatures and modules, configuring language model providers (OpenAI, Anthropic, Gemini, Ollama), building agent systems with tools, optimizing prompts, or testing LLM-powered functionality in Ruby applications.

1 1
Explore
nbbaier/compound-engineering-amp

git-worktree

This skill manages Git worktrees for isolated parallel development. It handles creating, listing, switching, and cleaning up worktrees with a simple interactive interface, following KISS principles.

1 1
Explore
nbbaier/compound-engineering-amp

andrew-kane-gem-writer

This skill should be used when writing Ruby gems following Andrew Kane's proven patterns and philosophy. It applies when creating new Ruby gems, refactoring existing gems, designing gem APIs, or when clean, minimal, production-ready Ruby library code is needed. Triggers on requests like "create a gem", "write a Ruby library", "design a gem API", or mentions of Andrew Kane's style.

1 1
Explore

Didn't find tool you were looking for?

Be as detailed as possible for better results