skip to content
‹ All posts

By Riya Madaan · Updated

Why we log commands, not screen video

Interview recording doesn't need a camera. A timestamped command log is searchable, costs kilobytes, and can't capture anything outside the lab.

#opinion

The best record of a debugging interview isn't a screen recording. It's a log of every command the candidate ran, with a timestamp and an exit code, plus the files they changed.

Interview recording has a default answer: point a screen recorder at the candidate and archive the pixels. We think the default is wrong on every axis that matters - searchability, storage, privacy - and the better answer is older than most of the people being interviewed. Here's the engineering case.

Record the work, not the picture of it

A terminal session is text going through a pty. script(1) was capturing it in BSD decades ago, and every shell history file is a cruder version of the same idea. What a hiring team needs from that stream is narrower still: what did the candidate run, when, from where, and did it work. A Faultybox command log row is exactly that:

{"offset": "04:31", "cmd": "kubectl logs api-0 --previous", "exit": 0, "cwd": "/home/candidate"}

Screen video is the same work after it's been rendered to a framebuffer, chopped into frames, and crushed through a codec tuned for movies. Small terminal text is roughly the worst case for video compression, so you pay gigabytes to store a lossy copy of something that was kilobytes at the source. Recording video of a terminal is printing a JSON file and scanning it back in.

Grep-able history beats scrub-able history

The useful property isn't playback. It's that a text record is data.

Want every interview where the candidate ran kubectl delete? That's a grep, not an intern watching video at 2x. Want to know how many commands failed before the first useful one, or how long the candidate spent reading before they changed anything? Those are queries over command, exit code and offset, not judgment calls made while squinting at frame 4:12.

This is what makes evidence-based grading mechanically possible. When our AI layer claims a candidate "verified the fix at 07:41," that citation has to point at a real row in the command log, or it gets retried and then withheld. The pass/fail verdict never comes from the model at all, but from deterministic scripts checking ground truth. Timestamped citations into pixels would be theater. Into text, they're auditable. It's also why a command log convinces people a score never will: the log is the primary record, not a summary of it.

Reading it back

A hiring manager reading the log isn't squinting at video. They're reading the commands the candidate actually ran, in order, with exit codes and times. Jump to the moment the fix landed. Find the three minutes where everything went sideways and see which commands caused it. Nothing is transcribed, so nothing is misread.

The log doesn't carry the terminal's output, and it doesn't pretend to. What the candidate saw is reproducible from what they ran against a known broken cluster, and what the cluster ended up as is checked directly by the grader. The record is of decisions, which is the thing being hired for.

Privacy is an architecture decision, not a policy

Here's the part we care about most. A screen recorder captures your screen - your bookmarks bar, your notification toasts, the tab with your bank in it, the Slack preview from your group chat. Add the industry-standard webcam requirement and you're archiving candidates' faces and bedrooms as a hiring artifact. Then that archive sits in a vendor's bucket, indefinitely, as a breach payload.

A command log structurally can't capture any of that. The recording surface is a shell inside a lab we provisioned; what's in the log is what was run in that environment, and nothing else exists to leak. No camera, no mic, no screen capture, by architecture rather than by promise. Secrets that look like secrets (password=, token:, API keys) are redacted before grading. We consider this a hard requirement, not a preference; the case against candidate surveillance is its own essay.

There's a completeness objection: the shell isn't everything. Candidates edit files, and since AI is allowed, they paste in whatever a model suggested. So alongside every command and exit code we keep diffs of the files changed in the environment, all structured, none optical. And the verdict doesn't depend on the shell's honesty: grader scripts outside the sandbox check what actually changed in the cluster, independently of what the log says.

The boring superpower: it's tiny

A 45-minute interview is tens of kilobytes of command log. The equivalent screen video is a few gigabytes. Five orders of magnitude is not an optimization; it's a different category of thing. It's why keeping every command log costs nothing worth discussing, and why storage never has to decide whose interview gets deleted.

Pixels are for humans watching in real time. Evidence should be text.