system-design

Evaluate software designs for deep modules and information hiding.

1|Updated Mar 31, 2026
One-click install
npx skills add https://github.com/ImBIOS/swarm-tools --skill system-design-imbios
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: system-design
Source: https://github.com/ImBIOS/swarm-tools/tree/main/packages/opencode-swarm-plugin/global-skills/system-design
Command: npx skills add https://github.com/ImBIOS/swarm-tools --skill system-design-imbios

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Reduce software complexity by promoting deep modules and robust information hiding.

Core Features & Use Cases

  • Deep modules with simple interfaces that hide complexity behind a robust implementation.
  • Information hiding to minimize coupling and prevent leakage of internal knowledge.
  • Design twice mindset: compare multiple designs before committing to an approach.
  • Error handling and boundaries: aim to redefine errors out of existence where possible.

Quick Start

Apply these principles when sketching a new library, API, or CLI to minimize future maintenance.

Frequently Asked Questions about system-design

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

FAQPage Schema
What is a deep module in software architecture?

A deep module in software architecture features a simple interface that hides substantial implementation complexity, providing robust information hiding while minimizing external coupling and preventing leakage of internal knowledge.

How do I reduce software complexity when designing a new API?

Reduce software complexity by applying a design twice mindset to compare multiple approaches, enforcing simple extensible interfaces, and establishing clear responsibility boundaries to ensure long-term maintainability.

Can I use these design principles for CLI and library architecture?

Yes, you can apply these architecture design principles to CLIs, libraries, and APIs to minimize future maintenance by hiding implementation details and defining clear boundaries.

What is the best way to handle error handling boundaries in software design?

The best way to handle error boundaries in software design is to aim to redefine errors out of existence where possible, preventing internal knowledge leakage and minimizing coupling across modules.

Why does information hiding matter for long-term maintainability?

Information hiding matters for long-term maintainability because it prevents leakage of internal knowledge, reduces system complexity, and minimizes coupling between deep modules with clear responsibility boundaries.

When should I not use deep modules for system design?

You should reconsider deep modules when early design comparison shows that simple interfaces cannot adequately hide implementation details without leaking internal knowledge or compromising clear responsibility boundaries.