architecture-advisor

Recommend .NET architectures by mapping questionnaire signals to a decision matrix.

640|145|Updated Feb 20, 2026
One-click install
npx skills add https://github.com/codewithmukesh/dotnet-claude-kit --skill architecture-advisor-codewithmukesh
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-advisor
Source: https://github.com/codewithmukesh/dotnet-claude-kit/tree/main/skills/architecture-advisor
Command: npx skills add https://github.com/codewithmukesh/dotnet-claude-kit --skill architecture-advisor-codewithmukesh

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Helps teams avoid costly architecture mistakes by guiding a structured decision process that matches system complexity, team organization, lifetime, and compliance needs to an appropriate .NET architecture. It prevents over-engineering (premature DDD or microservices) and under-engineering (no boundaries for complex domains) by surfacing the trade-offs and an evolution path.

Core Features & Use Cases

  • Structured questionnaire that collects signals across domain complexity, team size, system lifetime, regulatory needs, existing codebase, and integration patterns.
  • Decision matrix & recommendations that map signals to Vertical Slice Architecture, Clean Architecture, DDD + Clean Architecture, or Modular Monolith with clear reasoning and migration paths.
  • Anti-patterns and guardrails that warn against common mistakes (premature microservices, DDD everywhere, using Clean Architecture for simple CRUD) and suggest when to evolve architecture.
  • Use case: During project setup for a payment processing product, run the questionnaire to determine if DDD + Clean Architecture is warranted due to strong invariants and compliance, or if a simpler Vertical Slice Architecture suffices for an MVP.

Quick Start

Ask the architecture-advisor to run the architecture questionnaire for your project and recommend the best-fit architecture with reasoning and a migration plan.

Frequently Asked Questions about architecture-advisor

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

FAQPage Schema
How do I choose the right .NET architecture for my project?

To choose a .NET architecture, assess domain complexity, team size, system lifetime, compliance, and integration needs to map signals to Vertical Slice, Clean, DDD, or Modular Monolith patterns. This structured questionnaire approach prevents over-engineering and under-engineering by surfacing trade-offs and evolution paths.

When do I need DDD and Clean Architecture in a .NET application?

You need DDD and Clean Architecture in .NET when your project has strong invariants, complex domain logic, strict regulatory constraints, and requires clear bounded contexts. This approach is warranted for long-lived systems like payment processing where compliance is critical.

Should I use Vertical Slice Architecture or Clean Architecture for a simple .NET MVP?

For a simple .NET MVP, Vertical Slice Architecture is often sufficient and preferred over Clean Architecture to avoid over-engineering. Using Clean Architecture for basic CRUD operations is an anti-pattern that adds unnecessary complexity without proportional benefits.

When should I not use microservices for a new .NET project?

You should not use microservices for a new .NET project if your domain complexity is low or your team is small, as premature microservices create operational overhead. A Modular Monolith provides boundary enforcement and evolution paths without distributed system complexity.

What is the best way to restructure an existing .NET codebase architecture?

The best way to restructure an existing .NET codebase is to run an architectural review questionnaire evaluating current codebase characteristics and integration patterns. Mapping these signals to a decision matrix provides targeted migration paths and anti-pattern guardrails for safe evolution.

Does Modular Monolith architecture work for large .NET teams?

Modular Monolith architecture works for large .NET teams by organizing domain complexity into clear modules within a single deployable unit. It provides necessary boundaries for complex domains while avoiding the operational overhead of distributed microservices.