Career
Engine

For a long stretch, my hands-on relationship with code, infrastructure, and deployment had gone quiet. Design work doesn't always demand it, and the tooling moves fast enough that "it's been a while" turns into a real gap if you let it sit. I needed a project low-stakes enough to experiment recklessly with and repetitive enough to actually build muscle memory — and I already had one running in the background: my own job search, tracked, at that point, in a spreadsheet with no ambition beyond staying organized.

So I turned it into a tour of the current toolchain. I built the core of the system in Claude Code, then rebuilt pieces of it in Gemini Antigravity and Codex just to see how differently each agent reasoned through the same brief. I dusted off Git and GitHub — branching, committing, pushing to a real remote — until it stopped feeling like a refresher and started feeling like fluency again. I stood up a Supabase project to relearn what an actual data layer looks like next to a spreadsheet. And I walked the full deployment path more than once: build, environment config, continuous deploy, a live URL at the end of it.

One small, satisfying discovery came out of the data along the way — cross-referencing stale "No Response" applications turned up a handful of listings that had likely been ghosted from the start, roles quietly filled while the posting stayed live. Useful, but a footnote next to the bigger shift underway: by the time the system was live, I wasn't just the designer describing what I wanted built. I was the one orchestrating the agents, shaping the data model, and shipping the deploy.

I built the core of the system in Claude Code first — an agent orchestrating an agent, effectively, since the whole point was relearning how to direct a build rather than just critique one. Once the shape of it worked, I rebuilt pieces of it in Gemini Antigravity and separately in Codex, less to compare output quality and more to see how differently each one reasoned through the same brief: what it asked before writing code, where it made assumptions, how it handled a spec that was intentionally a little vague.

In parallel, I forced myself through the fundamentals I'd let go rusty. Git and GitHub stopped being something I gestured at and became something I actually did — branching, committing, resolving my own merge conflicts, pushing to a real remote. I stood up a Supabase project specifically to relearn what a real data layer looks like: schemas, queries, relationships, instead of a spreadsheet pretending to be a database. And I walked the deployment path end to end more than once — build step, environment configuration, continuous deploy — until "ship it" stopped being a phrase I said to other people and became something I did myself.

The job-search data underneath all of it was real, not a toy dataset, which made every decision have actual stakes: a scheduled intake agent scans Gmail on a daily and weekly cadence, classifies each thread, and reconciles it against a structured reference database — one queryable record of every application instead of forty open tabs. That same database is a small, satisfying discovery generator on the side, most notably flagging listings that had likely gone stale or been quietly filled while still posted.

Twenty years of product thinking, it turns out, comes with more range than I'd been using — orchestrator, engineer, strategist, not just the designer describing what should get built. The job search ended in a signed offer at Google, which was the smaller win.