Skip to content
Skills Library
Programming · Building & coding

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

Licence
MIT
Last repository change
07.09.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
35
Scripts
28
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 07.09.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 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

write a migrationadd a columnadd column to tablecreate an indexadd a foreign keyset up associationsfix N+1 queriesoptimize queries
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

  1. Quick Reference
  2. Eager Loading Decision Tree
  3. Validation vs Constraint Decision
  4. Associations Quick Reference
  5. Migrations Quick Reference
  6. Callbacks Quick Reference
  7. Batch Processing
  8. Best Practices
  9. Anti-Patterns Quick List
  10. Additional Resources
Original SKILL.md headings · 252 lines, 988 words
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",…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.