Essential .cursorrules Templates for Every Programming Language (2026)

# Python Development Rules

## Language Version and Style
- Use Python 3.11+ features when available
- Follow PEP 8 style guide strictly
- Use type hints for all function signatures
- Prefer f-strings over .format() or % formatting
- Use dataclasses or Pydantic models for structured data

## Code Organization
- Use clear, descriptive variable names (snake_case)
- Keep functions under 20 lines when possible
- Use docstrings for all public functions (Google style)
- Organize imports: stdlib, third-party, local
- Use __all__ to define public API

## Async Programming
- Use async/await for I/O-bound operations
- Prefer asyncio.create_task() over asyncio.ensure_future()
- Use aiohttp for HTTP clients, not requests
- Always handle async context managers properly
- Use asyncio.gather() for concurrent operations

## Error Handling
- Use specific exception types, not bare except:
- Implement proper logging with structlog or loguru
- Use contextlib for resource management
- Validate inputs early and fail fast
- Include error context in exception messages

## Performance Patterns
- Use list/dict/set comprehensions over loops when readable
- Prefer itertools for complex iterations
- Use slots for data classes when appropriate
- Cache expensive operations with functools.lru_cache
- Profile before optimizing with cProfile

## Testing Standards
- Use pytest for all testing
- Write tests before implementation (TDD)
- Use fixtures for common test data
- Mock external dependencies properly
- Test edge cases and error conditions
- Aim for 90%+ test coverage

## Data Handling
- Use pandas for data manipulation
- Prefer pathlib over os.path
- Use context managers for file operations
- Validate data with Pydantic or marshmallow
- Handle large datasets with generators/iterators

## Security Practices
- Never use eval() or exec() with user input
- Use secrets module for cryptographic operations
- Validate all inputs, especially user data
- Use parameterized queries for database operations
- Keep dependencies updated with security patches

## Project Structure
- Use pyproject.toml for project configuration
- Include requirements.txt and requirements-dev.txt
- Use virtual environments (venv, poetry, conda)
- Include .gitignore for Python projects
- Use pre-commit hooks for code quality

## Code Generation Guidelines
- Include comprehensive type hints
- Add docstrings with examples
- Handle exceptions appropriately
- Include logging for important operations
- Write accompanying tests
- Follow existing project patterns
- Consider performance implications
- Include input validation

# JavaScript Development Rules

## Language Standards
- Use ES2023+ features (async/await, optional chaining, nullish coalescing)
- Prefer const/let over var (never use var)
- Use arrow functions for simple operations
- Implement proper error boundaries
- Use strict mode in all files

## Code Style
- Use camelCase for variables and functions
- Use PascalCase for classes and constructors
- Use UPPER_SNAKE_CASE for constants
- Prefer template literals over string concatenation
- Use meaningful variable names

## Async Programming
- Use async/await over Promises.then()
- Handle Promise rejections with try/catch
- Use Promise.all() for concurrent operations
- Implement proper timeout handling
- Avoid callback hell with Promise chains

## Modern JavaScript Patterns
- Use destructuring for object/array extraction
- Implement proper module imports/exports
- Use optional chaining (?.) for safe property access
- Use nullish coalescing (??) for default values
- Prefer Set/Map over arrays/objects for collections

## Error Handling
- Always catch and handle errors appropriately
- Use custom Error classes for specific error types
- Include meaningful error messages
- Implement proper fallback mechanisms
- Log errors with context information

## Performance Optimization
- Use lazy loading for large modules
- Implement proper caching strategies
- Avoid memory leaks (event listeners, timers)
- Use WeakMap/WeakSet for object metadata
- Optimize DOM operations (batch updates)

## Testing Standards
- Use Jest or Vitest for testing
- Write unit tests for all functions
- Mock external dependencies
- Test async operations properly
- Include integration tests

## Security Practices
- Validate all user inputs
- Use Content Security Policy (CSP)
- Avoid eval() and innerHTML with user data
- Implement proper CORS handling
- Keep dependencies updated

