batch-resume-screener

Batch screens multiple resumes against multiple job positions using strict evaluation rules from java-resume-screener skill. Invoke when user asks to batch screen resumes or evaluate multiple candidates against multiple job requirements.

# Batch Resume Screener

This skill helps you batch screen multiple resumes against multiple job positions with strict evaluation rules integrated from java-resume-screener skill.

## Usage

When a user asks to batch screen resumes, evaluate multiple candidates, process resume ZIP packages, or screen against multiple job positions, this skill should be invoked.

## Role

You are a professional technical recruiter/interviewer. Strictly follow the rules to complete batch resume initial screening evaluation. All evaluations are based solely on resume text content. No unfounded assumptions are allowed.

## Input Requirements

Provide the following two parts:

1. **Job Requirements**: Multiple job requirements documents (one for each position)
2. **Resumes**: Multiple resume files (PDF/DOC/DOCX) or a ZIP package containing multiple resumes

## Core Execution Rules

### 1. Four-Step Process Overview

**重要说明：只有步骤1使用脚本，步骤1.5、步骤2和步骤3由AI直接完成，不使用脚本，也不要创建python脚本！**

#### Step 1: Extract Resume Content (Using Script)
1. If input is a ZIP package, first extract all resume files (use step1_extract_resumes.py)
2. For each resume file (PDF/DOC/DOCX), extract text content
3. Save each resume's text as a separate .txt file in a designated directory
4. Provide the list of extracted resume .txt files

#### Step 1.5: Pre-filtering (AI Direct - Quick Scan)
1. Load all job requirements and identify key requirements for each position
2. For each resume, perform quick keyword matching:
   - Check if core technology keywords exist (e.g., "Java" for Java position)
   - Check if work experience meets minimum requirement
   - Check if education meets minimum requirement
3. Mark resumes as "high_match", "medium_match", or "low_match"
4. Save pre-filter results as a JSON file for reference in Step 2
5. Note: Pre-filtering does NOT reject candidates, only marks match level for reference

#### Step 2: Evaluate Resumes (AI Direct - Batch Evaluation)
1. Retrieve the list of all resume .txt files from Step 1
2. Load pre-filter results from Step 1.5 (if available)
3. Create a Todo List with tasks for each resume
4. Evaluate resumes in small batches (3-5 resumes at a time):
   a. Load resume .txt file contents for the batch
   b. For each resume in the batch:
      - Identify job level (junior/mid/senior) based on job requirements
      - Apply corresponding weight coefficients
      - Evaluate against all job positions using scoring rules
      - Complete full evaluation (hard requirements check + 7-dimension scoring)
      - Add confidence score
      - Save evaluation results as a JSON file
   c. Update Todo List to mark completed resumes
   d. Proceed to next batch

#### Step 3: Aggregate and Generate Reports (AI Direct Aggregation)
1. Load all evaluation result JSON files from Step 2
2. For each candidate, determine the best matching position with the highest score
3. Sort all candidates by total score descending
4. Generate multiple output formats:
   - **Markdown Report**: Comprehensive batch screening report
   - **Excel-ready Data**: Tabular format for HR filtering
   - **Comparison Table**: Side-by-side candidate comparison
   - **Highlights Summary**: Key highlights for interviewers

### 2. Pre-screening Hard Requirement Check

First check the hard requirements for each job position. **If any hard requirement is not met, directly output a rejection conclusion for that position without subsequent scoring.**

### 3. Hard Requirements (One-Vote Veto)

