Verified.prof

verified.prof turns GitHub commits into verified engineering profiles and a real-time AI Voice Twin, so recruiters interview proof, not self-reported résumés.

Comment

Inspiration

Technical hiring is broken. As developers ourselves, we've seen both sides: inflated résumés claiming "expert" in frameworks touched once, and genuinely skilled engineers struggling to prove their capabilities beyond whiteboard algorithms. Recruiters spend 40+ hours per hire trying to verify claims through behavioral interviews that depend on memory and storytelling ability, not actual code.

The inspiration hit when we realized: your Git history is the most honest résumé you'll ever have. Every commit is timestamped, every design pattern is traceable, every architectural decision is preserved in code structure. Why not treat source code as structural ground truth and let AI reason over verified facts instead of unverifiable claims?

We wanted to build something that gives developers credit for real work while giving recruiters confidence that they're interviewing verified skills.

What it does

verified.prof analyzes your GitHub commits with Tree-sitter ASTs to generate a verified developer profile, then lets recruiters interview an AI Voice Twin trained exclusively on your code evidence.

The Analysis Pipeline

  1. Fetches commits from GitHub (via Octokit)
  2. Parses code with Tree-sitter (TypeScript, Python, Go, Rust, PHP, etc.)
  3. Extracts structural evidence: function definitions, import patterns, cyclomatic complexity, architectural layers
  4. Generates metrics with Gemini 3:
    • Code Impact (functions/classes owned)
    • Seniority Rank (Junior - Principal)
    • Tech Stack DNA (mastery levels per technology)
    • Mission Timeline (auto-generated project summaries)
  5. Stores verified profile in PostgreSQL

The vTwin

Built on Gemini 2.5 Flash Live API, the Twin conducts real-time voice interviews:

  • Recruiter asks: "What's your React experience?"
  • Twin responds: _"I've used React across 3 projects, primarily hooks-based components with Context API for state management, verified in my e-commerce mission from October 2025."

The key: The vTwin cannot hallucinate. Its entire knowledge base is AST-derived metrics, it physically cannot claim experience not backed by commits.

How we built it

Architecture

  • Backend: NestJS microservice with event-driven pipeline (EventEmitter2)
  • Frontend: Next.js 16 with React 19, TanStack Query for data fetching
  • Database: PostgreSQL with Prisma ORM
  • AI: Gemini 3 + Flash Live API (@google/genai)
  • Parsers: Tree-sitter with 9 language grammars

Key Technical Decisions

1. Tree-sitter over regex
We initially tried regex patterns to detect imports/functions. Fragile disaster. Tree-sitter gives us actual syntax trees, language-agnostic, maintainable, and precise. For example, extracting TypeScript imports:

const importNodes = rootNode.descendantsOfType('import_statement');
const libraries = importNodes
  .map(node => node.childForFieldName('source')?.text)
  .filter(lib => lib && !lib.includes('./'));

2. Event-driven orchestration
Analysis has 9 stages (fetching - parsing - AI - missions - tech stack). We use NestJS EventEmitter2 to decouple stages:

@OnEvent(JOB_EVENTS.ANALYSIS_PERSISTED)
async handleAnalysisPersisted(event: AnalysisPersistedEvent) {
  await this.generateTechStackDNA(event.userId);
  this.em.emit(JOB_EVENTS.TECH_STACK_DNA, ...);
}

This let us parallelize independent tasks and add real-time progress tracking.

3. Gemini Live for Voice Twin

  • Native audio processing (no middleware)
  • Sub-second latency (critical for natural dialogue)
  • Interruption handling (recruiter can cut in mid-sentence)

The challenge: Firefox has terrible Web Audio API timing. Solution: detect browser and adjust latency strategy:

const isFirefox = navigator.userAgent.toLowerCase().includes('firefox');
const firefoxBuffer = isFirefox ? 0.2 : 0;
const outputAudioContext = new AudioContext({
  latencyHint: isFirefox ? 'playback' : 'interactive',
});

4. Context caching for Gemini
AST summaries can be 50KB+. We cache Gemini contexts for repeated analysis: Reduced API costs by 60% and cut latency from 8s - 3s.

Challenges we ran into

1. Tree-sitter memory leaks

Tree-sitter runs native WASM modules. Parsing 1000+ files would crash Node.js. Solution: batch processing with parser.delete() after each file:

for (const chunk of chunks) {
  const parser = new Parser();
  parser.setLanguage(language);
  // ... parse files
  parser.delete(); // CRITICAL: free WASM memory
}

2. Gemini Live audio desync in Firefox

