Can't code without AI? A 4-week recovery plan
Published
By the Unrust team · 10 min read · Editorial method
Can't code without AI? Take a 4-check test with the assistant off, then train your weakest check 15 minutes a day for 4 weeks, with a re-test each Friday.
Short answer: test the gap, then train your weakest check
If you can't code without AI, test the gap with the assistant off: write a small function from a one-line spec, predict output before you run it, find a planted bug by reading, and explain each variable. Then train your weakest check for 15 minutes a day over four weeks, using AI only after your own attempt.
The plan is small enough to hold in your head. The sections below fill it in: four checks with runnable examples and answers, a table that turns a miss into a first drill, a week-by-week schedule with a Friday re-test, and a miss log. The 35-minute test, the pass-3-of-4 rule and the 15-minute slot are our own starting points, not researched doses or validated cut-offs.
Nothing here says AI caused the gap, and nothing asks you to stop using it. One sitting cannot separate rusty skills from an unfamiliar task or a bad day, so the plan measures first and trains only what the measurement shows.
Day 1 Self-test: 4 checks, 35 minutes, assistant off. Pass 3 of 4 = small gap.
Weeks 1-2 15 minutes a day on your weakest check. Attempt first, then compare.
Week 3 Add your second-weakest check. Friday: full self-test on new tasks.
Week 4 Train what you missed. Friday: full self-test again.
Done when Two full self-tests in a row pass at least 3 of 4.The four-check self-test: 35 minutes with the assistant off
Close the assistant, turn off autocomplete and inline suggestions, and keep search and documentation shut. Use the language you work in: the examples alternate between Python and JavaScript, and TypeScript readers can use the JavaScript versions. Set a timer for each check, write your answer in a file before you run anything, and open an answer only after the timer ends.
Each check is closest to one of the six skills in Unrust's free diagnostic, so a miss points at something you can practise. The checks are small on purpose: one that needs a framework or a project would measure your setup, not your coding. The table lists all four.
Every program in this post was run on CPython 3.11.18, 3.12.16, 3.13.18, 3.14.10 and 3.15.2 and on Node.js 18.20.4, 22.11.0, 22.23.5 and 24.11.0 on November 20, 2026. The outputs in the answers are what those runs printed, and they were identical on every version.
# Check You do (assistant off) Box Pass when Closest skill
- ---------- ------------------------------ ------ ---------------------------------- -------------
1 Blank file Write a function from a spec 10 min 3 of 3 calls match, 2 runs max Recall
2 Predict Write a program's output first 8 min Every printed value matches Tracing
3 Break it Find a planted bug by reading 7 min You name line, symptom, fix first Debugging
4 Explain it Say what each variable holds 10 min Your table matches a printed trace Find the FlawCheck 1: write it from a blank file (10 minutes)
Open an empty file and write the function from the spec below. No search, no autocomplete, no pasted code. You pass if all three calls give the expected label within 10 minutes and you ran the code at most twice.
This checks whether you can produce syntax, string formatting and a loop from memory. If you freeze, write the three expected results as asserts first, then the smallest code that makes them true. Starting from the examples counts as a pass; starting from a search does not.
# Spec: format_bytes(n) turns a byte count into a short label.
# Under 1024 it is whole bytes. From 1024 up, divide by 1024 per
# step (KB, MB, GB) and show exactly one decimal place.
#
# format_bytes(512) -> 512 B
# format_bytes(1536) -> 1.5 KB
# format_bytes(5 * 1024**2) -> 5.0 MBReveal the answer and explanation
Any version that prints 512 B, 1.5 KB and 5.0 MB passes. The reference below returns whole bytes under 1024, then divides by 1024 once per unit and formats one decimal. The last-unit check ends the loop at GB, so a huge value cannot fall off the end of the list.
Once you pass, run two more values. format_bytes(1023) prints 1023 B, but format_bytes(1048575) prints 1024.0 KB: the loop compares before it formats, so a size just under 1 MB rounds up to 1024.0 without changing unit. The spec never said what to do there. If 1.0 MB is the answer you want, compare the rounded size, round(size, 1) < 1024, instead of size < 1024.
def format_bytes(n):
if n < 1024:
return f"{n} B"
size = float(n)
for unit in ("KB", "MB", "GB"):
size /= 1024
if size < 1024 or unit == "GB":
return f"{size:.1f} {unit}"
print(format_bytes(512)) # 512 B
print(format_bytes(1536)) # 1.5 KB
print(format_bytes(5 * 1024**2)) # 5.0 MB
print(format_bytes(1023)) # 1023 B
print(format_bytes(1048575)) # 1024.0 KBCheck 2: predict the output, then run it (8 minutes)
Read the program and write down what each of the three console.log calls prints before you run anything. You pass if every value matches; spacing inside the brackets does not count. The function pays a list of charges in order from a balance.
Predict from the code, not from what the function is meant to do. A trace table helps: one row per charge, with the balance before, the action and the balance after.
function payInOrder(balance, charges) {
const paid = [];
for (const [name, amount] of charges) {
if (amount > balance) continue;
balance -= amount;
paid.push(name);
if (balance === 0) break;
}
return [balance, paid];
}
const charges = [["rent", 70], ["gym", 50], ["tea", 30], ["pen", 0]];
console.log(payInOrder(100, charges));
console.log(payInOrder(30, charges));
console.log(payInOrder(0, charges));Reveal the answer and explanation
The calls print [ 0, [ 'rent', 'tea' ] ], [ 0, [ 'tea' ] ] and [ 0, [ 'pen' ] ]. In the first call, rent leaves 30, gym (50) does not fit and is skipped, tea leaves 0 and the break fires, so pen is never reached.
The third call is the one that separates reading from guessing. With a balance of 0, rent, gym and tea are all skipped, but pen costs 0, so amount > balance is false and it is paid. The balance === 0 test only runs after a payment, so a balance that starts at 0 is not caught.
If you missed it, the fix is a habit, not a fact: write the trace table before you run. It takes about two minutes, and the zero case shows up in the last row.
// payInOrder(100, charges)
// charge amount balance before action balance after paid
// ------ ------ -------------- --------------- ------------- ---------
// rent 70 100 pay 30 rent
// gym 50 30 skip (50 > 30) 30 rent
// tea 30 30 pay, then break 0 rent, tea
// pen - - not reached 0 rent, tea
//
// payInOrder(0, charges)
// charge amount balance before action balance after paid
// ------ ------ -------------- --------------- ------------- ----
// rent 70 0 skip (70 > 0) 0 -
// gym 50 0 skip (50 > 0) 0 -
// tea 30 0 skip (30 > 0) 0 -
// pen 0 0 pay, then break 0 penCheck 3: find the planted bug by reading (7 minutes)
The function should return the average of every run of k consecutive values, and its two spec examples are in the comments. Read it and name the line, the symptom and the fix before you run anything. You pass if you can do that within 7 minutes.
Running it first turns this into a different check, so wait. The point is to find a defect by reading.
def moving_avg(xs, k):
"""Return the average of every run of k consecutive values."""
return [sum(xs[i:i + k]) / k for i in range(len(xs) - k)]
# The spec says:
# moving_avg([1, 2, 3, 4], 2) returns [1.5, 2.5, 3.5]
# moving_avg([5, 7], 2) returns [6.0]Reveal the answer and explanation
The bug is range(len(xs) - k). The last window starts at index len(xs) - k, and range stops before its argument, so the loop never builds the last window. For [1, 2, 3, 4] with k = 2 it returns [1.5, 2.5] instead of [1.5, 2.5, 3.5], and for [5, 7] it returns [] instead of [6.0].
The fix is one term: range(len(xs) - k + 1). The quickest way to find it by reading is to count windows for the smallest example. [5, 7] with k = 2 holds one window, and range(0) gives none. When there are fewer than k values the range is still empty, so the function returns an empty list.
The habit to keep: check the last window by hand before you trust a window loop. Our post on off-by-one loop boundaries goes through more cases.
def moving_avg(xs, k):
"""Return the average of every run of k consecutive values."""
return [sum(xs[i:i + k]) / k for i in range(len(xs) - k + 1)]
print(moving_avg([1, 2, 3, 4], 2)) # [1.5, 2.5, 3.5]
print(moving_avg([5, 7], 2)) # [6.0]
print(moving_avg([1, 2], 3)) # []Check 4: explain it, variable by variable (10 minutes)
This program finds the hour with the most timestamps. For each variable, write what it holds after every pass of each loop: counts after each timestamp, then best and n in the second loop. Then answer two questions without running it: what does the call print, and what does it print if you add a fifth timestamp, 2026-11-21T10:59?
You pass if your table matches a printed trace and both predictions are right. This is the skill you lean on when you review code an assistant wrote: if you cannot say what best holds after each pass, you cannot say whether its tie-break is intended.
function busiestHour(stamps) {
const counts = new Map();
for (const ts of stamps) {
const hour = ts.slice(11, 13);
counts.set(hour, (counts.get(hour) ?? 0) + 1);
}
let best = null;
for (const [hour, n] of counts) {
if (best === null || n > counts.get(best)) best = hour;
}
return best;
}
const stamps = ["2026-11-20T09:05", "2026-11-20T10:15", "2026-11-21T09:45", "2026-11-21T10:30"];
console.log(busiestHour(stamps));Reveal the answer and explanation
It prints 09. The first loop builds counts in insertion order: 09 has 2 and 10 has 2. The second loop replaces best only when a count is strictly larger, so on the tie, 10 does not replace 09. With the fifth timestamp, 10 has 3 and wins.
Two details decide it. ts.slice(11, 13) picks the two hour characters of an ISO timestamp, and a Map iterates in insertion order. Change > to >= and the tie goes to 10. The tie-break is a choice made by one character, and nothing in the description of the function states it.
// loop 1: timestamp -> hour -> counts after the pass
// timestamp hour counts
// --------- ---- --------------
// ...T09:05 09 {09: 1}
// ...T10:15 10 {09: 1, 10: 1}
// ...T09:45 09 {09: 2, 10: 1}
// ...T10:30 10 {09: 2, 10: 2}
//
// loop 2: Map entry -> best before and after the test n > counts.get(best)
// hour n best before best after
// ---- - ----------- ----------
// 09 2 null 09
// 10 2 09 09
//
// result: 09. Add "2026-11-21T10:59" and 10 has 3, so the result is 10.
// Change > to >= and the tie goes to 10.Score it and choose your first drill
Give yourself one point per pass. Three or four points is a small gap, and the plan works as maintenance; two or fewer means start the plan. Treat that cut-off as our rule of thumb: a single sitting is a snapshot, and it cannot say why a check was missed. Your weakest check is the one you missed by the widest margin: the most wrong values, the check you abandoned at the timer, or the one where you reached for a search first. With four passes, pick the check that took longest against its box.
Read the table below as a pattern of misses, not a diagnosis. A blank editor can mean rusty syntax, an unfamiliar library or a task that was larger than it looked. The drill is the same in every case: attempt first, compare second, log the difference.
What happened Check Daily 15-minute drill Friday re-test
---------------------------------- ----- ---------------------------------------------- ----------------------
Blank editor, or searched first 1 Rewrite a 10-line helper from its docstring New spec, 10 min
Predicted values were wrong 2 Write a trace table before each run New program, 8 min
Read the bug, still missed it 3 Name one cause, run the cheapest check New planted bug, 7 min
Could not say what a variable held 4 One sentence per variable per pass, then print New function, 10 minThe four-week plan: 15 minutes a day, five days a week
Every day has the same shape: 2 minutes to pick a task, 8 minutes to attempt it with the assistant off, 3 minutes to run it and compare, and 2 minutes to write one line in the miss log. The schedule is ours, not a researched dose. Five days a week is five hours over the month, and a missed day restarts nothing.
Week Daily 15 minutes Friday, assistant off Move on when
---- ------------------------------------------------- ------------------------- ------------------------------
1 Weakest check, small tasks Same check, new task It passes
2 Same check, 1-2 edge cases per task Same check, new task It passes
3 Second-weakest check Mon/Wed/Fri, weakest Tue/Thu Full self-test, new tasks Test done, misses logged
4 Any check you missed on the week 3 test Full self-test, new tasks Two tests in a row pass 3 of 4Pick tasks, re-test on Fridays and keep a miss log
Pick tasks from your own code (rewrite a helper from its docstring), from the practice material linked below, or by breaking a working function yourself and coming back to it the next day. For tracing, our posts on code tracing questions and trace tables have worked problems. For planted bugs, the ten programs in our Python debugging exercises post each come with an answer. For blank-file drills, the code recall guide has a three-step practice routine.
A Friday re-test uses a new task with the same box and the assistant off. Use a different task each time: repeating the same one tests whether you remember its answer. If a re-test fails, repeat that week once with smaller tasks: shrink the task, not the checking. The plan ends when two full self-tests in a row pass at least three of the four checks; if week 4 does not get you there, repeat week 4.
The log is what makes the plan measurable. After each session write one line: the check, what you missed, the smallest rule that would have caught it, and whether you used help. The rows below are invented to show the format; they are not user data.
Day Check What I missed Rule for next time Help used
--- ----- ---------------------------------- -------------------------------- ----------------
2 3 Loop bound dropped the last window Hand-check the last window none
3 2 Missed the break on a zero balance Trace the zero case first none
4 1 Compared before rounding near 1 MB Test the value just below a unit hint after 8 minWhere AI fits while you rebuild, and an outside check
Keep using AI for real work. The plan changes one thing: in each 15-minute practice slot your attempt comes first and the assistant second. After your attempt, ask it to explain a miss, to give you a counterexample to your function, or to review your fix. Do not ask it for the next attempt. Fill in the help column of the miss log, so a guided solution is never counted as an independent one.
For what research does and does not show about learning with assistants, read our earlier post on keeping your coding skills while using AI. It covers the Anthropic and METR studies and their limits, so this page does not repeat them.
For an outside check, the free diagnostic runs about 14 minutes with AI, autocomplete and lookups off, and it needs no account. It samples six skills and gives each a band from Sharp down to Offloaded. Take it on day 1 and again in week 4. Unrust's results page calls one session a rough read, says a low skill can mean unfamiliarity rather than decay, and suggests a retake after about 2 to 3 weeks. A free account keeps each dated read, so the second one has a baseline.
Questions about coding without AI
Can you code without AI? Yes, to some degree, and 35 minutes shows how far. Run the four checks with the assistant off: write from a spec, predict output, find a planted bug, explain each variable. Passing three of four is our rule of thumb for a small gap, not a validated threshold.
Why can't I code without AI anymore? We cannot tell you why from here, and one sitting cannot separate rusty skills from an unfamiliar task, a new language or a bad day. The four checks show which skill to train, not what caused the gap. Train that check for 15 minutes a day and re-test on Fridays.
How do I code without AI, and how do I know I have got it back? Spend 15 minutes a day on one check: pick a task, attempt it with the assistant and autocomplete off, then run the code and compare. You have got it back when two full self-tests in a row pass at least three of four checks on new tasks. That exit rule is ours.
How do I learn to code without AI? If you are rebuilding skills you once had, follow the four-week plan above, starting with your weakest check. If you are learning from zero, use a beginner course, write every first attempt yourself, and ask an assistant to explain or critique it afterwards. This page is practice and a test, not a course.
Do I have to stop using AI to get my skills back? No. Keep using it for real work. The plan asks only that your first attempt in each 15-minute practice slot is made with the assistant off, and that you use it afterwards: to explain a miss, produce a counterexample or review a fix. Nothing on this page says AI use caused the gap.
Questions from the community
These public discussions informed the question this article answers. They reflect personal experiences, not evidence of how common a problem is or what caused it. Sources checked October 28, 2026.
- Reddit r/Bard: “I can not code without AI”
Listed in Google's discussion results for “can't code without ai” on November 20, 2026. Cited by title only: our tools could not open the thread, so this page makes no claim about what it says.
- Reddit r/learnprogramming: “How do I do a project without using AI.”
Listed in Google's discussion results for “can't code without ai” on November 20, 2026. Cited by title only: our tools could not open the thread, so this page makes no claim about what it says.
References and next steps
- Python documentation: range
- Python documentation: format specification mini-language
- MDN: Map
- Unrust guide: What is unassisted coding?
- Unrust guide: What is code recall, and how do you practice it?
- Unrust guide: What is code tracing?
- Unrust guide: How do you debug code without AI?
- Unrust blog: How do I keep my coding skills while using AI?
- Unrust blog: How do I get back into coding after a long break?
- Unrust blog: Why do I understand code but forget how to write it?
- Unrust blog: Python debugging exercises: 10 bugs to fix
- Unrust blog: Code tracing questions: 10 practice problems with answers
- Unrust blog: Trace table examples: how to trace a loop by hand
- Unrust blog: Find an off-by-one error before running the loop
- Learn what a short unassisted session can and cannot show
Get a baseline before week 1
Take Unrust's free diagnostic with AI and hints closed: about 14 minutes, no account needed. Use the per-skill read to choose which check to train first, then retake it in about 2 to 3 weeks.
More from the blog
- How do I keep my coding skills while using AI?
AI & coding skills · 9 min read
- Python debugging exercises: 10 bugs to fix
Python · 16 min read
- Idiomatic Python: 10 patterns with examples
Python · 15 min read