architect

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

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

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 strongest shape before any implementation begins. ## Core Features & Use Cases - Grounded Design Exploration: Traces existing subsystems before sketching, so new designs respect real constraints like ownership, layering, and unbreakable callers. - Parallel Candidate Synthesis: Runs multiple model runners to produce at least two structurally distinct design packages, then screens them against design red flags (shallow modules, information leakage, temporal decomposition, pass-through methods) before synthesizing one. - Scrap-and-Redesign Loop: Detects repeated friction patterns during implementation (escape-hatch types, recurring workarounds, special-case branches) and triggers a first-principles redesign instead of bolting on fixes. - Use Case: When asked to "architect this" feature, the Skill produces a caller-first usage sketch, type definitions, a module map, and a one-page rationale documenting tradeoffs, alternatives, and the synthesis decision. ## Quick Start Ask the agent to architect the new feature before writing any code, for example by saying "architect this caching layer for the API service".

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?▼

Use a design-first workflow that sketches types, function signatures, and module boundaries with not-implemented bodies before coding. Write the caller's usage first, derive the type sketch from it, then fill in implementations against that contract.

How to compare multiple design candidates for a feature?▼

Generate at least two structurally distinct candidate designs in parallel, screen each against red flags like shallow modules and information leakage, then compare on interface depth. Prefer the design hiding more complexity behind a smaller public surface.

When should I scrap an architecture and redesign?▼

Redesign when you see a repeated pattern of friction, not single hard cases: recurring workarounds, types needing escape hatches like any or casts, or callers forced to know internal rules. Re-ground on implementation lessons and redesign from first principles.

What are signs of a shallow module in software design?▼

A shallow module exposes a large interface while hiding little complexity. Signs include callers coordinating several methods for one operation, public options exposing internal stages, and learning the interface not saving you from learning the implementation.

Does this design workflow require human approval before implementing?▼

No, human checkpoints are opt-in. By default the workflow proceeds directly from synthesized design to implementation; a checkpoint only happens when the invoker explicitly asks to review the design before coding.