ruby-optimise

Original：🇺🇸 English

Translated

Ruby performance optimization guidelines. This skill should be used when writing, reviewing, or refactoring Ruby code to ensure optimal performance patterns. Triggers on tasks involving object allocation, collection processing, ActiveRecord queries, string handling, concurrency, or Ruby runtime configuration.

1installs

Sourcepproenca/dot-skills

Added on2026-02-14

NPX Install

npx skill4agent add pproenca/dot-skills ruby-optimise

SKILL.md Content

View Translation Comparison →

Community Ruby Best Practices

Comprehensive performance optimization guide for Ruby applications, maintained by the community. Contains 42 rules across 8 categories, prioritized by impact to guide automated refactoring and code generation.

When to Apply

Reference these guidelines when:

Writing new Ruby code or gems
Optimizing ActiveRecord queries and database access patterns
Processing large collections or building data pipelines
Reviewing code for memory bloat and GC pressure
Configuring Ruby runtime settings for production

Rule Categories by Priority


alloc-
enum-
io-
str-
meth-
ds-
conc-
runtime-

Priority	Category	Impact	Prefix
1	Object Allocation	CRITICAL	`alloc-`
2	Collection & Enumeration	CRITICAL	`enum-`
3	I/O & Database	HIGH	`io-`
4	String Handling	HIGH	`str-`
5	Method & Dispatch	MEDIUM-HIGH	`meth-`
6	Data Structures	MEDIUM	`ds-`
7	Concurrency	MEDIUM	`conc-`
8	Runtime & Configuration	LOW-MEDIUM	`runtime-`

Quick Reference

1. Object Allocation (CRITICAL)

```
alloc-avoid-unnecessary-dup
```
- Avoid Unnecessary Object Duplication
```
alloc-freeze-constants
```
- Freeze Constant Collections
```
alloc-lazy-initialization
```
- Use Lazy Initialization for Expensive Objects
```
alloc-avoid-temp-arrays
```
- Avoid Temporary Array Creation
```
alloc-reuse-buffers
```
- Reuse Buffers in Loops
```
alloc-avoid-implicit-conversions
```
- Avoid Repeated Computation in Hot Paths

2. Collection & Enumeration (CRITICAL)

```
enum-single-pass
```
- Use Single-Pass Collection Transforms
```
enum-lazy-large-collections
```
- Use Lazy Enumerators for Large Collections
```
enum-flat-map
```
- Use flat_map Instead of map.flatten
```
enum-each-with-object
```
- Use each_with_object Over inject for Building Collections
```
enum-avoid-count-in-loops
```
- Avoid Recomputing Collection Size in Conditions
```
enum-chunk-batch-processing
```
- Use each_slice for Batch Processing

3. I/O & Database (HIGH)

```
io-eager-load-associations
```
- Eager Load ActiveRecord Associations
```
io-select-only-needed-columns
```
- Select Only Needed Columns
```
io-batch-find-each
```
- Use find_each for Large Record Sets
```
io-avoid-queries-in-loops
```
- Avoid Database Queries Inside Loops
```
io-stream-large-files
```
- Stream Large Files Line by Line
```
io-connection-pool-sizing
```
- Size Connection Pools to Match Thread Count
```
io-cache-expensive-queries
```
- Cache Expensive Database Results

4. String Handling (HIGH)

```
str-frozen-literals
```
- Enable Frozen String Literals
```
str-shovel-over-plus
```
- Use Shovel Operator for String Building
```
str-interpolation-over-concatenation
```
- Use String Interpolation Over Concatenation
```
str-avoid-repeated-gsub
```
- Chain gsub Calls into a Single Replacement
```
str-symbol-for-identifiers
```
- Use Symbols for Identifiers and Hash Keys

5. Method & Dispatch (MEDIUM-HIGH)

```
meth-avoid-method-missing-hot-paths
```
- Avoid method_missing in Hot Paths
```
meth-cache-method-references
```
- Cache Method References for Repeated Calls
```
meth-block-vs-proc
```
- Pass Blocks Directly Instead of Converting to Proc
```
meth-avoid-dynamic-send
```
- Avoid Dynamic send in Performance-Critical Code
```
meth-reduce-method-chain-depth
```
- Reduce Method Chain Depth in Hot Loops

6. Data Structures (MEDIUM)

```
ds-set-for-membership
```
- Use Set for Membership Tests
```
ds-struct-over-openstruct
```
- Use Struct Over OpenStruct
```
ds-sort-by-over-sort
```
- Use sort_by Instead of sort with Block
```
ds-array-preallocation
```
- Preallocate Arrays When Size Is Known
```
ds-hash-default-value
```
- Use Hash Default Values Instead of Conditional Assignment

7. Concurrency (MEDIUM)

```
conc-fiber-for-io
```
- Use Fibers for I/O-Bound Concurrency
```
conc-thread-pool-sizing
```
- Size Thread Pools to Match Workload
```
conc-ractor-cpu-bound
```
- Use Ractors for CPU-Bound Parallelism
```
conc-avoid-shared-mutable-state
```
- Avoid Shared Mutable State Between Threads

8. Runtime & Configuration (LOW-MEDIUM)

```
runtime-enable-yjit
```
- Enable YJIT for Production
```
runtime-tune-gc-parameters
```
- Tune GC Parameters for Your Workload
```
runtime-frozen-string-literal-default
```
- Set Frozen String Literal as Project Default
```
runtime-optimize-require
```
- Optimize Require Load Order

How to Use

Read individual reference files for detailed explanations and code examples:

Section definitions - Category structure and impact levels
Rule template - Template for adding new rules

Reference Files

File	Description
references/_sections.md	Category definitions and ordering
assets/templates/_template.md	Template for new rules
metadata.json	Version and reference information