extensible-by-design

Review software architectures for extensibility and prioritized recommendations.

Updated Jun 6, 2026
One-click install
npx skills add https://github.com/shuymn/skills --skill extensible-by-design
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: extensible-by-design
Source: https://github.com/shuymn/skills/tree/main/skills/extensible-by-design
Command: npx skills add https://github.com/shuymn/skills --skill extensible-by-design

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps you design and review software so that AI agents and humans can extend it over time without bloating the core product or hardcoding judgment into the runtime.

Core Features & Use Cases

  • Extensibility reviews: Evaluate whether a system has a minimal core, useful extension surfaces, and clear negative space.
  • Architecture guidance: Decide what belongs in core versus hooks, config, playbooks, or external extensions.
  • AI-native system design: Assess whether the system supports separate execution and instruction planes, on-demand context loading, and self-modification loops.
  • Use Case: A team is designing a new service and wants a principled review of where to add hooks, how to scope configuration, and what should remain outside core.

Quick Start

Ask for an extensibility review of your system and provide the architecture, current extension points, and any constraints on core behavior.

Frequently Asked Questions about extensible-by-design

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
What is negative space in software architecture design?

Negative space in software architecture identifies what the system explicitly leaves undefined, separating the minimal core from extension surfaces. It prevents hardcoded judgment in the runtime and keeps AI-native software systems extensible over time.

How do I design extensible AI-native software architectures?

Design extensible AI-native software architectures by identifying core boundaries, defining hook placements, and scoping configuration. Establish separate execution and instruction planes to support on-demand context loading and self-modification loops without hardcoding runtime judgment.

When should I use hooks versus configuration for software extensibility?

Use hooks versus configuration based on whether the core needs dynamic behavioral injection or static parameter tuning. Extensibility reviews score these decisions to separate the minimal core from external extensions and playbooks.

Does this approach work for greenfield product design and subsystem architecture review?

Yes, this approach works for both greenfield product design and existing subsystem architecture review. It applies decision lenses to score extensibility principles, evaluating hook placement, configuration scoping, and self-modification loops across new and legacy systems.

What are the limitations of hardcoded runtime judgment in extensible systems?

Hardcoded runtime judgment limits extensible systems by preventing AI agents and humans from adapting behavior without modifying the core product. It blocks the separation of execution and instruction planes, restricting self-modification loops and on-demand context loading.