The Cast That Hid the Bug: Bridging the Gap to Production-Ready | Sai Nikhil

Sai Nikhil built Scout, a Slack agent that reads his resume and searches for jobs he could actually get, and this update covers the gap between code that works and code that's production-ready. He walks through five correctness bugs, a restructure into two clean interfaces, roughly 170 tests, and a containerized deployment, and focuses in on the quietest of the bugs: one the code had been silently compensating for the whole time.

How Scout reaches job listings

Scout's reach into job postings is built from a set of small modules, six job sources in total, each a single file with a register function that hits the employer's own public endpoint directly rather than scraping a page. Greenhouse alone serves eight different companies off a single board API. Google is the exception in this set, with no public API available at all. None of this source-specific detail is something the model itself has to learn; it reads the schemas the registry builds and picks from what's available.

The bug that hid itself

The registry works by turning a Python function's signature into a schema by reading its type annotations. But every module in Scout starts with from __future__ import annotations, which changes how Python handles those annotations: instead of being a real type, an annotation like int becomes the string "int". That meant the type map Scout built never actually matched the real parameter types. The model was effectively told that fields like days and limit were strings, when they were meant to be integers. Critically, this never surfaced as a visible failure, because both of the affected functions cast their inputs to int on the way in anyway. The bug was real, but the defensive casting downstream quietly absorbed it.

The deployment fork

A separate issue turned out to be a genuine fork rather than a bug to fix: Scout runs in Slack's socket mode, holding an outbound websocket connection to Slack and listening on no inbound port. That architecture means scale-to-zero isn't just a configuration change, because Slack has no address to reach a stopped process at and therefore no way to wake it back up. Given that constraint, Sai shipped an always-on worker instead, and documented the alternative path for later rather than forcing a scale-to-zero setup that the architecture doesn't actually support.

What the restructure bought

The bigger structural change was splitting the code into two clean interfaces: a chat backend that normalizes a single underlying provider, and a separate conversational agent interface that the Slack layer talks to. Once those two seams existed as named, explicit boundaries, the rest of the restructuring stopped being risky, because each change had a clear boundary to respect rather than touching tangled, mixed logic.

The general lesson

The distance between code that works and code that's production-ready is mostly made up of things the code is already apologizing for: a cast here, a default value there, a try-except block that quietly makes bad input work without complaint. Each one of those is a place where something upstream is already wrong, and the defensive code around it has made that problem invisible rather than fixing it.

Key takeaways

• Scout pulls job listings from six source modules, each hitting a public employer API directly rather than scraping.
• Python's from __future__ import annotations turned real type annotations into strings, breaking the registry's type map without ever throwing a visible error.
• The bug stayed hidden because defensive casting to int on ingestion silently absorbed the mismatch.
• Slack's socket mode architecture rules out scale-to-zero deployment, since there's no address to wake a stopped process at.
• Splitting the code into a normalized chat backend and a separate conversational agent interface made further restructuring much less risky.

Who this is for

This is for developers building Slack bots or agent-style tools who want a concrete example of how defensive coding patterns can mask real bugs, and for anyone weighing deployment tradeoffs around socket-based connections versus scale-to-zero infrastructure.