Engineering Has Changed. Coding Tests Haven't.

Bridge analyzes how candidates research, use AI, debug, and write code, not just whether tests pass.

Book Demo

File Tree

Editor

Terminal

AI Chat

1:12/8:00

Candidate Session Timeline

Reads requirementsUses AI effectivelyTests and debugsCode structure

Uses AI effectively8/10

Gave a detailed prompt, then refined the output

Wrote a specific prompt with constraints and expected format; reviewed and edited the AI suggestion before using it.

0:48 – 2:00

Coding tests weren’t built for the AI era.

AI tools make passing coding tests easier than ever. What matters now is how engineers research, use AI, debug, and iterate. Bridge captures this entire workflow.

LegacyYour assessment tool

CandidateTimeScore

Sarah Chen38:124/4

Marcus Johnson44:514/4

Priya Patel31:072/4

James Wright42:334/4

Emily Nakamura34:184/4

Bridge

Session Recording

CandidateTimeScoreWorkflow

Sarah Chen38:124/492

Marcus Johnson44:514/434

Priya Patel31:072/478

James Wright42:334/456

Emily Nakamura34:184/495

How it works

A view into how your candidates think.

Generate a custom assessment

Job Description

›Frontend Engineer
›React + APIs
›Performance optimization

Generate Assessment

Take-Home ProjectGenerated

✓Build a React dashboard
✓Fetch API data
✓Render chart components
✓Handle loading states
✓Optimize performance

Candidates work in their own environment

Claude Prompt

Optimize time complexity for this function

Chrome Research

◎StackOverflow

◎Binary search explanation

VS Code

function twoSum(nums) {
  return nums.sort((a,b)=>a-b)
}

Terminal

$ npm test
✓ all tests passed

Bridge analyzes the workflow

Chrome

Researched binary search

Claude

Refactor time complexity

Cursor

Edited solution logic

Terminal

Ran tests, verified

Understand how candidates work

AI Prompt Detected2:34 PM

CandidateRefactor twoSum from O(n log n) sort-based approach to O(n) using a hash map lookup

Claude

Here's the O(n) solution using a Map for constant-time lookups:

const map = new Map();
for (let i = 0; i < nums.length; i++) {
  if (map.has(target - nums[i]))
    return [map.get(target-nums[i]), i];
  map.set(nums[i], i);
}

CandidateAdd early validation for empty arrays?

AI Usage

Targeted optimization prompt — specified exact complexity tradeoff (O(n log n) → O(n)) and data structure preference

Bridge analyzes how candidates prompt, iterate, and apply AI suggestions.

Communication Analyzed2:41 PM

Bridge AgentWalk me through your approach before you start coding. What tradeoffs are you considering?

CandidateI'm thinking hash map for O(n) time but that's O(n) space. Sorting would be O(1) space but O(n log n) time — I'll go with the hash map since the input size is unbounded

Bridge AgentWhat happens if the array contains duplicates?

CandidateGood catch — the map stores the latest index so duplicates are handled. We check before inserting so we won't match an element with itself

Communication

Articulated tradeoffs unprompted — justified decision with constraints and handled edge case reasoning clearly

Bridge captures how candidates reason about their solutions during the assessment.

Web Research Detected2:19 PM

CandidateSearched: "JavaScript Map vs Object performance"

CandidateConfirmed Map.has() runs in constant time — using Map over a plain object for reliable key lookups

CandidateSearched: "Array indexOf time complexity"

CandidateRuled out indexOf — too slow for this use case. Sticking with Map

Research

Used official documentation over forums — verified assumptions before committing to a solution

Bridge captures how candidates use documentation, examples, and resources while solving problems.

Test Iteration Tracked2:47 PM

Attempt 1✕ Failed — duplicate values returned wrong index

CandidateThe map is overwriting the first index before I check for a match. I need to move the lookup before the insert

Attempt 2✕ Failed — empty array throws unhandled error

CandidateMissing an edge case guard. Adding an early return for arrays shorter than 2 elements

Attempt 3✓ All tests passed

Testing

Identified root cause each attempt — fixed ordering bug then added edge case handling in 3 iterations

Bridge captures how candidates run tests, identify failures, and iterate on their solutions.

Final Submission Evaluated3:12 PM

✓

CorrectnessAll test cases passed including edge cases

✓

Time ComplexityO(n) solution — optimal for input size

✓

Input ValidationHandles empty arrays and missing targets

✓

ReadabilityClear variable names and consistent formatting

DocumentationNo comments or JSDoc explaining function behavior

Submission

Correct and well-structured solution with strong edge case coverage — minor gap in inline documentation

Bridge evaluates the structure, correctness, and quality of the final implementation.

AI Usage

Communication

Research

Testing

Submission

Bridge analyzes how candidates prompt, iterate, and apply AI suggestions.

design

Communication

Feedback

documentation

Changes

AI Prompt Detected2:34 PM

CandidateRefactor twoSum from O(n log n) sort-based approach to O(n) using a hash map lookup

Claude

Here's the O(n) solution using a Map for constant-time lookups:

const map = new Map();
for (let i = 0; i < nums.length; i++) {
  if (map.has(target - nums[i]))
    return [map.get(target-nums[i]), i];
  map.set(nums[i], i);
}

CandidateAdd early validation for empty arrays?

AI Usage

Targeted optimization prompt — specified exact complexity tradeoff (O(n log n) → O(n)) and data structure preference

Bridge analyzes how candidates prompt, iterate, and apply AI suggestions.

design

Communication

Feedback

documentation

Changes

See how it works

Check out the demo below.

Hiring engineers for the AI era.

Book a demo