The error backlog, what happens to every wrong answer

Every wrong answer you give me goes into a backlog with a return date, a domain tag, and a reason code. Nothing gets lost in a session log. The backlog drives your readiness score, your daily task selection, and the recovery plan when you start to slip. If you've wondered where your mistakes go after you click past the explanation, this is the answer.

TL;DR

• Every wrong answer creates a cognitive_error row tagged with the question, your answer, the correct answer, domain, milestone context, and one of four reason codes.
• The scheduler returns missed items at expanding intervals on success and contracting intervals on re-fail. You don't manage a deck.
• The backlog surfaces in three places: today's task card, micro-sessions, and milestone validation gates.
• Concentrated misses on a single domain hurt readiness more than the same count spread across many domains.
• Past five unresolved errors, I inject an Error Backlog cleanup task until the count drops.
• See the live view at the error dashboard, or start your own backlog at claudelab.me.

What gets logged on every miss

When you submit a wrong answer, I write a row before the next question loads. The row carries:

• Question ID so I can resurface the exact item later, not just the topic.
• Your answer verbatim, because the choice you made tells me which distractor pulled you.
• The correct answer so the resurfaced card can show both side by side.
• Domain tag mapped to the official exam blueprint for your cert.
• Topic tag at one level finer than the domain, so I can target practice without dragging in unrelated material.
• Milestone context that records which roadmap milestone you were in when the miss happened.
• Time taken before you submitted, because rushed wrongs and confident wrongs are different problems.
• Reason code that I assign in the same write, classifying the miss into one of four cognitive types.

The reason code is the part that makes this a backlog and not a flat error log. Without a reason, every miss looks the same and the only intervention available is "see it again." With a reason, I can pick the right intervention.

The four reason codes

I tag every miss with one of four cognitive error types. The taxonomy comes straight from the error dashboard, and it shapes how the item gets resurfaced.

Code	What it means	How I treat it
MISCONCEPTION	You answered with confidence and you were wrong. The dangerous one.	Short return interval, paired explanation, extra weight on readiness.
CONFUSION	You're mixing two adjacent concepts (stateful vs stateless, IAM role vs user, etc).	Side-by-side comparison card on resurface, then a discriminating question.
ATTENTION	You knew the answer, you misread the prompt or rushed it.	Lower interval bump, no extra weight; one re-test is usually enough.
KNOWLEDGE_GAP	You haven't learned this yet.	Short concept teach first, then practice items, then a test item.

Two misses on the same topic with different codes are different errors. A misconception about VPC peering is not the same problem as a knowledge gap on VPC peering. The first needs to be argued out of you. The second needs to be taught in.

How the interval scheduler works

Items don't return on a fixed timer. They return based on how you handled the last attempt.

First miss on a topic, the item returns inside the next session or two. Get it right on the return, the interval expands. Right again, it expands further. Three or four clean attempts in a row and the item drops to maintenance frequency, which means it might come back in two weeks instead of two days.

Re-fail contracts the interval. Miss the same item on its return and it comes back faster than the first scheduled, with the reason code potentially upgraded. A KNOWLEDGE_GAP that re-fails after a teach often re-tags as MISCONCEPTION, because you've been shown the right answer and you're still not picking it. That upgrade matters; it changes the next intervention.

The point of expanding-on-success, contracting-on-fail is that you spend session minutes on the items where the minutes move the needle. You don't drill what you already know.

Where the backlog surfaces

Three surfaces in the app pull from the backlog. None of them ask you to manage a deck.

Today's task card. When I pick the daily task, the priority engine weighs backlog age, domain weight, and readiness pressure. If your weakest domain has three open misconceptions on the same topic, that's the task. If your backlog is balanced and shallow, I send you to the next roadmap milestone. The card is the single tap entry that hides this routing.

Micro-sessions. The shorter practice runs scattered through the app pull weighted samples from your backlog. Five minutes between meetings becomes a focused review of three specific items, not a random shuffle.

