Deliberate Introduction of Desirable Difficulty into Daily Work

1. Desirable Difficulties in Practice

Interleaving: Instead of batch-learning one type of skill, you rotate between several. For coding, that might mean: debugging a patch, then writing a unit test, then planning architecture. The switching itself strengthens adaptability.
Spacing: Don’t finish a task in one sitting if you can come back later. Returning to a partly solved problem forces recall and re-structuring, which deepens learning.

Zoom In: Solve a nitty-gritty problem (like fixing a patch header).
Zoom Out: Immediately follow up by asking “What does this error tell me about the workflow?” (e.g. “Should I write a script that cleans patches before applying?”). Alternating levels keeps your brain from getting locked at one scale.

Engineers often improve by borrowing habits from other fields:
- Music: deliberate practice, feedback loops, drills vs. performance.
- Art: sketching rough drafts quickly, iterating.
- Psychology: reframing failures as experiments. You already do this with your psychology + coding crossover—leaning into that more gives your brain richer problem space.

People get sharper when they add friction deliberately:

Solve a problem without Googling until you’ve written down three hypotheses.
Limit yourself to one tool/library you wouldn’t normally pick.
Impose a timebox (e.g. “I have 45 minutes to make something run, no matter how ugly”). The constraint forces creative approaches you wouldn’t reach otherwise.

After a problem, take 2 minutes to ask:

What kind of problem was this? (syntax, conceptual, design, meta/coordination?)
What did I do first, second, third?
How could I shorten that loop next time? This trains you to recognize patterns across different problem types—not just the surface fix.

Take on a concrete, frustrating technical issue (patches, migrations, dependency hell).
Before searching/asking, write down 3 hypotheses for the cause.
Goal: improve diagnostic reasoning.
Boosts diagnostic reasoning by forcing hypothesis generation before googling—encourages deeper encoding rather than shallow search-driven fixes. (Bjork & Bjork, ‘Making Things Hard on Yourself, But in a Good Way’ 2011)

Pick a part of your project and “zoom out”:
- How could this system scale if it doubled in size?
- Where would you add modularity?
Deliverable: a diagram or doc (not just code).
Goal: practice systems-level thinking.

Engages systems-level thinking and “far transfer” by requiring you to abstract patterns, not just code. Analogical mapping plays a key role in higher-order reasoning. (Wikipedia, Gentner, Structure-Mapping Theory (1983).)

Choose a tool or habit from another discipline you know (music practice, art iteration, psych experiment design).
Apply it to a coding/creative task.
Example: practice scales = write 5 tiny utility functions fast.
Goal: import mental models from other domains.

Brings fresh mental models from other disciplines—cognitive flexibility improves when we align structural patterns across domains. (Frontiers, Wikipedia, Barnett & Ceci, ‘When and Where Do We Apply What We Learn?’ (2002))

Impose a weird rule:
- Solve without Google.
- Write only pseudocode first.
- Use a library you’ve never touched.
Goal: forced creativity.

Deliberate constraints create “desirable difficulties,” which help build robust, adaptable problem-solving paths. (Wikipedia, Bjork Learning and Forgetting Lab,Bjork, ‘Desirable Difficulties Perspective on Learning’ (1994))

Spend 20–30 minutes journaling:
- What kinds of problems did I hit this week?
- Which felt trivial, which stretched me?
- What patterns am I seeing in how I approach them?
Goal: learn about your own learning.

Reflection develops metacognition—knowing how you learn is the foundation of improving your learning strategy. (Flavell, ‘Metacognition and Cognitive Monitoring’ (1979))

Explore an idea with no immediate payoff:
- Try an experimental feature in FastAPI.
- Mock up an odd UI in Astro.
- Ask “what if this project had to work offline?”
Goal: build cognitive flexibility.

Exploratory tasks foster flexible thinking and discovery. These “low-stakes” experiments can lead to unexpected innovations. (Vygotsky, ‘Mind in Society’ (1978))

Write a short guide, README, or blog-style note teaching one thing you solved this week.
Explaining forces you to clarify and compress.
Goal: solidify knowledge + communication.

Explaining what you’ve learned deepens understanding and retention—retrieval practice coupled with generative learning. (Wikipedia, Fiorella & Mayer, ‘Learning as a Generative Activity’ (2015))