From frontend-skills
Shared vocabulary for designing deep modules. Use when the user wants to design or improve a module interface, find deepening opportunities, decide where a seam goes, make code more testable or AI-navigable, or when another skill needs deep-module vocabulary.
How this skill is triggered — by the user, by Claude, or both
Slash command
/frontend-skills:codebase-designThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
Repo/code changes: run `/deslop` before commit, push, PR, or merge.
Repo/code changes: run /deslop before commit, push, PR, or merge.
Design deep modules: much behavior behind a small interface at a clean seam, testable through that interface. Aim: leverage for callers, locality for maintainers, testability for agents and people.
Use these terms exactly; avoid loose synonyms.
Module -- anything with interface + implementation: function, class, package, slice. Avoid: unit, component, service.
Interface -- everything a caller must know: type surface, invariants, ordering, errors, config, perf. Avoid: API or signature when you mean the full contract.
Implementation -- what is inside a module. Distinct from Adapter: an adapter is the concrete thing filling a seam.
Depth -- leverage at the interface. Deep = small interface, large behavior. Shallow = interface nearly as complex as implementation.
Seam -- place where behavior can vary without editing that place; where the module interface lives. Avoid: boundary, overloaded with DDD bounded context.
Adapter -- concrete implementation satisfying an interface at a seam; names role, not substance.
Leverage -- caller gets more capability per interface learned.
Locality -- change, bugs, knowledge, and verification concentrate in one place.
Deep module:
Small Interface
----------------
Deep Implementation
Shallow module:
Large Interface
----------------
Thin Implementation
Ask:
interface or public methods: too narrow.npx claudepluginhub malinskibeniamin/skills --plugin frontend-skillsEnforces cross-project coding conventions for naming, readability, immutability, and code-quality review. Activates on new projects, refactoring, or code review.