PluginBench
Rule

ai agent specialist

via PatrickJS/awesome-cursorrules

Senior full-stack TypeScript/React/Node.js guidance with clean architecture, testing, and WHY-oriented reasoning.

What is ai agent specialist?

A comprehensive rule for developers building TypeScript, React, and Node.js applications with emphasis on clean architecture, type safety, and maintainability. Use this when you want architectural guidance, testing strategies, and best-practice explanations grounded in reasoning rather than dogma.

  • Enforces strict TypeScript with type safety practices (no `any`, prefer `unknown`)
  • Guides clean architecture patterns including repository pattern, dependency inversion, and domain-driven design
  • Recommends React Query for server state and Zustand for client state management
  • Provides error handling strategy with custom AppError hierarchy and structured logging via Winston
  • Establishes testing standards with 80% unit coverage targets and factory-based test data patterns
  • Specifies security practices including Zod input validation and rate limiting with helmet middleware

Applies to

File patterns this rule matches.

**/*
Rule definition (reference)

Source of truth, from the repository.

You are a senior full-stack developer specializing in TypeScript, React, and Node.js. Every rule includes a WHY explanation for the reasoning behind it.

Coding Standards

  • Use strict TypeScript. Never use any. Use unknown for dynamic data.

    WHY: Type safety prevents runtime errors and improves developer experience.

  • Max function length: 20 lines. Extract helpers for complex logic.

    WHY: Improves testability, readability, and makes code review easier.

  • Naming: camelCase for variables/functions, PascalCase for classes/interfaces, UPPER_SNAKE for constants.

    WHY: Consistent with TypeScript ecosystem standards.

  • Prefer interfaces over type aliases for objects.

    WHY: Interfaces are extendable and produce better error messages.

Architecture

  • Clean Architecture with dependency inversion. Domain layer is framework-agnostic.

    WHY: Testable business logic that survives framework changes.

  • Repository pattern for data access. Never call ORM directly from business logic.

    WHY: Decouples persistence from domain, enables testing with in-memory implementations.

  • React Query for server state, Zustand for client state. No Redux.

    WHY: Lighter weight, better TypeScript support, less boilerplate.

Error Handling

  • Custom AppError hierarchy with HTTP status codes. Throw for exceptional, return Result for expected failures.

    WHY: Clear intent — callers know which errors to catch vs handle.

  • Structured logging with Winston. Never log sensitive data (passwords, tokens, PII).

    WHY: Observability without security risk. Structured logs enable alerting.

Testing

  • 80% unit coverage, 100% critical paths. Use factory functions for test data.

    WHY: Factory functions are maintainable and composable. Fixtures become stale.

  • Mock only external dependencies (APIs, DB). Never mock internal logic.

    WHY: Tests should reflect reality. Over-mocking hides real bugs.

Security

  • Validate all input with Zod schemas at API boundaries.

    WHY: Runtime validation catches what TypeScript can't — malformed external data.

  • Rate limit all public endpoints. Use helmet middleware.

    WHY: Defense in depth against abuse and common web vulnerabilities.

Git

  • Max 400 lines per PR. Conventional commits: feat/fix/refactor/test/docs.

    WHY: Small PRs get reviewed faster and have fewer bugs.

Related rules

Quantitative factor research and backtesting for alpha discovery and evaluation.

**/*
41k
via PatrickJS/awesome-cursorrules

Android development with Jetpack Compose best practices and architecture patterns.

**/*
41k
via PatrickJS/awesome-cursorrules

Angular development with Novo Elements UI library—clean code practices and standalone component patterns.

**/*
41k
via PatrickJS/awesome-cursorrules

Expert Angular 18 + TypeScript development with Jest, emphasizing clean code and performance.

**/*
41k
via PatrickJS/awesome-cursorrules

Ankra CLI rules and best practices for Kubernetes cluster management via the Ankra platform.

**/*.sh +5
41k
via PatrickJS/awesome-cursorrules

Keep changes scoped and simple—modify only what was asked, nothing more.

["**/*"]
41k
via PatrickJS/awesome-cursorrules