LEARN.
COMPILE.
STAY SHARP.

A personal knowledge system for developers who work across stacks, fight context-switching, and want to actually own what they know — not just prompt for it.

// principle_01

Syntax is lookup. Judgment is yours. The goal is never to memorize everything — it's to deeply understand the things that matter and know how to find the rest.

// principle_02

Struggle is the learning. When you work through a problem yourself, it enters your bones. Use AI as a power tool — not a brain replacement.

// principle_03

The map grows with you. More you know, more gaps you see. That feeling is not failure — it is the proof that you are operating at a higher level.

THE CYCLE

ASK
FRAME
SEARCH
ACQUIRE
LEARN
COMPILE
UNDER
STAND
EMBED
REFLECT
TRACE

THE PHASES

// phase_00
FRAME
trigger: a gap appears

Before you can acquire anything, you have to honestly name the gap. Not "I don't know JS well enough" — but "I don't understand how the event loop actually processes microtasks vs macrotasks." Precision here makes everything downstream faster and more useful.

Write the gap as a question. "Why does my async function resolve in a different order than I expect?" Not a topic — a question.
Rate the urgency. Is this blocking work right now (🔴), will it matter soon (🟡), or is it a depth-gap worth filling later (🟢)?
Add it to your Gap Log. A simple running list so nothing slips. Revisit it weekly.
// phase_01
ACQUIRE
trigger: gap is defined

Go get the knowledge — but on your terms. The goal is not to consume everything. It's to understand enough to build your own mental model. Prefer primary sources (docs, specs, source code) over tutorials. Use AI as a dialogue partner, not a lecturer.

Read the official docs first. Even if they're dry. They're the ground truth.
Use AI with structured prompts — see the prompt templates below. Ask for explanations, not solutions.
Time-box it. 25 min of focused reading beats 3 hours of scattered consumption. Stop when you have enough to try something.
Build a tiny thing. Even a 10-line test script. Reading without doing is just passive input.
// phase_02
COMPILE
trigger: you've acquired raw input

This is the most important phase. Don't just copy what you learned — translate it into your own context. Ask: how does this connect to things I already know? What's the mental model behind it? What would go wrong if I got this wrong?

Write a one-paragraph explanation as if you're teaching it to a fellow dev. If you can't do it, go back to Acquire.
Map it to your stack. "In ABAP this would be... in Python this is similar to... in JS this is different because..."
Note the edge cases and gotchas you already encountered or can anticipate. These are the most valuable things to write down.
Write a code example from memory — not copy-pasted. Then check it. The delta is what you still need to internalize.
// phase_03
EMBED
trigger: mental model is formed

Put it somewhere structured. Your future self needs to find it fast. The system below is tool-agnostic — use Obsidian, Notion, plain markdown files, whatever you'll actually maintain. The structure matters more than the tool.

One note per concept — not per reading session. Notes should be atomic and reusable.
Tag by: language, topic, urgency, date. Searchability over perfect organization.
Include: your own explanation, a minimal code example, the gotcha, and a link to the source.
Link related notes. "See also: event loop, promise chains." The web of connections is where understanding lives.
// phase_04
TRACE
trigger: time-based (see rhythm)

Scheduled, non-negotiable review. Not grinding — just a brief look back at what you've learned and what you've applied. This is what turns short-term acquisition into long-term capability. Spaced repetition at a human scale.

Weekly: Review your Gap Log. What got resolved? What's still open? What new gaps appeared?
Monthly: Scan your Embed notes from the past 4 weeks. Update ones that were wrong or incomplete.
Quarterly: Look at your stack map. Where have you grown? Where are the persistent blind spots? What do you want to go deeper on?

AI PROMPT TEMPLATES

// template_01
UNDERSTAND, DON'T SOLVE
I'm working with [technology/concept] and I don't fully understand [specific thing].

Don't give me the solution.
Instead: explain the underlying concept, give me a minimal example, and tell me what I should try myself to verify I understand it.

My current (possibly wrong) mental model is: [your guess]
// template_02
CROSS-STACK TRANSFER
I know [concept X] well in [language A].

Explain how the equivalent works in [language B], focusing on:
— what's the same
— what's meaningfully different
— what gotchas exist that would trip up someone coming from [language A]

Be concise. No intro, no outro.
// template_03
RUBBER DUCK COMPILE
I'm going to explain my understanding of [concept]. Tell me what's correct, what's wrong or imprecise, and what important nuance I'm missing.

My explanation: [your explanation in plain language]

Be direct. Don't pad the response. If I got it right, say so briefly and add one thing I didn't mention.
// template_04
GAP EXCAVATION
I want to understand [broad topic] better. I work as a developer across [your stacks].

Give me a map of the key sub-concepts I should understand — not a reading list, not a tutorial.

Format: concept name + one sentence on why it matters + what I'd misunderstand if I skipped it.

Max 8 items. Prioritize ruthlessly.

THE EMBED SYSTEM — NOTE STRUCTURE

ANATOMY OF A NOTE
# [Concept Name] — [Language/Stack] The title. Specific and searchable. "Async/Await — JS" not "async stuff".
## What it is Your own explanation. 2-3 sentences max. If it's longer, you don't fully understand it yet.
## Minimal Example The smallest code that demonstrates the core idea. Written by you, not pasted.
## The Gotcha The one thing that will bite you if you forget it. Often the most valuable line in the note.
## See Also Links to related notes. This is what builds the knowledge graph.
TAG TAXONOMY
#lang/js #lang/python #lang/abap Language tag on everything. Makes cross-stack comparison easy.
#topic/async #topic/memory #topic/api Conceptual grouping independent of language.
#depth/surface #depth/working #depth/deep How well do you actually know this? Be honest. Revisit surface ones.
#status/fresh #status/validated #status/outdated Knowledge has a shelf life. Mark it so you know what to re-check.
#gotcha Tag any note that contains something that burned you or could. Easy to scan before starting a new project.
SPECIAL LOGS
Gap Log Running list of identified gaps. One line each. Prioritized by 🔴🟡🟢. Reviewed weekly.
TIL Log "Today I Learned" — one-liners. Fast to write, fast to scan. e.g. "JS: structuredClone() for deep copy without JSON tricks."
Burned Log Things that cost you time or caused bugs. Pure gold for future-you. e.g. "ABAP: internal table pass by value vs reference silently."
Stack Map A living doc per language showing your honest self-assessment of each area. Updated quarterly. Helps you see real growth.

REVIEW RHYTHM

DAILY
// 5 MIN
Write one TIL entry. Log any new gap you noticed. That's it. Low friction, high compound interest.
WEEKLY
// 20 MIN
Review your Gap Log. Pick one 🔴 gap to Acquire this week. Scan your TIL log from the past 7 days.
MONTHLY
// 45 MIN
Review all notes tagged #status/fresh. Update any that are wrong or incomplete. Pick one area for depth work.
QUARTERLY
// 90 MIN
Update your Stack Map. Look at your Burned Log. Set one learning intention for next quarter. Not a goal — an intention.