Skip to main content

​
Overview

Skills are the single most important factor in Recruitier’s job matching engine. When the AI searches for jobs, it relies heavily on the candidate’s confirmed skills to determine relevance — skills carry a 45% weight in the vector matching algorithm, more than any other factor (title is 35%, experience is 20%). This means that the accuracy of a candidate’s skill list directly determines the quality of their job matches. Taking a minute to review and confirm AI-extracted skills is one of the highest-impact actions you can take as a recruiter. The skill confirmation step is the formal gate that marks a candidate as fully set up for production-quality matching.

​
How AI Extracts Skills

​
From CV Upload

When you upload a CV, the AI (Gemini 3 Flash Preview) reads the entire document and identifies skills using deep contextual analysis. It does not just look for a “Skills” section — it analyzes the full document to infer skills from:
  • Work experience descriptions: “Developed REST APIs using Python and FastAPI” extracts Python and FastAPI
  • Project descriptions: “Built a CI/CD pipeline with Jenkins and Docker” extracts Jenkins, Docker, and CI/CD
  • Certifications and training: “AWS Certified Solutions Architect” extracts AWS and cloud architecture
  • Education details: “MSc in Machine Learning” extracts machine learning
  • Tool mentions: “Managed sprints in Jira and documented in Confluence” extracts Jira and Confluence
Each extracted skill is assigned a confidence score between 0 and 1 that reflects how explicitly and prominently the skill appeared:
Score RangeMeaningAction Needed
0.90 - 1.00Explicitly mentioned in a skills section or prominently featured in multiple contextsQuick scan is sufficient
0.75 - 0.89Clearly mentioned in experience or project descriptionsBrief verification recommended
0.60 - 0.74Inferred from context (e.g., “full-stack developer” implies JavaScript and HTML/CSS)Review carefully — may or may not be accurate
Below 0.60Weak signal, possibly inferred from tangentially related contentLikely needs manual verification or removal
CV-extracted skills typically receive the highest confidence scores (0.95+) because CVs are written by or for the candidate and tend to explicitly list their technical capabilities. The AI processes up to 50,000 characters of CV text (~12,500 tokens), giving it extensive context for accurate extraction.

​
From LinkedIn Import

When a candidate is imported from LinkedIn, skills come from two possible sources with different confidence characteristics: 1. LinkedIn Skills Section (confidence: 0.80) If the candidate has skills listed on their LinkedIn profile, these are imported directly with a fixed confidence score of 0.80. This is a strong signal since the candidate explicitly listed these skills themselves. The 0.80 score (rather than 0.95+) reflects a small discount for the fact that LinkedIn skills are self-reported and may include aspirational skills or technologies the candidate used years ago. 2. AI Fallback Extraction (confidence: variable) If the LinkedIn profile does not have publicly visible skills, the AI falls back to extracting skills from the candidate’s headline, summary, and work experience descriptions. This uses the same Gemini-powered extraction logic as CV upload, producing variable confidence scores based on how explicitly each skill was mentioned in the text.

​
Skill Normalization

Regardless of how skills are extracted, they go through a normalization pipeline that maps variations to canonical forms. The normalization taxonomy (SKILL_ALIASES) contains over 1,000 mappings from common variations to standardized skill names:
What the CV SaysNormalized ToCategory
”JavaScript”, “JS”, “Javascript”, “JavaScript Programming”javascriptLanguage
”React.js”, “ReactJS”, “React”reactFramework
”Amazon Web Services”, “AWS”awsCloud
”PostgreSQL”, “Postgres”, “psql”postgresqlDatabase
”Kubernetes”, “K8s”, “k8s”kubernetesDevOps
”Machine Learning”, “ML”machine learningAI/ML
”CI/CD”, “CICD”, “CI CD”, “Continuous Integration”ci/cdDevOps
This normalization serves two critical purposes:
  1. Prevents duplicate skills: Without normalization, a candidate might have both “React” and “ReactJS” in their skill list, which wastes a slot and can skew the vector embedding
  2. Improves matching accuracy: A candidate with “React” in their profile needs to match against jobs that mention “ReactJS” or “React.js”. Normalization ensures these are treated as the same skill in the vector space
The normalization happens automatically behind the scenes. In the interface, you see the skill name with proper capitalization as presented by the AI (e.g., “JavaScript” rather than “javascript”). The internal matching uses the normalized lowercase form. This approach is backed by IBM AAAI research that demonstrated a 29% improvement in Mean Reciprocal Rank when using skill taxonomy normalization.

​
The Skills Confirmation Workflow

