Priority Between Thinking and Knowing — A Playbook for the "Cram-but-Can't-Connect" and the "Leap-Before-You-Look" Types

• Target audience: Knowledge workers and technical professionals who recognize in themselves either “I accumulate knowledge but can’t apply it” or “I jump in without researching and spin my wheels” — or both
• Prerequisites: Basic understanding of LLMs and cognitive science terminology (supplementary explanations included)
• Reading time: 11 minutes

Overview

Most people who get stuck while learning or producing output lean toward one of two types.

• Type A (The Crammer): Reads widely. Has knowledge. But can’t connect it — can’t apply it to new situations, can’t translate it into work output, feels lost without AI’s help.
• Type B (The Leaper): Starts doing before researching. Says “it’s faster to figure it out myself.” But spins the wheels — repeats similar mistakes, proceeds on hunches and backtracks, misses errors until AI points them out.

The two look like opposites, but the root is the same: in both cases, the cycle between “knowing” and “thinking” is stuck on one side.

Both cognitive science and AI research point to the mechanism that keeps this cycle moving. An infant’s sensorimotor stage and an LLM’s pre-training are extreme cases of “knowing first”; the core knowledge Elizabeth Spelke describes¹ and in-context learning in LLMs² are extreme cases of “thinking first.” Placing both ends side by side reveals the crucial fact: neither side alone moves cognition forward. What Dedre Gentner calls mutual bootstrapping³ — a cycle in which knowing and thinking scaffold each other to update the schema network — is how cognition actually advances.

This article builds on that structure to offer concrete playbooks for how Type A and Type B can each break out of their stuck states. We first draw lessons from both extremes, then present a self-diagnostic for identifying your own lean, and finally deliver the specific prescriptions for each type.

Self-Diagnostic — Which Way Do You Lean?

Start with diagnosis. Count how many of the following apply to you.

Signs of Type A (The Crammer)

• You try to read the entire official documentation of a new language or framework before writing any code, and time slips by
• You read plenty of technical books and articles, but can’t retrieve them in a “usable form” when it matters at work
• Before starting design, you want to fully grasp every existing implementation and pattern
• You ask AI to write code, but don’t feel you could write it from scratch yourself
• In new situations you feel “I must have the relevant knowledge, but I don’t know how to apply it”

Signs of Type B (The Leaper)

• You start using a library without reading the docs, then learn best practices exist only after hitting errors
• You write something yourself before searching for similar implementations, then discover the same thing already exists in OSS
• When debugging, you tinker with code on hunches before reading the logs
• You say “it’s faster to figure it out myself” and spend almost no time investigating
• You have a vague sense you’re repeating the same kinds of design mistakes across projects

Many people fit both. The lean can also reverse by domain (Crammer in your strong domain, Leaper in unfamiliar territory). Treat the diagnostic as a snapshot of which side you’re leaning on for this particular problem.

Why Both Get Stuck — Lessons from the Two Extremes

The two failure types become clearer when examined against the extremes.

What the “Knowing First” Extreme Teaches Us

The sensorimotor stage (0–2 years old) of infant learning accumulates schemas through bodily experience: looking, touching, dropping. Jean Piaget described this through two processes, assimilation (incorporating new information into existing schemas) and accommodation (modifying schemas themselves)⁴.

LLM pre-training has the same structure. Trillions of tokens of next-word prediction etch vocabulary, grammar, world knowledge, and reasoning patterns into the parameters. What the GPT-3 paper⁵ showed is that once this model scales sufficiently, the capacity to solve new tasks from just a few examples emerges.

Translated to the working life of a technical professional, the type that tries to read a new language’s spec from cover to cover before writing any code is the practical version of this extreme. The spec is in their head, yet when it’s time to write, their hand stops. This stuck state shares the same structure as the infant needing “accommodation” before progressing to the next developmental stage, and the LLM needing scale and architecture before few-shot reasoning emerges.

What all three cases jointly tell us is:

Accumulation is necessary. But accumulation alone cannot transition into the next phase of reasoning.

The infant moves to the preoperational stage through accommodation. The LLM gains few-shot reasoning only through scale and structure. Without the moment when accumulation is reorganized as relational structure, knowledge grows but remains unusable.

This is the true nature of Type A’s stuckness. The information is there. But it hasn’t been reorganized as relational structure — assimilation has proceeded but accommodation hasn’t occurred. Because the schemas remain isolated from one another, the Crammer cannot choose which one to apply in new situations.

What the “Thinking First” Extreme Teaches Us

Now for the opposite extreme. The core knowledge Elizabeth Spelke describes¹ is an innate reasoning framework present before any experience. Infants within months of birth already hold principles like object continuity, number, and agent goal-directedness as expectations and perform reasoning that detects expectation violations. Renée Baillargeon’s research⁶ empirically demonstrates this innate reasoning framework through violation-of-expectation paradigms.

