I Turned Off Copilot for a Week: Field Notes
Last Monday I opened my editor settings, flipped the inline suggestions toggle to off, and left it there for seven days. No Copilot, no ghost text, no tab-tab-tab. Just me, the language server, and a suspicious amount of silence.
This was not a purity exercise. I still used AI agents for the heavy asynchronous work. That division of labor I already wrote about in June is not going anywhere. What I wanted to isolate was the autocomplete layer specifically: the ghost text that finishes my sentences hundreds of times a day. After two years of it, I honestly could not remember what typing code felt like without it.
These are the field notes, roughly in the order things happened.
Day 1 and 2: The Phantom Tab
The first thing I noticed was my left thumb. I kept pressing Tab into empty air. After a function signature, after a comment, after writing const. The muscle memory is real. I had wired "describe intent, press Tab, review output" so deeply that its absence felt like a missing stair.
Speed took an obvious hit. Boilerplate that used to appear in one keystroke now had to be typed character by character, like some kind of animal. Test scaffolding, switch arms, mapping functions between two obvious types. Day one felt roughly 30% slower on raw output. Nobody enjoys writing the fourth expect(result.status).toBe(...) by hand.
Day 3 and 4: The Recall Comes Back
Around Wednesday something shifted. APIs I use daily but had stopped really knowing started coming back. Array method signatures. The exact shape of a fetch error. Which arguments Intl.NumberFormat actually takes.
I had not forgotten these things. I had outsourced the recall. With ghost text, my working knowledge had quietly degraded from "I know this" to "I will recognize the correct version when it is suggested." Those are very different skills, and only one of them works during a whiteboard discussion, a code review, or a 2 a.m. incident.
The second shift: I started reading my dependencies again. Without an autocomplete confidently hallucinating a plausible method name, checking the actual types became cheaper than guessing. I jumped to definitions maybe five times more often than the week before. Twice, that habit surfaced a real problem: a deprecated option I had been passing for months because the suggestion engine kept suggesting it and I kept accepting it.
Day 5: The Scoreboard
By Friday the pattern was clear enough to tabulate:
| Activity | Without Copilot |
|---|---|
| Boilerplate (tests, mappers, config) | Noticeably slower. This is where autocomplete earns its rent. |
| Novel logic / actual thinking | Same speed, arguably better. Ghost text was never doing this part. |
| Debugging | Faster. I understood my own code because I had typed all of it. |
| API recall & reading dependencies | Dramatically better by day 4. |
The surprise was debugging. Every line in the diff was a line I had deliberately produced, so when something broke, the search space was small and familiar. There was no "wait, did I write this or did I accept this?" moment. Apparently I used to have that moment several times a day without registering it.
Day 6 and 7: The Flow Question
The last two days were the interesting ones, because the novelty had worn off and what remained was the actual trade-off.
Autocomplete interrupts constantly, in tiny amounts. Every ghost suggestion is a micro-decision: read it, evaluate it, accept or reject. Each one costs almost nothing. Hundreds of them per day add up to a background hum of evaluation that I only noticed once it stopped. Writing code without it felt quieter. Closer to writing prose than to reviewing someone else's PR one line at a time.
But quiet is not free. On day 7 I had to produce a repetitive migration script, and I badly missed the machine that types the obvious. Deliberate typing is a feature for logic and a tax for boilerplate.
What I Turned Back On
Monday came, and here is where I landed:
- Inline autocomplete: back on, but scoped. Enabled for test files, config, and mechanical refactors. Disabled for core business logic, where I want every line to pass through my hands.
- Jump-to-definition before accept. If a suggestion invokes an API I could not write from memory, I check the real signature first. Thirty seconds now versus a wrong belief compounding for months.
- The agent workflow stays. Delegating a whole task to an agent and reviewing the PR is a fundamentally different interaction from ghost text. It has a review boundary. The problem was never AI writing code; it was AI writing code inside my keystrokes, below the threshold of deliberate attention.
Would I recommend the experiment? Yes, precisely because it is mundane. No dramatic conclusion, no "I quit AI forever," no "10x." Just a week of noticing which parts of my skill were mine, which were rented, and what the rent actually costs. Turn it off for a week. Take notes. You will turn it back on, but you will not turn all of it back on.