composable-architecture

Structure SwiftUI features with TCA reducers, state, effects, and TestStore.

223|21|Updated Dec 20, 2025
One-click install
npx skills add https://github.com/johnrogers/claude-swift-engineering --skill composable-architecture
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: composable-architecture
Source: https://github.com/johnrogers/claude-swift-engineering/tree/main/plugins/swift-engineering/skills/composable-architecture
Command: npx skills add https://github.com/johnrogers/claude-swift-engineering --skill composable-architecture

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

TCA-based architecture provides a scalable, testable approach to building SwiftUI features by structuring reducers, centralizing state, and coordinating effects and navigation.

Core Features & Use Cases

  • Reducer-based state management with @Reducer, Store, and Action
  • Composition of reducers and modular feature wiring for complex screens
  • Unified presentation and navigation patterns via Destination state
  • Built-in testing workflow with TestStore to verify actions, state, and effects
  • Real-world use: building multi-feature flows with deterministic side effects and predictable state

Quick Start

Start by scaffolding a Swift feature with a State, an Action, and a Reducer using TCA patterns, wire it to a view, and validate behavior with a TestStore.

Frequently Asked Questions about composable-architecture

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

FAQPage Schema
How do I build scalable and testable SwiftUI features with centralized state management?

You can build scalable SwiftUI features using TCA architecture by structuring reducers, centralizing state, and coordinating effects. This approach applies @Reducer and Store patterns to create predictable state management across evolving app modules.

What is the best way to structure reducers for complex multi-feature Swift screens?

The best way to structure reducers for complex Swift screens is through reducer composition and modular feature wiring. TCA architecture enables combining multiple reducers to handle distinct features while maintaining centralized state and coordinated effects.

How do I test SwiftUI state changes and side effects deterministically?

You test SwiftUI state changes and side effects deterministically using TCA's TestStore. It verifies that actions produce expected state changes and effects, ensuring comprehensive testing across multiple features with predictable outcomes.

Can I handle navigation and presentation patterns within a Swift reducer architecture?

Yes, TCA architecture handles navigation and presentation patterns within a Swift reducer architecture using unified Destination state. This coordinates navigation across multiple features while maintaining centralized state management.

Does TCA architecture work for managing side effects in evolving Swift app modules?

TCA architecture works for managing side effects in evolving Swift app modules through Effect handling. It coordinates deterministic side effects within reducers, ensuring predictable state changes as app modules grow and require additional features.

How do I start scaffolding a Swift feature using TCA patterns?

Start scaffolding a Swift feature using TCA patterns by defining a State, an Action, and a Reducer. Wire the reducer to a SwiftUI view, then validate behavior using TestStore to verify actions and state changes.