andrew-kane-gem-writer

Scaffold Ruby gems with entry points, DSL macros, and Rails integration.

Updated May 20, 2022
One-click install
npx skills add https://github.com/andrewhwaller/dotfiles --skill andrew-kane-gem-writer-andrewhwaller
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: andrew-kane-gem-writer
Source: https://github.com/andrewhwaller/dotfiles/tree/main/opencode/skills/andrew-kane-gem-writer
Command: npx skills add https://github.com/andrewhwaller/dotfiles --skill andrew-kane-gem-writer-andrewhwaller

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Writing Ruby gems with consistent structure and best-practice patterns is time-consuming and error-prone. This skill provides a ready blueprint aligned with Andrew Kane's philosophies to scaffold production-ready gems.

Core Features & Use Cases

  • Provides a standardized entry point structure and guidance for Rails integration, error handling, and testing conventions used across Kane-pattern gems.
  • Includes reference materials to explore module organization, rails integration, and testing patterns, enabling rapid adoption for new gems.
  • Serves as a blueprint for creating maintainable, production-grade Ruby libraries with minimal dependencies.

Quick Start

Create a new gem scaffold following Kane's patterns and place the entry point and DSL in the standard locations.

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 scaffold a Ruby gem with a clean structure and minimal dependencies?

Scaffold a Ruby gem by generating a standardized entry point with explicit loading, a class macro DSL, and error handling templates, enforcing a clean, maintainable structure with minimal dependencies.

What are Andrew Kane's design patterns for Ruby gem architecture?

Andrew Kane's Ruby gem patterns emphasize minimal dependencies, explicit loading, and a clean module organization. They include scaffolding a gem entry point, a class macro DSL, Rails integration guidelines, and standardized testing conventions.

How do I set up Rails integration and testing conventions for a new Ruby gem?

Set up Rails integration and testing conventions for a new Ruby gem by applying predefined templates that outline module organization and integration guidelines, enabling rapid adoption and a maintainable, production-grade structure.

What's the best way to structure a production-ready Ruby gem entry point?

The best way to structure a production-ready Ruby gem entry point is using a standardized blueprint with explicit loading and a class macro DSL, ensuring minimal dependencies and a clean architecture for new projects.

Do I need Rails to use these Ruby gem scaffolding patterns?

You do not need Rails to use the core Ruby gem scaffolding patterns, but the blueprint includes specific Rails integration guidelines and templates for gems that require framework integration.

When should I not use a minimal dependency approach for Ruby gem development?

You should not use a minimal dependency approach when your Ruby gem inherently relies on complex external libraries for its core functionality, as this pattern focuses on explicit loading and minimal external requirements.