Principles
2,201 principles · page 35 of 46
Break complex causal explanations into chains…
Break complex causal explanations into chains of individually verifiable mechanisms rather than stopping at the first plausible cause.
Test each link in a causal chain by asking whether removing…
Test each link in a causal chain by asking whether removing that link would plausibly prevent the downstream effect.
When a causal chain closes into a loop where effects feed…
When a causal chain closes into a loop where effects feed back to influence their own causes, predict behavior by analyzing the loop's structure rather than any individual link.
Identify whether a feedback loop amplifies or stabilizes…
Identify whether a feedback loop amplifies or stabilizes by counting the number of negative (opposite-direction) links: even count including zero produces amplification, odd count produces stabilization.
When a balancing feedback loop contains a delay between…
When a balancing feedback loop contains a delay between action and effect, expect the system to oscillate through overshooting and overcorrecting.
Intervene in feedback loops by changing the structure…
Intervene in feedback loops by changing the structure of connections (adding, removing, or redirecting links) rather than trying harder at individual nodes.
Actively search for absent relationships in your maps…
Actively search for absent relationships in your maps by asking what connections should exist but do not, because missing links are often more informative than present ones.
Externalize all relationships in a system simultaneously…
Externalize all relationships in a system simultaneously through visual mapping to reveal structural patterns that sequential analysis cannot detect.
Look for hub nodes with disproportionately many connections…
Look for hub nodes with disproportionately many connections in your relationship maps, because they create both vulnerability to targeted disruption and resilience to random failures.
When reasoning about indirect connections between entities…
When reasoning about indirect connections between entities, explicitly verify that the relationship type supports transitive inference rather than assuming all chains propagate.
Design propagation systems with explicit damping factors…
Design propagation systems with explicit damping factors that reduce signal strength at each hop to prevent unstable accumulation in circular paths.
When evaluating information received through a chain…
When evaluating information received through a chain of recommendations or endorsements, multiply the confidence values at each hop rather than treating endpoint confidence as equal to any single link.
Concentrate redundancy investments at nodes and connections…
Concentrate redundancy investments at nodes and connections where failure consequences are highest rather than distributing uniformly across all system components.
Test backup systems periodically under realistic conditions…
Test backup systems periodically under realistic conditions to verify they can actually substitute for primary systems when needed.
When designing critical systems, ensure backup paths…
When designing critical systems, ensure backup paths do not share failure modes with primary paths by using independent implementations, physical separation, or diverse technologies.
Identify system bottlenecks by running removal tests…
Identify system bottlenecks by running removal tests that ask which single node or connection failures would make specific functions impossible rather than merely slower.
When queues consistently form at specific points…
When queues consistently form at specific points in a system, trace upstream to find the constraint where processing capacity is exceeded by arrival rate.
Use spatial layouts in visualizations to make relationship…
Use spatial layouts in visualizations to make relationship patterns available to perception rather than requiring serial cognitive computation.
When creating knowledge graphs from notes or documents…
When creating knowledge graphs from notes or documents, maintain multiple independent access paths to important concepts rather than relying on a single organizational taxonomy.
Construct relationship maps manually before using AI tools…
Construct relationship maps manually before using AI tools to generate them, as the cognitive benefit comes from making explicit decisions about entities, connections, and types rather than consuming finished artifacts.
Map from memory first before consulting sources to surface…
Map from memory first before consulting sources to surface the gaps between your mental model and reality, as these gaps reveal precisely where understanding is incomplete.
When relationship maps grow beyond 20-30 nodes, introduce…
When relationship maps grow beyond 20-30 nodes, introduce hierarchical abstraction by treating clusters of densely connected nodes as single units at higher levels.
When evaluating system resilience, count the number…
When evaluating system resilience, count the number of independent paths between critical nodes as this number equals the system's tolerance for node failures along those paths.
Address bottlenecks by increasing the constraint's capacity…
Address bottlenecks by increasing the constraint's capacity or by distributing its load across parallel paths rather than optimizing components that are not constraints.
Organize information into parent-child structures where each
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…
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…
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…
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…
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…
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…
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…
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…
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…
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…
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…
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…
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…
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…
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…
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…
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…
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…
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
Design containers to provide interpretive context that items inside them cannot or should not carry independently.
Store properties at the highest applicable hierarchical…
Store properties at the highest applicable hierarchical level and let inheritance distribute them to avoid redundant specification.
Audit inherited properties for context-fitness rather…
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…
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…
Make every override explicit by documenting which inherited property differs and why, rather than maintaining implicit mental exception lists.