From “Asking for Knowledge” to “Being Guided”: A Shift in AI Learning

1. Root Cause: Why AI Often Gives “Standard Answers”

When we directly ask AI “How should I learn Python?”, the answer is often complete, well-structured, and broadly applicable. It may look professional, but its practical value is limited: it assumes you are a blank slate and starts from the most basic concepts. You may already know most of them and only want to explore a specific difficulty.

The core problem is that the AI’s default “starting level” is uncertain. For the same question, it may provide a high-school-level explanation or a graduate-level derivation, depending on whether the context contains information about you. Without that information, the AI can only fall back to the statistical “average answer.”

A deeper issue is metacognition: knowing what you know, what you don’t know, and what you want to know. These three things must be clear to both the AI and the learner. In a traditional classroom, a teacher may decide whether a step should be skipped. With AI, it will not proactively make that judgment for you—the responsibility falls on the learner.

2. Design Idea: Translating Cognitive State into AI Signals

For AI to align accurately with your level, you need to provide at least three types of information:

• What you currently know (the boundary of existing knowledge)
• How deeply you understand what you already know (the level of cognitive depth)
• What goal you want to achieve (a specific definition of the end of learning)

The more specific the goal, the clearer the capability description, and the easier it is to articulate your current confusion—so the more accurate the AI’s answer becomes. However, if you have to manually provide this background in every conversation, the cost is high and it feels unnatural. A “profile system” is therefore needed to persist this information, allowing the AI to load your cognitive profile at the start of each conversation.

3. Layered Architecture: Three-Level Progressive Loading

A progressive-loading directory structure is recommended. The core idea is “expose details layer by layer according to the needs of the conversation,” avoiding the need to feed a large amount of information to the AI all at once.

skill-system/
├── index.md                  # Layer 1: global index (<=100 lines, always loaded)
├── Python Asyncio/
│   ├── profile.md            # Layer 2: domain profile (<=150 lines, loaded on demand)
│   └── notes/                # Layer 3: issue notes (<=300 lines, retrieved by keyword)
│       ├── event-loop-understanding-bias.md
│       └── cookie-sharing-approach.md
├── Machine Learning/
│   ├── profile.md
│   └── notes/
│       ├── backpropagation-intuition.md
│       └── vanishing-gradient-analogy.md
└── ...

This design borrows from the idea of cache hierarchy: information that is more frequent and more overview-oriented should be placed in earlier layers; information that is more detailed and occasional should be placed in later layers and retrieved only when needed.

Layer 1: index.md Global Index

This is the “master outline” that the AI must load at the start of each conversation. It should not pile up knowledge details. Instead, it should answer one meta-question: “What is this person currently learning?”

Recommended fields include the list of domains currently being learned or researched, the overall goal for each domain in one sentence, and the stopping point of the most recent conversation along with the next-step plan.

# Learning Index
## In Progress
- Python Asyncio: goal is to move from “can use libraries” to “understand event loops and concurrency models”
- Machine Learning: goal is to understand the mathematical intuition of backpropagation and vanishing gradients
## Next Step
- Explain the event loop model to verify whether the understanding is correct
- Do a handwritten derivation using a vanishing gradient case

Its value is that the AI knows your “current coordinates” at the beginning of each session and does not diverge aimlessly.

Layer 2: profile.md Domain Profile

When a conversation enters a specific domain, the AI loads the corresponding profile.md on demand. It records a “cognitive slice” of that domain:

• Mastered: knowledge points that you can actively explain and apply in practice
• Partially understood: concepts you know but cannot derive clearly or explain with sufficient analogies
• Blind spots: parts that are completely unfamiliar or have previously been misunderstood
• Target level: the depth of understanding you hope to achieve (can use / can derive / can transfer)

# Python Asyncio Capability Profile
## Mastered
- async/await syntax and basic coroutine usage
- Starting the event loop with asyncio.run
## Partially Understood
- The internal scheduling mechanism of the event loop (only know “there is a loop,” but cannot explain when switching occurs)
- Why blocking operations can stall the entire event loop
## Blind Spots
- How multiple coroutines share context, such as cookies or sessions
## Target Level
Move from “can call” to “can explain scheduling timing and refactor blocking code”

The key is the distinction between “partially understood” and “blind spots.” Partially understood items are often the highest-value learning target: the foundation is already in place, only the final step is missing, and the AI can most easily help you fill the gap.

Layer 3: notes/ Issue Notes

This is the finest-grained layer. Each note focuses on a specific question, attempt, or correction. It does not need to be highly structured; instead, it records “traces of thinking”: what I previously misunderstood and what approaches I tried.

# Event Loop Understanding Bias
## Wrong Understanding
I thought the event loop was “a new thread spinning continuously.”
## Corrected Understanding
The event loop runs on the main thread, uses I/O multiplexing to monitor ready events,
and yields the CPU only when there are no ready callbacks. It is essentially cooperative scheduling based on a ready queue.
## To Verify
Will executing a blocking sleep inside a coroutine stall the entire loop?

These notes turn misunderstandings into searchable and reviewable assets. When the AI reads a note, it can precisely correct your previous mental model instead of explaining from scratch.

4. Collaborative Workflow: How the Archive Drives Conversations

When the three layers are connected, they form a complete AI learning loop:

1. Load index.md at the beginning: the AI understands your overall coordinates and next-step goal.
2. Locate the domain and load profile.md: the AI aligns with your level in that domain, skips what you have mastered, and focuses on partially understood areas and blind spots.
3. Retrieve notes/ as needed: the AI pulls up your past specific questions and correction records for precise answers.
4. Write back to the archive after the conversation: new mastery, newly exposed blind spots, and new questions should be written back into profile.md and notes/ so the archive continues to evolve.

[Start] → Read index.md → Set target
   ↓
[Enter domain] → Read profile.md → Align level
   ↓
[Answer specific question] → Retrieve notes/ → Correct precisely
   ↓
[End] → Write back profile.md / notes/ → Archive evolves

The most easily overlooked step is the fourth one—writing back. The archive is not a one-time static document; it is a living system that updates as learning progresses. Without write-back, the archive quickly becomes outdated, and the AI falls back into “average answer” mode.

5. Practical Advice and Common Pitfalls

• Keep the “partially understood” list fresh: it is the area with the highest return on investment, so prioritize maintaining it.
• Write goals in a verifiable form: “can use” is vague, whereas “can write a producer-consumer model from memory without documentation” is a verifiable goal.
• Allow notes to be rough: they do not need to be carefully worded; recording the trace of thinking is itself valuable, and the AI can help complete the expression.
• Periodically perform a “cognitive check-up”: ask the AI to generate self-test questions based on the profile to check whether “mastered” is truly justified, preventing overestimation of your own level.
• Maintain boundaries between layers: index.md should only provide navigation, not discussion; profile.md should only provide a profile, not a tutorial; notes/ should only provide records, not summaries. Clear responsibilities prevent the layers from contaminating each other.

6. Conclusion

The biggest obstacle to using AI for learning is not the AI’s capability, but the inability to express yourself clearly. The essence of the capability archive system is to structure implicit metacognition into persistent, AI-readable signals, transforming the AI from an encyclopedia that “knows everything but does not understand you” into a tutor that “knows your coordinates, goals, and blind spots.” Once you begin maintaining this archive, every AI answer will be closer to your real needs, and learning efficiency will undergo a qualitative change.