andrew-kane-gem-writer

Generate Ruby gem skeletons with explicit entry-point and class macro DSL structures.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/Folly-Partners/claudesync --skill andrew-kane-gem-writer-folly-partners
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: andrew-kane-gem-writer
Source: https://github.com/Folly-Partners/claudesync/tree/main/plugins/cache/every-marketplace/compound-engineering/2.23.1/skills/andrew-kane-gem-writer
Command: npx skills add https://github.com/Folly-Partners/claudesync --skill andrew-kane-gem-writer-folly-partners

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This skill helps developers create Ruby gems that follow Andrew Kane's proven patterns and design philosophy, reducing boilerplate and delivering production-ready libraries.

Core Features & Use Cases

  • Explicit entry-point structure: standard gem skeleton with a minimal, understandable lib layout.
  • Class macro DSL: single-call configuration to wire gem behavior and modules.
  • Rails integration best practices: use ActiveSupport.on_load patterns to extend Rails safely.
  • Testing and gemspec guidance: aligns with Kane's testing approaches and minimal dependency principles.

Quick Start

Use this skill to generate a new gem skeleton by providing a gem name and optional options; the AI will produce a ready-to-extend structure following Kane's patterns.

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 design a Ruby gem following production-ready patterns?

Design Ruby gems with explicit entry-point structure, class macro DSL for configuration, and Rails integration via ActiveSupport.on_load patterns. Andrew Kane's approach minimizes boilerplate while maintaining clarity, reducing common architectural mistakes in gem development.

What's the best way to structure a new Ruby gem for Rails integration?

Use an explicit gem skeleton with minimal lib layout, implement class macros for single-call configuration, and apply on_load patterns to extend Rails safely without forcing dependencies. This structure scales from standalone gems to Rails-specific libraries.

How do I create a class macro DSL for gem configuration?

Define a class macro that wires gem behavior and modules through a single declarative call. Kane's pattern encapsulates configuration logic, making gems easier to test and document while keeping the API surface minimal and predictable.

Can I use Andrew Kane patterns with standalone Ruby gems, or only Rails?

Kane's patterns work for both standalone Ruby libraries and Rails applications. The explicit entry-point structure and macro DSL approach remain independent of Rails; on_load integration is optional and only applied when Rails is present.

What testing and dependency practices should I follow when building gems?

Align testing with Kane's minimal dependency philosophy: use clear testing conventions, avoid unnecessary external dependencies, and keep gemspec lean. This reduces maintenance burden and makes gems more composable within larger ecosystems.

Why should I refactor an existing gem using Kane patterns?

Refactoring to Kane patterns clarifies gem architecture, reduces boilerplate, improves testability, and makes APIs more predictable. The explicit structure and macro DSL approach surface design intent, making gems easier for users to understand and contribute to.