architecture-strategy

Identify architectural boundaries and ownership to recommend system shape.

1|Updated Apr 18, 2026
One-click install
npx skills add https://github.com/mopeyjellyfish/flywheel --skill architecture-strategy
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-strategy
Source: https://github.com/mopeyjellyfish/flywheel/tree/main/skills/architecture-strategy
Command: npx skills add https://github.com/mopeyjellyfish/flywheel --skill architecture-strategy

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Ground architectural questions to determine the best system shape for a codebase, aligning boundaries, ownership, and deployment implications with the repo's reality.

Core Features & Use Cases

  • Ground current truth by identifying module boundaries, ownership, and dependency directions.
  • Compare viable shapes (local changes, modular monoliths, bounded contexts, or service boundaries) and surface tradeoffs.
  • Produce actionable recommendations with concrete next steps and guardrails for maintainable evolution.

Quick Start

Analyze the current project to propose the minimal durable architecture that fits the repo's constraints.

Frequently Asked Questions about architecture-strategy

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

FAQPage Schema
How do I identify the right system shape and architectural boundaries for my codebase?

To determine the right system shape, analyze the codebase to identify current module boundaries, ownership, and dependency directions. Grounding the architecture in the repo's reality ensures boundaries align with actual project constraints rather than theoretical ideals.

When should I consider moving from a monolith to microservices?

Consider monolith-to-microservice migration when evaluating service boundaries and bounded contexts. Compare viable shapes like modular monoliths against service boundaries to surface tradeoffs, ensuring deployment implications align with the repo's current truth and ownership structure.

What is the best way to define bounded contexts and dependency direction in a modular monolith?

Defining bounded contexts in a modular monolith requires identifying current architectural boundaries and enforcing strict dependency direction. This approach surfaces tradeoffs between local changes and bounded contexts to produce actionable recommendations with concrete guardrails.

How do I evaluate architectural tradeoffs when proposing system design changes?

Evaluate architectural tradeoffs by establishing the current truth and decision surface, then comparing candidate options. Surface the constraints of each system shape to produce a recommendation with concrete next steps, guardrails, and verification methods for maintainable evolution.

Can I use this approach to analyze existing project structures without migrating to microservices?

Yes, analyzing existing project structures works without microservice migration. The process compares viable shapes including local changes and modular monoliths, applying bounded contexts and dependency direction to propose the minimal durable architecture fitting the repo's constraints.

Why does architectural strategy require identifying current truth before recommending a system shape?

Architectural strategy requires identifying current truth because grounding recommendations in actual module boundaries and ownership prevents misaligned system shapes. This ensures the proposed architecture satisfies constraints, verification, and next moves for maintainable evolution.