## Node.js Specific
- Use ES modules over CommonJS when possible
- Handle process signals gracefully
- Implement proper logging with winston or similar
- Use environment variables for configuration
- Handle unhandled promise rejections

## Browser Specific
- Use modern APIs (fetch, IntersectionObserver, etc.)
- Implement proper progressive enhancement
- Handle different browser environments
- Use service workers for offline functionality
- Optimize for mobile performance

## Code Generation Guidelines
- Include JSDoc comments for complex functions
- Handle edge cases and error states
- Use appropriate design patterns
- Consider browser compatibility
- Include proper input validation
- Implement accessible code patterns
- Follow existing project conventions

# TypeScript Development Rules

## Type System
- Use strict TypeScript configuration (strict: true)
- Define explicit types for all public APIs
- Use utility types (Pick, Omit, Partial) when appropriate
- Prefer interfaces over types for object shapes
- Use enums for finite sets of values

## Advanced Typing
- Use generic types for reusable code
- Implement proper type guards and predicates
- Use conditional types for complex type relationships
- Leverage mapped types for transformations
- Use template literal types for string validation

## Code Organization
- Use barrel exports for clean imports
- Organize types in separate .d.ts files when appropriate
- Use namespaces sparingly, prefer modules
- Implement proper index signatures
- Use const assertions where appropriate

## Error Handling
- Use discriminated unions for error states
- Implement Result patterns for error handling
- Use type-safe error boundaries
- Validate runtime data with type guards
- Use assertion functions for runtime checks

## Performance Patterns
- Use readonly arrays and objects when possible
- Implement proper memoization with correct types
- Use lazy evaluation with proper typing
- Type narrow in conditional blocks
- Use type assertions sparingly and safely

## Testing with TypeScript
- Type your test data properly
- Use jest with @types/jest
- Mock with proper type safety
- Test type behavior with tsd or similar
- Include tests for type guards

## Module Patterns
- Use proper import/export syntax
- Implement module augmentation carefully
- Use declare global for global type extensions
- Type external libraries with DefinitelyTyped
- Create proper type-only imports

## API Design
- Design type-safe APIs with proper generics
- Use branded types for type safety
- Implement proper builder patterns with types
- Use function overloads judiciously
- Create self-documenting APIs with types

## React with TypeScript (if applicable)
- Use React.FC sparingly, prefer function declarations
- Type props interfaces explicitly
- Use proper event handler types
- Implement generic components with proper constraints
- Use React hooks with correct typing

## Node.js with TypeScript (if applicable)
- Type environment variables properly
- Use proper types for Express middleware
- Implement type-safe database operations
- Type API responses and requests
- Use proper types for configuration

## Code Generation Guidelines
- Always include explicit return types
- Use the most specific types possible
- Implement proper type guards for runtime validation
- Include comprehensive JSDoc with @param and @returns
- Use readonly modifier where appropriate
- Prefer composition over inheritance
- Implement proper error handling with typed errors
- Use discriminated unions for state management

# React TypeScript Development Rules

## Component Patterns
- Use functional components with hooks (no class components)
- Prefer arrow function components for simple cases
- Use function declarations for named components
- Implement proper component composition
- Use React.memo for performance optimization when needed

## TypeScript Integration
- Define interfaces for all component props
- Use generic components where appropriate
- Type event handlers explicitly (React.MouseEvent, etc.)
- Use proper typing for refs (useRef)
- Type context values and providers

## Hooks Best Practices
- Use useState with proper type inference
- Type useEffect dependencies correctly
- Use useCallback for event handlers in props
- Use useMemo for expensive calculations
- Create custom hooks for reusable logic

## State Management
- Use useState for simple local state
- Use useReducer for complex state logic
- Use Context API for global state (avoid prop drilling)
- Type all state interfaces explicitly
- Implement proper state update patterns

## Performance Optimization
- Use React.lazy for code splitting
- Implement proper loading states
- Use React.memo with proper comparison functions
- Optimize re-renders with useCallback and useMemo
- Use key props correctly for list items

