architect

Sketches types, signatures, and module structure before implementation using parallel multi-model design candidates.

1|Updated Aug 26, 2026
One-click install
npx skills add https://github.com/edivad1999/stuc-stack --skill architect-edivad1999
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: architect
Source: https://github.com/edivad1999/stuc-stack/tree/main/skills/architect
Command: npx skills add https://github.com/edivad1999/stuc-stack --skill architect-edivad1999

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Jumping straight into code on non-trivial work often locks in the wrong architecture, forcing painful rewrites later. This Skill enforces a design-first workflow that explores multiple structurally distinct designs before any implementation begins. ## Core Features & Use Cases - Five-phase design workflow: Ground the problem, sketch candidates, optionally agree with a human checkpoint, implement against the sketch, and scrap the design when repeated friction proves it wrong. - Parallel multi-model arena: Runs several model runners (e.g., Claude, GPT, Grok) on the same design task, screens candidates against design red flags like shallow modules and information leakage, then synthesizes one design package. - Structured rationale output: Ships a type sketch with not implemented bodies plus a prose rationale covering usage, shape, synthesis decision, tradeoffs, and alternatives. - Use Case: Before building a new Compose feature module, invoke the skill to produce two or more competing module maps and type sketches, compare interface depth, and implement against the winning contract. ## Quick Start Ask the AI to architect the new feature before writing any code, for example by saying "/architect the offline sync layer for the notes module".

Frequently Asked Questions about architect

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

FAQPage Schema
How do I design a module architecture before writing code?▼

Invoke the architect skill, which grounds the problem in existing systems, generates at least two structurally distinct design candidates via parallel model runners, and synthesizes one type sketch with signatures and a module map before implementation starts.

What is design-it-twice and why use multiple models for architecture?▼

Design-it-twice requires at least two structurally distinct candidates before choosing one, preventing premature commitment to the first workable shape. Running candidates on different models (Claude, GPT, Grok) maximizes structural diversity, and the differences between candidates drive the synthesis decision.

When can I skip the architecture design phase?▼

Copy-the-last-screen and smallest-diff work may skip the skill with an explicit skip note such as "architect skipped: copy last similar screen". Genuinely greenfield work with no surrounding system can also skip the grounding phase, but the sketch phases still apply when the skill runs.

What design red flags should I check before choosing an architecture?▼

Screen candidates for shallow modules, information leakage, temporal decomposition, and pass-through methods. Prefer deep modules that hide substantial complexity behind a small public surface, and keep transport or wire types off the public interface.

When should I scrap an architecture and redesign from scratch?▼

Scrap when implementation shows a repeated pattern of friction: the same workaround shape across unrelated code, types needing escape hatches like Any or casts, or callers forced to know internal rules. Single hard cases do not condemn a design; repeated same-shape friction does.