The LLM counterpart is in-context learning (ICL). Lin et al.’s 2024 work (URIAL)² proposed and demonstrated that just three in-context demonstrations can bring a base LLM close to instruction-following mode. The weights remain frozen; new behavior arises from prompt-internal reasoning alone (though there are limits — on some benchmarks, this approach still falls short of instruction-tuned versions, so full equivalence isn’t claimed).

In a technical context, Fermi estimation and the approach of running code with minimal documentation to understand it are close to this side. An experienced developer enters production code with only an API reference overview and a few samples, then fills in the remaining specification by reasoning as the code runs — this is an ICL-like pattern where the weights (decades of accumulated general engineering knowledge) stay frozen while reasoning ignites from the code fragment in front of them.

These are extreme cases of “thinking first” — but thought does not spring from zero. Core knowledge assumes innate prior knowledge, ICL assumes pre-trained weights, and the veteran developer’s “proceed with minimal documentation” mode assumes accumulated general engineering knowledge. The shared lesson:

To ignite reasoning, minimum prior knowledge is required. Without prior knowledge, thinking doesn’t engage.

This is the true nature of Type B’s stuckness. They’re trying to reason, but their prior knowledge is too thin. Without a general map or key terminology, they begin thinking — and the reasoning spins out.

When the Cycle Doesn’t Turn, You Get Stuck — Acquisition Mode and Reasoning Mode

Placing both extremes side by side reveals that the “knowing first vs. thinking first” dichotomy is a false opposition. Real cognition operates as a cycle between two modes.

• Acquisition mode: The loop of incorporating, adding, and modifying schemas takes the foreground (sensorimotor stage / pre-training / where Type A gets stuck)
• Reasoning mode: The loop of running inference on top of frozen prior knowledge takes the foreground (core knowledge / ICL / where Type B gets stuck)

flowchart TB
    A["Schema Network"] --> B["Acquisition Mode<br/>Assimilate / Accumulate / Accommodate"]
    A --> C["Reasoning Mode<br/>Infer / Detect Violations"]
    B --> D["Incorporate new info<br/>and reorganize schemas"]
    C --> E["Match hypothesis and observation<br/>on existing prior knowledge"]
    D --> A
    E --> A
    F["Type A<br/>Stalled in Acquisition"] -.-> B
    G["Type B<br/>Spinning in Reasoning"] -.-> C

Type A doesn’t switch from acquisition to reasoning. Type B dives into reasoning and doesn’t return to acquisition. Both are stuck on one side of the cycle. As Gentner showed, knowledge and reasoning stand in a mutual bootstrapping³ relation that accelerates each other — cognition advances only once this loop begins to turn.

Playbook A — How the Crammer Breaks Out

Type A’s challenge is connecting accumulated knowledge to reasoning mode. You need to deliberately trigger “reorganization as relational structure.”

1. Manufacture your own expectation violations

The most powerful driver of infant learning is the experience of “different from what I expected.” This applies to adult learning — switch from passively reading information to a predict-then-verify loop.

• Before reading a library’s documentation, write out “this API probably has this signature”
• While reading a spec, put into words the gaps between your prediction and the actual API design
• Before running new code, write on paper “given this input, it probably behaves like this” and then execute
• When a gap appears, investigate the structure of the gap (not merely an error, but which part of your schema was wrong)
• Before submitting a PR, predict the specific spots a reviewer would flag

This process carries far higher cognitive load than simply reading. But cognitive load is precisely what drives schema accommodation.

2. Transfer by analogy across domains

What Gentner’s research has consistently shown is that capturing relational structure through analogy accelerates knowledge acquisition³. Build the habit of transferring what you have into another domain.

• When learning a new framework, write out explicitly: “this has the same structure as ○○ I used before”
• When you see a design pattern, ask: “which known structure is this an analogy of?”
• Map design philosophies across different languages (e.g., Rust’s Result ≒ Haskell’s Either)
• Always ask: “Where else have I seen this structure?”

You can’t transfer knowledge that isn’t stored as relational structure. The practice of transfer effectively forces your schemas to become relational.

3. Move from being the one asked by AI to the one asking it

Type A tends to get stuck in a state of constantly asking AI to “teach me” or “write this.” That locks in acquisition mode. To escape it:

• Switch to questions that put your knowledge to work: “For this problem, answer from perspective A and then from perspective B”
• Verify how AI’s answer differs from your prediction
• Put AI on the verifying side: “Here’s my understanding — where are the holes?”

While conversing with AI, hold a stance as the primary reasoner. This aligns with the expert’s pattern detailed in the related article Behind the “AI Does It All” Facade: What Experts Actually Do.

