The irreducible epistemic atoms underlying the curriculum. 4,828 atoms across 8 types and 2 molecules
Organize information into parent-child structures where each parent summarizes its children and each child specifies its parent, enabling navigation by choosing your level of detail.
Identify and operate at the 'basic level' of your domain's hierarchy — the level where categories carry maximum information with minimum cognitive effort.
Break information into chunks of 3 to 5 items at each level of a hierarchy, using nested grouping to extend effective processing capacity beyond raw working memory limits.
When explaining or communicating, explicitly match your level of abstraction to your audience's purpose and current need rather than your own cognitive comfort zone.
When stuck on a problem, shift abstraction levels deliberately: drill down when you need mechanism and specifics, zoom out when you need context and patterns.
Frame tasks concretely (how will I do this?) rather than abstractly (why does this matter?) to reduce procrastination and increase immediate action.
Use multiple classification dimensions (tags, categories, relationships) rather than forcing knowledge into single-parent tree structures when concepts legitimately belong to multiple parent categories.
Test hierarchical organizations by attempting to retrieve items via all their legitimate access paths, treating retrieval failures as structural defects in your organization system.
Choose depth-first traversal when you need any solution quickly; choose breadth-first when you need the optimal solution.
Build broader, shallower hierarchies for novices exploring unfamiliar domains; build deeper hierarchies for experts navigating familiar paths.
Every task must decompose to the level where done-state is clear, no clarification is needed, and completion fits in a single focused session.
Separate meta-work on system structure from actual leaf-level work; track time spent on each to prevent mistaking organization for output.
Externalize root assumptions as explicit, testable statements; trace which decisions inherit from each root to make dependency visible.
Test root concepts by negating them and asking what would change; if everything changes, you've found a genuine root.
Design intermediate navigation levels to answer questions users actually ask during search, not categories that made sense during filing.
Each intermediate level should reduce options to 5-12 items; if a level presents more, split it; if it presents fewer, consider removing the level.
Default to three-level hierarchies (root, intermediate, leaf); each additional level requires explicit justification for the structural information it preserves.
Distinguish structural depth (encodes real containment, scope, or inheritance) from bureaucratic depth (added for appearance of organization); remove all bureaucratic levels.
When AI generates hierarchies, verify you can navigate them without AI assistance; if not, the structure serves the tool rather than your cognition.
Design containers to provide interpretive context that items inside them cannot or should not carry independently.
Store properties at the highest applicable hierarchical level and let inheritance distribute them to avoid redundant specification.
Audit inherited properties for context-fitness rather than accepting them automatically, marking properties that create friction as override candidates.
Design inheritance chains to be shallow rather than deep to minimize fragility when parent-level properties change.
Make every override explicit by documenting which inherited property differs and why, rather than maintaining implicit mental exception lists.