I used to love this job differently

I used to love this job differently. Something changed when AI moved into my editor. Six memories that keep coming back.

I used to love debugging

Starting a Spring Boot application, watching the startup logs scroll past, setting a breakpoint somewhere deep, then walking through the code one line at a time. Stepping into a method I wrote. Then into one I didn't. Then into a third-party library to see what it was actually doing. By the time I found the bug I knew the system better than the fix required.

The moment of realization was the best part. An hour of stepping through, then suddenly seeing it. That's the off-by-one. That's the cache nobody invalidated. That's the transaction that committed too early. A breath I didn't know I was holding.

Now I paste the stack trace and read the answer. I don't even need the project running locally. The patch lands clean. The map of the system I would have built is missing.

The stubborn one

A bug that wouldn't go for days.

Heading home with it still in my head. Thinking about it on the Hibiya line out of Ebisu. Still on it when the doors opened at Akihabara. Trying to fall asleep and going over the path one more time. A possible cause arriving on Sunday afternoon while doing something else. Getting back to the laptop just to check. Opening the project. Running the case. Watching it fail in the same way. Or sometimes, watching the cause finally show itself.

The bug was a roommate for those days. I lived with it. When it broke, I knew exactly why.

After enough of those, the title of a client ticket was usually enough. One line, and I knew roughly where in the code to look before I opened the project.

Now I paste the error and the context. The model proposes three causes. One of them is right. The bug is gone by lunchtime.

A quieter one

Code that read well.

Fetching the rows you actually need. A Java stream. A map that turns the row into the shape the caller wants. A Collectors.groupingBy. A collect. Reading the chain back and seeing the data flow through it left to right, every step named, nothing extra. Reformatting three times until the line breaks fell in the right places.

Map<CustomerId, List<OrderView>> byCustomer = orderRepository
        .findPlacedSince(cutoff)
        .stream()
        .map(OrderView::from)
        .collect(Collectors.groupingBy(OrderView::customerId));

The code did one thing and looked like it. That was the point.

Now the model writes the chain. The first version usually works.

The rare one

A problem that wanted recursion.

Realizing a tree had to be walked. Or that the shape of the input was the same as the shape of the subproblem. Writing the base case first. Then the recursive call. Three lines that handled an arbitrary depth. Reading it back, knowing it would work for inputs I hadn't thought of yet. Half a second of pride that lasted the rest of the day.

Now the model writes the recursion. Sometimes it adds memoization I didn't ask for. The tree gets walked. I move on.

The other joy

Making a query faster.

The slow query log had been enabled since day one. That's production hygiene, not the work. The fun came months later. A permission check that used to take 20ms now took 800ms because the join scaled badly. A load test that surfaced the one query melting the box. A morning sat with what the log had been quietly collecting.

I'd pick a query. Generate a few hundred thousand rows of representative data on a local copy so the planner had something to chew on. Try a subquery. Try a CTE. Force an index hint on a join the planner kept misreading. Read EXPLAIN before and after. Watch a 2-second query drop to 40ms.

Half a day would disappear. Not because anyone asked. Because I wanted to know why.

Now I paste the query and ask. The model suggests three indexes and a rewrite. One of them works. The query is fast. I move on.

The slow one

Days of system design before a line of code.

An infrastructure diagram on drawio. VPC, Subnets and ECS tasks, RDS. Asking where the choke point would be at ten times the load. A database schema in a notebook. Indexes worked out from the access patterns. An API surface drawn as a list of resources and the questions about idempotency and pagination that came with each one. Sleeping on it. Erasing half of it the next morning. Coming back with something simpler.

The system existed in my head before it existed in the repo. By the time I started writing, every file knew its job.

Now I describe what I want. The model proposes an architecture. It looks reasonable. We start.

What's left

The answers still come. The path to them is gone. With it went the map of the system I would have built, the pride that lasted the day, the bug that lived with me. I move faster now. I outsource the figuring out. The intuition I built up over years is thinning. I think my brain is going soft. Something is quieter. I don't know what to do about it.