software-design

Enforce domain boundaries and layering to identify internal design problems.

15|3|Updated Apr 9, 2026
One-click install
npx skills add https://github.com/LazyIsEfficient/agentic-os --skill software-design-lazyisefficient
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: software-design
Source: https://github.com/LazyIsEfficient/agentic-os/tree/main/.claude/skills/software-design
Command: npx skills add https://github.com/LazyIsEfficient/agentic-os --skill software-design-lazyisefficient

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) and assets (resource) components.

What problem does it solve?

Shapes and enforces proper internal structure in software by guiding how modules and classes are organized, how domain concepts are modeled, and where logic should live to keep changes local.

Core Features & Use Cases

  • Guides the placement of business rules on domain entities and value objects, not in services.
  • Supports hexagonal architecture, ports & adapters, and layered design to keep the core logic decoupled from infrastructure.
  • Provides design-review heuristics and references to established principles (SOLID, cohesion and coupling) to improve PR quality.

Quick Start

Review a module and propose a cohesive refactor that improves single-responsibility, boundary clarity, and maintainability.

Frequently Asked Questions about software-design

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

FAQPage Schema
How do I refactor code to enforce domain boundaries and proper layering?

Refactor code to enforce domain boundaries by guiding module organization and placing business rules on domain entities or value objects. This keeps changes local and decouples core logic from infrastructure using hexagonal architecture.

What is the best way to structure code for hexagonal architecture and ports & adapters?

Structure code for hexagonal architecture by isolating core domain logic from infrastructure through ports and adapters. This approach enforces proper layering, ensuring business rules remain decoupled and maintainable across bounded contexts.

How does domain-driven design handle SRP and cohesion in module refactoring?

Domain-driven design handles SRP by enforcing one reason to change per module, improving cohesion and coupling. It guides the placement of business rules on domain entities rather than services, ensuring invariants remain consistent during refactoring.

Can I use design heuristics for PR reviews in a layered architecture?

You can use design heuristics for PR reviews in layered architecture by checking single-responsibility, boundary clarity, and domain-owned behavior. These heuristics ensure business rules are correctly placed on entities and value objects.

When should I not use domain-driven design for module organization?

Avoid domain-driven design for module organization when bounded contexts are unclear or when infrastructure changes dominate business logic. Without well-defined invariants and domain entities, enforcing hexagonal architecture adds unnecessary complexity.