4. Write, teach, summarize

Finally, force relational structure into explicit form through output. Writing, teaching, and summarizing all require drawing lines between pieces of knowledge. Isolated schemas simply cannot be put into words.

• A week after reading something, try summarizing it in your own words
• Explain what you learned to someone (a hypothetical person or even AI works)
• Turn it into a blog post or internal document

The exact places where you get stuck in output are the places where relational structure is weak. Identifying them puts you back on the acquisition-to-reasoning loop.

Playbook B — How the Leaper Breaks Out

Type B’s challenge is stacking minimum prior knowledge before igniting reasoning. Instead of “think without research,” switch to “identify and quickly stack the minimum necessary prior knowledge.”

1. Decide your stop condition for research in advance

Type B folks often feel “research melts my time.” So they don’t research. But the real problem is that time melts because there’s no stop condition, not research itself.

• “After reading 5 articles, start writing a hypothesis”
• “After 30 minutes of research, stop and start moving”
• “Once I’ve pinned down items A, B, and C, move on”

With a stop condition, research functions as the phase that builds scaffolding for reasoning. This shares the time-boxing thinking of Evidence-Based Learning Methods for the AI Era.

2. Identify what counts as “minimum prior knowledge”

You don’t need to know everything before thinking. The minimum prior knowledge needed to make reasoning viable, in a technical context, usually comes down to these three:

1. The overall map — the major components of this system/framework and their relationships (architecture-diagram level)
2. Terminology — vocabulary whose meaning is specialized in this domain/library (e.g., React’s “hydration,” Kubernetes’ “pod,” Rust’s “ownership”)
3. Assumptions — constraints and typical design choices that are tacitly shared (e.g., “this framework assumes async,” “this DB is eventual consistency”)

Trying to “think” without these three in hand almost always causes your reasoning to slide off. With them, reasoning moves forward surprisingly smoothly. This is exactly the structure core knowledge and ICL demonstrate — with the minimum but necessary prior knowledge, reasoning ignites.

3. Use AI to summarize the big picture as scaffolding

AI is extremely effective for stacking minimum prior knowledge quickly. The right question for a Type B person to ask AI is not “build me this,” but:

• “Explain this framework’s overall architecture using 5 main components and their relationships”
• “List 10 specialized terms and pitfalls beginners hit in this language, with definitions”
• “What design assumptions do experienced users tacitly bring when using this library?”
• “What thinking and trade-offs lie behind this API design?”

AI is extremely strong at summarizing pre-trained knowledge. Type B should use this strength to build minimum prior knowledge fast, then return to reasoning mode.

4. Ignite from analogies to domains you already know

An adult’s strength when entering a new domain is already holding a vast amount of general prior knowledge. By analogy to core knowledge’s “innate frameworks,” adults have acquired many frameworks equivalent to core knowledge through years of learning.

• “Which domain I already know is structurally similar to this new territory?”
• “Which parts of this new domain can I explain by analogy to my strong domain?”
• “Where does the analogy break down? — that’s where this domain is specific”

Establish the big picture through analogy, then focus intensively on the parts where the analogy fails. This is a way to accelerate the construction of minimum prior knowledge using existing prior knowledge.

Turning the Cycle — Implementing Mutual Bootstrapping

Both Type A and Type B share the same final goal: becoming able to turn the cycle between acquisition mode and reasoning mode. Overlaying Gentner’s mutual bootstrapping³ with Piaget’s assimilation/accommodation⁴ makes the implementation concrete.

1. Ignite reasoning with minimum prior knowledge (Type B’s move)
2. Expectation violations (gaps between prediction and observation) emerge in reasoning
3. Examine the structure of the gap and accommodate the schema (Type A’s move)
4. The accommodated schema lets the next round of reasoning reach slightly further
5. The new reasoning produces new violations, which produce further accommodation

This loop runs independently for each domain. In new domains, what matters is starting the loop quickly even if it’s small; in mastered domains, what matters is turning it deeply and carefully.

Type A struggles with step 1 (ignition) and defers reasoning. Type B struggles with step 3 (accommodation) and moves on before observing the gap. For both, consciously strengthening the weaker side starts the cycle moving.

Caveats — Generalizing from Two Extremes, and How to Strengthen That

The article’s claims center on analogical reasoning from two extremes: infants and LLMs. Sample size 2 is a logical weakness, and on that alone, claiming “this applies to adult knowledge workers in general” would be too strong.

A third line of observation that partially reinforces this is adult expertise research. What K. Anders Ericsson and colleagues consistently found⁷ is that the back-and-forth between years of structured experience (acquisition mode) and deliberate repetitive practice that internalizes relational structure (accommodation) is what grows domain-specific schema networks. Not mere accumulation of experience, not thought without experience, but the cycle between them — this is the same shape as the article’s central claim. When infants, LLMs, and experts — three independent objects of observation — show the same pattern, the robustness of the structural lesson gains some support.

