GitHub - gitrank-ai/gitrank-app: Helping companies to align Product <-> Dev teams while reducing burnout.

AI-powered PR scoring for bug bounties and developer recognition

Features • Quick Start • How It Works • Configuration • Contributing

What is GitRank?

GitRank is an open-source platform that automatically evaluates and scores pull requests using AI. Connect your GitHub organization, and GitRank will:

• Analyze every merged PR using Claude AI
• Classify components and severity based on your configuration
• Calculate scores with customizable multipliers
• Power leaderboards for developer recognition
• Post comments with evaluation details directly on PRs

Perfect for running internal bug bounty programs, performance reviews, or recognizing open source contributors.

Features

Core Platform

• AI-Powered Evaluation — Claude analyzes PR diffs, linked issues, and commit messages
• Configurable Scoring — Define components, multipliers, and severity levels
• Real-time Dashboards — Track team velocity, quality metrics, and contributor trends
• Leaderboards — Weekly MVP, top PRs, cumulative scores with gamification
• PR Comments — Instant feedback posted directly on merged PRs
• Developer Profiles — Individual pages showing score history and contribution patterns
• Product Insights — Ship-level insights that summarize what actually changed

GitHub Integration

• Webhook-driven — Instant processing when PRs are merged
• Diff Analysis — Full access to code changes and file lists
• Issue Linking — Detects linked issues from PR descriptions
• Backfill Support — Process historical PRs on demand

Self-Hosting

• Open Source — CC BY-NC 4.0 licensed, free for non-commercial use
• Supabase Backend — PostgreSQL with Row Level Security
• Docker Ready — Easy deployment on any infrastructure
• Your API Keys — Use your own Anthropic credentials

Product Tour

• Dashboard overview — PR velocity, throughput, and open work at a glance.
  

• Product insights — Automatic summaries of shipped work by area so you always know what changed.
  

• Knowledge silos detection — See ownership gaps and teammates who can help unblock reviews.
  

• AI-generated changelog — Ready-to-paste release notes that distill merged PRs into user-facing updates.
  

• Dev analytics — Track PR cycle time, review responsiveness, and contributor impact.
  

Quick Start

Prerequisites

• Node.js 18.x or later (LTS recommended)
• Docker (for Supabase local development)
• PNPM package manager
• Anthropic API key (for Claude)

1. Clone the Repository

git clone https://github.com/gitrank-ai/gitrank-app.git
cd gitrank-app

2. Install Dependencies

3. Start Supabase

Make sure Docker is running, then:

pnpm run supabase:web:start

Access the Supabase Dashboard at http://localhost:54323.

4. Configure Environment Variables

Copy the example environment file and configure your settings:

cp apps/web/.env.example apps/web/.env.local

Required variables:

5. Start the Development Server

Open http://localhost:3000 to see GitRank.

6. Set Up GitHub App

1. Go to GitHub Settings → Developer settings → GitHub Apps
2. Create a new GitHub App with these permissions:
   • Repository permissions:
     • Contents: Read
     • Pull requests: Read & Write
     • Issues: Read & Write
   • Subscribe to events:
     • Pull request
3. Generate a private key and add it to your .env.local
4. Install the app on your organization

How It Works

┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│   GitHub    │───▶│  Webhook    │───▶│   Claude    │───▶│  Database   │
│  PR Merged  │    │  Received   │    │  Analysis   │    │   + Score   │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘
                                                                │
                   ┌─────────────┐    ┌─────────────┐           │
                   │ PR Comment  │◀───│ Leaderboard │◀──────────┘
                   │   Posted    │    │   Updated   │
                   └─────────────┘    └─────────────┘

1. Developer merges a PR — Business as usual
2. GitHub sends webhook — GitRank receives PR details
3. Fetch diff — GitRank retrieves the full code diff
4. AI evaluation — Claude analyzes changes, classifies component/severity
5. Score calculation — Base points × multiplier = final score
6. Store & notify — Save to database, post PR comment, update leaderboards

Scoring Formula

Final Score = Severity Base Points × Component Multiplier

Example:

• P1 severity (High) = 50 base points
• Auth component = 1.5× multiplier
• Final Score = 50 × 1.5 = 75 points

Eligibility Criteria

PRs must pass these checks to earn points:

Configuration

Components

Define the components of your product with multipliers:

