Case studies

Four systems, written up honestly

Each of these still runs on my laptop. I have written them up the same way: what the problem was, what I was not allowed to do, what broke, and what is still broken. The last section is the one I would be asked about in an interview, so it is the one I did not tidy up.

A local agent framework, supervised

Problem
I wanted a coding agent that keeps working while I am in class — long tasks, several steps, no one watching the terminal.
Constraints
Windows laptop, 8 GB of graphics memory, no container runtime, and the framework ships as a desktop application I do not control.
What I built
A separate runtime with a profile that only exposes the tools I allow, a launcher that runs it headless, and a supervisor that restarts it.
What broke
The supervisor hung for two hours because the launcher process stays alive while it waits for a login. A process being alive is not the same as the service being up.
Still broken
Session state is per-profile, so a restart loses the open conversation. I work around it by keeping tasks short enough to survive one restart.

The fix was a clock, not a check: after 100 seconds of "starting" the supervisor assumes the launch failed and moves on. Time-boxing a wait is the cheapest reliability tool I know.

A chat bot with layered memory and a temper

Problem
A friend group wanted a bot that remembers context across days and does not sound like a support page.
Constraints
One Windows machine, no cloud database allowed, and a chat protocol whose HTTP transport is unreliable in this build.
What I built
Four memory layers — a short rolling window, extracted facts, a profile refreshed every few turns, and a raw archive per day — all keyed by conversation so one chat never leaks into another.
What broke
The protocol library reported a healthy HTTP endpoint that never actually bound a port. Logs said "started", the socket said otherwise.
Still broken
Fact extraction is keyword-driven, so a fact phrased unusually is simply not stored. A better extractor would need a model call per turn, which costs more than this project is worth.

I stopped trusting "the service says it is up" and started trusting a socket. Every status check in the project now talks to the port, not to the log.

A plugin that reads what the browser hides

Problem
Short video links carry their content behind an anti-scraping shell: the HTML I could fetch contains no text at all.
Constraints
No API key, no login, and it had to work from inside my own tooling rather than as a separate app I have to remember to open.
What I built
A plugin that drives a real browser, waits for the page to make its own data request, and keeps that response — then exposes the parsed video, its frames and its file as three tools.
What broke
Three approaches died first: a downloader that demanded cookies, a cookie reader that could not open the browser profile, and a plain HTTP fetch that returned a 72 KB obfuscated script.
Still broken
It depends on one browser being installed and on an endpoint name that the site can rename any day. When it breaks, the fix is one line — but I will not know until it does.

The lesson was about who does the work: I could not beat the obfuscation, so I let the page do the request it was always going to do and listened.

Turning 276 slides into a document I could revise from

Problem
A statistics course shipped its material as slide decks where most of the mathematics is an image, not text.
Constraints
A deadline of one evening, a free word processor, and no OCR service I could send 276 pages to.
What I built
An extractor for the slide XML, a renderer that turns each page into an image, and a generator that composes the final document with proper tables, code blocks and running heads.
What broke
The document opened fine but the export to PDF hung forever. The cause was element order inside a table definition — a file that opens is not the same as a file that is valid.
Still broken
Formulas that were images are transcribed by hand, so a wrong symbol is invisible to the pipeline. Two of them were wrong on the first pass.

Rendering every page as an image was the decision that saved the evening: the text layer was lying, and only the pictures told the truth.

A village in a teacup

A single HTML file that draws a volcanic hot spring town inside a porcelain cup. Open it.

Problem
Build a whole landscape — volcano, springs, inns, bridges, bamboo, a shrine — and keep it readable at the size of a teacup, with no model files and no textures downloaded.
Constraints
One pasteable file. Three.js only, loaded as a module. No art assets, so every material is a colour, a gradient or something painted into a canvas at load time.
What I built
A lathe for the cup and saucer, a polar grid for the ground whose height function carves a valley ring and climbs to the wall, a cone for the volcano with three lava channels laid along its surface, five springs with their own glow, thirteen buildings, two arched bridges, forty-one bamboo clusters, a torii and six stone lanterns, a shader-driven steam field, and drifting cloud sprites.
What broke
The ground rendered black although its colours were green: the polar grid was wound the wrong way, so every normal pointed into the earth. Making the material double-sided fixed the lighting without touching the mesh.
Still broken
The steam is a particle field with velocity and drag, not a fluid simulation, and the lava is a tube on a curve rather than something that flows and cools. Both read correctly at a glance and would not survive a closer look.

The scene only started to look intentional after I raised the ground to the brim and let soil fill the cup: a bowl that is mostly empty is a bowl, but a bowl full of earth is a world.

Want the shorter version? The notes page collects the transferable parts — the checks I now run before calling something finished.