arch-core

Guides software architecture design using Domain-Driven Design, Clean Architecture, and SOLID principles.

Updated Dec 31, 2025

Search Tags:#architecture #system design #design patterns #ddd #clean architecture #software architecture

Ready to run

npx skills add https://github.com/victorzhuk/go-ent --skill arch-core

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: arch-core
Source: https://github.com/victorzhuk/go-ent/tree/main/pkg/skills/core/arch-core
Command: npx skills add https://github.com/victorzhuk/go-ent --skill arch-core

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides expert guidance on designing robust, maintainable, and scalable software architectures, focusing on Clean Architecture, Domain-Driven Design, and SOLID principles.

Core Features & Use Cases

Architecture Diagrams: Visualizes system structure, layers, and data flow.
Bounded Contexts: Defines clear domain boundaries and responsibilities.
Design Patterns: Recommends appropriate patterns with rationale.
ADR Documentation: Assists in creating Architectural Decision Records.
Package Structure: Suggests layouts reflecting architectural boundaries.
Use Case: Designing a new microservices-based e-commerce platform, ensuring clear separation of concerns and maintainable code.

Quick Start

Provide architecture diagrams for a layered e-commerce application.

Frequently Asked Questions about arch-core

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

FAQPage Schema

How do I design a layered architecture for a new application?▼

To design layered architecture, enforce clear dependency rules and separation of concerns using Clean Architecture and SOLID principles. This ensures maintainable system boundaries and a robust structure for your application's data flow.

What is the best way to define bounded contexts for a microservices platform?▼

Defining bounded contexts requires Domain-Driven Design to establish clear domain boundaries and responsibilities. This approach ensures scalable microservices by enforcing strict separation of concerns and maintainable system boundaries.

How do I document architectural decisions for my software project?▼

Document architectural decisions by creating Architectural Decision Records (ADRs). This process captures the rationale behind selected design patterns and structural choices, ensuring maintainable and transparent software architecture documentation.

Can I generate architecture diagrams that visualize system structure and data flow?▼

Yes, you can generate architecture diagrams that visualize system structure, layers, and data flow. These diagrams facilitate the creation of clear package layouts reflecting your architectural boundaries and dependency rules.

When should I not use Clean Architecture for system design?▼

You should reconsider Clean Architecture if your project lacks complexity or does not require strict separation of concerns. Over-implementing layered architecture and bounded contexts on simple systems introduces unnecessary structural overhead.

How do I select appropriate design patterns with clear rationale?▼

Selecting design patterns involves evaluating your system boundaries and applying SOLID principles. This ensures the chosen patterns align with your Domain-Driven Design strategy and maintainable architecture requirements.