## Event Handling
- Type all event handlers properly
- Use useCallback for handlers passed to children
- Implement proper form handling with controlled components
- Handle async operations in event handlers safely
- Use event delegation where appropriate

## Error Boundaries
- Implement error boundaries for graceful failures
- Use React Error Boundary or similar libraries
- Type error boundary props and state
- Provide meaningful fallback UIs
- Log errors appropriately for debugging

## Accessibility (a11y)
- Include proper ARIA attributes
- Ensure keyboard navigation works
- Use semantic HTML elements
- Provide meaningful alt text for images
- Maintain proper heading hierarchy
- Test with screen readers

## Styling Approaches
- Use CSS Modules or styled-components consistently
- Follow your project's styling convention
- Use CSS custom properties for theming
- Implement responsive design patterns
- Avoid inline styles except for dynamic values

## Testing Patterns
- Use React Testing Library for component testing
- Test user interactions, not implementation details
- Mock external dependencies properly
- Test error states and edge cases
- Include accessibility tests

## File Organization
- Co-locate related files (component, styles, tests)
- Use PascalCase for component files
- Use index.ts files for clean imports
- Separate container and presentational components
- Organize by feature when appropriate

## API Integration
- Use React Query, SWR, or similar for data fetching
- Implement proper loading and error states
- Type API responses with interfaces
- Use environment variables for API endpoints
- Handle authentication properly

## Component API Design
- Design props interfaces for flexibility
- Use children prop appropriately
- Implement render props or compound component patterns
- Provide sensible defaults for optional props
- Use forward refs when necessary

## Code Generation Guidelines
- Always include TypeScript interfaces for props
- Include proper error handling and error states
- Implement loading states for async operations
- Add accessibility attributes by default
- Include prop validation through TypeScript
- Use semantic HTML elements
- Implement proper event handling patterns
- Consider mobile-first responsive design
- Include meaningful error messages
- Follow existing component patterns in the project

## React 18+ Features
- Use Suspense for data fetching when appropriate
- Implement proper concurrent features
- Use transitions for non-urgent updates
- Use automatic batching patterns
- Implement proper streaming SSR when needed

# Go Development Rules

## Language Idioms
- Follow effective Go principles and style guide
- Use gofmt and goimports for code formatting
- Follow Go naming conventions (camelCase, short names)
- Keep functions and methods small and focused
- Use early returns to reduce nesting

## Error Handling
- Always check and handle errors explicitly
- Use custom error types for specific errors
- Wrap errors with fmt.Errorf and %w verb
- Use errors.Is() and errors.As() for error checking
- Return errors as the last return value

## Package Organization
- Use clear, concise package names (lowercase, no underscores)
- Keep package scope focused and cohesive
- Use internal/ directory for internal packages
- Organize by feature, not by type
- Use go.mod for dependency management

## Concurrency Patterns
- Use goroutines and channels for concurrent operations
- Prefer channels over shared memory for communication
- Use context.Context for cancellation and timeouts
- Implement proper goroutine lifecycle management
- Use sync package primitives when appropriate

## Memory Management
- Avoid memory leaks in long-running programs
- Use object pools for high-frequency allocations
- Be mindful of slice and map growth patterns
- Use defer for resource cleanup
- Implement proper connection pooling

## Interface Design
- Use small, focused interfaces (single method preferred)
- Accept interfaces, return concrete types
- Use embedded interfaces for composition
- Keep interface definitions close to usage
- Use empty interface{} sparingly

## Testing Practices
- Use table-driven tests for multiple scenarios
- Test public APIs, not internal implementation
- Use testify/assert for better test readability
- Mock external dependencies with interfaces
- Include benchmarks for performance-critical code

## HTTP and API Development
- Use net/http for HTTP services
- Implement proper middleware patterns
- Use context for request-scoped data
- Validate input data thoroughly
- Implement graceful shutdown patterns