After a candidate is created (via CV upload or LinkedIn import), their skills are in an unconfirmed state. The skills_confirmed flag on the candidate profile is false, which means:
  • The AI has extracted skills, but they have not been reviewed by a recruiter
  • Skills are visible on the profile but marked as “pending confirmation”
  • Job matching can still run, but the results are considered provisional
  • The candidate is not yet marked as “setup complete” in the system

​
Confirming Skills During the Upload Wizard

When you first add a candidate, skill confirmation happens as Step 3 of the upload wizard. Skills are displayed as interactive chips with confidence indicators:
  • Color-coded confidence: Green dot for high confidence (90%+), accent color for medium (70-89%), red for low (below 70%)
  • Toggle on/off: Click any skill chip to toggle its confirmed state. Confirmed skills show a checkmark.
  • Remove: Click the X on any skill chip to remove it entirely
  • Add: Type a new skill name in the input field and press Enter to add it
  • Counter: A summary at the bottom shows how many skills are selected out of the total
You can also skip this step and go directly to location if you want to review skills later.

​
Reviewing Skills from the Candidate Profile

After a candidate is created, you can review and edit skills at any time from the candidate detail page by clicking the Edit button.
1

Open the Candidate Profile

Navigate to the candidate whose skills you want to review. Click on them in the candidate list.
2

Click Edit

Click the Edit button in the top right of the candidate detail page to open the edit dialog.
3

Review and Modify Skills

In the edit dialog, the skills section shows all current skills as removable badges. You can:
  • Remove skills by clicking the X on each badge
  • Add new skills by typing in the input field and pressing Enter
  • Skills with high confidence (0.85+) are almost always accurate — a quick scan is sufficient
  • Focus your detailed attention on lower-confidence skills (below 0.75) that the AI was less certain about
A fast review strategy: scan the high-confidence skills for any obvious errors, then carefully evaluate everything below 0.75 confidence. This focuses your time where it has the most impact.
4

Save Changes

Click Save to update the candidate’s skills. If skills were added or removed, the system detects the change and can trigger re-matching automatically. Protected matches (favorited, applied, etc.) are always preserved.

​
Why Skill Confirmation Matters

​
Impact on Matching Quality

The matching engine uses confirmed skills in three distinct ways across the matching pipeline:
The candidate’s confirmed skills are embedded as a vector in the Qdrant vector database. This Skills vector is compared against every job’s skills vector during semantic search, carrying 45% of the total search weight. More accurate skills produce a more representative vector, which means the semantic search returns more relevant jobs.Example: If a candidate has “React” confirmed but actually works with “Angular”, the Skills vector will be oriented toward React-heavy jobs, missing Angular opportunities entirely.
When the AI scores individual job matches in Stage 5, it receives the candidate’s confirmed skills only (not unconfirmed ones). It compares these against the job’s requirements and produces a Skills Fit score. If the confirmed skills accurately represent the candidate, the Skills Fit score will be meaningful. If they contain errors, the scoring is unreliable.The AI uses confirmed skills to evaluate alignment and surfaces the results as key matching points (green badges showing strengths) and potential concerns (orange badges highlighting gaps like missing skills). These are displayed alongside each match score.
When generating the diverse search queries in Stage 2 of matching, the AI uses the candidate’s confirmed skills to build targeted keyword searches. Skills inform queries like “python backend engineer” or “react frontend developer”. Inaccurate skills lead to misdirected search queries.

​
What Happens Without Confirmation

Candidates with unconfirmed skills (skills_confirmed = false) can still receive matches, but with these caveats:
  • Match results may include jobs based on incorrectly extracted skills, leading to false positives
  • The AI scoring may overvalue skills the candidate does not actually have, producing misleading scores
  • The candidate is not marked as “setup complete”, which may affect prioritization in incremental matching
  • Re-matching triggered by skill changes may behave differently for unconfirmed profiles
Unconfirmed skills are treated as provisional. While matching will still work, the results will be less precise than with confirmed skills. Always confirm skills before relying on match results for client conversations, candidate outreach, or interview preparation. The investment of 30-60 seconds in skill confirmation pays significant dividends in match quality.

​
Editing Skills After Confirmation

Skills are not locked after confirmation. You can update them at any time, and the system intelligently handles changes:
  • Add new skills — When you learn about additional capabilities (e.g., after a phone screening reveals the candidate also knows Terraform)
  • Remove skills — When a skill is no longer relevant (e.g., candidate explicitly says they do not want Java roles anymore)
  • The system detects changes — When you save an updated skill set, Recruitier compares the new skills against the previous set using case-insensitive, order-independent comparison. Only actual additions or removals trigger the change detection.
