A good day of preparation has four parts: recall what you learned before, learn one thing, practise it under time pressure, and log what went wrong.
AI fits differently in each part. It quizzes you during recall, explains during learning, stays out of the way while you practise except for hints, then grades you and helps write cards at the end.
The plan itself is simple arithmetic. Your time goes where a round counts most and you score lowest. Some weeks you'll be surprised by what it says.
- Recall: Producing an answer from memory, which is what strengthens it. Rereading doesn't do this.
- Spaced review: Seeing a card again just as you're starting to forget it.
- Mock: A full, timed round with no pauses, as close to the real thing as you can get.
Steps:
- Recall (15 minutes). Do your due cards from the revise page. No notes.
- Learn (30 minutes). One lesson, or one concept. Ask AI to explain it, then explain it back to the AI and have it find the holes.
- Practise (60 minutes). One timed task. Hint ladder only.
- Review (15 minutes). Have AI grade your work. Add your misses to the ledger and make cards.
- Update the plan weekly. New scores change the numbers.
Short on time?: Thirty minutes a day still works: 10 minutes of cards, 20 minutes on one drill. Doing that every day beats one huge weekend. If you have under 5 days, skip planning and drill your weakest round.
Explain it back: The strongest learning prompt is reversed. You explain a concept, and the AI asks about whatever you got wrong or left out. It shows you what you don't know far faster than reading does.
Prompt, Explain it back:
I'll explain [concept] to you as if you were a junior engineer. Don't correct me while I'm explaining. When I'm finished, ask me 3 questions about what I got wrong, left vague or skipped. Then tell me what a senior interviewer would still want to hear.
Prompt, Mock interviewer:
You are interviewing me for [role] at a company like [type of company]. This round is [round]. It lasts [minutes] minutes.
Ask one question at a time, and keep replies short. Probe weak answers rather than moving on. Don't teach me or give answers during the round. When I say 'end', score me 1 to 5 on problem solving, code quality, verification and communication, quoting my words as evidence.
Code, Sharing out your days. Time goes where a round counts most and you're weakest.
/** More time goes where a round counts most and you score lowest. Largest remainder keeps the total exact. */
export function allocateDays(goals: RoundGoal[], days: number): Record<string, number> {
const need = goals.map((g) => ({ round: g.round, need: g.weight * Math.max(6 - g.score, 1) }));
const total = need.reduce((a, b) => a + b.need, 0);
const shares = need.map((n) => ({ ...n, exact: (n.need / total) * days, whole: Math.floor((n.need / total) * days) }));
let left = days - shares.reduce((a, b) => a + b.whole, 0);
[...shares]
.sort((a, b) => b.exact - b.whole - (a.exact - a.whole) || a.round.localeCompare(b.round))
.forEach((s) => {
if (left > 0) {
s.whole++;
left--;
}
});
return Object.fromEntries(shares.map((s) => [s.round, s.whole]));
}
g.weight * Math.max(6 - g.score, 1): Even a strong round gets some time, so it never drops to zero need.b.exact - b.whole: Largest remainder: leftover days go to the rounds that lost the most to rounding.
Code, Building the schedule. Baseline, training, a stretch with AI off, then rest.
export function buildPlan(goals: RoundGoal[], days: number): PlanDay[] {
if (days < 5) throw new Error("under 5 days, skip the plan and drill your weakest round");
const aiOff = Math.max(2, Math.round(days * 0.25)); // the last quarter proves it stuck
const trainDays = days - 2 - aiOff; // day 1 is the baseline and the last day is rest
const counts = allocateDays(goals, trainDays);
const queue = [...goals].sort((a, b) => a.score - b.score).map((g) => g.round);
const plan: PlanDay[] = [{ day: 1, kind: "baseline", focus: "One timed mock per round, AI off. Write down your scores." }];
for (let i = 0, d = 2; i < trainDays; i++, d++) {
const round = queue.find((r) => counts[r] > 0) ?? queue[0];
counts[round]--;
queue.push(queue.splice(queue.indexOf(round), 1)[0]);
plan.push({ day: d, kind: i % 4 === 3 ? "mock" : "train", focus: round });
}
for (let i = 0; i < aiOff; i++) plan.push({ day: plan.length + 1, kind: "ai-off", focus: queue[i % queue.length] });
plan.push({ day: days, kind: "rest", focus: "Light card review only. Sleep." });
return plan;
}
Math.round(days * 0.25): The last quarter runs with AI off, to prove that the skill stuck.i % 4 === 3: Every fourth training day is a full mock.queue.push(queue.splice: Rotates rounds, so you don't do five days of one thing.Failure, Practising only what's comfortable: That's why the plan is arithmetic: it doesn't care what you enjoy.
Failure, Endless reading: If a day had no timed practice, it barely counts.
Failure, Never updating the plan: Your scores should change. If they don't, change the method.
- Why start with recall, not new material?
- Producing answers from memory is what makes them stick, and doing it first shows what's fading.
- Why does a low score on a low-weight round get less time?
- The plan weighs both. A weak round that hardly matters still gets something, but a weak round that matters gets more.
Sources:
- How I used AI to practice for my Meta interview (Individual): https://dev.to/karuha/how-i-used-ai-to-practice-for-my-meta-interview-and-got-the-offer-543n
- The best AI prompts for coding interview practice (Individual): https://paulepps.substack.com/p/the-best-ai-prompts-for-coding-interview