Skip to content
AtomicReps
Guide

How to keep your coding skills when an agent writes the code

The short answer

You keep a coding skill by doing the thinking that the skill needs, and a coding agent can do that thinking for you. The studies so far agree on one pattern: people who let an AI write the code while they learn score lower once the AI is taken away, and people who use the AI to ask questions and check their understanding score higher than people who hand the task over.

Three habits keep the skill. During the task, write the parts that involve a real decision yourself. Before you accept the agent's code, ask why it made its choices and read the code. A day or more later, answer questions on the topics the task covered from memory. The third habit, retrieval practice, has the largest body of evidence of the three for remembering material weeks later; the evidence for the first two comes mainly from one small trial.

Do coding agents make developers lose their skills?

The studies so far show that people learn less from a task when an AI does most of the work, and the drop shows up on tests taken without the AI. The studies cited here measure how well people learn new material; none of them measures whether experienced engineers lose skills they already have.

In a randomized trial run by Anthropic, 52 developers learned a new Python library. The developers who had an AI chat assistant scored about 15 percentage points lower on a comprehension quiz taken right after the task (4.15 of 27 points) than developers who used documentation and web search. The largest gap by topic was on debugging questions, about 21 points, but that breakdown was not planned in advance (Shen & Tamkin, 2026). The study is one trial of 52 people and has not been peer-reviewed.

A preregistered meta-analysis of 10 programming-learning studies, with 1,069 participants, found the same pattern. When learners could still use the AI during the test, they scored much higher, by about three-quarters of a standard deviation. When the AI was removed for the test, no gain remained (the difference was close to zero), and the overall effect on learning was not significant (Maier et al., 2026). The meta-analysis is a preprint.

Outside programming, a field experiment with nearly a thousand high-school mathematics students found the same shape. Unrestricted GPT answers improved practice scores by about 48%, then left students about 17% below the control group once the AI was removed. A tutor built on the same model with added safeguards largely removed that harm (Bastani et al., 2025).

Many developers also say they feel their skills getting worse. In a poll of 3,593 developers, 63% placed their own coding skills on the diminishing side (Syntax, 2026). The poll is self-selected and self-reported, so it measures how those developers feel, not what they can do.

Which ways of working with a coding agent keep the skill?

The ways of working that kept the most understanding are the ones where the developer keeps thinking: asking conceptual questions, asking for explanations with the code, and questioning the code after the AI writes it. In the Anthropic trial, developers in the AI group who worked that way scored 65-86% on the quiz. Developers who delegated the task, relied more on the assistant as the session went on, or pasted errors back until they went away scored 24-39% (Shen & Tamkin, 2026).

Each of those groups had two to seven people, and the trial did not assign anyone to a way of working, so the split is a pattern to watch, not proof. A lab study outside programming points the same way: handing a task to a tool lowered later memory of the material, and a deliberate intention to learn almost removed that cost (Grinschgl et al., 2021).

In practice, those findings point to four things to do during a task:

  • Before you hand a task to the agent, pick the part you want to learn, such as the error handling or the data model, and write that part yourself.
  • Ask the agent why it chose an approach, and ask for the alternatives it considered, not only for the code.
  • Read the diff before you accept it, and say in your own words what each changed function does. If you cannot, ask before you move on.
  • When an error appears, form your own guess about the cause before you paste the error back to the agent.

Can a coding agent make you write part of the code?

Claude Code can, through its built-in Learning output style. An output style is a set of instructions that Claude Code sends with every request in a session. Anthropic's documentation describes the Learning style this way:

“In the Learning style, Claude adds the same Insight blocks as the Explanatory style and also asks you to write some of the code. Claude handles routine implementation itself. When it reaches a piece with a real design decision, such as error handling, a data structure, or business logic with more than one valid approach, it leaves a few lines for you.”

Anthropic, Claude Code documentation, Output styles

Turn the Learning style on with /output-style learning. The same documentation says an output style is an instruction, so it does not guarantee that something always happens, and that the Learning style produces longer responses than the Default style. Claude chooses which lines you write, and the style works only while the task is open. Nothing in the style brings the material back a week later.

How do you still remember a topic weeks after the agent finished the task?

Answer questions on the topic from memory, days after the task, and check your answers. This method is called retrieval practice, and more than a century of studies show that it produces better recall after a delay than reading the material again.

In the reference experiment, students who read a passage once and then practiced recalling it three times remembered 61% of it a week later. Students who read it four times remembered 40% (Roediger & Karpicke, 2006). A 2021 meta-analysis of 222 classroom studies, covering 48,478 students, found that quizzing raised achievement by about half a standard deviation (Yang et al., 2021).

The gap between practice sessions matters too, and the best gap grows with how long you want to remember. In one large study the best gap was about 43% of a one-week goal and about 8% of a one-year goal (Cepeda et al., 2008). A common working rule is to space reviews at about 10-20% of the time you want to remember the material for (Kang, 2016).

The limit for engineers: there are about six studies of retrieval practice on working professionals, their pooled result has a confidence interval that crosses zero, and there is no randomized trial on programming.

How do the habits compare?

The habits happen at different times and protect different things. This table compares the three on four points.

Three habits for keeping coding skills while using a coding agent
Write the hard partsQuestion the agent's codeRecall the topics later
WhenDuring the taskBefore you accept the changeA day or more after the task
What it helps withPractice at the decisions in this taskUnderstanding this changeRemembering the material weeks later
CostThe task takes longerA few minutes per changeShort sessions, separate from the task
EvidenceIndirect: the higher-scoring pattern in one 52-person trialThe same trial; groups of two to seven people, not assignedA century of studies on recall after a delay; few on professionals, none randomized on programming

Where Atomic Reps fits

Atomic Reps handles the third habit for you. When your coding agent finishes a task in Claude Code, GitHub Copilot, Cursor or Codex, it asks you questions on the topics the agent worked on, and you answer each one with a letter, from memory. Questions on a topic come back days to weeks apart, so you practice recall later without planning it.

The first two habits are still yours. Atomic Reps does not write code or review the agent's changes.

See how it works in your coding agent

Sources