experiments

Enforces idiomatic Ruby 4.0 code generation. This skill should be used whenever writing, reviewing, or refactoring Ruby code in a Ruby 4.0+ project. It ensures modern idioms (hash shorthand, `it` block param, endless methods, Data.define, pattern matching) are used by default and prevents generation of removed APIs (RJIT, pipe-based open, ObjectSpace._id2ref, old Ractor API, SortedSet, full CGI) and pre-4.0 patterns that have cleaner modern equivalents.

Use the bttf CLI for datetime arithmetic, formatting, timezone conversion, and duration calculation. Reach for this instead of doing date math mentally — LLMs are unreliable for datetime computation, especially across DST boundaries and leap years.

Apply SOLID as design judgment for Ruby, not as a mechanical rulebook. Use this skill when deciding WHETHER a SOLID refactor is warranted, when a class "feels wrong" but you're not sure splitting helps, when reviewing code for over-application (anemic models, service-object sludge, concern drawers, over-injection), or when reasoning about how Ruby's open classes, duck typing, and protocols change what each principle actually buys you. Complements the solid-principles skill, which covers detection heuristics and refactoring mechanics.

Convert speech to text with RubyLLM. Use this skill for transcribing meetings, podcasts, lectures, interviews with support for speaker diarization, timestamps, and multiple languages.

ActiveSupport::Notifications instrumentation for RubyLLM. Use this skill when building custom monitoring, logging, or analytics for RubyLLM usage. Publishes events for chat completions, tools, embeddings, images, moderation, and transcription.

One beautiful Ruby API for GPT, Claude, Gemini, and more. Use this skill when building AI-powered applications with RubyLLM - chatbots, AI agents, RAG applications, content generators, vision/audio analysis, embeddings, image generation, and Rails integration. Supports 15+ providers with a unified interface. v1.16 adds concurrent tool execution (threads or fibers), built-in instrumentation, and per-provider API base URL overrides.

Function calling for RubyLLM. Use this skill when creating tools that let AI call your Ruby code, declaring parameters with the params DSL, using tools in chat, monitoring tool calls with callbacks, handling tool security, and implementing advanced patterns like halt, provider-specific parameters, and concurrent tool execution (v1.16+).

Create, analyze, proofread, and modify Office documents (.docx, .xlsx, .pptx) using the officecli CLI tool. Use when the user wants to create, inspect, check formatting, find issues, add charts, or modify Office documents.

Use when building, changing, or extending a software project so work stays continuous, prioritized, and consistent across sessions

Use while building or maintaining a project to continuously improve the development system itself by fixing recurring process failures, tightening docs/skills, and proposing larger improvements when uncertain

OpenTelemetry tracing for RubyLLM. Use this skill when you need observability into LLM applications with support for Langfuse, Datadog, Honeycomb, Jaeger, Arize Phoenix, and any OpenTelemetry-compatible backend.

Local LLM execution with quantized GGUF models for RubyLLM. Use this skill when running models locally for zero latency, no API costs, complete privacy, and offline capability. Supports Metal (macOS), CUDA (NVIDIA), and CPU.

Ruby DSL for JSON Schema creation. Use this skill when defining structured data schemas for LLM function calling or structured outputs with RubyLLM. Provides Rails-inspired API for creating complex nested schemas.

Define reusable AI assistants with RubyLLM::Agent. Use this skill when creating class-based agents with persistent configuration, runtime context, prompt management, Rails-backed agents, and agentic workflows.

Rails integration for RubyLLM. Use this skill when setting up ActiveRecord-backed chats, Hotwire/Turbo streaming, background job processing, chat UI generation, agents in Rails, file attachments with ActiveStorage, and multi-tenant LLM contexts.

Use when writing, reviewing, or analyzing a screenplay — evaluating character depth, story motivation, plot construction, narrative structure, or dramatic conflict. Also use when a screenplay feels flat, aimless, or lacks tension.

Generate vector embeddings with RubyLLM. Use this skill for semantic search, recommendations, content similarity, RAG applications, and any task requiring numerical text representations.

Generate images from text with RubyLLM. Use this skill for creating images with DALL-E 3, GPT Image 1, Imagen, editing existing images, and working with masks for constrained editing.

Model Context Protocol (MCP) client for RubyLLM. Use this skill when connecting RubyLLM to MCP servers for tools, resources, and prompts. Supports stdio, HTTP streaming, and SSE transports with OAuth 2.1 authentication.

Content safety checking with RubyLLM. Use this skill to identify potentially harmful content in text before sending to LLMs, screen user inputs, and moderate AI outputs for safety.

Rails engine for RubyLLM monitoring dashboards and alerts. Use this skill when you need visibility into LLM costs, throughput, response times, and error rates. Captures events from ruby_llm-instrumentation.

LLM evaluation and testing for RubyLLM. Use this skill when you need to verify AI response quality, test for hallucinations, check safety, run red team attacks, or integrate LLM-as-judge assertions into your test suite.

This skill should be used when writing or editing public announcements of new versions for Ruby gems and command-line utilities. It provides structured guidance for crafting authentic release announcements that use honest facts instead of marketing hyperbole, ensuring readers trust the software's actual capabilities.

Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.