## Database Interactions
- Use database/sql with appropriate drivers
- Implement proper connection pooling
- Use prepared statements for queries
- Handle SQL null values properly
- Use transactions for multi-statement operations

## Logging and Monitoring
- Use structured logging (logrus, zap, or slog)
- Include appropriate log levels
- Log errors with sufficient context
- Implement proper health checks
- Use metrics for monitoring

## Security Practices
- Validate all inputs thoroughly
- Use crypto/rand for random number generation
- Implement proper authentication and authorization
- Use HTTPS for all network communication
- Keep dependencies updated

## Performance Optimization
- Profile before optimizing (go tool pprof)
- Use buffered I/O for large data operations
- Implement proper caching strategies
- Use worker pools for CPU-intensive tasks
- Optimize for garbage collector efficiency

## Build and Deployment
- Use Go modules for dependency management
- Include Dockerfiles for containerization
- Use build tags for environment-specific code
- Implement proper health checks
- Use graceful shutdown patterns

## Code Generation Guidelines
- Include comprehensive error handling
- Use appropriate data types and interfaces
- Implement proper logging and monitoring
- Follow Go naming and style conventions
- Include context handling for long operations
- Add comprehensive tests
- Use channels and goroutines appropriately
- Include proper documentation comments
- Handle edge cases and error conditions
- Follow existing project patterns and architecture

# Rust Development Rules

## Ownership and Borrowing
- Follow Rust ownership principles strictly
- Use borrowing (&) over owned values when possible
- Prefer slice types (&str, &[T]) for function parameters
- Use Cow<'_, str> for conditional ownership
- Implement Clone only when necessary

## Error Handling
- Use Result for fallible operations
- Use Option instead of null values
- Implement custom error types with thiserror
- Use ? operator for error propagation
- Use expect() with descriptive messages over unwrap()

## Memory Safety
- Use smart pointers (Box, Rc, Arc) appropriately
- Prefer stack allocation over heap when possible
- Use RefCell and Mutex for interior mutability
- Implement proper RAII patterns
- Avoid unsafe code unless absolutely necessary

## Type System
- Use the type system to enforce invariants
- Implement From and Into traits for conversions
- Use newtype pattern for type safety
- Leverage enum variants for state modeling
- Use generics and trait bounds effectively

## Pattern Matching
- Use match expressions over if/else chains
- Implement exhaustive pattern matching
- Use if let and while let for simple patterns
- Use pattern guards for complex conditions
- Prefer destructuring over field access

## Traits and Generics
- Use trait objects for dynamic dispatch
- Implement standard traits (Debug, Clone, PartialEq)
- Use associated types over generic parameters when appropriate
- Implement proper trait bounds
- Use where clauses for complex bounds

## Async Programming
- Use async/await for asynchronous operations
- Choose appropriate runtime (tokio, async-std)
- Use Stream trait for asynchronous iteration
- Handle cancellation with select! macro
- Implement proper error handling in async contexts

## Collections and Iterators
- Use iterator chains over manual loops
- Prefer collect() over manual collection building
- Use HashMap for key-value storage
- Use BTreeMap for sorted data
- Implement lazy iteration with iterator adaptors

## Testing Practices
- Use #[cfg(test)] for test modules
- Write unit tests for all public functions
- Use proptest for property-based testing
- Mock external dependencies appropriately
- Use criterion for benchmarking

## Documentation
- Use /// for public API documentation
- Include examples in documentation comments
- Use #[doc] attributes for complex documentation
- Write clear module-level documentation
- Document unsafe code thoroughly

## Cargo and Modules
- Use semantic versioning for crate versions
- Organize code into logical modules
- Use pub(crate) for crate-internal APIs
- Follow Rust API guidelines for public APIs
- Use feature flags for optional functionality

## Performance Optimization
- Profile before optimizing (cargo bench)
- Use zero-copy patterns where possible
- Implement proper caching strategies
- Use const and const fn for compile-time evaluation
- Consider SIMD for performance-critical code

