Tab to accept
Autocomplete finished my lines for about a year, and then over one summer an agent started finishing whole tickets.
In July I closed a ticket without typing any of the code in it.
It was a size chart for a client’s product pages, pulled from a metafield so their team could edit it product by product. I wrote a paragraph saying what I wanted and where the data lived.
Claude Code read the theme and found the drawer the store already used for its shipping details. It reused that instead of building a second one and added the new setting to the section’s schema. The whole thing took about 20 minutes. I’d guessed half a day.
I read every line. It was fine, honestly better than fine. If a coworker had opened that pull request I’d have approved it without a comment. I felt clever for most of the afternoon.
Then it sank in that I’d skipped the only part of the ticket I’d have enjoyed.
Half a gimmick
I’ve had Copilot in my editor since sometime last year. It suggests the rest of the line in gray text. You hit tab to accept it or keep typing. Now and then the suggestion is a whole function.
On a good day that saved real time. On a bad day it invented a Liquid filter with total confidence, and checking a suggestion like that took longer than typing the line would have.
A few of my coworkers tried it and decided it was a gimmick. I thought they were about half right. Autocomplete made me a little faster at the job I already had, which is a nice thing for a tool to do but not a new one.
I’d been trying the agents since the spring, and around June I stopped just trying them. The difference took me a while to put into words.
Autocomplete guesses the next line while I’m still holding the plan. The agent just takes the plan.
It opens the files it thinks it needs and runs the build. When the build fails it reads the error and goes around again. I hear about it when it’s done.
So the job changed shape over about a month. Most of my part now happens before any code exists, in writing down what the ticket actually wants. The rest happens afterward, in reading the diff.
The writing down is harder than it sounds. It’s the same trick as typing a question out for a channel, where about a third of the time I catch my own wrong assumption before anybody else has to.
Evangelist is a strong word
I brought it up in developer meetings. A lot. I’m aware that’s a type of person, and I’m aware I became one.
The skepticism was earned, for what it’s worth. A year of autocomplete inventing Liquid filters is a fair reason not to get excited about the next thing that promises to write your code. I don’t think anybody who waited was wrong to.
Talking about it didn’t move anybody, as far as I can tell. Screen shares did. Somebody would watch me hand it a ticket on a call and watch it go read four files they’d have had to hunt down themselves. Afterward they’d message me to ask what I’d actually typed.
The practical part was less glamorous. Most of the client repos I work in have a CLAUDE.md in them now (a page or so on how the theme is put together and which parts to leave alone). Without one the agent relearns the project at the start of every session.
I wrote most of them. Nothing I’ve written gets read more often, though the reader is a language model and I’m choosing not to think about that too hard.
Somewhere around bargaining
Grief is a big word for this, and I keep using it anyway.
I liked writing code, which I didn’t really know until this summer. It always came bundled with building things and getting them launched. I’d assumed those were the point.
It turns out I liked the coding and the problem solving more than the building and the launching. That’s an inconvenient thing to find out about yourself 10 years in.
I’ve always liked the half hour where a layout does something I can’t explain and I have to go find out why. The agent finds out why now. It’s usually right and it’s always faster, and I don’t get the half hour 🥲
For now it’s worst at CSS. That’s my favorite part, so I get to keep it a while longer. I’d call that a reprieve if I thought it was going to last.
My sense is that writing code by hand stops being most of this job within a few years. I don’t think the job itself goes away, though. Somebody still has to decide what the work is for, read the diff and know which parts of a system fall over when you breathe on them.
But the typing is going the way of hand-written vendor prefixes, and the puzzling is going with it. Nobody misses the prefixes. I’m less sure about the puzzling.
No, I don’t want to go back
I shouldn’t overstate any of this, least of all as the person who kept bringing it up in meetings. Clients get more for their money than they did in the spring. I say yes to things I’d have scoped down a year ago. And some days being this fast is its own kind of fun.
It’s even changed my mind about testing, which was not on my list for this year. I wrote in September that I’m coming around on writing tests first after a decade of passing on it. A test written before the code is a definition of done the agent can run without me.
I guess that’s the whole shift in miniature. The parts of the job that were me typing keep shrinking and the parts that are me deciding what I want keep getting bigger.
I’d be so curious to hear how this has gone for anybody else who liked the same part I did. Did the puzzle come back in some other shape once you’d been at it a while? Or did you find a different part of the job to like?