implementation-patterns

Name: implementation-patterns
Availability: InStock
Author: Houke

Guide TypeScript/React developers through TDD workflows and Clean Architecture.

Updated Jan 25, 2026

Search Tags:#testing #architecture #TDD #React #TypeScript #patterns

Ready to run

npx skills add https://github.com/houke/nexus-playground --skill implementation-patterns

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: implementation-patterns
Source: https://github.com/houke/nexus-playground/tree/main/.github/skills/implementation-patterns
Command: npx skills add https://github.com/houke/nexus-playground --skill implementation-patterns

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill consolidates TDD workflows, coding standards, debugging strategies, and production code patterns into a practical reference for software developers.

Core Features & Use Cases

TDD Workflow: Red-Green-Refactor cycles, and how to apply them in TypeScript/React projects.
Architecture & Patterns: Clean Architecture guidance, domain and application layer separation, and common design patterns.
Developer Toolkit: Examples, templates, and reference materials to accelerate learning and adoption.

Quick Start

Use the Skill to review example patterns, read the quick references, and adapt templates to your project. For a hands-on example, follow the TDD workflow by writing a failing test, making it pass, and refactoring, then apply the clean-architecture guidance to restructure a small module.

Frequently Asked Questions about implementation-patterns

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

FAQPage Schema

How do I apply TDD workflows in TypeScript and React?▼

To apply TDD in TypeScript and React, follow the Red-Green-Refactor cycle by writing a failing test, implementing code to make it pass, and then refactoring. This workflow provides a structured, repeatable approach to building maintainable components.

What is clean architecture and how do I separate domain layers in React?▼

Clean architecture in React separates domain and application layers to decouple business logic from UI frameworks. Restructuring modules using this guidance isolates core logic, ensuring your scalable TypeScript applications remain maintainable across projects.

Can I use these coding standards and patterns to scale existing TypeScript apps?▼

Yes, you can use these production code patterns to scale existing TypeScript apps. The reference materials and templates adapt to your project, allowing you to apply documented architectural patterns and debugging strategies to improve maintainability.

What is the best way to start structured pattern-driven development for scalable TS apps?▼

The best way to start pattern-driven development is to review the provided example patterns, read the quick references, and adapt templates to your project. You can follow the TDD workflow hands-on by writing a failing test, making it pass, and refactoring.

Why should I use consolidated architecture patterns instead of ad-hoc testing strategies?▼

Using consolidated architecture patterns provides a structured, repeatable approach to testing and architecture decisions, unlike ad-hoc strategies. This ensures consistent coding standards and maintainable code across multiple TypeScript and React projects.

When should I not use clean architecture guidance for a small React module?▼

Clean architecture guidance might be excessive for trivial UI components where domain and application layer separation adds unnecessary boilerplate. However, applying it to restructure a small module with core business logic can effectively demonstrate the pattern's maintainability benefits.