PluginBench
Rule

code pair interviews

via PatrickJS/awesome-cursorrules

Expert-level code pair interview guidance with clean structure, readability, and best practices.

What is code pair interviews?

This rule prepares you to write interview-quality code by emphasizing clean architecture, readable style, and thoughtful problem-solving. Use it when pair programming in technical interviews to demonstrate professional coding standards and communication.

  • Organize code with clear separation of concerns and single responsibility principle
  • Use meaningful variable/function names and maintain consistent 2-space indentation
  • Write docstrings and strategic comments to explain non-obvious logic
  • Select appropriate data structures and algorithms balancing clarity with efficiency
  • Handle edge cases and test thoroughly before optimizing
  • Structure solutions with a high-level plan before implementation

Applies to

File patterns this rule matches.

**/*
Rule definition (reference)

Source of truth, from the repository.

You are an expert software developer focused on producing clean, well-structured, and professional-quality code, suitable for a code pair programming interview.

Code Structure and Organization

  • Organize code logically with a clear separation of concerns.
  • Break down problems into smaller, self-contained units using functions and classes.
  • Ensure modularity and reusability of code components.
  • Adhere to the Single Responsibility Principle: each function/class should have one specific job.
  • When tackling complex problems, begin by outlining a high-level plan before writing code.
  • Start with a simple, straightforward solution to the core problem, optimizing later if time allows.
  • Select appropriate data structures and algorithms with a focus on clarity and efficiency.
    • Example: Use a hash map for quick lookups when appropriate.

Coding Style

  • Maintain consistent indentation using 2 spaces (prefer spaces over tabs).
  • Use meaningful and descriptive names for variables, functions, and classes.
    • Avoid single-letter or cryptic abbreviations.
    • Example: Use calculate_total_cost instead of calc.
  • Employ comments judiciously to explain non-obvious logic or provide high-level overviews.
    • Use docstrings for functions and methods to describe purpose, parameters, and return values.
    • Avoid over-commenting self-explanatory code.
  • Keep lines of code within a reasonable length (80-100 characters) to enhance readability.
  • Use blank lines to separate logical blocks of code and improve visual organization.

Coding Best Practices

  • Write clean and readable code.
  • Prioritize clarity in code structure and style.
  • Consider edge cases and implement error handling.
  • Strive for efficient solutions.
  • Test code thoroughly with various inputs, including edge cases.
  • Start simple and optimize later.

Related rules

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

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

Quantitative factor research skills for designing, evaluating, and mining alpha factors in equities markets.

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

Android development with Jetpack Compose, clean architecture, and Material Design 3.

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

Angular development with Novo Elements UI library using standalone components.

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

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

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

Manage Kubernetes clusters, add-ons, stacks, and credentials via the Ankra CLI platform.

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