When a genuine change is detected:
  1. The updated skills are saved to the profile
  2. The system can trigger automatic re-matching with the updated skill set
  3. Protected matches (favorited, applied, contacted, interviewing, etc.) are preserved
  4. New matching runs with exclude_job_ids for protected matches, only adding new opportunities
The skill comparison is intelligent: changing the order of skills does not count as a change. “Python” vs “python” is treated as the same skill (case-insensitive). Only actual additions or removals trigger change detection and potential re-matching. This prevents unnecessary re-matching when you simply reorganize the skill list.

​
Confidence Scores Explained

Confidence scores help you prioritize your review effort. Here is how to interpret them and where they come from:

High Confidence (0.85+)

The AI found this skill explicitly mentioned in the CV or LinkedIn profile, often in multiple contexts. These are almost always correct. A quick scan is sufficient.Common sources: Skills sections, certifications, repeated mentions across multiple jobs

Medium Confidence (0.65-0.84)

The AI found strong evidence for this skill but it was not explicitly listed in a dedicated section. Common with skills mentioned in job descriptions, project details, or tool references. Worth a closer look.Common sources: Work experience descriptions, project writeups, LinkedIn headline

Low Confidence (0.50-0.64)

The AI inferred this skill from indirect evidence. These are the skills most likely to need correction. Review carefully and verify with the candidate if possible.Common sources: Inferred from role titles (“full-stack” implies JavaScript), tangential mentions, related technology references

Very Low Confidence (below 0.50)

Weak signal. The AI thinks this might be a skill but is not confident. Consider removing unless you can verify it independently through conversation with the candidate.Common sources: Ambiguous mentions, skills inferred from industry context, possible misidentification

​
Confidence by Source

Different import methods produce different baseline confidence levels:
Extraction SourceTypical ConfidenceWhy
CV upload (explicit skills section)0.95+Explicitly listed by candidate, multiple context signals
CV upload (inferred from experience)0.60-0.89Mentioned in descriptions but not explicitly labeled as skills
LinkedIn skills section0.80 (fixed)Self-reported by candidate, high reliability with small discount for potential staleness
LinkedIn AI fallback0.60-0.90 (variable)Extracted from text descriptions, same as CV inference
Legacy/unknown import0.70 (fixed)Default score for skills without clear extraction provenance

​
Tips for Effective Skill Management

Focus on Technical Skills

The matching engine performs best with specific, technical skills — programming languages, frameworks, tools, platforms, certifications. Generic soft skills like “communication”, “teamwork”, or “problem-solving” add noise to the Skills vector without improving match quality. Remove them unless they are genuinely differentiating for the target roles.

Match the Market Language

If job postings in your niche use specific terminology, make sure the candidate’s skills reflect that. For example, Dutch job postings may use “Azure DevOps” rather than just “DevOps”, or “Scrum Master” rather than just “Agile”. The normalization taxonomy handles many variations, but exact market language can still improve results.

Less Is More for Junior Candidates

Junior candidates with a long list of technologies they have only briefly touched will get matched to jobs that require deep expertise in those technologies. Keep the skill list focused on what they can genuinely deliver in an interview and on the job. A curated list of 8-12 core skills outperforms a sprawling list of 30.

Review LinkedIn Imports Carefully

LinkedIn skills are self-reported by the candidate and may include aspirational skills, technologies from years ago, or skills endorsed by connections without verification. Cross-reference against the candidate’s actual work experience and current capabilities. A 2-minute conversation about their technical stack often reveals which LinkedIn skills are still relevant.
The 80/20 rule for skills: For most candidates, 80% of match quality comes from getting the top 5-8 core skills right. Make sure the candidate’s primary programming language, main framework, and key domain expertise are correctly represented. Secondary skills matter less for initial matching and can be refined after reviewing the first batch of results.

​
Advanced

​
The SKILL_ALIASES Normalization Taxonomy

The skill normalization system is built on a comprehensive taxonomy called SKILL_ALIASES. This is a static mapping maintained in the codebase that maps over 1,000 known skill variations to canonical lowercase forms. How normalization works:
  1. The raw skill string from AI extraction is cleaned (whitespace trimmed, basic formatting removed)
  2. The cleaned string is lowercased and looked up in the SKILL_ALIASES dictionary
  3. If a match is found, the canonical form is used; otherwise, the lowercased version becomes the canonical form
  4. Duplicates (after normalization) are removed from the skill list
Examples of normalization chains:
  • “JavaScript Programming” -> “javascript programming” -> lookup -> “javascript”
  • “ReactJS” -> “reactjs” -> lookup -> “react”
  • “Amazon Web Services” -> “amazon web services” -> lookup -> “aws”
  • “K8s” -> “k8s” -> lookup -> “kubernetes”