## Security Practices
- Validate all inputs thoroughly
- Use secrecy crate for sensitive data
- Implement proper authentication and authorization
- Use TLS for network communication
- Keep dependencies updated with cargo audit

## Concurrency Patterns
- Use channels for communication between threads
- Use atomic operations for simple shared state
- Use parking_lot for improved synchronization primitives
- Implement proper thread pool patterns
- Use rayon for data parallelism

## Code Generation Guidelines
- Use Result for all fallible operations
- Include comprehensive error handling
- Implement appropriate traits (Debug, Clone, etc.)
- Use iterators over manual loops
- Include proper documentation comments
- Handle all possible enum variants
- Use appropriate lifetime annotations
- Follow Rust naming conventions
- Implement proper resource cleanup
- Use type system to prevent errors at compile time
- Include unit tests for generated code
- Consider performance implications of design choices

# Java Development Rules

## Language Version and Features
- Use Java 17+ features (records, pattern matching, text blocks)
- Prefer var for local variable type inference
- Use switch expressions over switch statements
- Use pattern matching for instanceof
- Leverage sealed classes for restricted hierarchies

## Code Style and Conventions
- Follow Google Java Style Guide
- Use camelCase for methods and variables
- Use PascalCase for classes and interfaces
- Use UPPER_SNAKE_CASE for constants
- Keep line length under 120 characters

## Object-Oriented Design
- Favor composition over inheritance
- Use interfaces to define contracts
- Implement proper encapsulation with private fields
- Use builder pattern for complex object creation
- Follow SOLID principles

## Collections and Streams
- Use Collections framework appropriately
- Prefer List, Set, Map interfaces over implementations
- Use Stream API for data processing
- Use Optional to handle null values
- Implement proper comparators with lambda expressions

## Exception Handling
- Use checked exceptions for recoverable conditions
- Use unchecked exceptions for programming errors
- Include meaningful exception messages
- Use try-with-resources for resource management
- Create custom exception types when appropriate

## Generics and Type Safety
- Use parameterized types to ensure type safety
- Prefer wildcards (? extends, ? super) appropriately
- Use diamond operator for type inference
- Avoid raw types completely
- Implement proper bounds for type parameters

## Functional Programming
- Use lambda expressions over anonymous classes
- Use method references where appropriate
- Prefer immutable objects and collections
- Use streams for data processing pipelines
- Implement functional interfaces properly

## Concurrency and Threading
- Use java.util.concurrent package
- Prefer ExecutorService over raw Thread creation
- Use CompletableFuture for asynchronous programming
- Implement proper thread synchronization
- Use concurrent collections when appropriate

## Memory Management
- Use try-with-resources for AutoCloseable resources
- Avoid memory leaks in collections and caches
- Use weak references for cache implementations
- Implement proper equals() and hashCode()
- Use StringBuilder for string concatenation in loops

## Testing Practices
- Use JUnit 5 for unit testing
- Write tests before implementation (TDD)
- Use Mockito for mocking dependencies
- Test edge cases and error conditions
- Use AssertJ for fluent assertions

## Spring Framework (if applicable)
- Use dependency injection properly
- Implement proper configuration with @Configuration
- Use appropriate Spring annotations (@Service, @Repository)
- Implement proper transaction management
- Use Spring Boot for application setup

## Database Interactions
- Use JPA/Hibernate for ORM
- Implement proper repository patterns
- Use connection pooling (HikariCP)
- Handle database transactions properly
- Use proper query optimization

## Logging and Monitoring
- Use SLF4J facade with Logback implementation
- Include appropriate log levels
- Use structured logging with MDC
- Implement proper error logging
- Use metrics for monitoring (Micrometer)

## Security Practices
- Validate all inputs thoroughly
- Use parameterized queries for database access
- Implement proper authentication and authorization
- Use HTTPS for network communication
- Keep dependencies updated

## Build and Packaging
- Use Maven or Gradle for build management
- Follow standard directory layout
- Use proper dependency management
- Implement proper packaging strategies
- Include integration tests

