What Instructional Design Actually Means

By Pritesh Yadav 8 min read

Imagine you hire two people to help your nephew pass a math exam. The first person knows math perfectly. She sits him down and talks for three hours, covering everything she knows. The second person also knows math, but she starts by asking what he already understands, breaks the topic into small pieces, gives him problems to try, watches where he stumbles, and only explains the parts he actually needs. A week later, only one of these approaches has stuck. The difference between them is instructional design.

2.1 A plain-English definition

Instructional design (sometimes called instructional systems design) is a careful, repeatable process for building a learning experience that actually causes learning, rather than just presenting information and hoping. The word "design" is the important part: just as an architect plans a house before anyone picks up a hammer, an instructional designer plans how a person will move from not-knowing to knowing before any lesson is written.

It works as a loop with four basic jobs:

  1. Define the goal — figure out what the learner needs and what "success" actually looks like (a measurable outcome).
  2. Design and build — create the explanations, examples, and practice that lead to that outcome.
  3. Deliver — put it in front of the learner.
  4. Measure and revise — check whether learning really happened, then fix what didn't work.

The motto of the field is blunt: training isn't just delivered, it actually works. That phrase exists because so much "teaching" is really just delivery, and delivery alone teaches almost nobody.

Analogy: Instructional design is to teaching what architecture is to building a house. You don't start nailing boards together. You study who will live there, draw blueprints, build, move people in, then inspect and fix. An AI tutor built without instructional design is a house with no blueprint — rooms exist, but nothing connects to a goal, and the staircase might lead to a wall.

2.2 Having information is not the same as teaching it

This is the single idea that separates a teacher from a textbook, and it deserves its own section because it is so easy to get wrong, especially when building software.

A person can know a subject completely and still be a terrible teacher. Why? Because teaching is not about the information living in the expert's head — it's about getting that information to survive the trip into the learner's head. And the learner's head has a very narrow doorway. Your working memory (the small mental "workbench" where you actively think about whatever is in front of you right now) can only hold about four new things at once, and it empties out in seconds if you stop paying attention. Real, lasting knowledge lives in long-term memory (the vast, durable "warehouse"). Learning is the act of moving something from the cramped workbench into the warehouse.

An expert who simply "tells you everything she knows" floods that tiny doorway. The learner tries hard, feels busy, and stores almost nothing. The expert delivered information; she did not teach. Teaching means pacing, sequencing, chunking, giving practice, and checking understanding — all the work of getting ideas through the doorway one manageable load at a time.

Common mistake: Assuming that because you (or an AI model) "knows" the answer, you can teach it. The most common failure of a raw AI chatbot used as a tutor is exactly this — it dumps a fluent, complete answer. The learner reads it, feels the comfortable glow of "that makes sense," and remembers none of it tomorrow. Knowing the content is the easy half; designing its delivery is the hard, valuable half.

2.3 The instructional designer's mindset

If you take on this role, your attention shifts in a few specific ways. These habits are what you are really hiring an instructional designer (or building into an AI tutor) for:

  • Start with the destination, not the content. Before writing a single lesson, you write a learning objective: a precise statement of what the learner will be able to do, using an observable verb. "The learner can solve a two-step equation" — not "the learner will understand algebra." You can't see "understand," so you can't tell when it's happened.
  • Obsess over the learner, not the subject. What do they already know? Where will they get confused? A great designer is constantly asking "where is this person right now?"
  • Treat struggle as the point, not a bug. A little productive effort (recalling an answer, trying before being told) is what builds memory. The goal is not to make learning feel effortless.
  • Measure, then revise. The first version is a hypothesis. You watch where learners stall and fix it.
Analogy: A learning objective is a GPS destination. "Get better at driving" is not a destination a GPS can route to. "123 Main Street" is. Without a real address, a tutor can't know which turns to recommend — or even whether you've arrived.

2.4 A quick tour of the formal models

Over the decades, researchers turned these instincts into named, reusable frameworks. You'll meet each in depth later; for now, just learn what each one is for, because they operate at different "zoom levels."

ModelWhat it isZoom level
ADDIEA five-phase process for building a whole course: Analysis, Design, Development, Implementation, Evaluation.The big picture — building the course
Gagne's Nine EventsA nine-step script for a single lesson: gain attention, state the objective, recall prior learning, present content, guide, practice, give feedback, assess, help it transfer.The small picture — running one lesson
Merrill's First PrinciplesFive things every good lesson shares, built around a real-world problem: anchor to a real task, activate prior knowledge, demonstrate, let them apply, integrate into their life.A teaching recipe for any lesson

Notice they don't compete — they nest. ADDIE is the recipe for building the cooking class; Gagne is the recipe for running a single session inside it; Merrill is the shape each session takes.

  ADDIE  (build the whole course)
  +------------------------------------------+
  | Analysis  Design  Develop  Deliver  Eval |
  |                       |                   |
  |              each lesson uses:            |
  |              GAGNE'S 9 EVENTS             |
  |   attention -> objective -> recall ->     |
  |   present -> guide -> practice ->          |
  |   feedback -> assess -> transfer          |
  +------------------------------------------+
        ^ evaluation feeds back, you revise
Tip: Don't memorize these as rival "methods." Read them as one toolbox at three sizes: a project plan (ADDIE), a lesson script (Gagne), and a lesson shape (Merrill). When you build an AI tutor, you'll quietly use all three at once.

2.5 Why "content is not a course"

Here is the sentence to tape above your desk: content is not a course.

A pile of correct, well-written information — a textbook, a stack of slides, a brilliant video — is raw material. A course is what happens when that material is sequenced, chunked to fit the narrow doorway of working memory, paired with practice that forces the learner to retrieve and apply it, checked for understanding, and revised based on what actually sticks. The information might be identical in both cases. The learning outcome is wildly different.

Example: Two learners get the exact same worked math example. The first just reads it and moves on. The second pauses at each line and asks "why did they do that?" before continuing. Same content, but the second learner remembers far more — because the explaining, not the reading, is what builds understanding. Instructional design is the discipline of engineering that second experience on purpose, for everyone, at scale.

This is also why an AI learning platform is not "a chatbot plus a PDF." Uploading a book gives the model the content. Turning that content into a sequence of objectives, chunked lessons, retrieval practice, spaced reviews, and honest assessment — that is the course, and that is the work the rest of this guide is about.

Key takeaways
  • Instructional design is a repeatable process — define the goal, build, deliver, measure, revise — for making learning actually happen, not just presenting information.
  • Knowing a subject and teaching it are different skills; teaching is the work of getting ideas through the learner's narrow working-memory doorway and into long-term memory.
  • The designer's mindset starts with a measurable objective (an observable "the learner can DO X"), focuses on the learner, and treats some struggle as productive.
  • ADDIE, Gagne's Nine Events, and Merrill's First Principles are nested tools at different zoom levels (whole course, single lesson, lesson shape), not rival methods.
  • Content is not a course. Raw material becomes learning only when it is sequenced, chunked, practiced, checked, and revised — which is exactly the gap an AI tutor must fill, not just a chatbot bolted to a document.

Continue reading