Awesome Reviewers ✨

Create clear, well-structured API documentation following proper formatting, correct references, informative examples...

Choose the appropriate assertion method based on the data type being tested. This improves test readability and provi...

Design APIs that favor both type safety and flexibility. Use strongly typed wrappers instead of primitive types, but ...

When implementing Axum-based applications, it is crucial to ensure that the interaction patterns between components a...

Ensure technical documentation is precise, accurate, and correctly formatted to prevent confusion and improve develop...

When building Next.js applications that handle sensitive data, it's crucial to implement robust security measures to ...

When implementing caching in Next.js applications, it is crucial to be intentional about the caching behavior for eac...

Documentation should be clear, precise, and self-contained while following established style conventions. When writin...

When implementing Next.js components that rely on dynamic content (e.g. random values, current time), it is crucial t...

Maintain consistent and clear testing patterns by following these guidelines: use strict equality assertions, prefer ...

When running concurrent operations in tests, ensure all operations complete before concluding the test. Race conditio...

Always opt for simpler, more idiomatic code constructs over complex or verbose alternatives. This includes using buil...

When writing tests, ensure assertions can handle non-deterministic content while providing clear failure context: use...

As a code reviewer, I recommend the following practices to optimize resource utilization when implementing Next.js ap...

Design APIs with strong type safety to improve developer experience and catch errors at compile time. Avoid using any...

When implementing error handling in Fastify applications, it is important to always throw instances of the Error clas...

When handling errors, always ensure the original error context is preserved and properly surfaced. Error information ...

Use concise null checking patterns to prevent runtime errors and improve code readability when handling potentially u...

When using the Fastify framework in Typescript, ensure that all configuration options are explicitly declared and pro...

Document all public APIs and significant internal functions with comprehensive JSDoc comments that include accurate d...

When implementing code that uses the Fastify package in Typescript, ensure the following conventions are followed: av...

Choose clear, descriptive names over abbreviated or shortened versions. Names should be self-documenting and follow R...

Maintain consistent documentation formatting standards across all project files, especially in changelogs, code examp...

When implementing Typescript code that uses the axum package, maintain consistent and idiomatic usage: always use low...

Design API interfaces with strong type safety while maintaining excellent developer experience. Prefer explicit types...

Always use consistent patterns and utility functions for handling null and undefined values. This improves code relia...

When writing tests, explicitly assert specific conditions and expected values rather than relying on general success/...

When implementing HTTP clients with proxy support, ensure the connection to the proxy uses the protocol specified in ...

Always ensure documentation accurately represents the actual code behavior and implementation details. Include import...

Design API methods with predictable behavior patterns that follow common conventions. Methods that modify objects dir...

Implement comprehensive error handling throughout the codebase by ensuring all error scenarios are properly caught, t...

In performance-critical code paths that execute frequently, optimize to reduce unnecessary operations that can impact...

When designing APIs, carefully evaluate constraints imposed on consumers. Each limitation should serve a clear purpos...

When writing or updating documentation, ensure all code examples, installation commands, and project references accur...

When building Next.js applications that leverage server-side rendering (SSR) or Partial Prerendering (PPR), it is ess...

This review focuses on ensuring proper error handling in Next.js API routes. Key principles include validating incomi...

As a code reviewer for Next.js projects, ensure that all code artifacts, including component names, file names, and c...

When implementing Fastify applications in TypeScript, it is important to follow consistent patterns for handling prom...

When building APIs, implement proper content negotiation to handle various media types in both requests and responses...

Use precise, consistent, and descriptive naming conventions throughout your code to enhance readability and maintaina...

Always benchmark different implementation approaches for performance-critical operations before selecting a method. D...

Instead of verbose conditional logic, prefer Rust's Option combinators like map, and_then, and filter for handling po...

Create specific error types with appropriate status codes while ensuring sensitive details are logged but not exposed...

Optimize performance by minimizing unnecessary memory allocations and using allocation-efficient APIs. Key practices ...

When using locks in async code, follow critical guidelines to avoid deadlocks. Never hold std::sync::Mutex locks acro...

When implementing network services, especially proxies and protocol handlers, proper HTTP header management is critic...

Always validate and sanitize user-supplied inputs before using them in security-sensitive operations. This helps prev...

This review focuses on ensuring robust and type-safe usage of the Axios library in Typescript codebases. Key recommen...

As a code reviewer, it is important to ensure that Axios-based Typescript code properly handles and propagates errors...

Complex expressions and repeated code should be extracted into well-named variables to improve readability and mainta...

