architecture-planner

Plan component architecture and module structure for feature implementations.

25|2|Updated Oct 26, 2025

Search Tags:#architecture #design patterns #clean architecture #hexagonal #layered

Ready to run

npx skills add https://github.com/matteocervelli/llms --skill architecture-planner

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: architecture-planner
Source: https://github.com/matteocervelli/llms/tree/main/.claude/skills/architecture-planner
Command: npx skills add https://github.com/matteocervelli/llms --skill architecture-planner

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill guides component architecture planning using layered/hexagonal/clean patterns for maintainable systems.

Core Features & Use Cases

Layered Architecture Design: Clear separation of presentation, business, and data layers.
Hexagonal Patterns: Ports and adapters for flexible integrations.
Dependency Injection: Promotes testability and decoupling.

Quick Start

Outline a multi-layer architecture for a new feature with component boundaries and data models.

Frequently Asked Questions about architecture-planner

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

FAQPage Schema

How do I plan a layered architecture for a new feature?▼

Layered architecture separates concerns into presentation, business, and data layers. Define component boundaries within each layer, specify dependencies between layers, and ensure each layer has a single responsibility. This approach maintains testability and makes refactoring easier as your codebase grows.

What's the difference between layered and hexagonal architecture patterns?▼

Layered architecture organizes code into horizontal tiers (presentation, business, data). Hexagonal architecture uses ports and adapters to decouple your core business logic from external dependencies like databases and APIs. Hexagonal offers more flexibility for testing and swapping integrations.

How do I structure components for better testability and maintainability?▼

Apply dependency injection to decouple components, define clear interfaces between layers, and separate business logic from infrastructure concerns. This structure lets you test components in isolation, swap implementations without touching core logic, and add new features without breaking existing code.

Can I use clean architecture patterns to refactor an existing codebase?▼

Yes. Clean architecture helps you incrementally refactor by establishing clear layer boundaries, extracting business logic from framework code, and introducing dependency injection. Start with high-risk or frequently-changed modules, then extend the pattern across your system.

What role do ports and adapters play in system design?▼

Ports define contracts for how external systems interact with your core logic; adapters implement those contracts for specific technologies. This pattern isolates business rules from database, API, and UI details, making your system testable and adaptable to technology changes.

When should I apply single-responsibility principles to module structure?▼

Apply single responsibility during initial design and refactoring to prevent god objects and tangled dependencies. Each module should have one reason to change. This keeps components focused, easier to test, and reduces the blast radius when requirements shift.