Micro-skills vs “overall level”

Scenario

The teacher says: “Ivan is at level B.” What does that mean?

Often it implies something like:

• solves ~60% of textbook exercises,
• average grade ~3.8,
• makes “typical” mistakes.

That wording hides reality. Ivan might:

• nail 2x + 3 = 11 (P = 0.95),
• struggle on 2(x − 3) = 10 (P = 0.40),
• stumble on −5x = 15 (P = 0.55).

“Level B” really means: “it varies.” That’s useless for a differentiated worksheet.

What is a micro-skill

A micro-skill (or KC — Knowledge Component) is the smallest unit of knowledge you can test with a single problem.

Examples from “Linear equations, grade 8”:

%%{init: {'theme': 'base','flowchart': {'nodeSpacing': 96,'rankSpacing': 108,'padding': 40,'curve': 'basis','useMaxWidth': true}}}%%
flowchart TB
T[Linear equations · grade 8]
subgraph row1[" "]
  direction LR
  A[Arithmetic signs] --- B[Distributive law] --- C["Expand<br/>brackets"] --- D["Move terms<br/>across ="]
end
subgraph row2[" "]
  direction LR
  E["Divide by<br/>coefficient"] --- F[Fractions] --- G[Like terms] --- H["Verify<br/>solution"]
end
T --> A
T --> E

One micro-skill — one concrete action the student can or cannot do.

Good signs of a micro-skill:

• describable in one phrase (“expand brackets”);
• testable with a problem;
• either works or doesn’t (almost);
• reused across many tasks in the topic.

Why split

Three reasons:

1. Targeted diagnosis

If something’s wrong we name what: “parentheses,” not “linear equations.” The teacher knows what to assign.

2. Precise model updates

When a student works $2(x-3) = 10$ and slips on parentheses — only that micro-skill updates, not “overall math.”

Without that one weak skill would drag all estimates down. The model would say “Ivan is weak everywhere” — false.

3. Teacher trust

Teachers trust models they can verify. Compare:

“The system says level B-minus. Assign problem 4.7.”

vs.

“Ivan’s $P(\text{brackets}) = 0.41$. This exercise trains exactly that; arithmetic, where he’s strong, won’t block him.”

The second is checkable. The teacher can skim Ivan’s work and nod.

What “right granularity” means

Not too coarse (then it bundles sub-skills) and not too fine (then you get 200 skills per topic).

A practical rule of thumb: 5–10 micro-skills per topic as taught over 4–8 lessons.

Our hackathon plan: 8 micro-skills on “linear equations.” Enough for an adaptive engine without overwhelming the teacher.

Not all skills sit on the same level

Micro-skills don’t live in isolation — there are prerequisites between them. No point handing a student a brackets task if they still mix up signs. A small picture for linear equations:

%%{init: {'theme': 'base','flowchart': {'nodeSpacing': 96,'rankSpacing': 108,'padding': 40,'curve': 'basis','useMaxWidth': true}}}%%
flowchart LR
A[Arithmetic signs] --> B[Distributive law]
B --> C[Expand brackets]
D[Like terms] --> E[Linear equation]
C --> E
F["Move terms across ="] --> E
G[Divide by coefficient] --> E

An arrow means “learn first”: e.g., without the distributive law, expanding brackets won’t click.

What that changes in practice:

• if the student is shaky on signs, the selector won’t pile brackets on top — it patches the base first;
• if a task needs “expand brackets,” the system checks the student already handles the distributive law;
• the teacher sees where to start for a struggling student: at the leftmost node where they’re still weak.

It’s not a separate model — just a prerequisite graph layered over the same micro-skills. Dependencies are marked once by the teacher; the engine takes it from there.

How Andri does it

On the MATx team, Andri Suga — a practicing math teacher — owns task tagging to micro-skills. That’s the costliest, least-transferable asset:

• slicing the curriculum into micro-skills;
• tagging each problem (which micro-skills it exercises);
• estimating relative difficulty.

That work is not delegated to AI — we deliberately don’t trust LLMs to curate math content because they hallucinate.

See full argument in docs/00-idea.md.

A problem is a set of micro-skills

Real tasks rarely test one skill. For example:

$2(x − 3) = 10$

needs all at once:

• expanding brackets (linear_eq.expand_brackets);
• arithmetic with signs (arith.signs);
• moving terms (linear_eq.move_to_one_side);
• dividing by coefficient (linear_eq.divide_by_coefficient).

When the student solves it — all four counters rise slightly. When they fail — all four dip slightly, or only the skill where they actually tripped (if we have step-level data).

How probabilities combine across skills — chapter 9 on multi-skill tasks.