Caveats still remain. The correspondence between core knowledge and ICL, and between sensorimotor stage and pre-training, is functional similarity, not implementation equivalence. As Cuskley et al.’s 2024 review⁸ points out, LLM learning processes differ fundamentally from human learning in embodiment, sociality, and developmental process. Because a knowledge worker’s work contains bodily, social, and emotional dimensions, treating AI behavior as a complete model of human learning would be dangerous. The playbooks in this article extract structural lessons from the extremes and expertise research and translate them into practice — they don’t use AI as a cognitive model directly.

Summary — Diagnosis and Action Table

Symptom	Type	Cause of stuckness	How to break out
Forget what you read / can’t apply it	A (Crammer)	Stalled in acquisition mode, no relational restructuring	Expectation violation / analogy / turn AI into the one being asked / output
Spin wheels thinking without researching	B (Leaper)	Minimum prior knowledge too thin in reasoning mode	Stop conditions / 3-point minimum prior knowledge / use AI for summary / ignite from analogy
Both tendencies	Mixed A/B	Lean differs by domain	Diagnose per domain, prescribe for the side you lean on

The core claim is singular: the priority between knowing and thinking is not fixed. Which side you trigger depends on the domain, the stage, and your own lean. What the two extremes teach us is that cognition doesn’t advance on one side alone — it’s only when the cycle turns that knowledge becomes alive and thinking engages.

Diagnose your type, and take a step in the direction opposite your lean. That’s how this playbook is meant to be used.

Related Articles

See also the following related articles:

• Behind the “AI Does It All” Facade: What Experts Actually Do — How experts stay as the primary reasoner
• Why AI Boosts Creativity Only for the Metacognitively Skilled — The role of metacognition in turning the cycle
• Unlearning and Relearning in the AI Era — Techniques for deliberately accommodating schemas
• LLM Knowledge Limits and the Skills/Rules Boundary — The structure of LLM pre-training as prior knowledge
• Evidence-Based Learning Methods for the AI Era — Learning design that balances accumulation and reasoning

References

References cited in the text are listed below in numerical order.

1. Core Knowledge and Conceptual Change — Elizabeth S. Spelke, Harvard University (2016). A representative review of innate core knowledge systems in infants (object, number, space, agent). 【Reliability: High】 ↩︎ ↩︎²

2. The Unlocking Spell on Base LLMs: Rethinking Alignment via In-Context Learning (URIAL) — Bill Yuchen Lin et al., arXiv:2312.01552 / ICLR 2024. Proposes and demonstrates that just 3 in-context demonstrations can bring a base LLM close to alignment (instruction-following). A subsequent evaluation study (Zhao et al., arXiv:2405.19874) also showed limits where this approach falls short of instruction-tuned versions on some benchmarks. 【Reliability: High】(ICLR 2024 accepted) ↩︎ ↩︎²

3. Bootstrapping the Mind: Analogical Processes and Symbol Systems — Dedre Gentner, Cognitive Science, 34(5), 752–775 (2010). Argues the mutual bootstrapping of language/symbols and analogical processes. 【Reliability: High】 ↩︎ ↩︎² ↩︎³ ↩︎⁴

4. Assimilation and Accommodation in Psychology — Saul McLeod, Simply Psychology (last verified 2024). Overview of Piaget’s assimilation and accommodation concepts and schema construction/modification processes. 【Reliability: Medium】 ↩︎ ↩︎²

5. Language Models are Few-Shot Learners — Tom B. Brown et al., arXiv:2005.14165 / NeurIPS 2020. The paper that demonstrated GPT-3’s few-shot/in-context learning capabilities. 【Reliability: High】(peer-reviewed, NeurIPS accepted) ↩︎

6. Innate Ideas Revisited: For a Principle of Persistence in Infants’ Physical Reasoning — Renée Baillargeon, Perspectives on Psychological Science, 3(1), 2–13 (2008). Demonstrates through the violation-of-expectation method that infants’ physical reasoning is based on innate principles. 【Reliability: High】 ↩︎

7. The Role of Deliberate Practice in the Acquisition of Expert Performance — K. Anders Ericsson, Ralf Th. Krampe, & Clemens Tesch-Römer, Psychological Review, 100(3), 363–406 (1993). Foundational work on the role of structured experience and deliberate repetitive practice in the acquisition of expertise. 【Reliability: High】 ↩︎

8. The Limitations of Large Language Models for Understanding Human Language and Cognition — Christine Cuskley et al., Open Mind, 8 (2024). A review pointing out that LLMs differ from human learning in embodiment, sociality, and developmental process. 【Reliability: High】 ↩︎