The Exercise Was Correct. And Still Bad. Finding the Invisible Architecture I'd Missed.

I was testing Spanish exercises and caught a strange moment.

The screen showed this task:

```text Translate into Spanish: It's probably around three in the afternoon.

Hint: Use futuro simple.

Correct answer: Serán las tres de la tarde. ```

Technically, everything checked out.

The exercise was attached to the right topic. The theory did say that futuro simple in Spanish can express not just the future, but probability in the present: Serán las cinco — "It's probably five o'clock."

And still, I got stuck on a simple question:

``text how does this relate to this topic? ``

This is where bad engineering defense of the product usually kicks in.

"But the rule is in the theory."

Sure. So what?

A recipe sitting on the kitchen counter doesn't mean a person knows how to hold a knife, dice an onion, or keep dinner from becoming a fire drill. Theory isn't skill. Theory only says what should be understood. Practice needs to know what the person should learn to do.

There was no middle ground here.

The exercise was correct. And still bad

My first instinct was to blame the generator.

Classic move: the model produced a weird exercise, slapped it onto the wrong topic, now I need to fix the prompt.

But no.

I checked. The answer was correct. The topic was correct. The rule was in the theory.

The bug wasn't where it was convenient to look.

The bug was in an assumption: if a rule is written down, I can already use it.

I can't.

To produce Serán las tres de la tarde, I didn't just need to "recall the topic." I needed to make several small moves that nobody showed on screen:

• recognize that "probably right now" isn't about the future — it's a guess about the present;
• connect that guess to futuro simple;
• remember how to conjugate ser in the future tense;
• not mix up será and serán;
• assemble a complete time-telling phrase.

On screen, it's one task.

In my head — a staircase.

I was standing at the bottom, and the system was already asking from the top step.

We skipped the practice map

That's where the real hole was.

We had theory. We had an exercise generator. Between them, everything seemed obvious: take a topic, give an assignment, check the answer.

But that's like saying: "We have a city map and a taxi, so the route will build itself."

It won't.

A city map says streets exist. A taxi knows how to drive. But a route is a separate thing entirely.

Learning needs that separate thing too.

I'm calling it Practice Map.

Not "another theory." Not "another prompt." A map of which small actions live inside a topic and what order to train them in.

In the old setup, a topic was too big a container. Inside it sat rules, exceptions, constructions, verb forms, examples, and traps. The generator received the whole topic and tried to produce an exercise.

But it had no idea which small operation I should be training right now.

That small operation is what I now call a target learning atom.

Not "future tense" in the abstract.

But specifically: recognize a guess about the present, choose futuro simple for that guess, recall the form serán, assemble the short pattern Serán las tres.

Things like these can be explained, trained, measured, and tied to a specific mistake. A big topic can't do that — it's too wide to tell you exactly where you fell apart.

Which atoms we didn't see

When I broke this example apart, I saw how much we'd hidden inside a single topic.

We had a topic: futuro simple, ir a + infinitivo, presente. The topic had theory. The theory had examples.

But underneath it sat atoms we never treated as first-class citizens:

• vocabulary level: is this word appropriate for the learner right now;
• verb form: does the learner know this specific form, not just "the verb in general";
• frequency: are we training a construction people actually use, or a rare museum piece;
• usage example: has the learner seen a similar phrase in a normal sentence;
• syntax and morphology: does the learner understand what connects to what;
• semantic neighbors: is the learner confusing related ideas, like the future and a guess about the present.

These are target learning atoms.

Not "topic completed." Not "example exists in the theory." Not "the generator can produce a sentence."

But specifically:

• can I recognize the signal "probably right now";
• can I choose futuro simple for a guess;
• do I know the form serán;
• do I understand why it's not será here;
• have I seen this construction before anyone asked me to build it from scratch.

That's what was missing.

Not data as a reference sheet.

But atoms as training targets.

