app-implement-feature

Guide architecture-first TDD implementation of new Swift features.

323|28|Updated Feb 18, 2026
One-click install
npx skills add https://github.com/tddworks/asc-cli --skill app-implement-feature
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: app-implement-feature
Source: https://github.com/tddworks/asc-cli/tree/main/.claude/skills/app-implement-feature
Command: npx skills add https://github.com/tddworks/asc-cli --skill app-implement-feature

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill streamlines the process of adding new features to Swift applications by enforcing a robust architecture-first design, Test-Driven Development (TDD), and rich domain models, ensuring high-quality, maintainable code.

Core Features & Use Cases

  • Architecture Design: Guides users through creating component diagrams and documenting interactions before coding.
  • TDD Implementation: Facilitates writing domain model and infrastructure tests using Chicago-style TDD.
  • Domain-Driven Design: Promotes rich domain models that encapsulate behavior and align with the user's mental model.
  • Swift 6.2 Patterns: Encourages direct consumption of domain models by SwiftUI views, eliminating the ViewModel layer.
  • Use Case: When a user requests a new feature like "implement a user profile management system," this Skill will first help design the architecture, then guide the TDD implementation of domain models and services.

Quick Start

Use the app-implement-feature skill to start implementing a new user authentication flow.

Frequently Asked Questions about app-implement-feature

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

FAQPage Schema
How do I implement a new feature in Swift using TDD and Clean Architecture?

To implement a feature with TDD and Clean Architecture, this skill enforces an architecture-first design phase for domain and infrastructure layers, followed by Chicago-style TDD to build rich domain models and protocol-based dependencies before writing SwiftUI views.

Can I use SwiftUI to directly consume rich domain models without a ViewModel layer?

Yes, you can consume rich domain models directly in SwiftUI views without a ViewModel. This approach leverages Swift 6.2 patterns to eliminate the intermediate ViewModel layer, allowing views to interact directly with domain behavior.

What's the best way to design architecture before writing tests in Swift?

The best way to design architecture before testing is to create component diagrams and document interactions across domain, infrastructure, and app layers. This skill mandates user approval of this design phase before proceeding to TDD implementation.

Does Domain-Driven Design work with protocol-based dependency injection in Swift?

Yes, Domain-Driven Design works seamlessly with protocol-based dependency injection in Swift. This combination allows you to define clear boundaries for infrastructure layers while maintaining rich domain models that encapsulate behavior aligned with the user's mental model.

How do I write domain model tests using Chicago-style TDD?

To write domain model tests using Chicago-style TDD, you focus on testing the behavior of the entire domain object from the outside. This skill guides you through writing these tests to ensure your rich domain models function correctly before integrating infrastructure components.

When do I need to create a component diagram for a Swift feature?

You need to create a component diagram for a Swift feature during the mandatory architecture design phase before any coding begins. This ensures that interactions across domain, infrastructure, and app layers are documented and approved prior to TDD implementation.