I Let AI Write My Code for Four Years. The Skill I Lost Was Quiet.

Can four years of Codex create a large gap between a student who uses it every day and a classmate who does not? The answer depends on what “using Codex” means.

If it means letting AI finish assignments and projects for four years, the gap is probably small. You may even get lazier. If it means using AI every day to expose blind spots, review code, run experiments, and rebuild fundamentals, the gap will be large.

Codex, Claude Code, and tools like them are production tools. They are built to complete work, not to teach. Put them in the middle of a learning phase and they hit hard: you produce faster, but you skip the part where your own thinking forms.

I am a senior. For my first two years I wrote code the old way. I wrote a line, ran it, watched what happened. When it broke, I stared at the error, searched the docs, guessed, changed one thing, ran it again. It was slow. Every step was mine.

In my junior year I started using Claude Code. It came before Codex, at least in my feed, and I got used to it. Projects were finished in minutes. Assignments were finished in minutes. The speed and novelty tore through my study habits. What I learned that semester was a stable U.S. IP and how not to get my account banned.

In the summer I used Claude Max on an agent project. I lived inside vibe coding. Dozens of agents ran at once. The quota was generous. The output was fast. Then I opened the repository. Tens of thousands of lines. I could not read them. The README was in Chinese and I had to translate it. That was the cost of the speed.

Agent products do not fit the early learning stage. Their product goal is to take over the task. They do not care whether you learn. You give a requirement, they give a result, you accept or reject, the loop closes. Learning needs the opposite loop: you form a hypothesis, test it, make a mistake, correct it, explain it. The agent eats the middle. You are left with accept or reject.

Chat mode and IDE chat are better for learning because the thinking stays on your side. You ask for a concept, it explains. You write code, it reviews. You get stuck, it gives a hint. You finish, it asks questions. The core module is still yours. The train of thought is still yours. An agent is not forbidden. Restrict it: repetitive work only, small diffs only, tests and review required. Treat it as an intern. Do not let it become your stand-in.

Most teachers do not know how to use AI. The technology moved faster than the syllabus. They say “combine AI with learning” and leave the scale to the student. Some teachers will hand your question to AI and return the answer. I still think teachers should study pedagogy. But the institution moves slowly. You have to protect your own learning process.

What does the gap look like after four years? Everyone can use AI by then. The gap is who can explain the key code in their own project; who can debug a hidden bug the AI wrote; who can make architecture tradeoffs, design interfaces, judge performance and security; who can read a large project, locate the problem, change a small experiment, verify the result; who can survive an interview, an exam, or an outage without AI.

A student who only lets AI finish assignments has many demos and weak maintenance. The first real bug exposes him. A student who uses AI and knows the principles produces faster and judges better. AI magnifies existing ability. It also magnifies holes. If AI extends your skill, you get stronger. If it replaces your skill, you get better at leaning on it.

I am still looking for a smoother curve. Change the sentence from “AI writes, I watch” to “I write, AI reviews.”

When I start a new field, AI acts as a tutor. I keep the writing. I use chat mode for concepts, examples, and questions. I write the code. When I am stuck, I search the docs first, then ask AI to explain the error. I do not let it edit files.

In the next stage, I use IDE chat for local help. I write the pseudocode and design first. Then I ask AI for two alternative designs, a test suite, a code review, and edge cases. The core module stays with me.

During a project, the agent does repetitive work and exploration. Scaffolding, boilerplate, migrations, and batch call-site changes can go to the agent. Architecture, interfaces, core logic, tests, and final review stay with me. I limit permissions. I force small commits and CI.

For a large project, I slice it. I ask AI for a module map and call chain, but I draw the map myself. I predict what a function will do before I read the source. I read one entry point to one exit. I write a test to verify my understanding. I change one parameter and run an experiment. Tens of thousands of lines are unreadable because I lacked slicing and verification, not because I am unsuited to code.

The rules I can follow are plain. Two days a week with no AI, to keep handfeel and search skills. A design note and pseudocode before AI generates anything. Every piece of AI code needs tests, comments, and edge cases from me, or it does not count as learned. Once a month, write a small module from zero: a data structure, a parser, a small tool, an algorithm problem. Use AI as a reviewer and questioner, not an answer generator. Define daily progress as explain, reproduce, debug, transfer, verify. Not lines committed.

I also use three questions at every switch: from heating up to cooling down, from approach to distance, from trust to doubt. First, if I delete this paragraph, does the rest still connect? If yes, the paragraph is filler. Second, if I swap the project or the people, does this still hold? If yes, it is too generic. Replace it with a detail that belongs only here. Third, is this claim shown by an action or a test, or is it declared? If it is declared, go back to the code.

Four years of Codex does not create a gap by itself. The pattern creates the gap. The dangerous mistake is treating “the AI can run it” as “I learned it.”

I am a senior. If I started again, I would not reject AI. I would draw one line earlier: AI can help me move faster, but it cannot grow bones for me. Before I close the laptop, I write one small module by hand, with no autocomplete.