The research foundation for this approach comes from IBM’s AAAI paper on skill taxonomy, which demonstrated a 29% improvement in Mean Reciprocal Rank when using normalized skill taxonomies for job matching compared to raw skill strings. This improvement comes from eliminating false negatives — without normalization, a candidate with “React.js” would not match against a job requiring “ReactJS” even though they are the same technology.

​
How Skills Drive the Three-Vector Architecture

Skills are not just one input — they influence the matching pipeline at multiple levels: Skills Vector (45% of search weight): The candidate’s confirmed skills are embedded into a dedicated vector in Qdrant. This vector captures the “skill fingerprint” of the candidate. During search, this vector is compared against each job’s skills vector using cosine similarity. Because skills carry the highest weight, this vector has the most influence on which jobs are retrieved. Title Vector (35%): While primarily driven by the candidate’s job title, the Title vector is also indirectly influenced by skills. A title like “Python Developer” creates a different vector than “Developer” because it contains a skill-specific qualifier. Experience Vector (20%): The Experience vector is generated from the full CV text, which naturally contains skill mentions throughout work experience descriptions. Skills mentioned in context (e.g., “Led a team of 5 to migrate the platform from PHP to Python”) provide the AI with richer understanding than isolated skill names.

​
The Confirmation Gate in the Matching Pipeline

The skills_confirmed boolean is more than a UI indicator — it plays an active role in the matching pipeline:
  • Scoring prompt: During Stage 5 (AI Scoring), only confirmed skills are included in the scoring prompt sent to Gemini. This means the AI evaluates the candidate based on recruiter-verified skills, not raw AI extraction.
  • Incremental matching priority: When incremental matching runs on login (top 5 candidates, 50 new jobs each), candidates with confirmed skills are prioritized because their match results are more reliable.
  • Setup completeness: The candidate is not considered “fully set up” until skills_confirmed = true. This status is visible in the candidate list and affects how the candidate is presented in the UI.

​
Re-Matching Triggered by Skill Changes

When you modify a confirmed candidate’s skills, the system performs intelligent change detection:
  1. The new skill list is normalized (lowercased, ordered alphabetically)
  2. The previous skill list is normalized the same way
  3. A set comparison is performed: are there any additions or removals?
  4. If the sets are identical, no re-matching is triggered (reordering is not a change)
  5. If they differ, the re-matching pipeline is initiated
During re-matching after a skill change:
  • The candidate’s Skills vector in Qdrant is regenerated from the new skill set
  • New search queries are generated based on the updated skills
  • The vector search runs with the new embeddings
  • Protected matches (favorited, applied, etc.) are preserved via exclude_job_ids
  • Only genuinely new job matches are added to the candidate’s pipeline

​
Edge Cases and Business Rules

If you confirm an empty skill list (remove all AI-extracted skills without adding any), the candidate’s skills_confirmed flag is still set to true, but the Skills vector will be effectively empty. This severely degrades matching quality because the 45%-weighted skills dimension has no signal. Always ensure at least a few core skills are confirmed.
The AI handles Dutch, English, and German CVs and normalizes skills to English canonical forms. “Projectmanagement” (Dutch) becomes “project management”. However, very niche or industry-specific Dutch terms may not be in the normalization taxonomy. If a Dutch skill term does not normalize correctly, add the English equivalent manually.
Some skills are hierarchical: having “React” implies “JavaScript”. The matching engine handles this through vector similarity — the “React” vector is close to the “JavaScript” vector in the embedding space. You do not need to manually add implied skills. However, if a job specifically requires “JavaScript” and the candidate only has “React” confirmed, the explicit match may score slightly lower on the Skills Fit dimension.
There is no hard limit on the number of skills, but extremely long skill lists (30+) can dilute the Skills vector by making it too broad. A focused list of 10-20 well-chosen skills typically produces better matching results than an exhaustive list of everything the candidate has ever touched.

​
Power-User Tips

Use skill confirmation as a quality control checkpoint. Before confirming skills, briefly scan the candidate’s CV or LinkedIn profile alongside the extracted skills. This dual-view lets you quickly catch extraction errors and add missing skills in a single pass.
For niche roles, add specific tool names. The normalization taxonomy covers mainstream technologies well, but niche tools (e.g., specific ERP modules, industry-specific platforms, proprietary frameworks) may not normalize correctly. Adding the exact tool name that appears in job postings for that niche ensures accurate matching.
When in doubt, keep the skill. If you are unsure whether a skill is relevant, it is generally better to keep it with a plan to review after seeing initial match results. You can always remove it later if it is attracting irrelevant matches. Removing a skill that should be there costs you relevant matches that are harder to notice.