pattern-stack-architect

Design Pattern Stack backend architectures with Atomic Architecture layer boundaries.

1|Updated Nov 2, 2025
One-click install
npx skills add https://github.com/pattern-stack/claudecode-patterns --skill pattern-stack-architect
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: pattern-stack-architect
Source: https://github.com/pattern-stack/claudecode-patterns/tree/main/.claude/skills/pattern-stack-architect
Command: npx skills add https://github.com/pattern-stack/claudecode-patterns --skill pattern-stack-architect

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires pattern-stack.

What problem does it solve?

Developing complex backend systems with the Pattern Stack framework requires deep understanding of its Atomic Architecture, Field abstraction, and pattern composition, which can be challenging to master and apply consistently.

Core Features & Use Cases

  • Architectural Guidance: Provides expert advice on Pattern Stack's four-layer Atomic Architecture (Atoms, Features, Molecules, Organisms) and their responsibilities.
  • Field Abstraction Mastery: Guides on using Field() for SQLAlchemy models, eliminating mapped_column and ensuring cleaner, more validated code.
  • Pattern Composition: Explains how to effectively combine core patterns (Catalog, Actor, Event, Temporal, Hierarchical) via multiple inheritance for robust domain modeling.
  • Use Case: You're building a new backend model. This skill will guide you to correctly use Field() for type inference and validation, choose the right patterns (e.g., ActorPattern, EventPattern), and ensure your code adheres to the Atomic Architecture's layer boundaries, preventing common anti-patterns.

Quick Start

Use the pattern-stack-architect skill to create a new Account model using Field() and appropriate patterns.

Frequently Asked Questions about pattern-stack-architect

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

FAQPage Schema
How do I design a backend architecture using Pattern Stack's Atomic Architecture?

Pattern Stack's Atomic Architecture organizes backend code into four layers—Atoms, Features, Molecules, and Organisms—each with distinct responsibilities. This layered approach enforces separation of concerns, prevents anti-patterns, and ensures consistent pattern composition across SQLAlchemy models, services, and domain logic.

When should I use Field() instead of mapped_column in SQLAlchemy models?

Use Field() for cleaner type inference, built-in validation, and Pattern Stack compliance. Field() eliminates mapped_column verbosity, provides type hints that flow through your models, and integrates with Atoms, Features, Molecules, and Organisms for consistent domain modeling.

How do I combine patterns like ActorPattern, EventPattern, and TemporalPattern in a single model?

Pattern Stack supports multiple inheritance to compose core patterns—Catalog, Actor, Event, Temporal, and Hierarchical—into robust domain models. Combine patterns by inheriting from multiple pattern classes; the Skill guides correct composition to avoid conflicts and ensure layer boundaries remain intact.

What are the responsibilities of each layer in Pattern Stack's Atomic Architecture?

Atoms are foundational building blocks; Features add business logic; Molecules combine Features; Organisms orchestrate complete workflows. Each layer has explicit boundaries; the Skill enforces these constraints, prevents cross-layer violations, and ensures correct implementation of services, entities, and APIs.

How do I ensure my Pattern Stack code follows layer boundaries and composition rules?

The Skill reviews your code against Pattern Stack's layer structure and pattern composition rules, catching violations early. It validates Field() usage, pattern inheritance chains, and API/service design to prevent anti-patterns and keep your architecture aligned with Atomic Architecture principles.

Can I use Pattern Stack patterns for both data models and business logic workflows?

Yes. Pattern Stack patterns apply to SQLAlchemy models, services, entities, and domain workflows. The Skill guides you through using patterns for data layer design and orchestrating those patterns into higher-level Molecules and Organisms for business logic and API design.