software-design

Guide software design decisions for architecture, APIs, and module structure.

Updated Jan 20, 2026
One-click install
npx skills add https://github.com/jmmarotta/skills --skill software-design-jmmarotta
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: software-design
Source: https://github.com/jmmarotta/skills/tree/main/skills/software-design
Command: npx skills add https://github.com/jmmarotta/skills --skill software-design-jmmarotta

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Proactive software design guidance for architecture, interfaces, and implementation planning. Use this skill when helping users make decisions before or during implementation: planning features, designing APIs, structuring modules, or evaluating architectural approaches.

Core Features & Use Cases

  • Design methodology: understand problems, identify abstractions, design interfaces first, evaluate information hiding, consider alternatives, plan verification, and plan failure/rollback.
  • Design principles: strategic thinking, module depth, information management, separation of concerns.
  • Testing and closed-loop verification: define coverage strategies, unit/integration/end-to-end tests, manual smoke tests, verification evidence.
  • Performance considerations: assess time/space complexity, scale assumptions, measure before optimizing, document intentional tradeoffs.
  • Coding style: straightforward inline flow, single-purpose helpers, clear naming.
  • Comments as design tools: interface and implementation comments guidance.
  • Red flags: avoid shallow modules, information leakage, temporal decomposition, overexposure, etc.
  • Gathering context and clarifications: explore patterns, identify abstractions, check integration with existing code.
  • Questions to clarify: scale, performance budgets, integration boundaries, extensibility, operational constraints, verification/rollback.

Quick Start

Apply this skill to guide architecture decisions, API design, and module structure before or during implementation.

Frequently Asked Questions about software-design

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

FAQPage Schema
How do I design software APIs and structure modules before implementation?

Design software APIs and structure modules by understanding the problem, identifying abstractions, and applying interface-first design to ensure information hiding. Evaluate architectural alternatives and plan verification strategies before writing implementation code.

What is the best way to evaluate architectural approaches for a new feature?

Evaluating architectural approaches requires strategic thinking, assessing separation of concerns, and checking for red flags like shallow modules or information leakage. Compare alternatives against scale assumptions and performance budgets to select the optimal design.

How do I plan verification and rollback strategies during software design?

Plan verification and rollback during software design by defining closed-loop testing coverage, including unit, integration, and end-to-end tests. Outline manual smoke tests and verification evidence to ensure the architectural approach can safely revert if needed.

When do I need proactive software design guidance for reducing architectural complexity?

You need proactive software design guidance during early product ideation or before implementing features to reduce architectural complexity. It helps structure modules, design interfaces, and clarify integration boundaries, scale, and operational constraints before coding begins.

Does this software design approach work for assessing performance and time complexity?

This software design approach assesses performance by evaluating time and space complexity, documenting intentional tradeoffs, and measuring before optimizing. It aligns architectural decisions with scale assumptions and performance budgets to maintain code quality.

What are common red flags to avoid in software architecture and module design?

Common red flags in software architecture include shallow modules, information leakage, temporal decomposition, and overexposure. Avoid these by applying clear naming, single-purpose helpers, straightforward inline flow, and using comments as design tools to enforce separation of concerns.