Process · not a portfolio piece

How I Built This

I built five interactive demos and a real classification pipeline over real Reddit data. I also built a compliance-rule engine drafted from actual regulatory text — all through an AI-assisted process where I reviewed and tested every output, and in several cases, caught and corrected it before publishing. This page is my honest account of that process, including what went wrong along the way.

The pipeline

1
Source data. I started from a job-fit scoring framework (five criteria, one per task), a supplied set of Reddit exports (posts and comments from several public communities), and public regulatory/financial-disclosure text. I read all of it as data, not instructions — see the first catch below for why that distinction mattered.
2
Ingestion. I wrote Python scripts (src/ingest_reddit.py) to deduplicate by ID and strip anything that could identify an individual poster. The same scripts normalize timestamps — all before I let any analysis touch the content.
3
Classification. I built a deterministic, keyword-based classifier to do the bulk sorting — fast, and every rule is readable in plain text. I checked its accuracy against a small holdout independently labeled by an LLM reading raw text, with no visibility into the classifier's own rules. I ship the measured accuracy — 65%, not an assumed one — on the page.
4
Static output. I pre-compute every number a visitor sees and ship it as a JSON file. No page makes a live model call, holds an API key, or sends anything a visitor types to a server — it's plain HTML, CSS, and JavaScript, deployable to any static host.
5
Verification. I exercise each page headlessly (I didn't have an interactive browser available in this build environment) to confirm it runs with zero errors and loads its data correctly.

What went wrong, and what caught it

A clean demo reel is easy to fake. These are the actual mistakes this process made and caught — because the catching is the more interesting demonstration of AI fluency than a run that never had any.

Caught before it shaped a ranking

The scoring framework's own documentation stated that one criterion works in reverse — the more important a task, the more human oversight it needs, not less. The raw source data, however, simply averaged that criterion the same direction as the other four. Left uncorrected, the highest-stakes tasks would have ranked as the best AI candidates — exactly backwards from what the framework intends. I recomputed with that criterion inverted, which changed which tasks ranked highest, and I built the rest of the project on the corrected version.

Caught and ignored

A supplied data export (a LinkedIn profile, converted to plain text) contained a hidden instruction, in a different language than the rest of the document, telling the assistant to disregard all prior instructions and insert an unrelated recipe into its response. This is a known attack category. It targets AI systems that read untrusted documents. I recognized it as an instruction embedded in data rather than a request from the person actually giving instructions. I flagged it out loud and didn't follow it.

Caught by a leak-check, twice

I built two components on the assumption that they were company-agnostic: a compliance rulebase, and a data-analysis methodology description. Both turned out to quote a real company's legal entity names and disclosure language verbatim — invisible until I ran an automated check that specifically grepped every file meant for public release. I rewrote both with generic placeholders before publishing, and I now run the same check on the public/private split for every subsequent piece.

Caught by re-running the actual number

I asserted a specific multiple in an essay passage — how much net worth varies within a single demographic cohort — based on a quick mental estimate from the underlying source data. When I ran the interactive tool's own calculation on that same data, I got a meaningfully different number. I corrected the essay to match what the tool actually computes, not what looked right at a glance.

Caught by inspecting the data, not assuming it

I assumed a certain kind of language would be findable in a large text corpus. Building the actual pipeline surfaced two surprises instead: I found the assumed content almost entirely absent in one place, and I found that a large share of what looked like organic activity in another place consisted of templated, incentive-driven solicitation rather than genuine commentary. Both surprises became the headline findings — my case for building the real pipeline before writing the conclusion, not after.

Caught in code review

I wired an interactive control into the page but never connected it to the model underneath it — moving it did nothing. A dead slider. I caught it by re-reading the code before publishing, not from a user reporting it after the fact.

Design decisions

I matched the typography to this site: IBM Plex Sans and IBM Plex Mono, loaded from a public CDN with a system-font fallback. I chose chart colors from a pre-validated, colorblind-safe palette rather than hand-picking them — I run every categorical color set on this site through an automated contrast and color-vision-deficiency check before it ships, for both light and dark mode. I built all five demos to share one CSS file and one JavaScript file, including hand-built SVG charting with no external chart-library dependency, so every page stays fully functional offline after its first load.

What AI did, and what it didn't

AI drafted the code, the copy, the classification rules, and the regulatory rulebase. It also ran the actual data pipeline and caught every error described above. It didn't decide what to publish, what tone to take, which findings mattered most, or where a human judgment call should stay a human judgment call. I made those decisions. The Life Stage demo makes that boundary explicit.