DevHunter

Landing Page
Analysis Page
Chat Page

Inspiration

Recruiting top-tier engineering talent is notoriously broken. Recruiters are flooded with hundreds of resumes, often lacking the technical depth to properly screen them. Engineers are frustrated by irrelevant screening calls and generic assessments that don't reflect their actual skills. We were inspired to fix this by building an agentic solution that bridges this gap. We asked ourselves: What if an AI could read code like a senior engineer and then interview candidates like a human recruiter?

What it does

DevHunter AI is an autonomous technical recruiter that automates the early stages of the hiring pipeline.

Deep Code Analysis: A recruiter simply pastes a candidate's GitHub repository URL. DevHunter's backend agent deeply scans the repo (handling complex file structures), identifies the tech stack, detects security vulnerabilities, and evaluates code complexity.

AI-Generated Interview: Based on the code analysis, it generates context-aware, "tough" technical questions specific to the candidate's actual work (e.g., "I noticed you used JWTs without rotation in auth.js. Why?").

Autonomous Voice Screening: The agent then initiates a real-time phone call to the candidate using Telnyx Voice API. It conducts the interview, listens to answers, and dynamically asks follow-up questions.

Live Recruiting Dashboard: Recruiters can watch the interview unfold in real-time on a "Live Transcript" dashboard and receive a final "Hire/No Hire" recommendation with a detailed competency score.

How we built it

We built DevHunter as a modern full-stack application with an agentic core.

Frontend: We used React with Vite for a snappy, responsive experience, styled with Tailwind CSS and Shadcn UI to create a professional "SaaS-grade" dashboard.

Backend: The server is built on Node.js and Express. It handles the complex logic of fetching raw GitHub content, navigating Git trees recursively, and managing interview states.

The "Brain": We leveraged OpenAI's GPT-4 Turbo to act as the Senior Staff Engineer. It analyzes thousands of lines of code to extract architectural patterns and generate high-context questions.

The "Voice": We integrated Telnyx Voice API for the telephony layer. The backend handles webhooks from Telnyx to manage the conversation flow (Speak -> Gather Input -> Process -> Speak), creating a seamless conversational loop.

Challenges we ran into

GitHub Rate Limits & Complexity: Accessing large repositories via the standard GitHub API quickly hits rate limits. We had to engineer a robust "hybrid fetcher" that uses the Git Tree API for structure but switches to raw content fetching for file data to bypass API constraints. We also built a "Blind Mode" fallback to guess common file paths (like package.json or src/App.jsx) if the API blocks us entirely.

Real-time Voice Latency: Orchestrating a conversation between a phone line and an LLM introduces latency. We optimized our webhook responses and prompt sizes to ensure the agent feels responsive rather than robotic.

Vite & TypeScript Conflicts: Integrating complex UI components meant for Next.js/TypeScript into a standard Vite/JavaScript environment caused build issues (like the type ClassValue error). We had to manually refactor components to ensure compatibility.

Accomplishments that we're proud of

True Agentic Behavior: DevHunter isn't just a chatbot. It acts—it navigates file systems, makes phone calls, and evaluates humans in real-time.

The "Wow" Factor: Seeing the dashboard update live with the transcript while talking to the AI on the phone feels like magic.

Robust Error Handling: Our backend successfully navigates messy repos, handles API failures gracefully, and keeps the interview flow intact even if the candidate gives unexpected answers.

What we learned

Voice is the new UI: Building voice interfaces requires a different mindset than building web UIs. You have to account for silence, interruptions, and tone.

Context is King: Generic AI is boring. AI grounded in specific data (like a user's actual code) becomes incredibly powerful and useful.

The Power of "Good Enough" Architectures: In a hackathon, you can't build a perfect distributed system. Using simple in-memory polling for the "Live Transcript" feature was a simple hack that delivered a premium user experience without complex WebSocket infrastructure.