code-architecture
Guides you through selecting the right architecture pattern—clean, hexagonal, feature-based, or vertical slice—based on team size and domain complexity. Covers folder structure, dependency inversion, module boundaries, and SOLID principles at application scale. Diagnoses architectural problems like fat controllers and circular dependencies.
Code Architecture helps you choose and implement application patterns like clean, hexagonal, or feature-based structures for maintainable code.
AI-generated summary based on this skill's SKILL.md
Decision gist · record as of 2026-07-14
Code Architecture helps you choose and implement application patterns like clean, hexagonal, or feature-based structures for maintainable code. Guides you through selecting the right architecture pattern—clean, hexagonal, feature-based, or vertical slice—based on team size and domain complexity. Covers folder structure, dependency inversion, module boundaries, and SOLID principles at application scale. Diagnoses architectural problems like fat controllers and circular dependencies.
Use it when
- code-architecture covers feature-based organization by defining clear module boundaries around business capabilities rather than technical.
- code-architecture diagnoses circular dependency problems by identifying where modules depend on each other cyclically.
Verify before relying
Read SKILL.md below before installing (3 files). Open directory: indexed for reading, not audited.
Install
curiositech/some_claude_skills/code-architecture · repository language: TypeScript
Open directory. Skills are indexed for reading, not audited. Review a skill's body before installing it.
Frequently asked questions
AI-generated answers based on this skill's SKILL.md and metadata
What clean architecture patterns work best for Node.js?
code-architecture guides you through selecting patterns like clean, hexagonal, feature-based, and vertical slice architectures tailored to Node.js projects. The skill helps you evaluate team size and domain complexity to choose the right fit, then walks through folder structure, dependency inversion, and module boundaries specific to Node environments. Each pattern trades simplicity for testability and maintainability differently.
How do I organize code in a feature-based structure?
code-architecture covers feature-based organization by defining clear module boundaries around business capabilities rather than technical layers. It shows how to structure folders vertically around features, establish dependency rules between features, and use barrel exports to control what each feature exposes. The skill also addresses when feature-based structure outperforms layer-based approaches and how to prevent cross-feature coupling.
How can I fix circular dependencies in TypeScript?
code-architecture diagnoses circular dependency problems by identifying where modules depend on each other cyclically, then applies dependency inversion and clear module boundaries to break cycles. The skill teaches you to extract shared abstractions, use interfaces to decouple modules, and restructure folder hierarchies so dependencies flow in one direction. It also covers detecting these issues early through architecture reviews.
What is the fat controller problem and how do I solve it?
code-architecture identifies the fat controller problem—when a single controller handles too many responsibilities—and shows how to refactor it into focused use cases and domain logic. The skill guides you toward extracting business logic into separate layers, organizing code around user workflows rather than HTTP verbs, and applying SOLID principles at module scale to keep controllers thin and testable.
When should I use clean vs hexagonal architecture?
code-architecture provides a decision framework comparing clean and hexagonal patterns based on team experience, domain complexity, and infrastructure needs. Clean architecture emphasizes concentric layers and testability; hexagonal (ports and adapters) emphasizes external dependency isolation. The skill helps you weigh trade-offs: hexagonal adds abstraction overhead but excels when you need to swap infrastructure; clean is simpler for smaller teams and domains.
How do I detect architectural problems in existing code?
code-architecture teaches you to recognize symptoms like fat controllers, circular dependencies, unclear module boundaries, and tight coupling between features. The skill walks through diagnostic techniques—mapping dependency graphs, measuring module cohesion, reviewing folder structure—and connects problems to root causes. Once identified, it guides you toward refactoring strategies using dependency inversion, SOLID principles, and clearer architectural patterns.
SKILL.md
Rendered from the published skill. Quoted content, verbatim.
name: code-architecture description: Application architecture patterns and code organization — clean architecture, hexagonal architecture, feature-based structure, dependency inversion, module boundaries, SOLID principles at module scale. Activate on "clean architecture", "hexagonal architecture", "feature-based structure", "dependency inversion", "module boundaries", "architecture pattern", "folder structure", "fat controller", "circular dependency", "IoC container". NOT for microservice decomposition (use microservices-patterns) or database schema design (use database-design-patterns). allowed-tools: Read,Write,Edit,Bash,Grep,Glob metadata: category: Code Quality & Testing tags: - code - architecture - clean-architecture - hexagonal-architecture - feature-based-structure pairs-with: - skill: refactoring-surgeon reason: Refactoring implements the architectural patterns that code-architecture prescribes - skill: monorepo-management reason: Monorepo workspace boundaries enforce architectural module separation - skill: microservices-patterns reason: Service decomposition decisions depend on application architecture patterns - skill:
(truncated - see the full file via the links below)
File tree — 3 files
.claude/skills/code-architecture/SKILL.md
.claude/skills/code-architecture/references/architecture-patterns.md
.claude/skills/code-architecture/references/dependency-inversion.md
Let your AI agent find skills like this
Example. Real query, live index.
You found this page by searching. An agent finds it by wishing: SkillFed indexes 56,283 agent skills by what they can do, searchable in plain language.
wish › “Choose and implement an application architecture pattern”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
This skill guides you through building Spring Boot applications with clean architecture principles, ensuring domain logic stays independent of frameworks and infrastructure. Learn to structure layered packages, implement ports and adapters, apply domain-driven design tactical patterns, and maintain strict dependency rules that keep your codebase testable and maintainable.
Master the Ports & Adapters pattern to isolate business logic from frameworks and infrastructure. This skill covers domain modeling, use-case orchestration, inbound and outbound port design, adapter implementation, and composition wiring across multiple languages.
This skill covers foundational architectural approaches for structuring software systems at scale. It walks through monolithic, microservices, event-driven, serverless, clean, and domain-driven architectures—each with use cases, trade-offs, and implementation guidance. A decision tree helps you pick the right pattern based on team size, deployment autonomy, audit requirements, and load variability.
Master three foundational backend architecture approaches—Clean Architecture, Hexagonal Architecture, and Domain-Driven Design—to structure systems for testability, maintainability, and scalability. Each pattern teaches dependency management, separation of concerns, and technology-agnostic core logic through practical examples and directory structures.
Master three foundational backend architecture approaches: Clean Architecture's layered dependency flow, Hexagonal Architecture's port-and-adapter model for technology independence, and Domain-Driven Design's strategic and tactical patterns for complex domains. Use this skill when designing new systems, refactoring monoliths, or establishing architecture standards for your team.
Master the decision to decompose systems into independent services and the patterns that keep them reliable. Covers bounded contexts, strangler fig extraction, synchronous vs. asynchronous communication, circuit breakers, saga patterns, and event sourcing—helping you avoid distributed monoliths and operational chaos.