@tank/app-architecture

Select application architecture patterns for service or monolith codebases.

1|1|Updated Feb 20, 2026
One-click install
npx skills add https://github.com/tankpkg/packages --skill tank-app-architecture
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: @tank/app-architecture
Source: https://github.com/tankpkg/packages/tree/main/skills/app-architecture
Command: npx skills add https://github.com/tankpkg/packages --skill tank-app-architecture

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

It helps you decide where code belongs in a service or monolith, reduce architecture drift, and pick the lightest pattern that fits your domain, team, and delivery constraints.

Core Features & Use Cases

  • Architecture selection: Compare layered, hexagonal, clean, DDD tactical, CQRS, event sourcing, modular monolith, and vertical slice approaches.
  • Boundary design: Clarify dependency direction, module ownership, ports, adapters, repositories, use cases, and shared kernels.
  • Practical migration guidance: Move from a tangled structure toward better boundaries without a risky rewrite.
  • Use case: When a codebase starts mixing business rules, persistence, and HTTP handling, this Skill shows how to separate concerns and choose the next architectural step.

Quick Start

Ask for the best application architecture for your codebase, then describe your domain complexity, team size, read and write patterns, and any audit or modularity constraints.

Frequently Asked Questions about @tank/app-architecture

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

FAQPage Schema
What is the best application architecture for a service with mixed business rules and HTTP handling?

The best application architecture depends on your domain complexity, team size, and read/write patterns. Comparing layered, hexagonal, clean, or vertical slice approaches helps separate concerns and choose the lightest pattern that fits your delivery constraints.

How do I decide between hexagonal architecture and clean architecture for my codebase?

Deciding between hexagonal and clean architecture involves comparing boundary design, dependency direction, and module ownership. Both clarify ports and adapters, but trade-off analysis for testability and modularity determines the right fit for your project structure.

When do I need DDD tactical patterns or CQRS in a modular monolith?

You need DDD tactical patterns or CQRS in a modular monolith when audit constraints or distinct read and write patterns demand strict boundary design. These approaches clarify use cases and repositories but increase operational complexity compared to vertical slices.

How to migrate a tangled codebase toward better architectural boundaries without a rewrite?

To migrate a tangled codebase toward better boundaries without a risky rewrite, apply practical migration guidance that clarifies dependency direction and feature placement. Move incrementally from mixed business rules toward separated concerns using ports and adapters.

Does vertical slice architecture work for small teams with high domain complexity?

Vertical slice architecture works for small teams by reducing architecture drift and placing features side-by-side. However, high domain complexity with strict audit or modularity constraints might require comparing DDD or modular monolith approaches for stronger boundary enforcement.