How Long Should We Let Learners Go Down the Wrong Path?
In a branching scenario, how long should we let learners go down the wrong path? What’s the balance between realism and efficiency?
In a branching scenario, how long should we let learners go down the wrong path? What’s the balance between realism and efficiency? In a comment to my post on Managing the Complexity in Branching Scenarios, Nicole Legault made a interesting point. “Why make a learner go so far down a wrong path? I think it’s best to correct and try to get them back on the right (or best) path.”
To some extent, I agree with Nicole. I’m not sure how much value there is to learners in going down seven steps of the wrong path with no way to recover. Where I perhaps disagree is about how the correction should happen. I try to give learners the opportunity to correct their own mistakes. However, that’s different from correcting them and forcing them back on the right path.
Depending on your goals and needs, you have a couple of options for handling wrong answers in scenarios.
- Limited branching (also known as a gauntlet structure)
- Immediate failure and restart
- A few consecutive wrong answers
- Opportunities to correct mistakes
Limited branching or gauntlet
One way is limited branching, also known as a gauntlet. Instead of a true branching scenario with multiple endings, this is essentially a single correct path and a single ending. When you make an incorrect choice, you get some customized feedback and perhaps see limited consequences of your decision. There are no long-term consequences for decisions unless something is controlled with variables and states. You are forced back to the correct path, regardless of your mistakes.
I use this structure in some of my demos, such as this Twine scenario on responding to instructional writing feedback.
Although he doesn’t call it that, limited branching is the model explained in Tom Kuhlmann’s Rapid eLearning Blog as an easy way to build scenarios. Tom points out that this model is simpler doesn’t get you overly bogged down in complexity.
Anna Sabramowicz uses this same structure for her interactive storytelling model. Her Broken Co-Worker example uses a central narrative; you’re faced with the same series of decisions no matter what choices you make. Norman Lamont did a nice analysis of the structure of the Broken Co-Worker if you want to see the flowchart.
In limited branching, you can get the wrong answer every single time, and the scenario still propels you forward. That can be helpful for teaching skills to less experienced learners, where you’re mostly using the scenario for instruction rather than decision-making practice.
This structure also works OK if your scenario is a series of independent decisions rather than multiple decisions in a single large scenario. If you’re teaching a process with multiple steps, where each step is contingent on the previous step, this method doesn’t create as realistic of an assessment.
Immediate failure and restart
The opposite end of the spectrum from limited branching (where you can make endless wrong answers) is immediate, catastrophic failure. If you make a single incorrect decision, you restart the scenario back at the beginning. Personally, I don’t like scenarios where a single wrong answer results in catastrophic failure unless that’s what would happen in real life. Some errors really are major and should result in immediate restarts.
If you’re creating training for nurses, administering 10 times the needed dose of a medication is a catastrophic failure. If you’re creating a scenario to show what to do in an active shooter situation, a decision that results in someone dying is a catastrophic failure. In both of those scenarios, forcing learners to restart at the beginning is appropriate.
A few consecutive wrong answers
Most of the time in scenarios, we’re working with gray area. In real life, we often have opportunities to change paths and correct mistakes. Where a single isolated mistake can be corrected, the cumulative effect of several wrong answers is the real concern.
In my scenarios, I usually try to limit it to two or three consecutive wrong answers before a restart. If they keep going down the wrong path, they have to restart and try again. I won’t force them to correct; learners need the opportunity to fail.
Limiting it to two or three consecutive wrong answers also helps limit the complexity of branching scenarios. You don’t have to create a full-length path of increasingly wrong answers.
Giving people a short, but incorrect (or partially incorrect), path also gives you the opportunity to show delayed consequences.
Opportunity to correct mistakes
In combination with having some paths ending early after making multiple consecutive mistakes, I also try to give learners the ability to correct their mistakes. I give people opportunities to get back on the right path by making better choices.
In this example, there are good (green), OK (orange), and bad (red) choices. If you choose C (red) at the beginning, you may reach a poor ending after just 2 choices. However, if you improve your choices, you can get back to a good (green) choice by correcting your mistakes.
You can also give people the opportunity to go back one decision to select a different choice, rather than fully restarting the scenario. That’s a simple way to give people the opportunity to immediately apply what they learned.
What do you do?
How do you handle wrong answers in a branching scenario? How long do you let learners go down an incorrect path before either forcing a restart or forcing them back on the correct path?
Originally published 8/15/2017. Updated 7/8/2021.
23 thoughts on “How Long Should We Let Learners Go Down the Wrong Path?”
When I’m feeling confident and I have time to do so, I have an even more twisted approach 😀 I give each possible answer a number of points: a good answer will up your total and a bad choice will bring it down (I even weigh the choices differently, betwee small and critical mistakes). Those totals are hidden from the learner, who only sees consequences of their choice instead. However, when the total gets too low – ie they made too many mistakes – that’s when the scenario ends. The learner then sees a recap of were they didn’t make the right choices.
So it’s not so much a certain path that leads to the end but a number of mistakes – some more costly than others. To write a consistent end to the scenario, I either use the consequences of the latest mistake, or a randomized pick of the biggest mistakes, or a combination.
For instance, if you 1/ forgot your seat belt (big mistake! -10), 2/ activated your wipers instead of your day lights (small mistake, -3), gave way to an old lady (good! 5 points), took a one-way street (big mistake! -10), boom, you’re over -15 so the scenario ends. Either with an accident because you were in a one-way street OR an even worse accident because in addition to that latest mistake, you weren’t wearing your seatbelt.
It’s definitely A LOT of variables but it’s also closer to reality 🙂
Ooh, I love that Marianick! I haven’t actually done it that way myself, but I can see exactly how that would work. In fact, I was thinking about going back to update one of my old scenarios. That one has a meter to show overall progress up and down, but I manually updated it on different slides rather than using variables. It should have been done with variables; my development skills just weren’t up to that at the time (7+ years ago). I could do it now though. Hmm…I need to ponder that some more…great inspiration!
Great explanation, Christie! I agree with a catastrophic results start-over.I also use a version of limited branching, in which the learner experiences “what happens next” with an incorrect choice (text, sequence of still images, or animation/video), receives feedback on why that choice produced negative results and/or a question pointing to the correct answer choice. The learner is brought back to that decision point for another choice. The correct answer continues the scenario.
I like the “what happens next?” approach. In fact, I might use that for one of my current projects. I need to do a branching video scenario, but we’re limited in how many video clips we shoot. I could potentially use some stills from the video for some wrong answers with a text description, rather than putting it all in video.
A similar approach was used in this sample branching scenario in H5P. Some of the wrong answers lead to video consequences, but some lead to text describing what happens and providing feedback.
As a classroom teacher I am constantly evaluating how my students are performing. I have found that it really depends on the student on how much you should let them make mistakes. With some students, after making mistakes one or two times, I need to immediately step in and help. If I don’t, they will give up and quit trying. However, I also have other students that will try and try, only needing a little redirecting, and they will use their problem solving skills to be successful. I really like that you pointed out that when we learn, we are creating those pathways. I never really thought of it that way, but now that I think about it, it makes a lot of sense. I can visual that student who has been practicing how to add fractions the wrong way and how hard it is to break them of their wrong habits because they have been practicing it the wrong way. I will definitely be thinking of the blog the next time I am evaluating my students as they work.
Not always easy but the principle, I think, is that if there are ways to recover in real life from a mistake we should offer those ways in the scenario. So for example the call centre person forgets to do the ID routine at the start of the call and is about to carry out the transaction. In real life they could still remember to do it, so that should be there as an option.
That’s a great example. I would rather have learners realize they made a mistake in forgetting that step and correct themselves.
A great article as usual Christy! I tend to follow the second model, even though the design (and review!) efforts are so much higher. My main reason to let learners go further on a path is that it actually reflects reality better, certainly if you are talking about choosing conversation options. Quite often we can rectify something that we did not say well, or steer a conversation back or even apologise :). Additionally, in reality we do not always find out immediately that we went wrong, it may be further down the line that this becomes clear.
I agree. Most of the branching scenarios I build are conversations, so it makes sense to give people a chance to say something to smooth over a mistake. In conversations, you often have an outcome that isn’t completely bad or completely good. A few choices down a partially correct path lets me show a consequence that is inbetween. A patient might verbally agree to make a change but not be very motivated. A counselor might miss an opportunity to probe deeper and find out an underlying cause. A sales person might make a sale of a smaller item rather than a larger one. All of those are situations that warrant letting people go a little longer down a wrong (or sort of wrong) path.
I believe that conversations are a great way of being able to correct mistakes. With younger kids, they do not like to be wrong in front of their peers. They also do not like to ask questions in front of their peers and would rather keep making mistakes then have their friends think they not smart. I have found more success when I have one on one conversations with these students. When a student is one on one, they are less anxious that their friends will make fun of them and are more likely to be honest about what they need help with. It also gives them a chance make connections with the teacher as well. Great blog!
Peer pressure and fear of publicly failing are real concerns. That’s one of the advantages of self-paced online learning; it gives people a safe place to fail without others watching.