What Are the Resume Evaluation Scoring Categories in InterviewStreet's Hiring Agent?

The hiring-agent evaluates resumes across four specific categories—Open Source (35 points), Self Projects (30 points), Production Experience (25 points), and Technical Skills (10 points)—with optional bonus points and deductions applied to generate a final assessment.

The interviewstreet/hiring-agent repository implements a structured scoring system that quantifies candidate qualifications through objective, weighted categories. This framework ensures consistent evaluation of software engineering profiles by assigning maximum point values to distinct types of experience and demonstrated competencies.

The Four Core Resume Evaluation Scoring Categories

The scoring model defined in models.py uses four CategoryScore fields within the Scores class. Each field tracks a score, a maximum value, and supporting evidence for validation.

Open Source (35 Points)

The Open Source category evaluates contributions to public repositories, measuring the quality and impact of merged pull requests, maintained libraries, or significant community involvement. With the highest weight of 35 maximum points, this category prioritizes demonstrated collaborative development and code visibility in the open-source ecosystem.

Self Projects (30 Points)

Self Projects capture personal side-projects that demonstrate initiative, architectural design, and end-to-end execution. Personal portfolios, GitHub repositories, and deployed applications contribute to this 30-point maximum category, rewarding candidates who build software outside of professional obligations.

Production Experience (25 Points)

Professional, production-grade work history—including full-time positions, internships, and contracted engineering roles—falls under Production Experience. Mapped to the production field in the Scores model, this category carries a 25-point maximum and validates enterprise-scale development practices and shipping code to live environments.

Technical Skills (10 Points)

The Technical Skills category assesses proficiency with programming languages, frameworks, tools, and platforms. With a 10-point maximum, this section quantifies explicit competencies listed on the résumé and demonstrated through project descriptions, serving as a baseline competency check.

Score Calculation and Validation

During evaluation, the print_evaluation_results routine in score.py (lines 78-84) retrieves each category's score and applies a hard cap to its predefined maximum. This prevents category overflow and ensures the weighted distribution remains intact.

The Scores model structure enforces this through four distinct CategoryScore instances:

• open_source
• self_projects
• production
• technical_skills

Each instance stores the assigned points, the ceiling value, and textual evidence supporting the rating.

Bonus Points and Penalty Deductions

Beyond the four core categories totaling 100 base points, the system incorporates adjustable modifiers:

• Bonus Points: Up to 20 additional points awarded for exceptional achievements like leadership roles, community contributions, or relevant certifications ( implemented via the BonusPoints class).
• Deductions: Penalties applied for identified weaknesses or missing critical competencies (implemented via the Deductions class).

These modifiers are aggregated within the EvaluationData object alongside the core Scores.

Implementation in Code

The following example demonstrates how the scoring categories are instantiated and evaluated according to the hiring-agent source code:

from models import CategoryScore, Scores, BonusPoints, Deductions, EvaluationData

# Create per‑category scores

open_source = CategoryScore(score=30, max=35, evidence="5 merged PRs to popular libs")
self_projects = CategoryScore(score=27, max=30, evidence="Full‑stack web app on GitHub")
production   = CategoryScore(score=22, max=25, evidence="2 years as backend engineer")
technical_skills = CategoryScore(score=9, max=10, evidence="Proficient in Python, Go, Docker")

# Assemble the Scores object

scores = Scores(
    open_source=open_source,
    self_projects=self_projects,
    production=production,
    technical_skills=technical_skills,
)

# Optional bonus and deductions

bonus = BonusPoints(total=12, breakdown="Leadership +2, Community +5, Certifications +5")
deductions = Deductions(total=3, reasons="Missing CI/CD pipeline description")

# Complete evaluation data

evaluation = EvaluationData(
    scores=scores,
    bonus_points=bonus,
    deductions=deductions,
    key_strengths=["Strong problem solving", "Effective communication"],
    areas_for_improvement=["CI/CD automation", "Cloud architecture"]
)

# Display results (the same routine used by the CLI)

from score import print_evaluation_results
print_evaluation_results(evaluation, candidate_name="Alice Example")

This implementation ensures that open_source, self_projects, production, and technical_skills are validated against their respective maximums before final rendering.

Summary

• The hiring-agent uses four weighted categories: Open Source (35 pts), Self Projects (30 pts), Production Experience (25 pts), and Technical Skills (10 pts).
• Category definitions reside in models.py, with validation logic in score.py via print_evaluation_results.
• Each category uses a CategoryScore object tracking score, maximum value, and evidence strings.
• The system supports up to 20 bonus points and custom deductions to adjust the final evaluation.
• The evaluator.py module drives the LLM-based population of these scores based on résumé content analysis.

Frequently Asked Questions

How is the maximum score calculated for each resume evaluation category?

Each category has a hardcoded maximum defined in the Scores model: 35 points for Open Source, 30 for Self Projects, 25 for Production Experience, and 10 for Technical Skills. The print_evaluation_results function in score.py enforces these caps during output generation, ensuring no single category exceeds its allocated weight regardless of raw calculation results.

What happens if a candidate scores higher than the category maximum?

The evaluation system automatically caps any exceeded scores to their predefined maximums during the results formatting phase. For example, if the LLM evaluator assigns 40 points to Open Source, the print_evaluation_results routine truncates this to 35 points before displaying the final assessment, preserving the intended weighting scheme.

Where are the scoring category definitions located in the codebase?

The four scoring categories are defined as CategoryScore fields within the Scores class in models.py. The fields are named open_source, self_projects, production, and technical_skills. The actual evaluation logic that populates these fields resides in evaluator.py, while validation and display formatting occur in score.py.

Can the scoring categories be customized or extended?

The current implementation in interviewstreet/hiring-agent defines the four categories as fixed fields within the Scores model. Adding new categories would require modifying the Scores class definition in models.py, updating the CategoryScore instantiations, and adjusting the print_evaluation_results function in score.py to handle additional maximum point validations. The bonus and deduction system provides flexibility for customization without altering the core four-category structure.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}