batch-resume-screener（批量简历筛选器）

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

1. Mark resumes as "high_match", "medium_match", or "low_match"
2. Save pre-filter results as a JSON file for reference in Step 2
3. 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

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 & Highlights:
   - Technical highlights/breakthroughs: 20 points
   - Some technical challenges: 10 points
   - Routine CRUD: 0 points

5. Project Results & Value:
   - Quantified results: 20 points
   - Qualitative result descriptions: 10 points
   - No result descriptions: 0 points

Score = Business + Scale + Responsibility + Difficulty + Results

5.5 Problem Solving Ability (0-100 points)

Scoring Rules (quantifiable indicators can stack, max 100 points):

Quantifiable Indicators:
- Clear performance improvement data (e.g., "improved 50%"): +20 points
- Clear cost reduction data (e.g., "saved 30% server cost"): +20 points
- Clear user growth data: +15 points
- Complete technical solution description: +15 points
- Online issue troubleshooting cases: +15 points
- Architecture optimization/refactoring cases: +15 points

Score = min(sum of all indicators, 100)

5.6 Learning Ability (0-100 points)

Scoring Rules (indicators can stack, max 100 points):

Assessment Indicators:
- Self-learned new technology and completed full project: +25 points
- High-quality open source projects/technical blogs: +20 points
- Technical competition awards: +20 points
- Relevant technical certificates: +15 points
- Quickly took over unfamiliar business and produced results: +15 points
- Clear technical growth trajectory: +10 points

Score = min(sum of all indicators, 100)

5.7 Bonus (0-100 points)

Scoring Rules:

1. Job Priority Items Satisfaction (40 points):
   - Satisfies all or most priority items: 40 points
   - Satisfies some priority items: 20 points
   - Does not satisfy any priority items: 0 points

2. Technical Certifications (20 points):
   - Relevant advanced certifications: 20 points
   - Relevant basic certifications: 10 points
   - No relevant certifications: 0 points

3. Technical Influence (20 points):
   - Open source contributions/technical blogs/technical sharing: 20 points
   - Some technical sharing records: 10 points
   - No technical influence proof: 0 points

4. Other Highlights (20 points):
   - Award records/special achievements: 20 points
   - General highlights: 10 points
   - No other highlights: 0 points

Score = Priority Items + Certifications + Influence + Other

6. Confidence Score

Each evaluation result includes a confidence score:

{
  "confidence": {
    "score": 0.85,
    "level": "high",
    "factors": {
      "resume_completeness": 0.9,
      "information_clarity": 0.8,
      "verifiable_data": 0.85
    },
    "suggestions": [
      "Resume project descriptions are detailed, scoring basis sufficient",
      "Recommend verifying work experience during interview"
    ]
  }
}

Confidence Levels:

• High (0.8-1.0): Resume information complete, scoring basis sufficient
• Medium (0.6-0.8): Resume information basically complete, some content unclear
• Low (<0.6): Resume information incomplete, recommend manual review

7. Total Score Rating Reference

• 90-100 points: Far exceeds job requirements, outstanding core dimension performance, high-quality candidate
• 75-89 points: Completely meets job requirements, high core dimension match, recommend for interview
• 60-74 points: Just meets basic job requirements, has obvious shortcomings, can be alternative evaluation
• Below 60 points: Meets hard thresholds, but large gap between core ability and job requirements, not recommended

8. Individual Evaluation JSON Output Format

For each resume, save the evaluation result as a JSON file with the following structure:

{
  "candidate_name": "候选人姓名",
  "resume_file": "简历文件名.txt",
  "evaluation_time": "YYYY-MM-DD HH:MM:SS",
  "job_level": "junior/mid/senior",
  "weight_coefficients": {
    "academic_background": 0.15,
    "career_stability": 0.05,
    "tech_stack": 0.15,
    "project_match": 0.20,
    "problem_solving": 0.10,
    "learning_ability": 0.20,
    "bonus": 0.15
  },
  "pre_filter": {
    "match_level": "high_match/medium_match/low_match",
    "key_findings": ["关键发现1", "关键发现2"]
  },
  "positions": [
    {
      "position_name": "岗位名称",
      "hard_requirements_check": {
        "passed": true/false,
        "rejection_reason": "如果未通过，说明原因"
      },
      "dimension_scores": {
        "academic_background": {
          "score": 85,
          "breakdown": {
            "institution_level": 30,
            "major_match": 40,
            "academic_performance": 15
          },
          "reason": "评分理由"
        },
        "career_stability": {
          "score": 70,
          "breakdown": {
            "average_tenure": 40,
            "job_hopping_frequency": 30
          },
          "reason": "评分理由"
        },
        "tech_stack": {
          "score": 75,
          "breakdown": {
            "match": 25,
            "breadth": 15,
            "depth": 20,
            "practical": 15
          },
          "reason": "评分理由"
        },
        "project_match": {
          "score": 80,
          "breakdown": {
            "business_match": 15,
            "project_scale": 18,
            "responsibility": 17,
            "technical_difficulty": 15,
            "achievement": 15
          },
          "reason": "评分理由"
        },
        "problem_solving": {
          "score": 65,
          "reason": "评分理由"
        },
        "learning_ability": {
          "score": 70,
          "reason": "评分理由"
        },
        "bonus": {
          "score": 60,
          "breakdown": {
            "job_priority": 20,
            "certifications": 10,
            "influence": 20,
            "other": 10
          },
          "reason": "评分理由"
        }
      },
      "weighted_score": 72.5,
      "rating": "推荐面试",
      "recommended": true
    }
  ],
  "best_position": {
    "position_name": "推荐岗位名称",
    "weighted_score": 72.5,
    "rating": "推荐面试"
  },
  "confidence": {
    "score": 0.85,
    "level": "high",
    "factors": {
      "resume_completeness": 0.9,
      "information_clarity": 0.8,
      "verifiable_data": 0.85
    },
    "suggestions": [
      "简历项目描述较为详细，评分依据充分"
    ]
  }
}

