architecture-workshop

Generate architectural options when existing design patterns do not fit.

4|Updated Dec 30, 2025
One-click install
npx skills add https://github.com/shanepadgett/agent-extensions --skill architecture-workshop
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-workshop
Source: https://github.com/shanepadgett/agent-extensions/tree/main/skills/architecture-workshop
Command: npx skills add https://github.com/shanepadgett/agent-extensions --skill architecture-workshop

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill provides a framework for designing options when changes don't fit cleanly into existing codebase architecture.

Core Features & Use Cases

  • Understand why a design doesn't fit and identify constraints.
  • Generate multiple architectural options (light-touch and architecture shift) to address gaps.
  • Evaluate blast radius, incremental path, and long-term impact to guide decision-making.
  • Emphasize maintainability and health of the codebase, preferring light-touch solutions when feasible.
  • Recommend between light-touch vs architecture shift based on risk, complexity, and future reuse.

Quick Start

Use the architecture-workshop skill to generate a set of architectural options when a problem does not fit existing patterns.

Frequently Asked Questions about architecture-workshop

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

FAQPage Schema
How do I design architectural options when a new feature does not fit existing codebase patterns?

To design architectural options for gaps in existing patterns, you need a framework that identifies constraints and generates both light-touch and architecture-shift approaches. This skill structures that evaluation by comparing blast radius, incremental adoption paths, and long-term maintainability to guide your decision.

What is the difference between a light-touch solution and an architecture shift for refactoring?

A light-touch refactoring solution minimizes blast radius and complexity by adapting current design patterns, while an architecture shift proposes structural changes for better long-term fit. This skill evaluates tradeoffs like risk, complexity, and future reuse to recommend the appropriate approach for your codebase health.

When do I need to evaluate blast radius and incremental adoption paths for scalability?

You need to evaluate blast radius and incremental adoption paths for scalability when existing design patterns cannot accommodate new requirements. This skill applies a guided decision framework across modules to assess long-term impact and maintainability before committing to structural changes.

Can I use this architectural decision framework across multiple modules?

Yes, you can apply this architectural decision framework across multiple modules to evaluate pattern fit and propose structured recommendations. It enforces explicit criteria and maintainability considerations for each module, ensuring incremental adoption remains consistent throughout the codebase.

What is the best way to choose between refactoring approaches when facing design pattern gaps?

The best way to choose between refactoring approaches for design pattern gaps is to evaluate explicit criteria including risk, complexity, and future reuse. This skill generates structured recommendations by comparing light-touch versus architecture-shift options to prioritize long-term codebase maintainability.

Why does my current architecture not fit new scalability requirements?

Your current architecture may not fit new scalability requirements because existing design patterns lack the flexibility to handle increased complexity. This skill helps identify those constraints and generates alternative architectural options with explicit tradeoffs to address the gaps.