Recommended resources
The freely available resources this lesson will direct you to.
Introduction
Hello again! In our last lesson, we explored elaborative encoding, a technique for building strong memories by actively connecting new information to your existing knowledge. We framed memory as a process of construction, not just storage, and established that the quality of that construction determines how well you retain and apply what you learn.
This lesson builds directly on that idea. We will now focus on a powerful method that forces you to engage in that deep, elaborative thinking: the generation effect. Today's learning outcome is to apply the generation effect by attempting to answer a question or solve a problem before consulting the solution.
You'll discover why struggling to find an answer before you're told what it is isn't a sign of inefficient learning, but rather one of its most essential ingredients. This shift in perspective is fundamental to building the robust, applicable knowledge you're aiming for in UX, coding, and data analysis.
What is the Generation Effect?
At its heart, the generation effect is the principle that information is remembered far better when it's actively produced from your own mind rather than passively consumed.
To get a formal definition and understand the classic research behind it, let's start with a short article.
The Generation Effect: Why Active Learning Sticks
This article from PsychoTricks, 'The Generation Effect: Why Active Learning Sticks', provides a clear and concise definition of this powerful learning principle.
Please read the introduction and the first section, 'What is the Generation Effect?'. Focus on the core distinction between passively receiving information and actively generating it.
The difference between reading a word and having to complete it from a fragment (F-L-O-W-E-R) might seem small, but that small act of "generation" makes a huge difference in memory. It's the difference between being a spectator and being a participant in your own learning.
The Ultimate Generation Task: Productive Failure
While simple generation tasks like filling in the blank are effective, the most powerful application of this principle—and the focus of our lesson—is attempting to solve complex problems before you've been taught the solution. This might sound inefficient or even frustrating, but research shows it's a key to developing deep, transferable understanding. This approach is often called productive failure.
Why does wrestling with a problem you're not equipped to solve actually help you learn? Let's explore the core idea in this fantastic TEDx talk.
Productive Failure | Manu Kapur | TEDxLugano
In his talk on 'Productive Failure', researcher Manu Kapur explains why the traditional 'teach first, solve later' model is often less effective than we think. This first clip introduces the foundational concept.
Please watch from 05:25 to 07:45. Focus on his analogy of the film director and the idea that an expert and a novice 'see' things differently. The goal of productive failure is to 'prepare the novice to see'.
This is a crucial insight. When you try to solve a problem first, you're forced to activate your existing knowledge, even if it's incomplete. This struggle makes you aware of the gaps in your understanding and primes your brain to notice the critical features of the solution when it's finally presented. You've prepared yourself to "see" what the expert sees.
So, how much of a difference does this make? Kapur's research provides a compelling answer.
Productive Failure | Manu Kapur | TEDxLugano
Let's look at the evidence. Kapur's research group directly compared traditional 'direct instruction' with the 'productive failure' approach. The results are striking.
Now watch from 07:45 to 12:38. Pay close attention to the difference in outcomes for basic knowledge versus conceptual understanding and the ability to solve novel problems.
The results are clear: for developing the ability to transfer and apply knowledge—your primary goal—struggling first and failing productively is significantly more effective. The very act of generating different (even incorrect) solutions prepares you to learn the correct one on a much deeper level.
But what if you generate the wrong answer? Won't that confuse you? This is a common and important question.
A Note on Getting it Wrong
Generating an incorrect answer is not harmful as long as you get timely, accurate feedback. The article from PsychoTricks addresses this in its FAQ section (which you can review later if you're interested). The key takeaway is that the process of attempting to generate an answer, even if you're wrong, highlights your knowledge gaps. This makes you much more receptive to the correct information when you receive it. The error, followed by correction, actually strengthens the memory for the right answer.
How to Apply the Generation Effect in Your Learning
Understanding the theory is one thing; putting it into practice is another. Your goal is to build a toolkit of actionable strategies. The "problem-solving first" approach is the most powerful, but there are several ways to incorporate generation into your daily learning.
The Generation Effect: Why Active Learning Sticks
This section of the PsychoTricks article provides an excellent summary of practical ways you can apply the generation effect.
Please read the section 'Practical Applications: Harnessing the Generation Effect for Enhanced Learning', paying close attention to the bulleted list under 'For Students and Learners'. As you read, think about how each one could be applied to learning a new UX method or a piece of code.
The article lists several powerful techniques, including:
- Self-Testing: Actively trying to recall information from memory (e.g., using flashcards or just a blank piece of paper).
- Summarizing: Explaining a concept in your own words without looking at the source material.
- Teaching Others: Articulating a concept to someone else forces you to generate a clear, coherent explanation.
- Problem-Solving First: The core strategy we've focused on today.
Let's put this main strategy into practice.
Application Exercise: Designing for Accessibility
Imagine you're mentoring a junior designer who is new to accessibility. You want to teach them about the Web Content Accessibility Guidelines (WCAG), specifically the guideline for contrast ratio.
The traditional "direct instruction" approach would be to start by explaining:
"WCAG 2.1 requires a contrast ratio of at least 4.5:1 for normal text and 3:1 for large text. This is to ensure readability for users with moderate visual impairments. Here's a tool to check it..."
Instead, let's use the productive failure approach.
Your Task:
Before looking up any specific rules or tools, try to solve the following design problem. The goal is not to get it right, but to generate solutions and identify the questions you need answered.
The Problem:
You have a new mobile app design that uses a light grey background (#F2F2F2). You need to choose a color for your body text and a color for your main call-to-action button text. The brand's primary color is a nice, friendly orange (#FFA500), but you're not sure if it will work.
Spend 5-10 minutes on this. Don't look anything up yet.
- Generate Potential Solutions: Using your designer's eye, what text colors might you try for the body text and the button text? Why? What are the trade-offs you're considering (e.g., brand consistency vs. readability)?
- Generate Questions: What specific information do you realize you're missing? What would you need to know to solve this problem confidently? What makes this a non-trivial problem?
Test your understanding!
After you've spent some time generating your own ideas and questions, compare them to this example thought process.
Show answer
Here's an example of what a "productive failure" thought process might look like for this problem:
1. Generated Solutions & Trade-offs:
- Body Text: "Standard black (
#000000) is probably safe, but maybe it's too harsh. A dark grey like#333333might feel more integrated with the design. I'm balancing pure readability with the overall aesthetic." - Button Text: "I really want to use the brand orange (
#FFA500) for the button background. If I do that, the button text has to be white (#FFFFFF) or maybe black. But will the orange background itself be visible enough against the light grey page? Maybe I should use the orange for the text on a white button? That feels weaker. The trade-off is between brand expression in the button and making the button stand out."
2. Generated Questions (The real goal!):
- How 'dark' does the text need to be on the light grey background? Is there a specific threshold?
- "Readability" is subjective. How can I quantify it? Is there a mathematical formula or rule?
- Does the required readability change for different font sizes? A big headline probably needs less contrast than small body text, right?
- Does text on a colored button have the same rules as text on a page background?
- Are there standard, accepted tools for measuring this, or is it just by eye?
Notice how this process moves you from a passive recipient of the "4.5:1 rule" to an active seeker of it. You now understand why the rule is necessary. When you now learn about contrast ratios and tools like the WCAG Contrast Checker, the information will land on fertile ground. It directly answers the questions your brain was already working on.
Conclusion
Today, we've explored the generation effect, a principle that fundamentally reframes the role of effort and struggle in learning. By attempting to produce information yourself, you engage your mind in a deeper, more constructive process that leads to lasting knowledge.
Key Takeaways:
- Generate, Don't Just Consume: Actively producing information (generating answers, summaries, or questions) is far more effective for memory than passively reading or listening.
- Embrace Productive Failure: Trying to solve a problem before you know the solution is not a waste of time. This struggle prepares your brain to deeply understand the solution when you encounter it.
- Failure Primes Your Brain: The process of attempting a problem activates your prior knowledge and, more importantly, makes you acutely aware of your knowledge gaps. This creates a "time to learn" moment where you are most receptive to new information.
- It's a Practical Strategy: You can apply this principle immediately by tackling practice problems before reading the chapter, trying to code a feature before watching the tutorial, or, as in our exercise, designing a solution before looking up the rules.
In our next lesson, we will focus on a closely related technique: self-explanation. While generation is about producing the answer, self-explanation is about articulating the process and reasoning behind it. It's the next logical step in ensuring your understanding is both deep and durable.