andrew-kane-gem-writer

Write Ruby gems following Andrew Kane's design patterns.

Updated Jan 21, 2026
One-click install
npx skills add https://github.com/ollieb89/orchestrator --skill andrew-kane-gem-writer-ollieb89
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: andrew-kane-gem-writer
Source: https://github.com/ollieb89/orchestrator/tree/main/.cursor/skills/andrew-kane-gem-writer
Command: npx skills add https://github.com/ollieb89/orchestrator --skill andrew-kane-gem-writer-ollieb89

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This skill helps developers write Ruby gems strictly following Andrew Kane's design patterns, ensuring maintainable, production-ready code with a clear structure and Rails-friendly integration patterns.

Core Features & Use Cases

  • Pattern-driven gem scaffolding: Sets up a minimal, dependency-light gem layout with a clear entry point and modular structure.
  • Rails-safe integration: Encourages on_load hooks for Rails integration instead of direct requires, enabling safe, lazy loading.
  • DSL-driven configuration: Provides a single-method class macro pattern for configuring gem behavior and options.
  • Reference patterns: Documents best practices and anti-patterns with concrete examples for entry points, class macros, and engine patterns.

Quick Start

Create a new Ruby gem following Kane's patterns with a minimal, production-ready structure.

Frequently Asked Questions about andrew-kane-gem-writer

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I structure a Ruby gem for modular architecture and production readiness?

Structure a Ruby gem using a modular entry-point layout at lib/gemname.rb with explicit requires, minimal dependencies, and Rails-safe on_load integration to achieve production readiness and maintainable code.

What is the best way to integrate a Ruby gem with Rails without causing load-time issues?

The best way to integrate a Ruby gem with Rails is using on_load hooks instead of direct requires, enabling safe, lazy loading that prevents load-time conflicts and initialization issues within the Rails application.

How do I implement DSL-driven configuration in a Ruby gem?

Implement DSL-driven configuration in a Ruby gem by applying a single-method class macro pattern for configuring gem behavior and options, providing a clean and predictable interface for users.

Can I use these gem patterns to refactor an existing Ruby API?

Yes, you can use these patterns to refactor an existing Ruby API by aligning its structure with a modular entry-point layout, enforcing explicit requires, and applying Rails-safe on_load integration.

Why should I use explicit requires and minimal dependencies in a Ruby gem?

Use explicit requires and minimal dependencies in a Ruby gem to ensure maintainable, production-ready code with a clear structure that avoids unnecessary bloat and conflicts in the host application.