Finishing an assisted exercise and learning to solve it are different outcomes. Anthropic’s January 2026 coding-skills study examines learning with AI assistance; it does not establish a universal effect for every programmer. The next-day drill below is our practical self-check, not a validated interview score or a claim that tools necessarily weaken skills.

Split practice into assist and prove modes

Use AI to generate variants, counterexamples, or review prompts. Then close the assistant and solve a small representative task from memory. Explain the invariant, complexity, and failure case aloud. This exposes what the tool helped with and what you actually own.

Use a weekly evidence scorecard

Track questions you can explain, tests you can write, bugs you can isolate, and trade-offs you can defend. Do not count prompts or generated lines as progress. A scorecard based on behaviors tells you what to practice next.

Protect attention and recovery

Set a stop time, batch notifications, and use short sessions for high-effort debugging. Fatigue makes plausible output feel correct. Rest is part of verification because it improves your ability to notice contradictions.

A concrete next-day drill: a bounded task runner

Suppose yesterday an assistant helped you write a runner that processes several asynchronous jobs. Today, close that conversation. On a blank page, describe what happens when one job fails, when the caller cancels, and when the queue receives more work than it can handle. Start with behavior, not syntax.

You might remember a library function but forget whether it cancels sibling work. That is useful information. Mark the gap, predict the behavior, and then inspect the documented contract or run a tiny experiment. Do not treat a correct guess as evidence that you understand every failure path.

Change one condition without regenerating the solution

Add a requirement that completed jobs must remain available after a partial failure. Sketch what state the caller needs, then change the smallest relevant part. If you immediately need the entire original answer, the training target is state modeling rather than typing speed.

Next, introduce one failing job and explain why the observed result differs from your prediction. The objective is to find the violated assumption. You may consult documentation after making a prediction; this is a rehearsal design, not a recommendation to ignore the rules of an actual assessment.

A repeatable practice schedule with an exit condition

An example schedule is one assisted session, a short same-day explanation, and a next-day variation. Keep the same small problem until you can explain its main invariant, produce a counterexample, and modify one requirement. The exact number of minutes is not the goal, and this schedule is not a study-derived optimum.

Record three outcomes separately: “completed with help,” “explained independently,” and “adapted independently.” A task can be green in the first column and incomplete in the other two. That distinction makes progress visible without pretending that a long chat history equals mastery.

When stuck, ask the assistant for a question or a counterexample instead of a complete replacement. For the task runner, a useful prompt is “Which cancellation assumption have I not checked?” Once you have resolved that point, stop. Generating another implementation can add material without addressing the missing concept.

Your interview story can then be specific: “The first implementation worked on the happy path. During independent review I found that cancellation did not stop sibling jobs, so I changed the lifecycle and added a failure test.” Use this wording only if it describes work you actually did; the runner is an illustrative exercise.

Treat AI assistance as a hypothesis, not proof

Anthropic’s research on AI assistance and coding skills studies a specific learning setting and does not establish one effect for every programmer. The practical response is to separate what the tool helped you produce from what you can independently explain, test, and adapt.

Use three evidence columns:

Assisted completion: the task worked with help.
Independent recall: you can state the invariant, complexity, and failure case later.
Independent adaptation: you can change a requirement or debug a new failure without reopening the original answer.

A green test in the first column is not a pass in the other two.

Use a next-day variation drill

On day one, ask for counterexamples, edge cases, or review questions rather than another complete implementation. On the next day, close the assistant and solve a small variation. Change one condition: cancellation, ordering, memory, retries, or malformed input. Then explain why the original invariant still holds or where it must change.

This drill is intentionally small. A repeatable twenty-minute review is more useful than a heroic session you cannot sustain. Record the failure that surprised you and the test that would catch it next time.

Protect learning signals

Stop requesting full rewrites once the missing concept is clear. Ask for a question, a counterexample, or a test oracle. In an interview, disclose tool use when the employer’s rules require it, and be ready to demonstrate the reasoning without the tool. The goal is not to prove that you never used AI; it is to prove that the responsibility remained yours.

Anthropic: How AI assistance impacts coding skills

Next Steps

Continue with junior engineer interview foundations. For rehearsal, organize your own examples in Interview AiBox materials; this does not automatically validate the claims in your project.