coding-standards

Enforce coding standards for TypeScript, JavaScript, React, and Node.js projects.

1|Updated Feb 7, 2026
One-click install
npx skills add https://github.com/ndhananj/codex-agent-setup --skill coding-standards-ndhananj
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: coding-standards
Source: https://github.com/ndhananj/codex-agent-setup/tree/main/docs/zh-CN/skills/coding-standards
Command: npx skills add https://github.com/ndhananj/codex-agent-setup --skill coding-standards-ndhananj

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a comprehensive set of coding standards, best practices, and patterns to ensure high-quality, maintainable, and readable code across TypeScript, JavaScript, React, and Node.js projects.

Core Features & Use Cases

  • Universal Principles: Covers readability, KISS, DRY, and YAGNI.
  • Language-Specific Guidelines: Detailed standards for variable/function naming, immutability, error handling, async operations, and type safety in TypeScript/JavaScript.
  • Framework Best Practices: Recommendations for React component structure, custom hooks, state management, and conditional rendering.
  • API Design: Standards for RESTful APIs, response formats, and input validation using Zod.
  • Project Structure & File Naming: Guidance on organizing code and naming files consistently.
  • Documentation & Comments: Best practices for explaining the 'why' and using JSDoc.
  • Performance Optimization: Techniques like memoization and lazy loading.
  • Testing Standards: Adherence to the AAA pattern and descriptive test naming.
  • Code Smell Detection: Identification and avoidance of long functions, deep nesting, and magic numbers.
  • Use Case: Ensure all new code contributions adhere to established best practices, reducing bugs and improving developer onboarding.

Quick Start

Review the coding standards for TypeScript and React development.

Frequently Asked Questions about coding-standards

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

FAQPage Schema
What are the best practices for enforcing coding standards in TypeScript and React?

Coding standards for TypeScript and React enforce universal principles like KISS, DRY, and YAGNI to ensure high-quality, maintainable code. They provide detailed guidelines on naming conventions, immutability, error handling, and component structure to elevate overall codebase consistency.

How do I structure RESTful APIs and validate inputs in a Node.js project?

To structure RESTful APIs in a Node.js project, apply standards for consistent response formats and use Zod for input validation. This ensures data integrity and standardizes API design across your backend services while improving overall reliability.

How can I detect and avoid code smells like deep nesting and magic numbers in JavaScript?

Detecting code smells in JavaScript involves identifying long functions, deep nesting, and magic numbers. By applying principles like DRY and KISS, you can refactor these patterns into clean, readable, and efficient code structures that improve long-term maintainability.

Does this coding standards skill work with my existing Node.js and JavaScript tech stack?

Yes, these coding standards are designed specifically for TypeScript, JavaScript, React, and Node.js projects. They integrate into your existing tech stack to enforce best practices in async operations, type safety, and project structure without requiring additional dependencies.

What is the best way to organize React component structure and custom hooks?

The best way to organize React components and custom hooks is by following framework-specific best practices for state management, conditional rendering, and file naming. This approach ensures consistent project structure and improves developer productivity across your application.

How do I write tests that follow the AAA pattern and optimize performance with memoization?

Writing tests with the AAA pattern requires descriptive test naming to clearly define Arrange, Act, and Assert stages. Performance optimization is achieved by applying techniques like memoization and lazy loading alongside these testing standards to ensure efficient, reliable code.