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.