architect

Sketch types, signatures, and module structure before implementing code.

Updated Sep 23, 2026
One-click install
npx skills add https://github.com/lucasheriques/pstack --skill architect-lucasheriques
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: architect
Source: https://github.com/lucasheriques/pstack/tree/main/skills/architect
Command: npx skills add https://github.com/lucasheriques/pstack --skill architect-lucasheriques

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 costly rewrites later. This Skill enforces a design-first workflow that grounds the problem, explores multiple structurally distinct design candidates in parallel, and synthesizes the best shape before any implementation begins. ## Core Features & Use Cases - Grounded Design Exploration: Traces how existing subsystems work before designing, then runs parallel candidate runners to produce at least two structurally distinct design packages. - Red-Flag Screening: Rejects shallow modules, information leakage, temporal decomposition, and pass-through methods before synthesis, comparing candidates on interface depth. - Scrap-and-Redesign Loop: Detects patterns of architectural friction during implementation (repeated workarounds, type escape hatches, special-case branches) and triggers a first-principles redesign instead of bolt-on fixes. - Use Case: When adding a feature that crosses function or module boundaries, invoke it to produce a type sketch, module map, and one-page rationale documenting the synthesis decision, tradeoffs, and alternatives before writing code. ## Quick Start Ask the AI to architect the new feature by sketching types, signatures, and module boundaries before writing any implementation code.

Frequently Asked Questions about architect

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

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

Start by grounding yourself in the existing systems the new code touches, then sketch types, signatures, and module boundaries with placeholder bodies. Explore at least two structurally distinct design candidates and synthesize the strongest shape before implementing.

What is interface depth in module design?▼

Interface depth measures the capability hidden behind a public surface relative to its size. A deep module concentrates substantial behavior behind a simple interface, while a shallow module exposes many methods but hides little complexity.

When should I scrap an architecture and redesign?▼

Redesign when friction forms a pattern: repeated workarounds across unrelated code, types needing escape hatches like casts or any, or callers forced to know internal rules. Single edge cases do not condemn a design; recurring shapes of friction do.

What are common software design red flags?▼

Key red flags include shallow modules with large interfaces hiding little, information leakage where internal decisions appear in multiple modules, temporal decomposition organized by execution order, and pass-through methods that forward arguments unchanged.

Can I review a design before implementation starts?▼

Yes, you can opt into a checkpoint by asking to stop and review the synthesized design before implementing. By default the workflow proceeds directly to implementation, but explicit requests pause for sign-off on the sketch.