home / skills / fusengine / agents / solid-react

This skill enforces SOLID React architecture by guiding modular design, interfaces, JSDoc, and code organization for components, hooks, and cores.

npx playbooks add skill fusengine/agents --skill solid-react

Review the files below or copy the command above to add this skill to your agents.

Files (18)
SKILL.md
5.1 KB
---
name: solid-react
description: SOLID principles for React 19. Files < 100 lines, hooks separated, interfaces in src/interfaces/, JSDoc mandatory. Use for React architecture and code quality.
version: 1.0.0
user-invocable: true
references: references/solid-principles.md, references/single-responsibility.md, references/open-closed.md, references/liskov-substitution.md, references/interface-segregation.md, references/dependency-inversion.md, references/architecture-patterns.md, references/templates/component.md, references/templates/hook.md, references/templates/service.md, references/templates/store.md, references/templates/interface.md, references/templates/validator.md, references/templates/factory.md, references/templates/adapter.md, references/templates/error.md, references/templates/test.md
---

# SOLID React - Component Architecture

## Codebase Analysis (MANDATORY)

**Before ANY implementation:**
1. Explore project structure to understand architecture
2. Read existing related files to follow established patterns
3. Identify naming conventions, coding style, and patterns used
4. Understand data flow and dependencies

## DRY - Reuse or Create Shared (MANDATORY)

**Before writing ANY new code:**
1. Search existing codebase for similar functionality
2. Check shared locations: `modules/cores/lib/`, `modules/cores/components/`
3. If similar code exists → extend/reuse instead of duplicate
4. If code will be used by 2+ features → create it in `modules/cores/` directly

---

## Agent Workflow (MANDATORY)

Before ANY implementation, use `TeamCreate` to spawn 3 agents:

1. **fuse-ai-pilot:explore-codebase** - Analyze project structure and existing patterns
2. **fuse-ai-pilot:research-expert** - Verify latest docs for all stack technologies
3. **mcp__context7__query-docs** - Check integration compatibility

After implementation, run **fuse-ai-pilot:sniper** for validation.

---

## Absolute Rules (MANDATORY)

### 1. Files < 100 lines

- **Split at 90 lines** - Never exceed 100
- Components < 50 lines (use composition)
- Hooks < 30 lines each
- Services < 40 lines each

### 2. Modular Architecture

See `references/architecture-patterns.md` for complete structure with feature modules and cores directory.

### 3. JSDoc Mandatory

```typescript
/**
 * Fetch user by ID from API.
 *
 * @param id - User unique identifier
 * @returns User object or null if not found
 */
export async function getUserById(id: string): Promise<User | null>
```

### 4. Interfaces Separated

```text
modules/[feature]/src/interfaces/
├── user.interface.ts
├── post.interface.ts
└── api.interface.ts
```

**NEVER put interfaces in component files.**

---

## SOLID Principles (Detailed Guides)

Each SOLID principle has a dedicated reference guide:

1. **`references/single-responsibility.md`** - One function = one reason to change
   - File splitting at 90 lines (components < 50, hooks < 30)
   - Component composition patterns
   - Split strategy

2. **`references/open-closed.md`** - Extend via composition, not modification
   - Plugin architecture patterns
   - Render props and slots
   - Strategy patterns

3. **`references/liskov-substitution.md`** - Contract compliance & behavioral subtyping
   - Interface contracts
   - Swappable implementations
   - Testing compliance

4. **`references/interface-segregation.md`** - Many focused interfaces beat one fat interface
   - Role-based interfaces
   - Props segregation
   - Context splitting

5. **`references/dependency-inversion.md`** - Depend on abstractions, not implementations
   - Constructor injection patterns
   - Factory patterns
   - Context for DI

See `references/solid-principles.md` for overview and quick reference.

---

## Code Templates

Ready-to-copy code in `references/templates/`:

| Template | Usage | Max Lines |
|----------|-------|-----------|
| `component.md` | React functional component | 50 |
| `hook.md` | Custom hook with TanStack Query | 30 |
| `service.md` | Service with dependency injection | 40 |
| `store.md` | Zustand store with persistence | 40 |
| `interface.md` | TypeScript interfaces | - |
| `validator.md` | Zod validation schemas | 30 |
| `factory.md` | Factory pattern | 40 |
| `adapter.md` | Adapter pattern | 40 |
| `error.md` | Custom error classes | 30 |
| `test.md` | Vitest + Testing Library | - |

---

## Response Guidelines

1. **Research first** - MANDATORY: Search Context7 + Exa before ANY code
2. **Show complete code** - Working examples, not snippets
3. **Explain decisions** - Why this pattern over alternatives
4. **Include tests** - Always suggest test cases
5. **Handle errors** - Never ignore, use error boundaries
6. **Type everything** - Full TypeScript, no `any`
7. **Document code** - JSDoc for complex functions

---

## Forbidden

- Coding without researching docs first (ALWAYS research)
- Using outdated APIs without checking current year docs
- Files > 100 lines
- Interfaces in component files
- Business logic in components
- Class components
- Missing JSDoc on exports
- `any` type
- Barrel exports (index.ts re-exports)
- `useEffect` for data fetching (use TanStack Query or Router loaders)
- Module importing another module (except cores)

Overview

This skill enforces SOLID architecture and code-quality rules for React 19 TypeScript projects. It prescribes small files, separated interfaces, mandatory JSDoc, hook/service size limits, and reuse via a cores/modules layout. Use it to validate and guide component design, hooks, services, and module structure for maintainable, testable code.

How this skill works

The skill inspects project structure, file sizes, and locations of interfaces and artifacts against the SOLID ruleset. It checks for mandatory JSDoc on exported symbols, enforces file-length limits (components <50, hooks <30, files <100 lines), and flags interfaces placed inside component files. It also recommends reuse from cores/modules and suggests patterns from the reference templates.

When to use it

  • Starting a new React 19 TypeScript feature or refactor
  • Enforcing architecture rules in code reviews or CI checks
  • Onboarding contributors to a consistent component/hook pattern
  • Designing modules intended for reuse across features
  • Preparing code for long-term maintainability and testability

Best practices

  • Research project patterns before any implementation—read related files and references first
  • Keep files very small: split components and hooks as prescribed and favor composition
  • Place all interfaces in modules/[feature]/src/interfaces/ and never inside component files
  • Always add JSDoc to exported functions, hooks, services and types
  • Reuse shared code from modules/cores/ and create new core utilities only when used by multiple features

Example use cases

  • Validate a pull request for file size, JSDoc presence, and interface placement
  • Refactor a large component into composable subcomponents under 50 lines each
  • Create a hook using the hook template (TanStack Query) and keep it under 30 lines
  • Introduce a service using dependency-inversion patterns and place abstractions in cores/
  • Generate interface files in the interfaces folder and link them across components and services

FAQ

What if an interface seems tiny—can it stay in the component file?

No. Interfaces must be separated into the feature's interfaces folder to maintain contracts and enable reuse and testing.

Are there exceptions to the file-length limits for complex logic?

Follow composition instead: split responsibilities across small files. If unavoidable, refactor into services/hooks/components per the templates and keep each unit within limits.