Skip to content
Back to search

vladikk-modularity

MarketplaceWorks with Claude CodeGitHub

Claude Code plugin for designing modular systems from functional requirements and reviewing existing codebases for modularity problems with actionable improvement recommendations. Based on the Balanced Coupling model.

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/vladikk-modularity/badge.svg)](/listings/vladikk-modularity)

HTML

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

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Requires [Claude Code](https://code.claude.com/docs/en/quickstart) v1.0.33 or later.

Add the marketplace and install the plugin:

/plugin marketplace add vladikk/modularity
/plugin install modularity@vladikk-modularity

Alternatively, clone the repo and load it directly:

git clone https://github.com/vladikk/modularity.git
claude --plugin-dir ./modularity

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 · 13 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": "vladikk-modularity",
  3. "owner": {
  4. "name": "Vlad Khononov"
  5. },
  6. "plugins": [
  7. {
  8. "name": "modularity",
  9. "source": "./",
  10. "description": "Design and analyze modular software systems using the Balanced Coupling model"
  11. }
  12. ]
  13. }
README.md · README · 111 lines

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

  1. # Modularity Skills
  2. **TL;DR:** A [Claude Code](https://code.claude.com) plugin for designing and analyzing modular software systems using the [Balanced Coupling](https://coupling.dev) model.
  3. There's no shortage of AI tools that provide code-level feedback: best practices, edge cases, potential bugs. That's useful, but it's not where the costly mistakes hide. In the AI era, code is generated faster than ever, and so technical debt accumulates faster too. Any architectural inefficiency, any misdrawn boundary, any unmanaged coupling will grow into a big ball of mud at a pace that wasn't possible before.
  4. This plugin operates at the architectural level. It includes two skills:
  5. - **`/modularity:review`** analyzes an existing codebase for coupling imbalances: what knowledge is properly encapsulated, what's leaking across component boundaries, and where cascading changes are waiting to happen. It produces actionable recommendations for improving modularity.
  6. - **`/modularity:design`** goes the other direction, designing modular architectures from functional requirements and producing module design docs with integration contracts, test specifications, and a full coupling assessment.
  7. Both skills are grounded in the [Balanced Coupling](https://coupling.dev) model, so every recommendation traces back to a concrete dimension (integration strength, distance, volatility), not gut feel.
  8. > _"One of the most useful Claude Code skills for your vibe-coded projects so far!"_ — Alexei Ledenev ([pumba](https://github.com/alexei-led/pumba), [k8s-mcp-server](https://github.com/alexei-led/k8s-mcp-server), [ccgram](https://github.com/alexei-led/ccgram))
  9. ## Installation
  10. Requires [Claude Code](https://code.claude.com/docs/en/quickstart) v1.0.33 or later.
  11. Add the marketplace and install the plugin:
  12. ```
  13. /plugin marketplace add vladikk/modularity
  14. /plugin install modularity@vladikk-modularity
  15. ```
  16. Alternatively, clone the repo and load it directly:
  17. ```bash
  18. git clone https://github.com/vladikk/modularity.git
  19. claude --plugin-dir ./modularity
  20. ```
  21. ## Skills
  22. ### `/modularity:review` — Modularity Review
  23. Analyzes an existing codebase for coupling imbalances. Use when:
  24. - Reviewing code for coupling problems
  25. - Assessing architecture quality
  26. - Identifying distributed monolith risks
  27. - Investigating why changes in one area break things elsewhere
  28. **How it works:**
  29. 1. Reads your code and functional requirements
  30. 2. Asks you about domain classification (core/supporting/generic), team structure, and known pain points
  31. 3. Maps integrations between components across three dimensions: integration strength, distance, and volatility
  32. 4. Applies the balance rule to flag imbalances
  33. 5. Produces a review document (Markdown + HTML) with a coupling overview table, issue descriptions, and concrete improvement recommendations
  34. **Usage:**
  35. ```
  36. /modularity:review
  37. ```
  38. The review output includes hyperlinks to [coupling.dev](https://coupling.dev) for each coupling concept referenced.
  39. ### `/modularity:design` — Modular Design
  40. Designs modular architectures from functional requirements. Use when:
  41. - Designing a new system from scratch
  42. - Creating architecture documentation for an existing system
  43. - Producing module-level design specs with integration contracts and test specifications
  44. **How it works:**
  45. 1. Reads your functional requirements and asks clarifying questions
  46. 2. Classifies domain areas by volatility (core/supporting/generic subdomains)
  47. 3. Designs the modular architecture, assessing coupling across all three dimensions
  48. 4. Produces design documents for each module (responsibilities, encapsulated knowledge, integration contracts, change vectors)
  49. 5. Produces test specifications for each module
  50. 6. Produces an architecture overview document
  51. 7. Self-reviews the design for modularity imbalances and iterates until clean
  52. Each step requires your approval before proceeding.
  53. **Usage:**
  54. ```
  55. /modularity:design
  56. ```
  57. ## The Balanced Coupling Model
  58. Both skills are grounded in the Balanced Coupling model, which evaluates coupling across three dimensions:
  59. - **Integration Strength** — how much knowledge is shared between components (intrusive > functional > model > contract)
  60. - **Distance** — the socio-technical cost of co-evolving components (code structure, team boundaries, runtime dependencies)
  61. - **Volatility** — the probability of a component needing to change, evaluated from the business domain perspective
  62. The balance rule: `BALANCE = (STRENGTH XOR DISTANCE) OR NOT VOLATILITY`
  63. Coupling is balanced when strength and distance counterbalance each other, or when volatility is low enough to neutralize the imbalance.
  64. Learn more at [coupling.dev](https://coupling.dev).
  65. ## Recommended Models
  66. Claude Opus 4.5 or later. The skills rely on nuanced architectural reasoning that benefits from the most capable models.
  67. ## License
  68. This work is licensed under [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/). For commercial use, contact skill at coupling dot dev.
  69. ## AI Training Restriction
  70. This repository and its contents may not be used for training, fine-tuning, or any other form of machine learning model development without explicit written permission from the author.

Ratings and comments

Sign in to rate this skill.

Sign in

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