ce-dhh-rails-style

Q: How do I install ce-dhh-rails-style?

Run npx skills add https://github.com/everyinc/compound-engineering-plugin --skill ce-dhh-rails-style in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/ce-dhh-rails-style/ (personal) or .claude/skills/ce-dhh-rails-style/ (project).

by everyincBackend & APIs

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.

Installs: 1.8K
Last 24h: —
Trending rank: —
Security: Not audited

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/everyinc/compound-engineering-plugin --skill ce-dhh-rails-style

01
Install
Run the command in your project. The CLI asks which agents to install for.
02
Describe the task
Ask your agent for something this skill covers. It loads ce-dhh-rails-style automatically when relevant.
03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.

SKILL.md

The instructions your agent reads when the skill is triggered.

<objective> Apply 37signals/DHH Rails conventions to Ruby and Rails code. This skill provides comprehensive domain expertise extracted from analyzing production 37signals codebases (Fizzy/Campfire) and DHH's code review patterns. </objective>

<essential_principles>

Core Philosophy

"The best code is the code you don't write. The second best is the code that's obviously correct."

Vanilla Rails is plenty:

Rich domain models over service objects
CRUD controllers over custom actions
Concerns for horizontal code sharing
Records as state instead of boolean columns
Database-backed everything (no Redis)
Build solutions before reaching for gems

What they deliberately avoid:

devise (custom ~150-line auth instead)
pundit/cancancan (simple role checks in models)
sidekiq (Solid Queue uses database)
redis (database for everything)
view_component (partials work fine)
GraphQL (REST with Turbo sufficient)
factory_bot (fixtures are simpler)
rspec (Minitest ships with Rails)
Tailwind (native CSS with layers)

Development Philosophy:

Ship, Validate, Refine - prototype-quality code to production to learn
Fix root causes, not symptoms
Write-time operations over read-time computations
Database constraints over ActiveRecord validations </essential_principles>

<intake> What are you working on?

Controllers - REST mapping, concerns, Turbo responses, API patterns
Models - Concerns, state records, callbacks, scopes, POROs
Views & Frontend - Turbo, Stimulus, CSS, partials
Architecture - Routing, multi-tenancy, authentication, jobs, caching
Testing - Minitest, fixtures, integration tests
Gems & Dependencies - What to use vs avoid
Code Review - Review code against DHH style
General Guidance - Philosophy and conventions

Specify a number or describe your task. </intake>

Response	Reference to Read
1, controller	`references/controllers.md`
2, model	`references/models.md`
3, view, frontend, turbo, stimulus, css	`references/frontend.md`
4, architecture, routing, auth, job, cache	`references/architecture.md`
5, test, testing, minitest, fixture	`references/testing.md`
6, gem, dependency, library	`references/gems.md`
7, review	Read all references, then review code
8, general task	Read relevant references based on context

After reading relevant references, apply patterns to the user's code. </routing>

<quick_reference>

Naming Conventions

Verbs: card.close, card.gild, board.publish (not set_style methods)

Predicates: card.closed?, card.golden? (derived from presence of related record)

Concerns: Adjectives describing capability (Closeable, Publishable, Watchable)

Controllers: Nouns matching resources (Cards::ClosuresController)

Scopes:

chronologically, reverse_chronologically, alphabetically, latest
preloaded (standard eager loading name)
indexed_by, sorted_by (parameterized)
active, unassigned (business terms, not SQL-ish)

REST Mapping

Instead of custom actions, create new resources:

POST /cards/:id/close    → POST /cards/:id/closure
DELETE /cards/:id/close  → DELETE /cards/:id/closure
POST /cards/:id/archive  → POST /cards/:id/archival

Ruby Syntax Preferences

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

# Private method indentation
  private
    def set_message
      @message = Message.find(params[:id])
    end

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

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

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

Key Patterns

State as Records:

Card.joins(:closure)         # closed cards
Card.where.missing(:closure) # open cards

Current Attributes:

belongs_to :creator, default: -> { Current.user }

Authorization on Models:

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

</quick_reference>

<reference_index>

Domain Knowledge

All detailed patterns in references/:

File	Topics
`references/controllers.md`	REST mapping, concerns, Turbo responses, API patterns, HTTP caching
`references/models.md`	Concerns, state records, callbacks, scopes, POROs, authorization, broadcasting
`references/frontend.md`	Turbo Streams, Stimulus controllers, CSS layers, OKLCH colors, partials
`references/architecture.md`	Routing, authentication, jobs, Current attributes, caching, database patterns
`references/testing.md`	Minitest, fixtures, unit/integration/system tests, testing patterns
`references/gems.md`	What they use vs avoid, decision framework, Gemfile examples
</reference_index>

<success_criteria> Code follows DHH style when:

Controllers map to CRUD verbs on resources
Models use concerns for horizontal behavior
State is tracked via records, not booleans
No unnecessary service objects or abstractions
Database-backed solutions preferred over external services
Tests use Minitest with fixtures
Turbo/Stimulus for interactivity (no heavy JS frameworks)
Native CSS with modern features (layers, OKLCH, nesting)
Authorization logic lives on User model
Jobs are shallow wrappers calling model methods </success_criteria>

<credits> Based on [The Unofficial 37signals/DHH Rails Style Guide](https://github.com/marckohlbrugge/unofficial-37signals-coding-style-guide) by [Marc Köhlbrugge](https://x.com/marckohlbrugge), generated through deep analysis of 265 pull requests from the Fizzy codebase.

Important Disclaimers:

LLM-generated guide - may contain inaccuracies
Code examples from Fizzy are licensed under the O'Saasy License
Not affiliated with or endorsed by 37signals </credits>

FAQ

What does the ce-dhh-rails-style skill do?

How do I install ce-dhh-rails-style?

Run npx skills add https://github.com/everyinc/compound-engineering-plugin --skill ce-dhh-rails-style in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/ce-dhh-rails-style/ (personal) or .claude/skills/ce-dhh-rails-style/ (project).

Which AI agents can use ce-dhh-rails-style?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is ce-dhh-rails-style safe to install?

No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.

Who maintains ce-dhh-rails-style?

It is published by everyinc in everyinc/compound-engineering-plugin. It has 1,767 recorded installs.