Skip to content
Back to search

skills

Skills based on the Layered Rails book and beyond

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/palkan--skills/badge.svg)](/listings/palkan--skills)

HTML

<a href="/listings/palkan--skills"><img src="/api/listings/palkan--skills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 25 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "layered-rails-skills",
  3. "owner": {
  4. "name": "Vladimir Dementyev",
  5. "url": "https://github.com/palkan"
  6. },
  7. "metadata": {
  8. "description": "A collection of Claude Code skills by Vladimir Dementyev",
  9. "version": "3.1.0"
  10. },
  11. "plugins": [
  12. {
  13. "name": "layered-rails",
  14. "description": "Design and review Rails applications using layered architecture principles from 'Layered Design for Ruby on Rails Applications'",
  15. "version": "3.1.0",
  16. "author": {
  17. "name": "Vladimir Dementyev",
  18. "url": "https://github.com/palkan"
  19. },
  20. "homepage": "https://github.com/palkan/layered-rails-skills",
  21. "tags": ["rails", "ruby", "architecture", "layered-design", "code-review"],
  22. "source": "./layered-rails"
  23. }
  24. ]
  25. }
README.md · README · 101 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Layered Rails Skills
  2. Design and review Rails applications using layered architecture principles from the [Layered Design for Ruby on Rails Applications](https://www.packtpub.com/en-us/product/layered-design-for-ruby-on-rails-applications-9781806114221) book.
  3. The bundled plugins and slash commands target [Claude Code](https://docs.anthropic.com/en/docs/claude-code), while the core skill content (`SKILL.md` + workflows + references + examples) is also usable from other environments such as Codex.
  4. **Install (recommended — full plugin with commands and sub-agents):**
  5. ```
  6. /plugin marketplace add palkan/layered-rails-skills
  7. /plugin install layered-rails@layered-rails-skills
  8. ```
  9. **Commands:**
  10. | Command | Purpose |
  11. |---------|---------|
  12. | `/layered-rails:analyze` | Full codebase architecture analysis |
  13. | `/layered-rails:analyze-services` | Audit `app/services/` — conventions, clusters, layer hygiene, test consequences |
  14. | `/layered-rails:analyze-callbacks` | Score model callbacks, find extraction candidates |
  15. | `/layered-rails:analyze-gods` | Find god objects via churn x complexity |
  16. | `/layered-rails:review` | Review code changes for layer violations |
  17. | `/layered-rails:spec-test` | Run specification test on specific files |
  18. | `/layered-rails:plan [goal]` | Plan incremental adoption of layered patterns |
  19. | `/layered-rails:archspec` | Generate and verify an `Archspec.rb` enforcing layer boundaries in CI |
  20. **Install via [skills.sh](https://skills.sh/) (skill content only — no slash-command bindings):**
  21. ```
  22. npx skills add palkan/layered-rails-skills --skill layered-rails
  23. ```
  24. skills.sh delivers the `skills/layered-rails/` tree — `SKILL.md`, `workflows/`, `references/`, and `examples/`. The `/layered-rails:*` slash commands and the `layered-rails-planner` / `layered-rails-reviewer` sub-agent registrations are not part of the skill spec and won't be copied, but every workflow they wrap is in `workflows/` and can be invoked by name in plain language ("run the layered-rails review workflow on this diff"). Use this path when you want the same skill in Codex, the Claude API, or any other agent that supports skills.sh; use `/plugin install` when you want the slash commands.
  25. **Install via [rails-hyperdrive](https://github.com/rails-hyperdrive/rails-hyperdrive) (Rails apps — bundle-aware, commands and sub-agents included):**
  26. ```ruby
  27. group :development do
  28. gem "rails-hyperdrive", ">= 0.8"
  29. gem "layered-rails-skills"
  30. end
  31. ```
  32. ```sh
  33. bin/rails hyperdrive:init
  34. ```
  35. Installs the same skill tree into `.claude/skills/layered-rails/`, tailored to the app's bundle: the architecture core installs into any Rails app, while each per-gem reference manual under `references/gems/` (Action Policy, ViewComponent, Alba, …) installs only when its gem is in the app's `Gemfile.lock` (the archspec manual is the exception — it installs unconditionally, since its job is to introduce that gem) — gating declared in [`hyperdrive.yml`](hyperdrive.yml) at the repo root — and `SKILL.md`'s Gem References table lists only what was installed. `bin/rails hyperdrive:sync` picks up updates on gem upgrades.
  36. The commands and sub-agents come along too, into `.claude/commands/` and `.claude/agents/`. Since that directory has no plugin namespace, the commands install prefixed — `/layered-rails-analyze` rather than `/layered-rails:analyze` — and the two sub-agents keep their names.
  37. ## Integration with compound-engineering
  38. We recommend asking Claude itself to update the instructions for Compound Engineering to include Layered Design features according to your needs. Below you can find some examples.
  39. If you use the [compound-engineering](https://github.com/EveryInc/compound-engineering-plugin) plugin, add explicit instructions to include layered-rails planning and reviewing agents.
  40. In your `compound-engineering.local.md` file:
  41. ```md
  42. ---
  43. review_agents:
  44. - layered-rails:layered-rails-reviewer
  45. - rails-reviewer
  46. - security-sentinel
  47. # - ...
  48. ---
  49. # ...
  50. # also worth adding something like:
  51. We are **gradually adopting layered design principles** from "Layered Design for Ruby on Rails Applications" — clean abstraction boundaries, explicit layers, and specification tests...
  52. ```
  53. Similarly, for planning features, add to your `CLAUDE.md` (or `AGENTS.md`, or whatever) smth like:
  54. ```md
  55. # ...
  56. ## For planning agents
  57. When planning new features or architectural changes, use the `layered-rails` skill for analysis:
  58. - `/layered-rails:plan` — plan incremental adoption of layered patterns
  59. - `/layered-rails:analyze` — full codebase architecture analysis
  60. - `/layered-rails:review` — review code from a layered architecture perspective
  61. - `/layered-rails:spec-test` — apply the specification test to evaluate layer placement
  62. ```
  63. Alternatively, you can try to add shorter instructions to `CLAUDE.md`:
  64. ```md
  65. Extend the list of **review agents** with the `layered-rails:layered-rails-reviewer` agent to check for architecture layer violations. Must be applicable to such commands from the compound-engineering plugin as `/workflow:review`, `/plan_review`, and similar.
  66. Extend the list of **planning agents** with the `layered-rails:layered-rails-planner` agent to plan refactoring according to the layered design principles. Must be applicable to such commands from the compound-engineering plugin as `/workflow:plan`, `/deepen_plan`, and similar.
  67. ```
  68. ## License
  69. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.