Chrome worked perfectly. Firefox played audio in robotic stutters. Root cause: Firefox's AudioContext doesn't handle rapid buffer scheduling well. We added linear interpolation for resampling and a 200ms safety buffer:

// Linear interpolation instead of floor-based sampling
for (let i = 0; i < targetSamples; i++) {
  const sourcePosition = (i * sourceSampleRate) / targetSampleRate;
  const sourceIndex = Math.floor(sourcePosition);
  const frac = sourcePosition - sourceIndex;
  const sample1 = dataInt16[sourceIndex] / 32768.0;
  const sample2 = sourceIndex + 1 < sourceSamples 
    ? dataInt16[sourceIndex + 1] / 32768.0 
    : sample1;
  channelData[i] = sample1 + frac * (sample2 - sample1);
}

This smoothed audio artifacts and eliminated lag.

3. Hallucination prevention

LLMs want to be helpful. When asked about tech not in the profile, early versions would say "I have some familiarity with X" (complete fabrication). Solution: aggressively constrain context and add explicit instructions:

const context = `
You are ONLY allowed to discuss technologies with verified evidence:
${verifiedTechStack.map(t => `- ${t.name}: ${t.usageCount} usages`).join('\n')}

If asked about anything else, respond: "I don't have verified commits demonstrating that technology."
`;

4. Mission extraction from commits

Commits are messy: fix typo, wip, asdfasdf. Clustering them into meaningful "missions" required:

  • Grouping by time windows (4-hour sessions)
  • Scoring by complexity + files changed
  • Using Gemini to synthesize narratives

We cap at 6 missions per profile to avoid overwhelming recruiters.

Accomplishments that we're proud of

  1. Zero hallucination Voice Twin: We built a conversational AI agent that literally cannot lie about technical skills. Every response is traceable to a commit.

  2. Multi-language AST parsing: Supporting 9 languages (TypeScript, Python, Go, Rust, PHP, Vue, Zig, etc.) with consistent extraction logic was non-trivial. Tree-sitter made it possible.

  3. Real-time voice interviews: Integrating Gemini Live for bidirectional audio streaming with <500ms latency felt like sci-fi. Recruiters can have natural conversations with the Twin.

  4. Event-driven architecture: The 9-stage pipeline with real-time progress updates and parallel execution shows clean engineering at scale.

  5. Developer ownership: Unlike ATS systems that serve employers, verified.prof gives developers a verified identity they control. Your profile is proof of work.

What we learned

Technical

  • Tree-sitter is production-ready for multi-language code analysis regex is dead
  • Gemini Live API beats STT, LLM, TTS architectures for conversational AI
  • Context caching is essential for LLM apps with repeated large contexts
  • Browser audio APIs have deep inconsistencies (Firefox ≠ Chrome)
  • Event-driven NestJS scales beautifully for complex pipelines

Product

  • Developers want proof, not claims: Early testers loved seeing actual commit evidence for skills
  • Recruiters don't trust résumés: The "Trust Gap" is real recruiters spend days verifying claims
  • Voice interviews > chat: Async chat feels robotic; real-time voice creates genuine human connection

AI Engineering

  • Structured outputs > raw text: Forcing Gemini to return JSON schemas eliminated 90% of parsing errors
  • Grounding ≠ RAG: True grounding requires deterministic data (AST facts), not retrieved documents
  • Hallucination is an architecture problem: If your AI can hallucinate, your data pipeline is wrong

What's next for Verified.prof

Phase 1: Multi-VCS Support (8 weeks)

  • GitLab, Bitbucket, Gitea integrations
  • Self-hosted repository support
  • Private organization repos

Phase 2: Advanced Metrics (6 weeks)

  • Test coverage analysis (test/*.spec.ts detection)
  • Performance benchmarking (runtime complexity)
  • Security vulnerability correlation (CVE mapping)

Phase 3: Recruiter Portal (10 weeks)

  • Bulk candidate screening
  • Custom interview templates ("Ask about React patterns")
  • Comparative analytics (benchmark across candidates)

Phase 4: Enterprise (12 weeks)

  • GDPR compliance (right to deletion, data export)
  • SSO/SAML authentication
  • On-premise deployment
  • SLA guarantees

Phase 5: Beyond Code (exploratory)

  • Stack Overflow contribution analysis
  • Open-source impact scoring (GitHub stars, merged PRs)
  • Technical writing evaluation (dev.to, Medium)

The vision: Every developer should have a verified identity that proves their skills through code, not claims. Every recruiter should be able to interview an AI twin that cannot hallucinate. verified.prof is the first step toward trust in technical hiring.

Built With

Share this project:

Updates