9. Output Format Requirements

9.1 Markdown Report Structure

---

# 批量简历初筛结果汇总报告

## 统计概览

- 总简历数：XX份
- 总岗位数：XX个
- 筛选完成时间：YYYY-MM-DD HH:MM:SS，耗时：xxx
- 岗位级别分布：初级X个，中级X个，高级X个

---

## 候选人排名（按加权总分降序排列）

| 排名 | 候选人姓名 | 推荐岗位 | 岗位级别 | 加权总分 | 综合评级 | 置信度 | 学术背景 | 职业稳定性 | 技术栈能力 | 项目经验匹配 | 问题解决能力 | 学习能力 | 加分项 |
|------|------------|----------|----------|----------|----------|--------|----------|------------|------------|--------------|--------------|----------|--------|
| 1 | 张三 | Java高级工程师 | 高级 | 85 | 推荐面试 | 高 | 75 | 80 | 85 | 90 | 80 | 75 | 70 |
| 2 | 李四 | 后端开发工程师 | 中级 | 78 | 推荐面试 | 高 | 70 | 75 | 80 | 85 | 70 | 80 | 65 |
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |

---

## 通过候选人综合评价

| 候选人姓名 | 推荐岗位 | 综合评价 | 关键亮点 |
|------------|----------|----------|----------|
| 张三 | Java高级工程师 | 技术栈全面，有源码阅读经验，有大型项目经验，问题解决能力强 | 熟悉JVM调优，有分布式架构经验 |
| ... | ... | ... | ... |

---

## 未通过候选人汇总

| 候选人姓名 | 未通过原因 | 涉及岗位 | 置信度 |
|------------|------------|----------|--------|
| 王五 | 学历不满足（岗位要求本科及以上，简历显示专科） | Java高级工程师, 后端开发工程师 | 高 |
| ... | ... | ... | ... |

---

## 低置信度候选人（建议人工复核）

| 候选人姓名 | 置信度 | 复核建议 |
|------------|--------|----------|
| 赵六 | 低(0.55) | 简历信息不完整，建议核实工作年限和项目经验 |
| ... | ... | ... |

---

9.2 Excel-Ready Data Format

Generate tabular data suitable for Excel import:

候选人姓名,推荐岗位,岗位级别,加权总分,综合评级,置信度,学术背景,职业稳定性,技术栈能力,项目经验匹配,问题解决能力,学习能力,加分项,关键亮点,评估时间
张三,Java高级工程师,高级,85,推荐面试,高,75,80,85,90,80,75,70,熟悉JVM调优,2024-01-15 10:30:00
李四,后端开发工程师,中级,78,推荐面试,高,70,75,80,85,70,80,65,有微服务经验,2024-01-15 10:35:00

9.3 Candidate Comparison Table

## 候选人横向对比表

| 对比维度 | 张三 | 李四 | 王五 |
|----------|------|------|------|
| 推荐岗位 | Java高级工程师 | 后端开发工程师 | - |
| 加权总分 | 85 | 78 | 45 |
| 学术背景 | 75 | 70 | 60 |
| 职业稳定性 | 80 | 75 | 50 |
| 技术栈能力 | 85 | 80 | 55 |
| 项目经验匹配 | 90 | 85 | 40 |
| 问题解决能力 | 80 | 70 | 35 |
| 学习能力 | 75 | 80 | 50 |
| 加分项 | 70 | 65 | 30 |
| 核心优势 | JVM调优、分布式架构 | 微服务、高并发 | - |
| 主要不足 | - | - | 学历不满足、经验不足 |

9.4 Highlights Summary

## 候选人亮点摘要（供面试官参考）

### 张三 - Java高级工程师（加权总分：85）
**核心优势**：
- 熟悉JVM调优，有实际性能优化经验
- 有分布式架构设计和实施经验
- 项目经验丰富，有大型系统开发经验

**面试建议**：
- 深入了解JVM调优的具体案例
- 询问分布式架构中的难点和解决方案

---

### 李四 - 后端开发工程师（加权总分：78）
**核心优势**：
- 有微服务架构实践经验
- 高并发场景有实际处理经验
- 学习能力强，有技术博客

**面试建议**：
- 了解微服务拆分的思路和经验
- 询问高并发场景的具体处理方案

10. Important Notes

• All evaluations must be based solely on resume text content
• No unfounded assumptions or guessing
• Strictly follow the given weights and scoring rules
• Must correspond to job requirements original text when stating non-compliance
• No vague descriptions allowed
• For each candidate, recommend the position with the highest score
• Sort all candidates by their highest score in descending order
• 不要为了效率试图创建py脚本来进行批量处理
• Always include confidence score for each evaluation
• Flag low-confidence evaluations for manual review