This skill should be used during all code development work to maintain future-proof documentation practices. It ensures code comments explain "why" not "what," maintains a DECISIONS.md log of architectural and design decisions, keeps a SCRATCHPAD.md session journal for context continuity, and treats the README as an operational runbook. This skill activates proactively during normal coding, not only when documentation is explicitly requested.

Incrementally upgrade Rails `config.load_defaults` by walking through each new_framework_defaults config one at a time. Use this skill whenever the user mentions load_defaults upgrade, new_framework_defaults, framework defaults, or wants to bring their Rails app's default configuration up to match their Rails version. Also trigger when the user mentions a gap between their Rails version and their load_defaults version (e.g., "app is on Rails 7.2 but load_defaults is 6.1"). This skill handles the iterative uncomment-test-commit workflow and the final consolidation into config/application.rb.

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.

This skill should be used when the user asks to "create a decorator", "write a decorator", "move logic into decorator", "clean logic out of the view", "isn't it decorator logic", "test a decorator", or mentions Draper, keeping views clean, or representation logic in decorators. Should also be used when editing *_decorator.rb files, working in app/decorators/ directory, questioning where formatting methods belong (models vs decorators vs views), or discussing methods like full_name, formatted_*, display_* that don't belong in models. Provides guidance on Draper gem best practices for Rails applications.

This skill should be used when the user asks to "create an MCP server", "build MCP tools", "define MCP prompts", "register MCP resources", "implement Model Context Protocol", or mentions the mcp gem, MCP::Server, MCP::Tool, JSON-RPC transport, stdio transport, or streamable HTTP transport. Should also be used when editing MCP server files, working with tool/prompt/resource definitions, or discussing LLM tool integrations in Ruby.

This skill should be used when the user asks to "write specs", "create spec", "add RSpec tests", "fix failing spec", or mentions RSpec, describe blocks, it blocks, expect syntax, test doubles, or matchers. Should also be used when editing *_spec.rb files, working in spec/ directory, planning implementation phases that include tests (TDD/RGRC workflow), writing Testing Strategy or Success Criteria sections, discussing unit or integration tests, or reviewing spec output and test failures. Comprehensive RSpec and FactoryBot reference with best practices, ready-to-use patterns, and examples.

Configure recommended Rails development dependencies. Checks for essential gems like strong_migrations, herb, bullet, and letter_opener. Provides installation and configuration guidance.

Design and review Rails applications using Vanilla Rails philosophy from 37signals/Basecamp. Emphasizes thin controllers, rich domain models, and avoiding unnecessary service layers. Use when analyzing Rails codebases, reviewing PRs, or refactoring toward simpler architecture. Triggers on "service layer", "service object", "thin controller", "rich model", "vanilla rails", "dhh style", "over-engineering", "unnecessary abstraction".

Use when building Rails 7+ web applications with Hotwire, real-time features, or background job processing. Invoke for Active Record optimization, Turbo Frames/Streams, Action Cable, Sidekiq.

Analyzes Rails applications and generates comprehensive upgrade reports with breaking changes, deprecations, and step-by-step migration guides for Rails 7.0 through 8.1.1. Use when upgrading Rails applications, planning multi-hop upgrades, or querying version-specific changes.

Design and review Rails applications using layered architecture principles from "Layered Design for Ruby on Rails Applications". Use when analyzing Rails codebases, reviewing PRs for architecture violations, planning feature implementations, or implementing patterns like authorization, view components, or AI integration. Triggers on "layered design", "architecture layers", "abstraction", "specification test", "layer violation", "extract service", "fat controller", "god object".

Perform comprehensive code audits of Ruby on Rails applications based on thoughtbot best practices. Use this skill when the user requests a code audit, code review, quality assessment, or analysis of a Rails application. The skill analyzes the entire codebase focusing on testing practices (RSpec), security vulnerabilities, code design (skinny controllers, domain models, PORO with ActiveModel), Rails conventions, database optimization, and Ruby best practices. Outputs a detailed markdown audit report grouped by category (Testing, Security, Models, Controllers, Code Design, Views) with severity levels (Critical, High, Medium, Low) within each category.

Performs thorough code review on git changes. Analyzes diffs for bugs, security issues, performance problems, and design concerns. Produces actionable feedback organized by severity. Use when reviewing code, checking a PR, or when the user says /smart-review.

Structured software development workflow that moves from specification through planning and review to test-driven implementation. Creates specs, breaks work into stories, defines test contracts, reviews plans with a devil's advocate agent, and builds features test-first. Use when building a new feature, refactoring a module, or when the user says /spec-dev.

Perform architectural review of Ruby gems and libraries. Evaluate API design, module organization, dependency management, Rails integration safety, testability, and extension patterns. Use when reviewing an existing gem's architecture, auditing a gem before adoption, preparing a gem for open-source release, or refactoring a library's internal structure. Complements the andrew-kane-gem-writer skill which handles gem creation.

Apply SOLID principles when writing, reviewing, or refactoring Ruby code. This skill should be used when designing classes, evaluating architecture, reviewing pull requests, or refactoring existing code. It provides actionable checklists, violation detection patterns, and Ruby-idiomatic refactoring strategies for each of the five SOLID principles.