The other week a flaky integration test in one of our Spring Boot services started failing on the build, and I did what I do these days: I pasted the stack trace into the coding agent and went to make coffee. By the time I was back, the fix was in — a test ordering dependency, one shared fixture leaking state between two test classes. Green build. Merged by lunch.

And here is the embarrassing part: if you asked me today exactly which fixture leaked what, I would have to look it up. The agent found the bug. I just carried the coffee.

The staging environment died on a Saturday morning, and for twenty minutes everyone was sure it was a bad deploy. It was not a bad deploy. Friday evening someone had pushed a perfectly good build, and Saturday morning every call to one Spring Boot service started failing TLS handshakes. The certificate on the ingress had expired at midnight, quietly, while we were all asleep.

I have seen the long-lived database password version of the same movie too. A credential that has not changed in two years, pasted into three config files and one wiki page, and rotating it feels like defusing something because nobody knows what will break. Both outages taught me the same lesson: rotation is not a ticket you handle when it fires. It is a drill you practice until it is boring.

A few weeks ago, someone two levels above me asked a simple question: how much faster is the team with AI coding tools? I opened my mouth, and what came out was a feeling dressed up as a number. Everyone feels faster. I feel faster. The cursor barely rests before the next suggestion lands, and on a good day with a Spring Boot service I have written before, the boilerplate practically types itself.

Then I looked at our actual delivery numbers for the quarter, and the feeling did not survive contact with them. Throughput was flat. Review times were up. That gap between what my fingers tell me and what the merge log says has been living in my head ever since.

I have written about running LLMs on this laptop twice before. In late 2023 I got Mistral 7B humming away in llama.cpp and called it a glimpse of the future. Early last year the DeepSeek-R1 distills made reasoning models light enough for my hardware. Both times the punchline was the same though: local models were promising but compromised. You traded down to a smaller dense model, and you felt it in every single response.

This spring something changed, and it is not that my aging IdeaPad got faster. It did not. The models got sparser instead of smaller, and that turns out to be exactly the trade my hardware needed.

One Saturday morning I opened Task Manager before I opened my mail. There it was: a model server holding nine-odd gigabytes of RAM, alive since Friday night, with a couple of things on the machine quietly pointing HTTP requests at it. A summarisation job had run overnight against my local model, on schedule, nobody watching. Somewhere in the past year or so, without any ceremony, my laptop stopped being a machine that occasionally plays with AI and became a small server that other software depends on.

I did not plan this. When I first ran models locally back in late 2023, it was a toy: Mistral 7B in a terminal, mostly to see whether it could hold a conversation at all. Fun toy. But a toy.

Somewhere in our account there is an S3 bucket that nobody owns and everybody uses. Our Spring Boot services dump daily statements, audit exports, and application logs into it, versioning switched on years ago by someone careful, lifecycle rules configured by nobody. Last quarter I opened Storage Lens out of curiosity and just stared. One prefix held three years of files nobody had opened since the week they were written, all sitting in Standard storage, all billed every single month.

Storing data feels free because the per-GB number is tiny. Keeping it there forever, and then moving it around carelessly, is where the real money goes.