Language-Specific

Comprehensive guidelines for writing clean, maintainable, and high-performance JavaScript/TypeScript code. Follow these best practices to ensure your code is simple, readable, and reusable.

Comprehensive guide to developing Chrome Extensions using JavaScript, HTML, CSS, and Chrome APIs. Learn best practices, performance optimization, security, and more.

A comprehensive guide to writing clear, readable, and efficient Rell code for blockchain applications on the Chromia platform. Learn best practices, core concepts, and advanced features to optimize your Rell code.

A detailed guide on using Pandas and Scikit-learn for efficient data analysis, visualization, and machine learning workflows in Python. This guide emphasizes best practices, performance optimization, and reproducibility.

Comprehensive guide for developing Telegram bots using Plasticode and PHP, focusing on best practices, coding standards, and dependency management.

A comprehensive guide and AI system prompt for developing advanced EEG signal processing applications using PyQt6, focusing on creating user-friendly interfaces, robust backend processing, and efficient workflows.

Comprehensive guide for Python and TypeScript development, focusing on best practices, modern frameworks, and efficient coding techniques.

Comprehensive guidelines for Python development, emphasizing modular design, robust error handling, and AI-friendly coding practices.

Experienced Python developer specializing in command-line tools, file system operations, and performance optimization. Proven track record in debugging complex issues and delivering high-quality, maintainable code.

Comprehensive guide for Python development focusing on project structure, modular design, configuration management, error handling, testing, documentation, dependency management, code style, CI/CD, and AI-friendly coding practices.

Expert guidelines for developing machine learning models in chemistry using Python, focusing on scikit-learn and PyTorch. Emphasizes code readability, reproducibility, and scalability.

Best practices and guidelines for developing secure and efficient Solidity smart contracts using Hardhat.

A comprehensive guide to implementing Large Language Model (LLM) architectures using TypeScript, focusing on functional programming, best practices, and developer-friendly APIs.

Comprehensive guidelines for TypeScript development in Node.js and Next.js environments with AI integration, focusing on practical code solutions and clear explanations.

Comprehensive guide and rules for TypeScript development in Node.js, Next.js, React, and UI projects, focusing on best practices, performance optimization, and modern styling techniques.

Comprehensive guidelines and best practices for developing applications using TypeScript, Node.js, React, and Vite. Includes coding standards, performance optimization, and UI styling with Tailwind CSS.

Comprehensive guide for TypeScript development with React, Next.js, and Cloudflare, including best practices, coding standards, and performance optimization.

A modern web application built with TypeScript, React, NextUI, and Supabase, featuring authentication, a responsive UI, and a dashboard for logged-in users.

Comprehensive guide to TypeScript best practices using shadcn/ui and Next.js, focusing on code style, structure, performance optimization, and error handling.

A comprehensive guide to building high-performance, maintainable, and scalable TypeScript applications using Vite, Vue.js, Tailwind CSS, and related technologies.

Comprehensive guidelines and best practices for using TypeScript with Vue.js, covering code style, structure, naming conventions, syntax, error handling, UI styling, and performance optimization.

A comprehensive guide to building scalable and maintainable TypeScript applications using Zod for validation, Tailwind CSS for styling, and Next.js for server-side rendering and routing.

Comprehensive guide and rules for developing TypeScript applications using Next.js, focusing on best practices, performance optimization, and maintainability.

Comprehensive guide for developing with TypeScript, Next.js, React, and Tailwind CSS. Includes best practices for data fetching, rendering, routing, and handling AI interactions using Vercel AI SDK.

A comprehensive guide and ruleset for building modern full-stack applications using TypeScript, Next.js, React, Tailwind CSS, and Supabase. This setup includes best practices for coding standards, performance optimization, and error handling.

Comprehensive guidelines for building scalable and maintainable TypeScript applications using Next.js, Supabase, and modern UI libraries like Shadcn UI and Radix UI.

A comprehensive guide and rules for building a TypeScript-based Notes Application using Node.js, Next.js App Router, React, Shadcn UI, Radix UI, and Tailwind CSS. This application includes features like adding, editing, deleting notes, search, filter, sort, pagination, loading states, error handling, and drag-and-drop functionality.

Comprehensive guidelines for developing React applications using TypeScript, focusing on best practices, performance optimization, and maintainability.

Comprehensive guide and rules for developing Google Apps Script projects using TypeScript and Clasp, focusing on best practices, performance optimization, and secure coding.

This article explains what clean code is and why it's important. It provides principles like avoiding hard - coded numbers, using meaningful names, writing short functions, following DRY principle, adhering to coding standards, etc. for writing clean and maintainable code.

This rule set provides comprehensive guidelines for C++ programming, covering basic principles, nomenclature, functions, data handling, classes, exceptions, memory management, testing, project structure, standard library usage, and concurrency. It aims to ensure code quality, readability, and maintainability in C++ projects.

These rules are for Python development with Temporal.io. They cover coding standards (e.g., following PEP 8, using type - hints), Temporal.io best practices (e.g., using decorators, naming conventions), error handling, project structure, dependencies, documentation, testing, and CI/CD integration.

This guide offers comprehensive best - practices for using pyright and BasedPyright in Python projects. It covers code organization, design patterns, performance optimization, security, testing, common pitfalls, and recommended tooling.

This document outlines best practices for using Poetry, a Python dependency management and packaging tool, covering code organization, patterns, performance, security, testing, common pitfalls, and tooling.

This document outlines best practices for using Matplotlib, a Python library for visualizations. It covers code organization, design patterns, performance, security, testing, common pitfalls, and tooling.

