Stop Building Slide-Based Courses (Build Systems Instead)

Key Takeaways

What if your training could automatically adapt to each learner, giving more support to those who need it, fast-tracking those who don't, writing specific feedback and making custom practice activities for each learner based on what they need, all without using AI? And what if I told you this would take you less time to build than what you're doing right now? Well, it's not fantasy. It's what happens when you start building courses as systems instead of slides. A course made up of slides is like those map quests we used to have before GPS. If you know, you know. We'd print those out and go out into the world, but you miss one exit and you're screwed. Your little paper is like, "I don't know, man. You're on your own." Well, slide-based training is kind of like that. It knows one route and the moment a learner goes off script, they struggle somewhere, they already know the content, or they need to practice something just one more time, well, too bad. Slides are not smart enough to adapt. But, we live in the GPS world now and designers who get that and apply systems thinking end up producing better training that doesn't bore learners and that gets way more results and they spend less time building it. That's what it takes now. So, in this video, I'm going to show you seven concrete, practical ways you can apply systems thinking to every part of your design. My name is Mary Jo and I've helped hundreds of instructional designers build training that drives cognitive engagement and real-world results. If learner engagement or making your training land is something you're struggling with, you might be a good fit for my program and community, so book a free call with me at the link below so we can talk about your goals and your sticking points. Now, let's see seven ways to go from static slides to systems thinking. >> [music] >> The major difference between systems and slides is that a system is dynamic. It'll take whatever's going on in the training with a learner and adapt in real-time. Not only is that more engaging for the learner because they don't know what they're going to get, it's also a lot less wasteful of their time and attention because they get just what they need built on the fly instead of a one-size-fits-all. So, let's start by applying this to scenarios and we'll use a classic example of handling customer complaints. The static way of doing this is to write 10 unique scenarios, each with a full story and a bunch of big choices. The stories are big and the choices are big because they're not broken into components. System thinkers do this differently. They ask, "What are the essential parts of all my scenarios?" Maybe it's the nature of the problem, the customer's emotional state, the solution, the communication channel. All of these elements affect how the learner should respond. And then based on that, you list the possibilities in each of those categories. Here are my problem types, the emotional states, past resolution, and communication channels. At the very least, what you can do with this is that at runtime, the system will randomly pick one from each of these lists and generate a scenario on the fly. That's procedural generation. We've talked about this before, and it makes your program endlessly replayable because you've got hundreds of combos here. But each of these elements affects how the learner should respond ideally. Am I on the phone or in person? Is the customer calm or irate? So, we can think of the ideal answer in terms of parts as well. So, instead of having a couple of large options that are pre-made combos of these elements, the learner will assemble their ideal answer from the parts as well. I understand your frustration. Let me escalate this. Whatever. That's a much more realistic and robust way to train them. This is systems thinking because you're not just coming up with examples, you're systematically covering every aspect of a situation that affects the ideal response. And you're training the learner to automatically diagnose those in real life. Doing this forces you to first figure out what the relevant parts are, but once you've done that, it's one slide and hundreds of stronger scenarios. Next is a close cousin of tactic one and one of my favorites. I love to use procedurally generated scenarios when I'm teaching a rule. For example, let's say I'm teaching people to determine the price to ship a package based on weight, size, distance, and speed. Again, I'm setting up these elements and at runtime, the system's going to pick random values for each one of these and generate a package for me to price. But I'm also programming the rule I need to teach. So when it creates a package, it also automatically calculates the right answer based on the rules I've given it. Then the learner's job is to get as close as possible to that perfect answer. So instead of thinking in examples, we're thinking in rules and we're training people to think that way, too. Of course, this gives you unlimited practice scenarios, but the really exciting part is when you start to adapt the scenarios to the learner and what they need, and I'm going to get into that a little bit later. The next tactic is about how you can teach knowledge systematically. If you watch this channel, you know I'm a fan of getting the learner to do things right from the start, first with a lot of guidance, then gradually less until they have no guidance at all. So let's say I want to teach you how to write a good bullet for your resume, and the recipe is action verb, task, method, outcome. Redesigned onboarding process using employee surveys, which reduced turnover by 15%. Instead of slides that explain each and every aspect, I'm going to have the learner perform this task immediately, first with a ton of guidance and hints. So here's what that looks like. At first, I tell them what the components are in order. Action verb, task, method, outcome. I've also color-coded it so that they can see that these are action verbs, tasks, methods, outcomes. That's all guidance. So they have to pick one of each, easy-peasy. So they pass this, and next they have to do it again, but this time there's no color code and I mix up the words. So now you have to remember what kinds of words are action verbs, built, launched, streamlined. What words describe a method like KPI dashboards, Notion, Agile, et cetera. But I'm still showing some guidance. The components are still displayed. Next time they do it, they have even less guidance. So maybe now I'm going to remove two of the labels and they have to remember what they were, and we go on like that until there's no support whatsoever and they have to know the four components in order, just like in real life. This is systemic because again, you have to think about what you want them to do, what extra information a newbie would need to get this right, you give it to them, and you gradually take it away. I'm not creating new challenges for each level of difficulty, I'm just reducing the amount of information I'm giving them. Now, a lot of the time as you're doing this, taking the learner from newbie to expert, you're also going to have to simultaneously increase the difficulty so that they reach an ambitious learning objective. For example, maybe they don't just need to do this without guidance, they also need to do it faster, more accurately, whatever. And this is one of the places where systems thinking really unlocks your superpowers. The usual instinct when you want to make something easier or harder is to change What's the capital of France? What's the capital of Mozambique? But that means building different content for different levels, which is not efficient. So, instead of changing the content, change the difficulty modifiers. Tweak the numbers, not the content. For example, in my activity about the packages, I can play with the range of acceptable answers. At first, you get it right if you're within 20% of the perfect answer, but later in the hard levels, you have to be within 5%. I'm just changing a number. Do you know how easy that is compared to making different packages, different scenarios for different levels? In my activity about the resume bullets, I could play with the number of decoys, like how many bad answers are there mixed in with the good. The modifiers you can play with depend on what the activity is, but there's always a couple of numbers you can play with. How many tries you're allowing, how many hints, how much time you're giving them if that's relevant to what you're teaching. And where you set the difficulty exactly can, of course, be tied to how well the learner is doing so that everyone gets the exact right level of challenge for them. The next tactic really shows how a system can help make your training reflect reality better. Let's say we're teaching learners to create merch that different businesses can give to their clients. So, I give you the business type, budget, audience, context, and based on that, you need to pick an object, a pen, a lanyard, a mug, a t-shirt, the message type, and the design style, playful, serious, sentimental, whatever. So, if we're designing merch for a bank, a nice fancy pen is a good choice. So, if you pick that, you get three out of three points. But as a pet store giveaway, it gets only a one. A mug can work for either situation, so it gets a two for the bank and a one for the pet shop. Every choice you make gets a score depending on the situation. A playful design is awesome for a daycare, it's okay for a pet shop, but it's terrible for a funeral home. This is way more realistic because in real life, a given answer isn't usually all right or all wrong. It's more or less so depending on the situation. So, this reflects that. But, the beauty of this is that over a few scenarios, you can develop an idea of the learners' learning gaps. Maybe they always pick the best object, but they always get the tone wrong. You can have a running score of how well they're doing, not just overall, but on each component of what you're teaching. And that'll be useful for the next two tactics, starting with dynamic progression. So, here, instead of a linear progression where everyone's doing the same thing in the same order, you can design the next exercise for each learner based on what kind of practice they need. So, let's say I always do great on scenarios with a big budget or where the audience is children, but I struggle with corporate audiences and lower budgets. Well, we can take big budgets and children out of the pool because I've mastered that, so we're not wasting my time and boring me with things I find easy. And we can also purposefully choose the things where my scores are the lowest to build the next scenario. That gives me and every single other learner exactly the practice we need. And finally, because we have so much more granular information about how the learner's doing, we can compose specific feedback for them. One way to do this is to pick for them to focus on. And we do this until everything is mastered. Or, you can start with all the feedback, and you just dynamically remove the things that they do well enough. So, here, I'm telling you you need to work on tone, and here's a tip, but I'm removing the passage about object choice because you got this. That the feedback mercifully shorter and more to the point and it ensures maximum relevance for each person. So, that's a quick tour of systems thinking with concrete applicable examples. Of course, you don't have to implement all these together or all at once, but just one can take your training from static to something that responds to each learner. And I swear each tactic you add isn't more work, it's less. Instead of writing 20 scenarios, you're creating one system that generates 400. You have to think more up front for sure, but it pays off in development time and results. And if you want to go deeper on all of these tactics step-by-step with hands-on practice, I'd love to help. So, check out my program The Effective Gamification Framework. The link is below. Thank you so much for watching and I'll see you next time. >> [music]