software-design-philosophy

Evaluate code interfaces against deep modularity and information hiding principles.

Updated Jul 31, 2026
One-click install
npx skills add https://github.com/fsolla/teqo --skill software-design-philosophy-fsolla
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: software-design-philosophy
Source: https://github.com/fsolla/teqo/tree/main/.agents/skills/software-design-philosophy
Command: npx skills add https://github.com/fsolla/teqo --skill software-design-philosophy-fsolla

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill addresses the fundamental challenge of software engineering: managing complexity. It helps you avoid "tactical-tornado" coding habits that lead to unmaintainable systems and technical debt.

Core Features & Use Cases

  • Complexity Diagnostics: Evaluate your code against eight diagnostic criteria to identify if your modules are deep or shallow.
  • Design Framework: Apply principles like information hiding, strategic programming, and comment-driven design to improve system architecture.
  • Use Case: When you are struggling with a complex API or deciding whether to split a class, use this Skill to score your design and receive actionable refactoring advice to simplify your module boundaries.

Quick Start

Analyze my current module design for complexity and suggest improvements based on the software design philosophy framework.

Frequently Asked Questions about software-design-philosophy

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

FAQPage Schema
How do I evaluate my software architecture for complexity?

To evaluate software architecture complexity, you score your code against eight diagnostic criteria to determine if modules are deep or shallow. This identifies change amplification and cognitive load issues, providing actionable refactoring guidance to improve maintainability.

What is the best way to refactor a shallow module API?

The best way to refactor a shallow module API is by applying information hiding and strategic programming principles. This minimizes change amplification and cognitive load, ensuring system interfaces remain deep and maintainable.

How do I reduce cognitive load in software design?

You reduce cognitive load in software design by applying deep modularity and information hiding principles. Evaluating architectural boundaries ensures modules hide complexity effectively, keeping systems easy to understand and maintain.

When do I need to apply strategic programming to manage technical debt?

You need to apply strategic programming to manage technical debt when struggling with complex APIs or deciding whether to split a class. It helps avoid tactical-tornado coding habits by evaluating architectural boundaries to minimize change amplification.

Does comment-driven design improve clean code interfaces?

Yes, comment-driven design improves clean code interfaces by clarifying module boundaries and information hiding. It provides diagnostic scoring to ensure interfaces remain deep, effectively managing complexity and reducing cognitive load.