architecture

Convert domain concepts into predicate-driven relationships mapped to classes and contracts.

Updated Apr 20, 2026
One-click install
npx skills add https://github.com/thistleknot/skills --skill architecture-thistleknot
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture
Source: https://github.com/thistleknot/skills/tree/main/architecture
Command: npx skills add https://github.com/thistleknot/skills --skill architecture-thistleknot

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It helps you turn an unclear idea or domain into a coherent system design by structuring the reasoning from first principles (FOL-style relationships), mapping concepts to code abstractions, and choosing appropriate design patterns and requirements discipline.

Core Features & Use Cases

  • FOL-based reasoning model: expresses system structure as predicates acting on subjects/objects to clarify what interacts and through which operations.
  • Abstract class bridge: maps problem-domain concepts to abstract base classes and concrete implementations, ensuring correct dependency direction and interface segregation.
  • Structural Dev perspective: organizes inputs, processes, entities (API/accessors), and outputs so the design stays consistent from spec through implementation.
  • Pattern selection guide (GoF): selects creational/structural/behavioral patterns based on what kind of complexity you face (creation, interface mismatch, or interaction/algorithm complexity).
  • Requirements phase discipline: encourages exploratory requirements early, then locks a verifiable spec to prevent scope-change churn mid-implementation.
  • Pragmatic design principles: applies DRY/orthogonality, tracer bullets (end-to-end skeleton first), systematic debugging, and real requirement gathering.

Quick Start

Use the architecture skill to design a new system by first converting your domain into predicates and entities, then mapping them into abstract classes and concrete implementations, and finally selecting GoF patterns that match the interaction and creation complexity.

Frequently Asked Questions about architecture

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

FAQPage Schema
How do I map domain concepts to abstract classes for system design?

System design maps domain concepts to abstract classes by converting them into predicate-driven relationships, ensuring correct dependency direction and interface segregation before implementing concrete classes.

What's the best way to structure system design before writing code?

Structure system design by organizing inputs, processes, entities, and outputs from a Dev perspective, then locking a verifiable spec to prevent scope-change churn during implementation.

When do I need design patterns in software architecture?

Select design patterns in software architecture when facing creation, interface mismatch, or interaction complexity, using a GoF-based guide to choose creational, structural, or behavioral patterns.

How does FOL reasoning clarify software requirements?

FOL reasoning clarifies software requirements by expressing system structure as predicates acting on subjects and objects, defining what interacts and through which operations before locking the spec.

Can I use this system design approach for greenfield projects?

Yes, this system design approach applies to greenfield architecture, abstract class planning, and novel system structure by mapping domain concepts to code-level contracts with requirements discipline.

Why should requirements be locked before implementation in system design?

Requirements should be locked before implementation in system design to reduce nondeterministic scope changes, ensuring exploratory requirements are finalized into a verifiable spec to prevent mid-implementation churn.