Always validate performance optimizations through measurement rather than assumptions. Run multiple iterations of per...

When writing tests, use the appropriate testing utilities and ensure proper test isolation. For testing warning behav...

When working with concurrent operations, separate conditional logic from potentially expensive or suspenseful executi...

When implementing React components, ensure that dependencies between component state, props, and side effects are acc...

Choose error handling mechanisms based on the error's severity and context. For critical issues that should prevent f...

Always specify complete dependency arrays in React hooks to prevent bugs from stale closures and avoid unnecessary re...

Always verify that an object and its properties exist before accessing them to prevent 'cannot read property of undef...

Favor concise and idiomatic expressions in your Rust code to improve readability and maintainability.

Carefully review GitHub Actions workflow configurations to prevent subtle errors that can cause CI/CD pipeline failur...

When working with props, state, or other values in Next.js components that may be null, undefined, or contain error s...

Choose data structures that match your specific access patterns and performance requirements. The right data structur...

Maintain consistent patterns for variable declarations and naming conventions: use const by default for variable decl...

When implementing integrations and plugins using the Fastify framework, maintain consistent coding patterns and conve...

When configuring feature flags in Cargo.toml, ensure they are properly structured and documented. Chain feature depen...

When implementing code that uses the Axios library in TypeScript, it is important to follow best practices for config...

When using the Axios library in Typescript, it is important to follow consistent naming conventions to improve code r...

Always define configuration properties with sensible defaults and consistent naming conventions. When adding new conf...

Structure conditionals for maximum clarity and comprehension. Avoid unnecessary negation in boolean expressions, use ...

When working with URLs in networking code, always use the standard `URL` constructor to properly resolve relative URL...

When using the React library in Typescript, ensure that you are correctly implementing the recommended React hooks ba...

When implementing React components, it is important to ensure that variables are properly scoped and used throughout ...

When creating configuration files for development environments that use multiple technology stacks, ensure settings a...

When implementing Content Security Policy (CSP) protections, always explicitly pass nonce values to components rather...

Apply DRY (Don't Repeat Yourself) principles to all configuration files to improve maintainability. Extract shared co...

Add clear comments that explain the intent and behavior of code that might not be immediately obvious to other develo...

When working with React components that may return null or undefined values, implement defensive coding patterns to p...

When implementing Next.js in your application, ensure that you are correctly using the framework's documented configu...

When building Next.js components, it is crucial to implement robust error handling to ensure the stability and predic...

When implementing panic handlers, follow these critical practices to ensure robust error handling: register panic han...

When implementing observability mechanisms like telemetry or status monitoring, ensure they don't block or interfere ...

When providing configuration instructions, document the exact location and method to obtain required values. Include ...

Design APIs with dependency implications in mind. Carefully consider how your API design choices might force dependen...

Implement robust error handling patterns that ensure both proper resource cleanup and error context preservation.

When implementing data structures such as tries, trees, or graphs, ensure all critical operations (insertion, deletio...

Select data structures based on their performance characteristics and actual usage patterns. When implementing algori...

Use explicit type assertions in TypeScript tests to verify that types behave as expected across various scenarios. In...

When configuring Git operations in GitHub Actions workflows, especially for automated commits, use the GitHub Actions...

When designing logging interfaces, create flexible APIs that accommodate both standard and custom logging needs. This...

This review focuses on secure implementation patterns when using the Fastify web framework in Typescript: prevent Pro...

When constructing URLs with IP addresses, ensure IPv6 addresses are properly formatted according to RFC standards by ...

When working with Fastify decorators, always perform explicit null checks before accessing potentially undefined prop...

When implementing code using the Fastify package in Typescript, it is important to use consistent and accurate naming...

When building asynchronous Axum applications that share mutable state, it's important to select the right concurrency...

As an Axum code reviewer, I recommend implementing proper distributed tracing in your Axum-based web applications to ...

Error messages should be concise and clearly communicate what went wrong without unnecessary verbosity. When implemen...

Design configuration interfaces to be flexible and extensible rather than overly specific. When creating configuratio...

Always terminate statements with explicit semicolons to maintain consistency with the existing codebase style. Avoid ...

Maintain consistent usage of the Axios library throughout your Typescript codebase. Pay special attention to consiste...

When handling security-related attributes (like nonces, integrity hashes, or CSP directives), always document the log...

Always decode URL paths before performing security validations to prevent bypass attacks using URL encoding. Security...

When implementing Content-Type validation, ensure regular expressions start with '^' or include ';?' to properly dete...

Always set appropriate security flags on cookies, especially those used for authentication or session management. At ...