rails-stack-conventions

Use when writing new Rails code for a project using PostgreSQL, Hotwire, and Tailwind CSS. Covers MVC structure, query patterns, Turbo Frames/Streams, Stimulus controllers, and Tailwind components. For design principles, use rails-code-conventions.

Quality

71%

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Passed

No known issues

Optimize this skill with Tessl

npx tessl skill review --optimize ./rails-stack-conventions/SKILL.md

Quality

Discovery

100%

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

This is a strong skill description that clearly identifies its scope (writing new Rails code with a specific tech stack), lists concrete capabilities, and includes explicit trigger guidance with a 'Use when' clause. The cross-reference to rails-code-conventions for design principles is a nice touch that reduces ambiguity. The only minor weakness is that it could mention a few more user-facing trigger variations (e.g., 'Ruby on Rails', '.rb files'), but the existing terms are already quite comprehensive.

Dimension	Reasoning	Score
Specificity	Lists multiple specific concrete actions and technologies: MVC structure, query patterns, Turbo Frames/Streams, Stimulus controllers, and Tailwind components. These are concrete, actionable areas rather than vague abstractions.	3 / 3
Completeness	Explicitly answers both 'what' (covers MVC structure, query patterns, Turbo Frames/Streams, Stimulus controllers, Tailwind components) and 'when' ('Use when writing new Rails code for a project using PostgreSQL, Hotwire, and Tailwind CSS'). Also includes a helpful scope boundary referencing rails-code-conventions for design principles.	3 / 3
Trigger Term Quality	Includes strong natural keywords users would say: 'Rails', 'PostgreSQL', 'Hotwire', 'Tailwind CSS', 'Turbo Frames', 'Turbo Streams', 'Stimulus controllers', 'MVC'. These are terms developers naturally use when requesting help with Rails development.	3 / 3
Distinctiveness Conflict Risk	Highly distinctive with a clear niche: Rails + PostgreSQL + Hotwire + Tailwind CSS stack. The explicit mention of the companion skill 'rails-code-conventions' for design principles further reduces conflict risk by drawing a clear boundary between this skill and a related one.	3 / 3
	Total	12 / 12 Passed

Implementation

42%

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

This skill is well-organized with good use of tables and clear cross-references to companion skills, but it suffers from a lack of actionable, executable examples—it reads more like a style guide checklist than an instructional skill. There is significant redundancy across sections (N+1 queries, style guide adherence, etc.), and much of the content restates conventions Claude already knows without adding project-specific value.

Suggestions

Add concrete, executable code examples for key patterns (e.g., a Turbo Frame snippet, a service object template, an eager loading example with includes) to raise actionability significantly.

Deduplicate repeated guidance—consolidate N+1/eager loading, style guide references, and security mentions into single authoritative locations rather than repeating across Quick Reference, body sections, Common Mistakes, and Red Flags.

Add a concrete TDD example in the HARD-GATE section showing actual commands (e.g., `bundle exec rspec spec/models/user_spec.rb`) and expected output for the fail-then-implement cycle.

Remove generic advice Claude already knows (e.g., 'Exceptions for exceptional cases', 'Descriptive names', 'OOP and functional patterns as appropriate') to improve token efficiency.

Dimension	Reasoning	Score
Conciseness	The skill is reasonably organized with tables and short sections, but contains significant redundancy—many conventions are stated multiple times (e.g., N+1/eager loading appears in Quick Reference, Ruby and Rails, Performance, Common Mistakes, and Red Flags). Several sections restate things Claude already knows (e.g., 'Exceptions for exceptional cases, not control flow', 'Descriptive names'). Could be tightened considerably.	2 / 3
Actionability	The skill is almost entirely declarative guidance with no executable code examples, no concrete commands, and no copy-paste-ready snippets. Statements like 'Use ActiveRecord effectively' and 'Prefer Rails built-in helpers' are vague directions rather than actionable instructions. Even the TDD hard-gate lacks a concrete example of the workflow with actual commands.	1 / 3
Workflow Clarity	The HARD-GATE section provides a clear 3-step TDD sequence, which is good, but it delegates the full cycle to another skill without showing validation commands. The rest of the skill has no workflow sequencing—it's a collection of guidelines rather than step-by-step processes. The TDD gate does include a basic feedback loop (verify failure before implementing).	2 / 3
Progressive Disclosure	The Integration table clearly signals related skills with one-level-deep references and explains when to chain each one. The content is well-structured with distinct sections, tables for quick scanning, and appropriate delegation to companion skills (rails-code-conventions, rspec-best-practices, etc.).	3 / 3
	Total	8 / 12 Passed

Validation

100%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 11 / 11 Passed

Validation for skill structure

No warnings or errors.

Repository: igmarin/rails-agent-skills
Commit: ae8ea63

Reviewed: 3 days ago

Table of Contents

Discovery Implementation Validation

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.