Modern AI Tools in Developer Recruitment

Traditional IT recruitment processes – based on scanning resumes for keywords and sending candidates simple algorithmic tasks – are no longer working. In the era of widespread use of code generators and AI assistants (such as Cursor, GitHub Copilot, or Claude Code), candidates can effortlessly generate correct solutions to technical tests. For this reason, HR Tech leaders have shifted their strategy: instead of banning the use of artificial intelligence, they assess how effectively the candidate collaborates with it.

1. Assessing Work with AI in Practice: Codility AI Posture Control & Copilot

One of the most interesting implementations in the field of technical skills verification is the approach by Codility. Instead of blocking the use of code assistants, Codility has introduced systems that allow recruiters to flexibly manage the degree of artificial intelligence usage during tests.

• AI Posture Control: Allows recruiters to configure AI assistant policies individually for each position. We can set the "AI Restricted" mode (where the system aggressively monitors attempts to copy code or switch tabs) or the "AI Enabled" mode (where artificial intelligence is officially allowed).
• AI Copilot in the Test Environment: In "AI Enabled" mode, the candidate gets an integrated AI assistant inside the browser-based IDE. The task is not to write code from scratch, but to build an advanced solution in collaboration with AI.
• Assessing Prompting and Critical Thinking: The tool records the history of queries (prompts) sent by the candidate to the AI and how they modify the suggested code. The Senior Developer evaluating the test sees the candidate's exact train of thought: whether they uncritically pasted incorrect suggestions, or were able to precisely debug AI responses and catch security vulnerabilities.

2. Autonomous Technical Interviews: HackerRank Chakra AI

Another major breakthrough is the automation of the initial stage of the technical interview (pre-screening). The HackerRank Chakra AI tool is an autonomous assistant conducting interactive voice and video interviews with candidates.

Unlike old one-way video recordings (where candidates recorded their answers without interaction), Chakra AI works bidirectionally in real time:

1. Adaptive Interviewing: The model dynamically adjusts the difficulty level of the questions based on the candidate's previous responses. If a candidate excels at microservices architecture, Chakra will move on to deeper questions about distributed transactions or network error handling.
2. Real Technical Dialogue: When a candidate presents a design concept, Chakra AI can challenge certain assumptions (e.g., "You mentioned using Redis as the primary database for financial transactions. What risks does this entail?") and expects a substantive defense of the architectural decision.
3. Automated and Structured Report: After the session, the recruiter receives a transcript, an assessment of individual competencies, and a recording with timestamps indicating potential weak points or attempts at non-independent work.

3. Reducing Administration by 80%: Metaview AI Notetaker

While HackerRank and Codility focus on developer verification, Metaview (available at metaview.ai) is revolutionizing the work of recruiters and Hiring Managers themselves.

Metaview is an intelligent AI notetaker that automatically integrates with calendars and tools like Zoom, Microsoft Teams, and Google Meet. The tool automatically joins the recruitment call in the background, transcribes it, and then generates structured notes tailored to scorecards in the ATS system (e.g., Lever, Greenhouse).

4. Niche Sourcing vs Outbound: hireEZ vs SeekOut

Searching for passive candidates is the most time-consuming stage of recruitment. AI has automated this process in two different ways, represented by leading sourcing platforms:

5. Do It Yourself (GDPR-Safe): Local Candidate Repository Auditor

Instead of relying on expensive SaaS licenses that upload candidate code to the cloud (which may violate copyright or Non-Disclosure Agreements - NDAs), you can build a fully secure and local tool yourself using Python and Ollama.

The script below automatically analyzes source code from a local candidate directory (e.g., a cloned GitHub repository) and generates 3-5 personalized technical questions for the recruitment interview. The entire process runs 100% locally on your machine using the llama3 or bielik model.

import os
import requests

# Local Ollama server configuration
OLLAMA_URL = "http://localhost:11434/api/generate"
MODEL_NAME = "llama3"  # You can replace this with the "bielik" model for Polish

def get_code_files(repo_path, extensions=('.py', '.js', '.ts', '.go')):
    """Collects content of code files with specified extensions"""
    code_bundle = ""
    for root, dirs, files in os.walk(repo_path):
        # Skip dependency and configuration directories
        if any(x in root for x in ['node_modules', '.git', 'dist', 'venv', '__pycache__']):
            continue
        for file in files:
            if file.endswith(extensions):
                file_path = os.path.join(root, file)
                try:
                    with open(file_path, 'r', encoding='utf-8') as f:
                        code_bundle += f"\n\n# File: {file}\n" + f.read()[:2000] # Size limit
                except Exception:
                    pass
    return code_bundle

def generate_questions(code_content):
    """Generates personalized questions based on the code"""
    system_prompt = (
        "You are an experienced software architect and technical recruiter. "
        "Analyze the submitted candidate code and generate exactly 3 personalized, non-trivial technical "
        "questions for an interview. The questions should focus on specific design decisions, "
        "security, performance, or potential bugs in their code. Answer in English."
    )
    
    prompt = f"Here is the candidate's project source code:\n\n{code_content}\n\nGenerate questions:"
    
    payload = {
        "model": MODEL_NAME,
        "prompt": prompt,
        "system": system_prompt,
        "stream": False,
        "options": {
            "temperature": 0.2
        }
    }
    
    try:
        response = requests.post(OLLAMA_URL, json=payload, timeout=120)
        response.raise_for_status()
        return response.json().get("response", "").strip()
    except Exception as e:
        return f"Error generating questions: {e}"

if __name__ == "__main__":
    # Point to the path of the cloned candidate project
    code_path = "./path_to_candidate_project"
    
    if not os.path.exists(code_path):
        print(f"Path {code_path} does not exist. Set the correct directory.")
    else:
        print("Loading code...")
        code = get_code_files(code_path)
        if len(code) < 100:
            print("No code found for analysis.")
        else:
            print("Local analysis by Ollama and question generation...")
            questions = generate_questions(code)
            print("\n=== GENERATED RECRUITMENT QUESTIONS ===")
            print(questions)

Summary: The New Recruitment Paradigm

Artificial intelligence is lifting a massive burden of repetitive administrative tasks from IT recruiters (notes from Metaview, automated pre-screening with Chakra AI, initial candidate filtering with hireEZ). At the same time, it forces a shift in technical verification: instead of testing how well a candidate can write an algorithm from memory, we now evaluate their architectural skills, critical thinking, and maturity in using modern tools that assist programming.