Sign in page
Adding team members
Candidates page
Scenario page
User Interview start page
Compare candidates
Website
Settings page
Preferences page
Roles page
Integrations page
Candidate Report
Audit Logs
Scenario
Interview report

Inspiration

While watching AI engineer hiring at my company, I noticed a gap between the interview and the job. DSA exercises and technical discussions could reveal useful skills, but they showed less of how someone actually investigates a bug, builds a feature, or works with an AI coding agent.

AI tools make that gap more interesting. A candidate can produce working code with AI, but the hiring team still needs to understand the decisions behind it. What did the candidate investigate? Which suggestions did they question? How did they check the result?

That inspired Trust Issues: an AI-assisted interview platform that helps hiring teams see how engineers build, debug, and solve problems with AI.

What it does

Trust Issues gives candidates a real repository, a browser-based coding workspace, and Claude Code. They complete a debugging or feature-building exercise while the platform records prompts, agent responses, commands, file activity, and test results.

After submission, the hiring team receives a readable working profile with observations linked to session evidence. Reviewers can examine both the code’s outcome and the candidate’s approach: how they explored the repository, directed the agent, responded to failures, and verified their changes.

The platform supports HR professionals, recruiters, and engineering hiring managers. It provides evidence for their discussion and leaves the hiring decision with them.

How I built it

The application uses Python with Starlette and Uvicorn, React and TypeScript with Vite and Tailwind, and SQLAlchemy, with SQLite for local development and Postgres support for deployment.

Each candidate workspace runs in a Docker container containing code-server, Claude Code, and a recording harness. The harness writes session activity to an event trace.

A deterministic checkpoint engine evaluates that trace. Test outcomes and observed events establish the facts; AI helps turn those facts into readable report prose, with references checked against the recorded evidence.

I also built an authoring pipeline for role-relevant exercises. AI drafts repositories, tasks, and tests, while mechanical verification and human approval control which scenarios become available to candidates.

Challenges I faced

Capturing the whole workflow. Agent messages alone miss what candidates do independently. Recording editor activity, terminal commands, and test results was necessary to give reviewers a fuller picture.

Making realistic exercises. A convincing task needs meaningful repository history, believable dependencies, and tests that distinguish a narrow fix from a complete solution. Generating files was only the beginning; verification became a substantial part of the project.

Keeping reports grounded. Fluent AI prose can sound more certain than the evidence supports. Separating deterministic facts from generated explanations became a central design choice.

Verifying the complete experience. Browser workspaces, Docker provisioning, telemetry, and report generation had to work together. Local execution restrictions also left some runtime checks pending in the submission workspace, which I documented explicitly.

What I learned

The biggest lesson was that a passing test is one useful signal within a larger engineering process. Investigation, verification, and recovery from a mistaken hypothesis can reveal different strengths.

I explored this through three scripted browser sessions using real Claude Code calls: careful investigation, a quick symptom fix, and a course correction after a failed hypothesis. Each produced its own recorded trace and report.

Those demonstrations reinforced the purpose of Trust Issues: make engineering work with AI visible enough for a hiring team to understand and discuss.