Milestone validation. Before I mark a milestone passed, the validation step checks whether the milestone's domain still carries unresolved errors above a threshold. If it does, the milestone doesn't pass even if your scored answers cleared the cut. The roadmap is a measurement, not a checkbox grid.

Auto-injection sits on top of all this. Past five unresolved errors, I override the next roadmap task with an Error Backlog cleanup task. The home screen shows the title Error Backlog and routes you straight to the dashboard. The roadmap pauses until the backlog stops compounding.

How the backlog feeds readiness

Readiness is a 0 to 100 number with five inputs. The backlog touches three.

Error trend is 15% of the score. It looks at whether your unresolved errors are growing or shrinking across a rolling window. Resolve faster than you accumulate, the input climbs. Accumulate faster, it falls. Full breakdown lives on readiness and decay.

Domain average is 35%. Each error pulls its domain's mastery score down, and the pull isn't linear. Five misses on the same topic in one domain hurt that domain more than five misses scattered across five domains, because the math weights concentrated weakness. The live damage is visible on the domain map where the worst domain sits at the top.

Session frequency hits indirectly. If the backlog grows past the auto-injection threshold and you avoid the cleanup task, you stop completing roadmap-required tasks, and that 15% input collapses too. One ignored backlog turns into three input drops at once.

This is why the backlog matters more than its row count suggests. A handful of unresolved misconceptions in your weakest domain can pull readiness down by ten points without any single dramatic event.

The error dashboard view

The view is plain on purpose. Open the Readiness tab and scroll to Unresolved errors. Each row shows a colored type badge, the domain, the topic, my one-line diagnosis, the age, and a Resolved button. Filter chips up top let you narrow by type. Default sort is newest first.

Tap a row to expand the full diagnosis. Tap Resolved to clear it from the active set. The row disappears optimistically and flags resolved = true behind the scenes, stopping its pull on readiness in the next recompute.

Coming back to a long list, the move is not to bulk-resolve. Filter by MISCONCEPTION, work the top three topics in a focused session, and mark them resolved as the next attempts land clean. Spread misses get cleared by repetition; misconceptions get cleared by argument. Different sessions.

When you've been away long enough that the dashboard is the smaller problem, see carry-over and recovery.

Common questions

How long do errors stay in the backlog?

Until you resolve them, or until enough scheduled returns land clean that the item drops to maintenance frequency. Resolved rows stay in the database for analytics but disappear from your dashboard. The backlog is a working set, not an archive.

Can I clear the backlog by tapping resolved on everything?

You can, and it will catch up with you. Resolved is honor-system. The next time the topic surfaces and you miss it, a fresh row logs and your readiness drops again. Filter by MISCONCEPTION, work the topic, mark resolved when the next attempt is clean. That's the order that holds.

Why did my readiness drop after I resolved a bunch of errors?

Resolving stops a row counting, but the error trend input looks at the rate of resolution versus accumulation across a window, not the absolute count. If you bulk-resolved without actually studying, the underlying domain mastery didn't move and other inputs may have shifted. Readiness reflects the full composite.

What's the difference between an error and a forgotten topic?

An error is a logged miss with a reason code. A forgotten topic is something you knew once and haven't seen recently. I track both, and both can drive your daily task, but they live in different systems. The backlog is for measured wrongs. Spaced repetition handles decay on items you got right.

Does the backlog block me from advancing in my roadmap?

Past five unresolved errors, I inject an Error Backlog cleanup task in place of the next milestone. Sessions still work, but the daily plan prioritizes cleanup until the count drops. Milestone validation also checks for unresolved errors in the milestone's domain before passing.

Start a backlog ARIA actually owns

If you've been studying with a tool that doesn't track wrongs across sessions, your real backlog already exists. It lives in your head, undated and untyped. The fastest way to externalize it is to run the diagnostic and watch where the first misses land on the domain map.

Run the free CAT evaluation at claudelab.me and the first errors land in your dashboard inside the first session. From there the scheduler does the work; you read the next task on the home card and tap Start. For the wider view of how I think about cert prep end to end, the companion piece is AI tutor for certifications.