activerecord
/activerecord
This skill should be used when the user asks to "write a migration", "add a column", "add column to table", "create an index", "add a foreign key", "set up associations", "fix N+1 queries", "optimize queries", "add validations", "create callbacks", "use eager loading", or mentions ActiveRecord, belongs_to, has_many, has_one, :through associations, polymorphic associations, inverse_of, touch: true, counter_cache, dependent: destroy, where clauses, scopes, includes, preload, eager_load, joins, find_each, batch processing, counter caches, foreign key constraints, or database constraints. Should a
- Author
- hoblin ↗
- Repository
- claude-ruby-marketplace ↗
- Licence
- MIT
- Last repository change
- 07.09.2026
Assessment and security
- Files in this package
- 35
- Scripts
- 28
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 07.09.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
- 28 scripts in this package. Review them before installing, as Claude may execute them.
Scripts: examples/associations/association_extensions.rb, examples/associations/basic_associations.rb, examples/associations/counter_caches.rb, examples/associations/polymorphic_associations.rb, examples/associations/self_referential.rb, examples/associations/through_associations.rb, examples/basics/crud_operations.rb, examples/basics/dirty_tracking.rb
What it does and when to use it
This skill should be used when the user asks to "write a migration", "add a column", "add column to table", "create an index", "add a foreign key", "set up associations", "fix N+1 queries", "optimize queries", "add validations", "create callbacks", "use eager loading", or mentions ActiveRecord, belongs_to, has_many, has_one, :through associations, polymorphic associations, inverse_of, touch: true, counter_cache, dependent: destroy, where clauses, scopes, includes, preload, eager_load, joins, find_each, batch processing, counter caches, foreign key constraints, or database constraints. Should a
Triggers from the description
Original author description
This skill should be used when the user asks to "write a migration", "add a column", "add column to table", "create an index", "add a foreign key", "set up associations", "fix N+1 queries", "optimize queries", "add validations", "create callbacks", "use eager loading", or mentions ActiveRecord, belongs_to, has_many, has_one, :through associations, polymorphic associations, inverse_of, touch: true, counter_cache, dependent: destroy, where clauses, scopes, includes, preload, eager_load, joins, find_each, batch processing, counter caches, foreign key constraints, or database constraints. Should a
How it works
- Quick Reference
- Eager Loading Decision Tree
- Validation vs Constraint Decision
- Associations Quick Reference
- Migrations Quick Reference
- Callbacks Quick Reference
- Batch Processing
- Best Practices
- Anti-Patterns Quick List
- Additional Resources
SKILL.md preview
---
name: activerecord
description: >-
This skill should be used when the user asks to "write a migration", "add a
column", "add column to table", "create an index", "add a foreign key", "set
up associations", "fix N+1 queries", "optimize queries", "add validations",
"create callbacks", "use eager loading", or mentions ActiveRecord, belongs_to,
has_many, has_one, :through associations, polymorphic associations, inverse_of,
touch: true, counter_cache, dependent: destroy, where clauses, scopes,
includes, preload, eager_load, joins, find_each, batch processing, counter
caches, foreign key constraints, or database constraints. Should also be used
when editing *_model.rb files, working in app/models/ directory, db/migrate/,
discussing query performance, N+1 prevention, validation vs constraint
decisions, or reviewing database schema design.
version: 1.0.2
---
# ActiveRecord
This skill provides comprehensive guidance for working with ActiveRecord in Rails applications. Use for writing migrations, defining associations, optimizing queries, preventing N+1 issues, implementing validations, and following database best practices.
## Quick Reference
### CRUD Operations
```ruby
# Create
user = User.create(name: "Alice", email: "alice@example.com")
user = User.create!(...) # Raises on failure
# Read
User.find(1) # Raises RecordNotFound
User.find_by(email: "x") # Returns nil if not found
User.where(active: true) # Returns Relation
# Update
user.update(name: "Bob")
user.update!(...) # Raises on failure
# Delete (callbacks run)
user.destroy
# Delete (no callbacks)
user.delete
```
### Key Concepts
| Concept | Purpose |
|---------|---------|
| `belongs_to` | Child side of association (has foreign key) |
| `has_many` / `has_one` | Parent side of association |
| `has_many :through` | Many-to-many via join model |
| `includes` / `preload` | Eager loading (prevent N+1) |
| `scope` | Named query builder |
| `validates` | Model-level data validation |
| `before_save` / `after_commit` | Lifecycle callbacks |
## Eager Loading Decision Tree
```
Need to access associated data?
├── NO → Use `joins` (filtering only)
└── YES → Need to filter/sort by association?
├── NO → Use `preload` (separate queries)
└── YES → Large dataset with many associations?
├── YES → Use `includes` with `references`
└── NO → Use `eager_load` (single JOIN)
```
### Quick Comparison
| Method | Strategy | Best For |
|--------|----------|----------|
| `includes` | Auto-choose | Default choice |
| `preload` | Separate queries | Large datasets, no filtering |
| `eager_load` | LEFT OUTER JOIN | Filtering by association |
| `joins` | INNER JOIN | Filtering only, not accessing data |
```ruby
# N+1 problem
Post.all.each { |p| p.author.name } # 1 + N queries
# Solution
Post.includes(:author).each { |p| p.author.name } # 2 queries
```
## Validation vs Constraint Decision
```
Does the rule ALWAYS apply, regardless of business logic?
├── Yes → Database constraint
│ └── Examples: NOT NULL, foreign keys, unique emails
└── No → Model validation
└── Examples: Format rules that change, conditional requirements
Need helpful user-facing error messages?
├── Yes → Model validation (possibly WITH constraint)
└── No → Constraint alone is fine
```
**Best Practice**: Use both for critical fields:
```ruby
# Migration (data integrity)
add_index :users, :email, unique: true
# Model (user feedback)
validates :email, presence: true, uniqueness: true
```
## Associations Quick Reference
### Basic Types
```ruby
class Author < ApplicationRecord
has_many :books, dependent: :destroy
has_one :profile
end
class Book < ApplicationRecord
belongs_to :author # Required by default
belongs_to :publisher, optional: true # Allow NULL
end
```
### Through Associations
```ruby
class Physician < ApplicationRecord
has_many :appointments
has_many :patients, through: :appointments
end
class Appointment < ApplicationRecord
belongs_to :physician
belongs_to :patient
# Join model can have attributes
validates :scheduled_at, presence: true
end
```
### Critical Options
| Option | Purpose |
|--------|---------|
| `inverse_of` | Required with custom foreign_key |
| `dependent: :destroy` | Cascade delete with callbacks |
| `counter_cache: true` | Cache association count |
| `touch: true` | Update parent's updated_at |
## Migrations Quick Reference
### Safe Patterns
```ruby
# Always reversible
add_column :users, :name, :string
add_index :users, :email, unique: true
add_reference :orders, :user, foreign_key: true
# Concurrent index (no table lock)
disable_ddl_transaction!
add_index :users, :email, algorithm: :concurrently
```
### Must Include Type for Reversibility
```ruby
remove_column :users, :legacy_field, :string # Include type!
change_column_default :users, :status, from: nil, to: "active"
```
## Callbacks Quick Reference
### Order of Execution
```
before_validation → after_validation →
before_save → around_save → before_create →
around_create → [INSERT] → after_create →
after_save → [COMMIT] → after_commit
```
### Critical Rule: Use after_commit for External Systems
```ruby
# WRONG - Race condition!
after_save :enqueue_processing
# CORRECT - Runs after COMMIT
after_commit :enqueue_processing, on: :create
```
## Batch Processing
```ruby
# BAD - loads all records
User.all.each { |u| process(u) }
# GOOD - processes in batches
User.find_each { |u| process(u) }
# Bulk operations
User.where(old: true).in_batches.update_all(archived: true)
```
## Best Practices
### Do
- Add database index for columns used in WHERE, ORDER BY, JOIN
- Use `includes` to prevent N+1 queries
- Pair uniqueness validations with unique database indexes
- Use `find_each` for processing large datasets
- Use `pluck(:column)` instead of `all.map(&:column)`
- Define `inverse_of` when using custom `foreign_key`
- Use `after_commit` for background jobs and external APIs
- Prefer `has_many :through` over `has_and_belongs_to_many`
### Don't
- Don't use `default_scope` (causes subtle issues)
- Don't use `delete` when you need callbacks
- Don't skip database constraints for critical uniqueness
- Don't use `update_column` to bypass validations casually
- Don't reference models in migrations (use raw SQL)
- Don't edit already-deployed migrations
- Don't use `after_save` for external system interactions
## Anti-Patterns Quick List
| Anti-Pattern | Solution |
|--------------|----------|
| N+1 queries | Use `includes`, `preload`, or `eager_load` |
| `User.all.map(&:email)` | Use `User.pluck(:email)` |
| Uniqueness without index | Add unique database index |
| `validates :active, presence: true` | Use `inclusion: { in: [true, false] }` for booleans |
| `after_save` for jobs | Use `after_commit` |
| Callback hell | Extract to service objects |
| `default_scope` | Use explicit scopes |
| `has_and_belongs_to_many` | Use `has_many :through` |
## Additional Resources
### Reference Files
For detailed patterns and complete API references, consult:
- **`references/basics.md`** - Conventions, CRUD, dirty tracking, STI, type casting
- **`references/migrations.md`** - Schema changes, indexes, constraints, safe patterns
- **`references/validations.md`** - Built-in validators, custom validators, contexts
- **`references/callbacks.md`** - Lifecycle hooks, transaction callbacks, alternatives
- **`references/associations.md`** - All association types, inverse_of, dependent options
- **`references/querying.md`** - Finders, eager loading, scopes, batch processing
### Example Files
Ready-to-use code patterns in `examples/`:
- **`examples/basics/`** - CRUD, dirty tracking, type casting, inheritance
- **`examples/migrations/`** - Schema changes, indexes, safe patterns, reversibility
- **`examples/validations/`** - Built-in, conditional, custom, contexts, constraints
- **`examples/callbacks/`** - Lifecycle, transaction callbacks, conditional, alternatives
- **`examples/associations/`** - Basic, through, polymorphic, self-referential, extensions
- **`examples/querying/`** - Finders, eager loading, scopes, batch processing, optimization
Files in this package (35)
- SKILL.md 8 KB
- examples/associations/association_extensions.rb 7 KB
- examples/associations/basic_associations.rb 3 KB
- examples/associations/counter_caches.rb 6 KB
- examples/associations/polymorphic_associations.rb 6 KB
- examples/associations/self_referential.rb 8 KB
- examples/associations/through_associations.rb 5 KB
- examples/basics/crud_operations.rb 5 KB
- examples/basics/dirty_tracking.rb 7 KB
- examples/basics/inheritance.rb 9 KB
- examples/basics/type_casting.rb 8 KB
- examples/callbacks/alternatives_to_callbacks.rb 11 KB
- examples/callbacks/conditional_callbacks.rb 9 KB
- examples/callbacks/lifecycle_callbacks.rb 7 KB
- examples/callbacks/transaction_callbacks.rb 9 KB
- examples/migrations/indexes_and_constraints.rb 11 KB
- examples/migrations/reversible_patterns.rb 11 KB
- examples/migrations/safe_patterns.rb 12 KB
- examples/migrations/schema_changes.rb 8 KB
- examples/querying/batch_processing.rb 6 KB
- examples/querying/eager_loading.rb 8 KB
- examples/querying/finder_methods.rb 5 KB
- examples/querying/optimization.rb 8 KB
- examples/querying/scopes.rb 7 KB
- examples/validations/built_in_validators.rb 8 KB
- examples/validations/conditional_validations.rb 7 KB
- examples/validations/custom_validators.rb 11 KB
- examples/validations/database_constraints.rb 14 KB
- examples/validations/validation_contexts.rb 11 KB
- references/associations.md 18 KB
- references/basics.md 14 KB
- references/callbacks.md 16 KB
- references/migrations.md 16 KB
- references/querying.md 15 KB
- references/validations.md 15 KB
Versions
The database has no other skills named activerecord.
Database snapshot: 13.11.2026 · package version 2944fd024456 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 81rails-ai:models
Use when designing Rails models - ActiveRecord patterns, validations, callbacks, scopes, associations, concerns, query objects, form objects - 95rails-active-record-patterns
Use when active Record patterns including models, associations, queries, validations, and callbacks. - 100rails
Use when building or maintaining a Ruby on Rails app — models, controllers, views, routes and migrations; ActiveRecord associations, scopes and query performance; Hotwire (Turbo and Stimulus) UI; Active Job or Solid Queue background work; and Rails tests. Covers N+1 queries,… - 100n-plus-one-hunter
Detect ORM loop-of-queries (N+1) patterns from query logs and eliminate them with batched eager loading, keeping the N+1s that are cheap. Use when a list endpoint is slow, a request issues many near-identical SELECTs differing only by an id, query logs show repeated SELECTs in a… - 100advise-indexes
This skill should be used when the user asks which database indexes are missing, unused or redundant, or reviews a schema, model or migration for indexing, for example \"missing index\", \"add an index\", \"unindexed foreign key\", \"slow where clause\", \"slow order by\",… - 90find-n-plus-one
This skill should be used when the user reports or suspects slow pages or endpoints caused by many repeated queries, for example "N+1", "n plus one", "too many queries", "query per row", "lazy loading", "eager loading", "includes", "preload", "select_related",…