system-design

Enforce deep module boundaries and information hiding in software design.

729|67|Updated Dec 8, 2025
One-click install
npx skills add https://github.com/joelhooks/swarm-tools --skill system-design-joelhooks
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: system-design
Source: https://github.com/joelhooks/swarm-tools/tree/main/packages/opencode-swarm-plugin/global-skills/system-design
Command: npx skills add https://github.com/joelhooks/swarm-tools --skill system-design-joelhooks

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a structured philosophy and practical guidance for building reusable, maintainable coding systems. It helps teams reduce complexity, enforce clean boundaries, and promote durable modules.

Core Features & Use Cases

  • Deep modules: Favor simple interfaces that hide complex implementations behind them.
  • Information hiding: Encapsulate knowledge to prevent leakage and reduce coupling.
  • Design twice: Compare alternatives before implementing to surface better decisions.
  • Red flags detection: Identify shallow interfaces, exposed internals, and repeated patterns.
  • Apply to CLI/Tools: Use these principles when designing commands, plugins, or APIs to ensure composability and longevity.

Quick Start

Start applying these principles when designing a new module or API: focus on a small surface, keep implementation private, and plan multiple design options before coding.

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 complex implementation details. This design reduces cognitive load and enforces clean boundaries by minimizing the surface area exposed to users.

How do I design APIs that reduce complexity and prevent information leakage?

Design APIs by enforcing a small surface area, keeping implementation details private, and encapsulating knowledge to prevent information leakage. Compare multiple design alternatives before coding to ensure clear separation of concerns.

Can these system design principles be applied to CLI tools?

Yes, these system design principles apply to CLI tools, commands, and plugins. Applying deep module boundaries and information hiding to CLIs ensures robust interfaces, composability, and long-term maintainability across projects.

What are the red flags of shallow interfaces in system design?

Red flags of shallow interfaces include exposed internal implementation details, repeated patterns, and a large surface area. These issues increase coupling and cognitive load, making the system harder to maintain over time.

What's the best way to start building maintainable coding systems?

The best way to start building maintainable coding systems is to design twice by comparing multiple alternatives before implementation. Focus on a small surface area, keep implementation private, and establish deep module boundaries.