Python

A single readiness percentage is a number you can fool yourself with. Waypoint replaced it with ten independent gates that each pass or fail on their own evidence.

A live practice-exam submission returned a 502 and the retry said 'already submitted', leaving a permanent error in front of a button that could never succeed. The proxy had a five-second default nobody had questioned, the submit path took 29 seconds, and the first optimization made it slower. The fixes preserved output exactly or were reverted.

Listing sites edit and pull their own pages. Homestead keeps every capture as immutable evidence and rebuilds the searchable database from it, so a delisted house keeps its record.

Loupe got its first real test suite. Writing it found two things: one of the new tests could not fail, and the search feature had been silently broken since a move two days earlier while the service reported healthy the whole time.

Every mode of my study assistant returned a server error before the model was ever called. The context packet's fixed part had grown past the safety limit on its own, and one unbounded field guaranteed it would keep growing. The fix went into the shared layer three different callers depend on, with caps chosen by measurement and a degrade path before any error.

The free model on my own hardware kept failing halfway through jobs. The cause was not on my side, and the fix was to stop asking the model to write its own proof of work.

My notes could answer what I decided but not what I actually did, so I built a second searchable layer over the working history itself, and a rule for when it is allowed to be used.

I stopped picking which AI model runs each job by hand and built a router that scores the options on what each one has left, reserves the winner, and writes down why it chose.

The harness that runs my local model was reporting success unconditionally, no matter what happened. Hardening it went in four phases, each one proving the defect on the unmodified code before patching, and ended with a single terminal contract that maps every way a run can end to an honest status and exit code.

Culling a hundred-thousand-photo library should never come down to one mysterious score, so I split the decision into three plain roles that each answer a different question.

Pulled fleet health and my entire notes vault onto one gated dashboard, then added semantic search over my own work by borrowing an embedding model already running elsewhere on the network.

Reskinned davidgomez.cc into a Swiss/International typographic system, stood up a GPU box and proved face-embedding runs on it, and brought up a regenerable wiki over every one of my notes, run by hand for now.

The marketing demo stopped being a screenshot tour and became the actual Loupe app running over a hand-authored fixture, every view wired in owner mode, real detected face crops, a library full of believable junk frames, and a production deploy.

Built a reusable image generator to manufacture a synthetic photo library for the public cull demo, wired the static demo to behave like the real app across several views, and ran a code-mapping tool over the app to chart its architecture and data flow.

The whole project finally lives somewhere other than my one machine: I pushed a private backup of the repo. Then a small but careful change to how the app resolves edited renders so it stops checking thousands of network files on every restart, plus a power-outage readiness check and a move of my project notes vault out of the folders iCloud sweeps.

I merged Loupe's pipeline repo into the app repo as a folder with its history intact, untangled a code-vs-data path coupling that would have quietly broken everything, and then (right before the first push to a private GitHub repo) ran a full-history audit that came back dirty. It found a home address, GPS coordinates, and a dump of my home network's internal layout buried in old commits. The rest of the day was rewriting history to purge all of it, normalizing my commit identity, and collapsing everything to a single clean branch.

A wide day: shipped a dormant glass redesign and a fully responsive header, chased a stats box that kept clipping, traced six photo-pairing mis-binds down to a filename suffix, sorted out the faithful way to pull edited photos, relocated my notes vault, and ran a security review I'm keeping vague on purpose.

A long, many-threaded day. I built the full path that lets a second person's Apple-photo metadata become my app's enrichment database, turned the setup console into something that can actually start the pipeline stages itself, split the frontend out of the monolith, unified the brand across app and marketing site, stood up real email, and fixed a couple of bugs that had been silently breaking the photo pipeline for a while.

A long, many-threaded day: renamed both repos to loupe, shipped the Map and Cutting Room pages, built the in-app People view on top of face embeddings, redrew the brand mark down to the favicon, and stood up the onboarding front door.

Redesigned the month view's day cards into a contact-sheet film motif, polished the marketing site's desktop nav, survived a concurrent-edit collision that wiped my work off disk, and finally figured out what machine I've actually been building on.

The day Loupe stopped being a thing that only runs on my machine. I reframed it as a self-hostable product, made the pipeline portable through environment variables, scrubbed both repos clean for publishing, finalized a brand and header, fixed the photobook's repetition problem, and registered loupeculling.com for a marketing site.

Day one of the photo project: build an ingest tool that reads ~91,000 photos and videos into a SQLite database so I can cull systematically. The build went fine. The environment fought me, and the performance lessons were not where I expected.