architect

Sketch types, signatures, and module boundaries before implementing non-trivial code changes.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Jumping straight into code on non-trivial, cross-boundary work locks in the wrong structure early. This Skill forces a design-first pass: it sketches types, function signatures, and module boundaries before any implementation, then keeps the implementation aligned with that sketch. ## Core Features & Use Cases - Design sketching: Produces type definitions, signatures, and module maps with not implemented bodies before writing real code. - Multi-candidate exploration: Requires at least two structurally distinct design candidates, screens them against red flags (shallow modules, information leakage, pass-through methods), and synthesizes the strongest shape. - Implementation governance: Treats deviations from the sketch as signals, and scraps and redesigns the architecture when friction patterns repeat. - Use Case: Before refactoring a service that touches multiple modules, run the architect flow to ground the existing system, compare two design candidates, and implement against the chosen sketch. ## Quick Start Ask the agent to architect this feature by sketching the types, signatures, and module structure 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?▼

Sketch types, function signatures, and module boundaries with placeholder bodies first, then fill in implementation against that sketch. This Skill formalizes that flow with grounding, multi-candidate design comparison, and deviation tracking.

When should I use a design-first workflow instead of coding directly?▼

Use it for non-trivial work crossing module boundaries where the wrong shape would be costly to undo. Skip it for trivial one-liners, settled designs, or when the user has already approved a concrete design.

What happens when implementation reveals the design is wrong?▼

The Skill treats repeated friction patterns as a signal to scrap the sketch and redesign from first principles, subtracting before adding. Isolated edge cases do not trigger a redesign; only recurring structural problems do.

What inputs does the architect workflow require?▼

It requires a problem statement with constraints, a decision on whether parallel design exploration is in scope, and clarity on where the sketch lives. If any input is missing, it holds and reports the gap instead of guessing.

Does the architect skill write the implementation code too?▼

Yes, after the sketch is synthesized it guides implementation against the sketch as a contract. Deviations during implementation are surfaced as signals rather than silently absorbed.