I opened a blank file. No Copilot ghosting the next line. No chat window one alt-tab away. Just me, a cursor, and a feature I've built a hundred times.
And I sat there. For four minutes. Not thinking about the problem — thinking about how to start.
That was the moment I knew this experiment was going to hurt.
The rule
One week. No AI in the loop. Not "AI-lite." No chat, no autocomplete beyond my editor's dumb built-in, no "just ask it for the boilerplate." If I wanted a Zod schema, I typed the Zod schema. If I forgot the exact Intl.NumberFormat options, I read the docs like it was 2019.
Some context on why this was even a question: a month ago I ran the opposite experiment — I let AI write 100% of my code for 30 days and didn't type a line of app logic myself. It shipped a real product. I came out of it using AI for all of my typing, permanently, and I meant it.
So this wasn't me trying to prove AI is bad. I wanted to know something scarier: after leaning on it that hard, what had I actually lost?
Day 1–2: the muscle had atrophied
The first thing that broke wasn't knowledge. It was initiative.
I knew how to build the thing. I just wasn't used to being the one who starts the sentence. For a month my whole workflow had been describe → review → approve. Take that away and you find out you've quietly outsourced the hardest ten seconds of programming: the blank-page moment where you decide the shape of the solution before a single line exists.
I could still read anything you put in front of me. Generating from zero felt like speaking a language I only ever listen to now.
Day 3–4: my recall was shot — my judgment wasn't
Here's the split that surprised me, and it's the whole point of the piece.
The thing I lost was recall. Exact API signatures. The flag order. The name of that one array method. Embarrassing amounts of docs-tab-opening for things I "knew." That felt bad in the moment and turned out not to matter at all — it was always cheap knowledge, and good riddance.
The thing I kept was judgment. I still knew the billing webhook had to persist before it acknowledged — the exact bug that bit me during the 30-day run. I still smelled the N+1 before I ran the query. I still knew which abstraction would rot in six months. AI never gave me any of that. I earned it before AI, the slow way, and it stuck.
AI erodes your recall fast and your judgment not at all. So the real danger isn't for me. It's for anyone who never got to build the judgment in the first place.
Day 5–7: I got faster, and it got quiet
By day five the initiative came back. Blank files stopped scaring me. I was still slower than AI on raw output — obviously — but something else happened that I didn't expect.
I understood my own codebase again.
When AI writes it, you approve it, and you carry a fuzzy, approximate model of what's actually in there. When you type it, you carry an exact one. I caught two design mistakes that week purely because the whole system was genuinely in my head instead of sitting in a diff I'd skimmed and blessed.
The uncomfortable synthesis
There are two skills hiding inside the word "coding," and we've been treating them as one:
- Recall — remembering the syntax, the API, the incantation. AI makes this obsolete, and I'm glad. This was never the valuable part.
- Judgment — knowing what to build, what to distrust, what breaks at 2am. AI cannot give you this. You can only earn it by doing the work AI now does for you.
The trap isn't that AI makes us dumber. It's that it removes the exact practice reps that used to build the judgment — the scaffolding, the boilerplate, the wrong first draft you had to debug — and it removes them so smoothly you never notice the ladder is gone until you reach for a rung and there's nothing there.
That's the same conclusion my 30-day experiment landed on from the other direction. Letting AI do everything showed me it had replaced the junior work. Turning AI off showed me why that matters: the junior work was never busywork. It was the gym where judgment gets built.
What I actually changed
I didn't quit AI. It still types 100% of my code and always will — the typing was never the hard part, it just felt like it was.
What I added is one small ritual: once a week I open a blank file with everything turned off, on purpose. Not because I need to ship it by hand. Because the day I can't start from zero is the day I stopped being the engineer and became the guy who approves things — and an approver who can't tell right from plausible is just a rubber stamp with a job title.
It's also why, when I build agents, I never let the thing that writes the code be the thing that blesses it. An author agent, a separate skeptic agent whose only job is to refute the diff, and a human on the merge button who can still see the blast radius the model can't. That last seat — the human judgment one — is precisely the thing seven days off reminded me you can't automate away, because you can't automate the reps that build it either. That separation is the whole shape of how we build xenition, and a week coding blind is the only stress test I trust for it.
So, honest question for the comments: when's the last time you wrote real code with everything turned off — no chat, no autocomplete, nothing? And be honest about how it actually felt. Because I think how uncomfortable that answer is might be the most important metric none of us are tracking. 👇
(If this was worth your time, a ❤️ and a 🔖 help — and tell me the moment you realized you'd forgotten something you "knew.")
Top comments (0)