Until they're isolated, the system looks at an exercise from the outside: topic matches, answer exists, everything's fine.

From the inside, there are five different small skills — and any one of them could be the hole.

One atom doesn't live in one topic

The next trap opens right away: the urge to pin each atom to a single topic.

Take the form serán.

It's needed here because we're talking about a guess in the present: Serán las tres. But the form itself doesn't belong to just this topic.

It'll show up in regular futuro simple. In exercises on ser. In sentences about time. In comparisons between "will be" and "probably is right now." In places where the learner isn't even thinking about our beautifully organized topic from the theory section.

If you make an atom part of only one topic, you get the same mess again. Just smaller pieces.

Better to think of it this way:

``text topic = context atom = trainable action link = why this atom matters here ``

Sometimes it's mandatory. Sometimes supporting. Sometimes prerequisite — can't move forward without it. Sometimes just useful, but not the main point.

And then the system starts seeing not "the whole topic" but the fabric of skills underneath it.

An atom has stages

But even that's not enough.

Even once we've found an atom, we can't throw it straight into combat.

"Recognize" and "produce" are different skills.

I can spot a rule when I see a finished example. That doesn't mean I can build the phrase from zero.

With serán, the staircase looks roughly like this:

• see a finished example and understand it's a guess about the present;
• choose futuro simple among similar options;
• given ser and the right person, recall the form;
• insert the form into a familiar pattern;
• only then assemble the answer with no hints.

These aren't new topics. They're stages of mastering one small patch on the map.

And each stage has its own difficulty.

If the system can't see this, it doesn't know where I broke down. It only sees the final answer. But what I need isn't a grade on the finish line — I need the next reasonable step.

Now the generator isn't the only one that has to work

And here's the new hypothesis: /go can no longer just pick a topic and hand it to the generator.

Before, it looked almost neat:

``text here's a topic make an exercise check the answer ``

That's not enough anymore.

A new working layer needs to sit in front of the generator. It takes a topic and breaks it into atoms: what exactly are we training right now, at what stage, with which words, which verb form, and which trap.

Only after that does the generator get its order.

Not "make something about futuro simple."

More like:

``text training: recognize a guess about the present stage: choosing between similar constructions vocabulary: only familiar words form: ser in futuro simple ``

Or like this:

``text training: the form serán stage: insert into a ready pattern pattern: ___ las tres trap: será vs serán ``

Now the generator finally finds its proper place.

It doesn't decide what to teach. It doesn't guess which piece of the topic matters right now. It doesn't pretend to be a curriculum designer.

It makes a specific exercise for a specific atom.

And /go stops being a "give me the next one" button. It becomes a small orchestrator: pick a topic, find the gap in the Practice Map, understand the stage, assemble the order, update atom progress after the answer.

Hints and explanations will eventually pull from this map too. But that's a consequence. The real work comes earlier: figuring out which atom we're even training.

There's more work now. But it's honest work.

Otherwise we keep hoping the generator accidentally lands not just on the right topic, but on the right micro-step of learning.

What I now consider the right architecture

After this mistake, I look at the architecture differently.

I used to think: there's a topic, there's theory, there's a generator. If everything is wired correctly, the system already teaches.

Now I think differently.

Between theory and generator, a Practice Map needs to live: a map of the small actions that a skill is actually made of.

Not "learning futuro simple."

But:

• recognize a guess about the present;
• distinguish it from the future;
• choose the right construction;
• recall the verb form;
• assemble a short pattern;
• check which step the person broke down on.

Only after that can /go honestly pick the next exercise.

Otherwise it's not picking the next step — just the next attempt.

From the outside, the difference is small. The screen still shows a task, an answer, and a check.

Inside, the difference is enormous.

In the first case, the system knows which atom it's training.

In the second, it's hoping the generator accidentally hit the right spot.

That hope is exactly what needs to go.

And I thought it was enough to wire up a topic, some theory, and a generator.

How naive.