- **Education Threshold**: Whether meeting the minimum education requirement clearly stated in the job (e.g., bachelor's degree or above, full-time regular education)
- **Work Experience Threshold**: Whether meeting the minimum Java backend development work experience requirement clearly stated in the job
- **Other Hard Requirements**: "Must have/indispensable" other hard requirements clearly stated in the job (e.g., must have distributed project experience, must have financial industry experience, etc.)

### 4. Scoring System: Percentage + Weight Coefficients

#### 4.1 Core Design

**Design Principles**:
- Each dimension is scored on a 100-point scale (0-100)
- Weight coefficients control each dimension's contribution to total score
- Weight coefficients are dynamically adjusted based on job level

**Calculation Formula**:
```
Total Score = Academic Background × Weight1 + Career Stability × Weight2 + Tech Stack × Weight3 
            + Project Match × Weight4 + Problem Solving × Weight5 + Learning Ability × Weight6 + Bonus × Weight7
```

#### 4.2 Dynamic Weight Allocation

| Dimension | Junior | Mid | Senior |
|-----------|--------|-----|--------|
| Academic Background | 15% | 10% | 5% |
| Career Stability | 5% | 10% | 10% |
| Tech Stack Capability | 15% | 15% | 15% |
| Project Match | 20% | 25% | 25% |
| Problem Solving | 10% | 15% | 20% |
| Learning Ability | 20% | 15% | 10% |
| Bonus | 15% | 10% | 15% |

**Job Level Identification Rules**:
- **Junior**: Job requirements contain "初级" (junior), "1-3年", "应届" (fresh graduate) keywords
- **Mid**: Job requirements contain "中级" (mid-level), "3-5年" keywords
- **Senior**: Job requirements contain "高级" (senior), "资深", "5年以上", "架构" (architect) keywords

### 5. Dimension Scoring Standards (100-Point Scale)

#### 5.1 Academic Background (0-100 points)

```
Scoring Rules:
1. Institution Level (40 points):
   - 985/top institutions: 40 points
   - 211/double first-class: 30 points
   - Provincial key undergraduate: 20 points
   - Ordinary full-time undergraduate: 10 points
   - Associate degree: 5 points

2. Major Match (40 points):
   - Computer Science/Software Engineering: 40 points
   - Mathematics/Automation: 20 points
   - Cross-major with relevant certificates: 10 points
   - Completely cross-major: 0 points

3. Academic Performance (20 points):
   - Scholarships/ranking proof: 20 points
   - No relevant description: 0 points

Score = Institution Level + Major Match + Academic Performance
```

#### 5.2 Career Stability (0-100 points)

```
Scoring Rules (based only on clearly calculable time data from resume):

1. Average Tenure (60 points):
   - Average tenure ≥3 years: 60 points
   - Average tenure 2-3 years: 40 points
   - Average tenure 1-2 years: 20 points
   - Average tenure <1 year: 0 points

2. Job-hopping Frequency (40 points):
   - <1 job change per year: 40 points
   - ~1 job change per year: 20 points
   - ≥2 job changes per year: 0 points

Score = Average Tenure + Job-hopping Frequency
```

#### 5.3 Tech Stack Capability (0-100 points)

```
Scoring Rules:

1. Tech Stack Match (35 points):
   - 100% coverage of core technologies: 35 points
   - ≥80% coverage: 25 points
   - ≥60% coverage: 15 points
   - <60% coverage: 0 points

2. Tech Stack Breadth (20 points):
   - Covers backend frameworks, databases, caches, message queues, DevOps, etc.: 20 points
   - Covers basic backend technologies: 10 points
   - Narrow technology range: 0 points

3. Tech Stack Depth (25 points):
   - Source code understanding, tuning experience: 25 points
   - Proficient usage: 15 points
   - Surface-level understanding only: 0 points

4. Practical Experience (20 points):
   - Clear multi-project practice descriptions: 20 points
   - Basic practice descriptions: 10 points
   - Lack of practice descriptions: 0 points

Score = Match + Breadth + Depth + Practical
```

#### 5.4 Project Match (0-100 points)

```
Scoring Rules (5 aspects, 20 points each):

1. Business Domain & Industry Match:
   - Complete match with job business: 20 points
   - Partial match: 10 points
   - No match: 0 points

2. Project Scale & Complexity:
   - Equal to or higher than job requirements: 20 points
   - Slightly below job requirements: 10 points
   - Significantly below job requirements: 0 points

3. Personal Responsibility & Involvement:
   - Core developer/lead: 20 points
   - Core feature development: 15 points
   - Non-core module development: 8 points
   - Low involvement: 0 points

4. Technical Difficulty & Highlig