Enforce open-closed design with explicit extension points and stable interfaces.
npx skills add https://github.com/alo-exp/silver-bullet --skill extensibility
Please help me install this Agent Skill. Skill: extensibility Source: https://github.com/alo-exp/silver-bullet/tree/main/forge/skills/extensibility Command: npx skills add https://github.com/alo-exp/silver-bullet --skill extensibility
Every design, plan, and implementation MUST allow new functionality to be added without modifying existing code. The system should be open for extension but closed for modification.
Why this matters: Software that requires modifying core code for every new feature becomes brittle, risky, and slow to evolve. Extensible design lets you add capabilities by writing NEW code — not editing existing, tested, working code. This is the difference between systems that scale with the team and systems that bottleneck at every change.
Use Case: When adding a new plugin or integration, implement changes through a registry-based extension point rather than modifying existing components.
Identify a concrete extension point in your project and implement a simple registry to allow new behavior without modifying existing code.
High-intent search queries and answers about installing and using this skill.
Open-closed design prevents brittle changes by making modules open for extension but closed for modification. It requires explicit extension points and stable interfaces so new functionality is added by writing new code, not editing tested code.
The best way to design a plugin architecture is to define explicit extension points with documented interfaces, adapters, and discovery mechanisms, enabling capabilities to be added via a registry without touching core components.
Maintain backward compatibility during evolution by applying versioning and configuration to your interfaces. This ensures safe extension of capabilities without breaking existing modules that depend on stable contracts.
You need explicit extension points when adding new plugins or integrations, ensuring changes are implemented through a registry rather than modifying existing components, thus preventing brittle changes and bottlenecked evolution.
Yes, you can use a registry pattern to enforce open-closed principles by routing new functionality through documented extension points, allowing configurable behavior and feature growth without altering existing tested code.
KAIROS7-team3Apply Single Responsibility, Open-Closed, and Dependency Inversion principles to robotics software modules.
proofoftomGenerate Drupal block plugins and custom plugin types with dependency injection.
akokenGuide extend-only public API design for C# libraries and NuGet packages.
JohannesKoningsIdentify shallow code modules and recommend deep-module refactors using domain glossaries and ADRs.