INSERT INTO repo_components (repo_id, key, name, multiplier, description)
VALUES
  (repo_id, 'AUTH', 'Authentication', 1.5, 'Login, sessions, tokens'),
  (repo_id, 'PAYMENTS', 'Payments', 2.0, 'Billing, subscriptions'),
  (repo_id, 'API', 'API', 1.2, 'REST endpoints, GraphQL'),
  (repo_id, 'UI', 'User Interface', 1.0, 'Frontend components');

Severity Levels

Configure severity levels with base points:

INSERT INTO severity_levels (org_id, key, name, base_points, sort_order)
VALUES
  (org_id, 'P0', 'Critical', 100, 1),
  (org_id, 'P1', 'High', 50, 2),
  (org_id, 'P2', 'Medium', 25, 3),
  (org_id, 'P3', 'Low', 10, 4);

AI Model

GitRank uses Claude by default. Configure the model in scoring_rule_sets:

UPDATE scoring_rule_sets
SET model_name = 'claude-haiku-4-5-20251001'
WHERE org_id = your_org_id AND is_default = true;

Project Structure

gitrank/
├── apps/
│   ├── web/                    # Next.js application
│   │   ├── app/
│   │   │   ├── (marketing)/    # Public landing pages
│   │   │   ├── api/            # API routes (webhooks, etc.)
│   │   │   ├── auth/           # Authentication pages
│   │   │   └── home/           # Protected dashboard pages
│   │   ├── lib/gitrank/      # Core business logic
│   │   ├── supabase/           # Database migrations
│   │   └── config/             # App configuration
│   └── e2e/                    # Playwright tests
├── packages/
│   ├── ui/                     # Shared UI components (shadcn)
│   ├── features/               # Feature packages
│   │   ├── auth/               # Authentication logic
│   │   └── accounts/           # Account management
│   ├── supabase/               # Supabase utilities
│   └── shared/                 # Shared utilities
└── tooling/                    # ESLint, Prettier configs

Contributing

We love contributions! GitRank is built by the community, for the community.

Ways to Contribute

• 🐛 Report bugs — Open an issue with reproduction steps
• 💡 Suggest features — Start a discussion with your idea
• 📖 Improve docs — Fix typos, add examples, clarify explanations
• 🔧 Submit PRs — Bug fixes, features, performance improvements

Development Workflow

1. Fork the repository
2. Create a feature branch: git checkout -b feature/amazing-feature
3. Make your changes
4. Run tests: pnpm run test
5. Lint & format: pnpm run lint && pnpm run format:fix
6. Commit: git commit -m 'feat: add amazing feature'
7. Push: git push origin feature/amazing-feature
8. Open a Pull Request

Commit Convention

We use Conventional Commits:

• feat: — New features
• fix: — Bug fixes
• docs: — Documentation changes
• style: — Code style (formatting, etc.)
• refactor: — Code refactoring
• test: — Adding or updating tests
• chore: — Maintenance tasks

Code Quality

Before submitting a PR, ensure:

# Type checking
pnpm run typecheck

# Linting
pnpm run lint

# Formatting
pnpm run format:fix

# Tests (if applicable)
pnpm run test

Local Development Tips

Reset database:

pnpm run supabase:web:reset

Create a migration:

pnpm --filter web supabase migration new <name>

View Supabase logs:

pnpm --filter web supabase logs

Tech Stack

Deployment

Vercel (Recommended)

Docker

docker build -t gitrank .
docker run -p 3000:3000 gitrank

Self-Hosted Supabase

For production, we recommend using Supabase Cloud or self-hosting Supabase with their self-hosting guide.

Roadmap

• GitLab integration
• Slack notifications
• Discord bot
• Custom AI prompts
• Team-level analytics
• Payout integrations
• Mobile app

See the open issues for a full list of proposed features.

Support

• 📖 Documentation — docs.gitrank.dev
• 💬 Discussions — GitHub Discussions
• 🐛 Bug Reports — GitHub Issues
• 🐦 Twitter — @gitrank

License

GitRank is licensed under Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0).

You are free to:

• Share — copy and redistribute the material
• Adapt — remix, transform, and build upon the material

Under these terms:

• Attribution — Give appropriate credit and link to the license
• NonCommercial — You may not use the material for commercial purposes

For commercial licensing, please contact: hello@gitrank.dev

Created by Jay Derinbogaz

GitHub • LinkedIn

Website • GitHub • Twitter