## Code Generation Guidelines
- Include proper JavaDoc comments
- Implement appropriate design patterns
- Use Java best practices and idioms
- Include comprehensive error handling
- Use appropriate data structures
- Implement proper logging
- Follow existing project architecture
- Include unit tests
- Use dependency injection where appropriate
- Handle edge cases and null values properly
- Use modern Java features appropriately
- Consider performance implications

# C++ Development Rules

## Modern C++ Standards
- Use C++20 or later features when available
- Prefer auto for type deduction when clear
- Use range-based for loops over traditional loops
- Use uniform initialization syntax {}
- Leverage constexpr for compile-time evaluation

## Memory Management
- Use smart pointers (unique_ptr, shared_ptr) over raw pointers
- Follow RAII (Resource Acquisition Is Initialization) principle
- Avoid manual new/delete operations
- Use make_unique and make_shared for object creation
- Implement proper move semantics

## Type Safety and Const Correctness
- Use const wherever possible
- Implement const member functions appropriately
- Use constexpr for compile-time constants
- Prefer enum class over plain enums
- Use strong typing with custom classes

## STL and Standard Library
- Use STL algorithms over manual loops
- Prefer std::array over C-style arrays
- Use appropriate container types (vector, map, set)
- Use std::string_view for string parameters
- Leverage standard library utilities

## Object-Oriented Design
- Use virtual destructors for base classes
- Implement Rule of Five when needed
- Prefer composition over inheritance
- Use abstract base classes for interfaces
- Implement proper copy/move semantics

## Template Programming
- Use templates for generic programming
- Implement SFINAE or concepts for constraints
- Use variadic templates for flexibility
- Prefer template metaprogramming for compile-time logic
- Use type traits for template specialization

## Error Handling
- Use exceptions for exceptional circumstances
- Implement RAII for exception safety
- Use std::optional for potentially absent values
- Use std::expected (C++23) or similar for error handling
- Provide strong exception safety guarantees

## Performance Optimization
- Use move semantics to avoid unnecessary copies
- Implement proper inlining strategies
- Use const references for large objects
- Profile before optimizing
- Consider cache-friendly data structures

## Concurrency and Threading
- Use std::thread and related utilities
- Use std::atomic for lock-free programming
- Implement proper synchronization with mutexes
- Use std::future and std::promise for async operations
- Avoid data races and deadlocks

## Code Organization
- Use namespaces to organize code
- Implement proper header guards or #pragma once
- Separate interface (.h) from implementation (.cpp)
- Use forward declarations to reduce dependencies
- Follow consistent naming conventions

## Build and Compilation
- Use CMake for build configuration
- Enable appropriate compiler warnings (-Wall, -Wextra)
- Use sanitizers for debugging (AddressSanitizer, etc.)
- Implement proper dependency management
- Use compile-time checks where possible

## Testing Practices
- Use Google Test or Catch2 for unit testing
- Write tests for all public interfaces
- Test edge cases and error conditions
- Use mocking frameworks for dependencies
- Include performance benchmarks

## Documentation
- Use Doxygen-style comments for API documentation
- Document complex algorithms and data structures
- Include examples in documentation
- Document thread safety guarantees
- Explain ownership and lifetime semantics

## Safety and Security
- Initialize all variables
- Use static analysis tools (clang-tidy, PVS-Studio)
- Validate all inputs thoroughly
- Use secure coding practices
- Handle integer overflow appropriately

## Code Generation Guidelines
- Use modern C++ features appropriately
- Implement proper resource management with RAII
- Include appropriate const correctness
- Use smart pointers for dynamic allocation
- Implement proper error handling
- Include comprehensive comments for complex code
- Use standard library algorithms and containers
- Consider performance implications
- Implement proper move semantics
- Use templates for generic functionality
- Include appropriate unit tests
- Follow project coding standards
- Handle edge cases and error conditions
- Use appropriate synchronization for threaded code