Project Story

SkillViewer is built around a simple idea: interview preparation shouldn't be limited to generic AI interviewers. Candidates and interviewers should be able to create the exact interviewer they need, customize how it behaves, and immediately practice with it.

I wanted to make this process agentic—users describe what they want, collaborate with AI to refine the interviewer, and turn that design into a ready-to-use voice interviewer.

Inspiration

I was inspired by the way AI design tools like Figma Make let people create and iteratively refine designs through natural language.

I asked: what if I applied the same idea to interviews?

Instead of iterating on a UI, what if I could iterate on an interviewer's style, rubric, questions, strategy, interview stages, and evaluation criteria?

What it does

SkillViewer lets users create customized AI interviewers through natural-language collaboration.

Users can define the role, rubric, questions, question strategy, interview stages, and evaluation dimensions, refine them interactively, and then launch the resulting interviewer for a real-time voice interview.

The interviewer uses the created Skill to adapt its questioning, probe candidate responses, and evaluate candidates during the conversation.

How I built it

I built SkillViewer with a React frontend and FastAPI backend.

Gemini-powered ADK agents handle both interviewer creation and interview execution. A structured skill-authoring pipeline parses and validates the interview design before compiling it into a versioned Skill.

At runtime, the Interviewer Agent retrieves that Skill and combines it with runtime policies before executing the interview through ADK, Pipecat, and WebRTC for real-time voice interaction.

Challenges I ran into

One of the biggest challenges was integrating Google ADK with a real-time voice pipeline. There wasn't a straightforward library or reference implementation for the exact ADK + real-time voice architecture I wanted.

I initially studied the architecture used by LiveKit with ADK and decomposed it to understand how the different components were connected. However, reproducing that architecture would have required writing a significant amount of glue code, which wasn't ideal for the scope of the project.

While researching alternatives, I came across another Python-based implementation that already handled much of the real-time voice orchestration I needed. I adapted that approach and integrated it with my ADK-based interviewer architecture.

This allowed me to focus on the core problem—building customizable, agentic interviewers—while still delivering a working real-time voice experience within the project timeframe.

Accomplishments I'm proud of

I'm proud that I built the complete path from a simple natural-language requirement to a functioning, customized voice interviewer.

The system doesn't just generate a prompt—it creates a structured interview Skill covering requirements, rubrics, questions, strategy, and evaluation, validates it, and makes it executable by an agent in a real interview.

What I learned

I learned that making an AI system genuinely customizable requires more than prompt engineering.

Giving the AI a structured representation of what the user wants makes the resulting agent much more controllable, reusable, and reliable.

I also learned the importance of separating the design-time agent from the runtime agent and putting deterministic validation between them.

What's next for SkillViewer

Next, I want to make SkillViewer a platform where interviewers can continuously build, test, version, and improve specialized interview Skills.

I want to expand adaptive interviewing, richer candidate evaluation and feedback, persistent Skill management, and eventually allow users to share and discover specialized interview Skills.

Built With

• adk
• agent
• pipecat
• python