Architectural Thinking Engine

The problem

AI agents often produce "spaghetti code" that works in isolation but creates massive technical debt. They optimize for local correctness while ignoring global coherence, leading to monoliths with no separation of concerns.

What it does

• Forces a pre-implementation analysis phase to select appropriate design patterns before writing code.
• Applies strict file and function length limits to trigger automatic decomposition.
• Enforces dependency direction rules to maintain clear boundaries between domain, application, and infrastructure layers.
• Executes a post-implementation SOLID check to ensure maintainability and testability.
• Uses the Rule of Three to decide exactly when to refactor versus when to keep code simple.

Why this beats prompting it yourself

Manually reminding an agent to follow SOLID principles every time you open a file is tedious and easy to forget. This skill embeds the senior engineering mindset into the agent's core loop, making architectural discipline the default state rather than a special request.

Use cases

• Starting a new feature where system-level design is more important than raw speed.
• Refactoring existing legacy files that have grown too complex to manage.
• Auditing a pull request for architectural soundness and naming consistency.
• Adding new integrations to a codebase where you need to maintain a strict repository pattern.

Known limitations

This skill adds a thinking step that can slow down trivial tasks like one-line bug fixes or configuration changes. It may lead to over-engineering for small, throwaway scripts where architecture is secondary to execution speed.