This rule set focuses on best practices for using Zod, a TypeScript-first schema declaration and validation library. It covers aspects such as code organization, common patterns, performance optimization, security, testing, and tooling. These rules aim to enhance the readability, maintainability, and security of Zod schema code, ensuring efficient and reliable data validation and transformation in applications.

This document outlines best practices and coding standards for developing games and multimedia applications using the Pygame library in Python, covering code organization, patterns, performance, security, testing, common pitfalls, and tooling.

This document details best practices for using Mypy in Python projects. It covers gradual typing, consistent configuration, advanced feature usage, code organization, common patterns, performance, security, testing, and more. Following these guidelines can enhance code maintainability, robustness, and readability.

This guide details best practices for Keras development. It covers code organization, common patterns, performance, security, testing, and tooling. For example, it suggests a clear directory structure, using design patterns like the Functional API, optimizing performance via GPU acceleration, and implementing various security and testing measures.

These rules focus on Trio code in Python. They cover code quality, like using `flake8-async` and following PEP 8. For code structure, it details directory layout, module organization, and component architecture. Also includes design patterns, anti - patterns, performance, security, testing, and tooling guidance.

Adopt Black as the primary formatter for Python projects. Follow its default style guide, integrate it into workflows via pre - commit hooks and CI/CD. Configure with `pyproject.toml` if needed. It enforces consistency, automates formatting, and integrates well with tools, while also promoting best practices in code organization, security, testing, etc.

This guide details isort best - practices in Python projects. It covers code organization (directory structure, file naming), common patterns, performance, security, testing, pitfalls, and tooling. It offers tips like using modular structure for large projects, sorting imports automatically, and integrating with other tools in CI/CD.

This document details best practices for Bash scripting. It covers code organization, common patterns, performance, security, testing, and more. For example, it suggests a proper directory structure, naming conventions, and using built - in commands for better performance. It also emphasizes security through input validation and avoiding common vulnerabilities.

These rules aim to ensure high - quality LLVM code. It covers coding standards, language usage, source formatting, and performance. Adhere to LLVM's style, use modern C++ and Python, manage memory efficiently, and follow best practices in testing, security, and tooling. Avoid common pitfalls and contribute to a consistent codebase.

This document details Rust development best - practices. It covers code organization, common patterns, performance, security, testing, pitfalls, and tooling. For example, it guides on directory structure, recommends design patterns, offers optimization techniques, and suggests testing approaches. Adhering to these can lead to efficient, secure, and maintainable Rust code.

These rules focus on Python development with the Rich library. They cover general coding style following PEP 8, installation, code organization, and best practices for using Rich features like console, styling, tables, etc. Also included are performance, security, testing aspects, and guidance on tooling and environment setup.

This document details best practices for using `setuptools` in Python projects. It covers code organization, design patterns, anti - patterns, performance, security, testing, common pitfalls, and tooling. Following these guidelines helps create maintainable, performant, and secure Python packages.

This guide offers comprehensive best - practices for Solidity smart contracts. It covers code organization, common patterns, performance, security, testing, and tooling. It details directory structure, naming conventions, design patterns, optimization techniques, and ways to prevent common vulnerabilities, ensuring secure, efficient, and maintainable contracts.

This document details Zsh scripting best - practices. It covers code organization, common patterns, performance, security, testing, and tooling. It advises on directory structure, naming, and avoiding anti - patterns. Also provides tips for optimization, input validation, and unit testing, ensuring reliable, maintainable, and secure Zsh scripts.

This document outlines best practices for Ruby development, covering code organization, design patterns, performance optimization, security, testing, and more. It provides guidelines on directory structure, file naming, common patterns, anti - patterns, and recommends tools and strategies for a high - quality Ruby project.

This guide offers guidelines for high - quality pandas code. It covers code organization, common patterns, performance, security, testing, pitfalls, and tooling. For organization, it suggests clear directory and file naming. It recommends vectorized operations for performance and parameterized queries for security. Testing strategies include unit and integration tests.

This document offers guidelines for AnyIO library development. It covers code organization, common patterns, performance, security, testing, common pitfalls, and tooling. For example, it suggests using task groups for concurrency, asynchronous I/O for performance, and proper input validation for security.

This document provides comprehensive best practices for Python development. It covers code organization, design patterns, performance optimization, security, testing, and tooling. Adhering to these standards helps create clean, efficient, maintainable, and secure Python code.

This guide details using Flake8 in Python projects for high - quality code. It covers code organization, common patterns, performance, security, testing, pitfalls, and tooling. For example, it advises on directory structure, recommends design patterns, and provides optimization and security strategies to maintain code quality and prevent errors.

These rules present best practices for using BeautifulSoup4 to build web scrapers. By adhering to them, you can create robust, efficient, and secure scrapers, ensuring high - quality data extraction and smooth operation in various web scraping scenarios.

This document presents best - practices for using Python's `tqdm` library. It covers basic usage, performance optimization, nested bars, customization, and avoiding pitfalls. It also provides testing approaches, tooling suggestions, and an example of downloading files with a progress bar. Following these guidelines can enhance code efficiency and user experience.

This guide offers comprehensive guidelines for using the Python `requests` library. It covers code organization, common patterns, performance, security, testing, common pitfalls, and tooling. It details best - practices like using sessions for performance, proper error handling, and secure authentication, while also highlighting anti - patterns to avoid.

This document offers best practices for Dask development. It covers code organization, like directory structure and file naming. It details common patterns, anti - patterns, performance optimization, security measures, testing approaches, and common pitfalls. Following these guidelines ensures efficient, maintainable, and robust Dask applications.

This document details best practices for Python's tkinter GUI development. It covers code organization, design patterns, performance optimization, security, testing, and tooling. It also points out common mistakes and provides solutions to ensure you can create robust, maintainable, and performant tkinter applications.