Skip to main content

​
Overview

Code reviews are critical for maintaining code quality but can be time-consuming. Righthands perform preliminary code analysis, identify potential issues, and help teams be more effective in their review process.

​
Core Capabilities

​
Pre-Review Analysis

Before human review, Righthands provide:

Code Quality Check

Identify code smells, complexity issues, and style violations

Security Scan

Flag potential security vulnerabilities and unsafe patterns

Performance Review

Spot inefficient algorithms and performance bottlenecks

Test Coverage

Verify adequate test coverage for changed code

​
Support for Code Authors

1

Pre-Submission Review

Performs review before PR submission to catch obvious issues
2

Description Generation

Generates comprehensive PR descriptions from commit messages and code changes
3

Test Recommendations

Suggests test cases based on code changes
4

Breaking Change Detection

Identifies potential breaking changes to flag for reviewers

​
Support for Reviewers

1

Change Summary

Provides high-level summary of what changed and why
2

Risk Assessment

Identifies which changes carry highest risk
3

Context Gathering

Compiles related tickets, previous discussions, and architectural decisions
4

Review Comments

Generates draft review comments for common issues

​
Common Use Cases

​
Pre-Submission Code Review

"Review my changes in the authentication module before I submit the PR"

​
Pull Request Description Generation

Righthand can analyze your commits and changes to create comprehensive PR descriptions:
High-level summary of modifications, additions, and deletions
Link to tickets, explain motivation, provide business context
Steps for reviewers to verify the changes work correctly
Migration steps, configuration changes, or special deployment requirements
Example prompt: “Generate a PR description for my branch ‘feature/oauth-integration‘“

​
Reviewer’s Pre-Review Briefing

Before diving into code, reviewers can ask:
Example Queries
"Summarize the changes in PR #324"
"What are the riskiest parts of this change?"
"Has this component been modified recently?"
"What related PRs should I review for context?"
Use Righthand to identify which files need the most careful review based on complexity, risk, and test coverage.

​
Code Pattern Consistency

Righthand can verify consistency with codebase patterns:
1

Identify Pattern Deviations

Compare new code against established patterns in the codebase
2

Style Consistency

Check naming conventions, file organization, and code structure
3

Architectural Compliance

Verify changes follow architectural decisions and layer separation

​
Advanced Features

​
Security-Focused Review

For security-critical changes, Righthand performs deep analysis:
Security CheckWhat It Detects
Injection vulnerabilitiesSQL, command, LDAP injection patterns
Authentication issuesWeak auth, session management flaws
Authorization problemsMissing access controls, privilege escalation
Data exposureSensitive data in logs, error messages, or URLs
CryptographyWeak algorithms, hard-coded secrets, key management
DependenciesKnown vulnerabilities in dependencies

​
Performance Impact Analysis

Ask Righthand to evaluate performance implications:
Example Analysis
"Analyze performance impact of changes in PR #456"

PERFORMANCE ANALYSIS:

Database Queries:
- Added 2 new queries in product listing (potential N+1 issue)
- Recommendation: Use eager loading or add caching

API Calls:
- External API now called on every request (was cached before)
- Impact: Estimated 200-500ms added latency
- Recommendation: Restore caching or move to background job

Memory:
- New data structure increases memory usage by ~15%
- Within acceptable limits for typical workload
- Monitor in production for high-volume scenarios

​
Breaking Change Detection

Righthand identifies potential breaking changes:

API Changes

Modified or removed public API methods

Data Schema

Database schema changes requiring migration

Configuration

New required environment variables or config

Dependencies

Updated dependencies with breaking changes

​
Best Practices

​
For Code Authors

1

Run Self-Review First

Use Righthand to catch issues before submitting for review
2

Generate Comprehensive Description

Let Righthand draft PR description, then add business context
3

Address Automated Feedback

Fix issues flagged by Righthand before requesting human review
4

Add Context Comments

Explain complex or non-obvious code decisions

​
For Reviewers

1

Start with Summary

Get Righthand’s overview before diving into code
2

Focus on High-Risk Areas

Use Righthand’s risk assessment to prioritize review time
3

Verify Automated Findings

Check that critical issues identified by Righthand are addressed
4

Add Human Judgment

Focus your review on design decisions, business logic, and maintainability

​
Review Efficiency Tips

Time-saving approach: Let Righthand handle syntax, style, and common issues. Focus your human review on architecture, design patterns, and business logic correctness.

​
Integration with Development Workflow

​
GitHub/GitLab Integration

Righthand can integrate with your PR workflow:
Post review findings as comments on the PR
Block PRs with critical issues from merging
Suggest appropriate reviewers based on code changes
Automatically update CHANGELOG.md with PR summaries

​
Code Review Metrics

Track review effectiveness over time:
Example Queries
"How many security issues were caught in review this month?"
"What's the average time to first review for my PRs?"
"Which files generate the most review comments?"
"How has our code quality trend been over the last quarter?"

​
Example Workflows

Scenario: Complete code review from submission to merge
  1. Author Pre-Submission
    • Complete feature implementation
    • “Review my changes before I submit PR”
    • Fix issues identified by Righthand
    • “Generate PR description from my commits”
    • Submit PR with generated description
  2. Automated Review
    • Righthand automatically analyzes PR
    • Posts preliminary findings as comments
    • Tags specific reviewers based on code areas
  3. Human Review
    • Reviewer: “Summarize PR #567 and highlight risks”
    • Reviews code focusing on design and business logic
    • Righthand assists with suggesting test cases
    • Approves with comments
  4. Post-Review
    • Author addresses feedback
    • Righthand verifies all issues resolved
    • PR merged
    • Righthand updates changelog and documentation
Scenario: Reviewing a major code refactoring
  1. “Analyze the refactoring in PR #789 - 2,400 lines changed”
  2. Righthand provides:
    • Component-by-component change summary
    • Behavioral changes vs. pure refactoring
    • Risk areas where bugs might hide
    • Test coverage gaps
  3. Focus review on:
    • High-risk behavioral changes
    • Areas with insufficient tests
    • Potential performance regressions
  4. “Compare performance before and after refactoring”
    • Righthand analyzes algorithmic complexity
    • Identifies any performance improvements or regressions

​
Code Quality Checks

​
Standard Checks

  • Code Complexity: Cyclomatic complexity, nesting depth, function length
  • Code Duplication: Identify repeated code blocks
  • Naming Conventions: Verify consistent naming patterns
  • Documentation: Check for missing docstrings or comments
  • Error Handling: Ensure proper error handling and logging

​
Language-Specific Checks

  • Proper use of async/await
  • Type safety in TypeScript
  • React hooks rules compliance
  • Common anti-patterns
Righthand provides automated analysis, but human judgment is essential for design decisions, business logic validation, and architectural considerations.