Skip to content
← The Unplugged Drop
Loom & Lesson

No devices · Grades 6-8 · 50 min

Computing, woven in

Free integrated lesson · No devices needed

Decision Paths

6-8 · 50 min · Math · Science · Social Studies · ELA · CS/Technology

An integrated lesson on decision-making: students map a real back-to-school dilemma as a branching decision tree, weigh consequences, and discover that the questions you ask — and their order — decide the outcome, with a callout for whatever subject you teach.

Materials last updated Jun 23, 2026.

50 min in class~10 min prepNo devices needed
  1. The hookContextualize6m
  2. Fix the misconceptionReframe4m
  3. Do the activityAssemble22m
  4. Check the machineFortify11m
  5. Wrap up + connect forwardTransfer + review7m
Before class~10 min
  • Print the Decision-tree frame (decision-tree.pdf) — root plus yes/no branches — one per team of three.
  • Print the Scenario cards (scenario-cards.pdf): a few school dilemmas tied to your subject, plus one surprise edge-case card per team for the Check step.
  • Have sticky notes for leaf outcomes so teams can re-order questions without rewriting the whole tree.
  • Teaching one subject? Also print its page: ELA argument-branches, Social Studies stakeholder-tree, Math probability-tree, Science dichotomous-key, or CS if-else-logic.

Make it yours

One lesson, woven into your subject

No co-teacher needed. Open your subject for a single card with the core content you teach and the specifics for weaving this lesson into your room — nothing to look up elsewhere.

Topic refresher

New to a concept? Tap a topic for a printable cheat sheet — plain-language definitions and classroom examples.

Overview

Decisions are algorithms. Students take a real back-to-school dilemma — how to split group roles, resolve a shared-resource conflict, plan an event — and map it as a branching decision tree: each question sends you down a path to an outcome. They learn conditional logic and trade-offs, and discover the big idea: the questions you ask, and their order, decide where you land.

A base integrated lesson — run it in your room as-is. It’s the same test-it-at-the-edges discipline that engineers, scientists, and policymakers use when the rules they write start deciding things for real people.

Pre / Post assessment

  • Pre: “How do you make a fair decision when there are lots of ‘it depends’?”
  • Post: “Which question in your tree mattered most? What happens if you ask it first vs. last?”

Objectives

Students will (1) represent a decision as a branching tree, (2) trace paths to outcomes, and (3) revise questions when the tree gives a bad result.

CONTEXTUALIZE — why it matters

Courts, triage nurses, admissions, budgets, and apps all run on decision rules — and a community is only as fair as the rules behind those calls and the people who test them. Making a rule visible and probing it for the cases it gets wrong is logic, ethics, and systems thinking at once. The students mapping a tree here are practicing exactly what engineers, scientists, and policymakers do when they design the rules that decide things for real people — and the ones who learn to ask “whose case does this break?” are the ones who get to steer those systems toward justice.

REFRAME — surface the wrong model, install the right one

Students treat a decision as a single gut call. Reframe: it’s a sequence of conditions — yes/no questions, each narrowing the options. Change the questions and you change the outcome.

ASSEMBLE — I do / we do / you do

  • I do: Map a 2-question tree for a simple choice; trace one path.
  • We do: Build a class tree for a shared dilemma; name the consequence at each leaf.
  • You do: Teams build a tree for an assigned scenario and trade trees to trace each other’s.

FORTIFY — Check the Machine

Hand teams a new scenario their tree didn’t plan for. Run it down the branches. Sometimes it lands on a bad or missing outcome — a real edge case. Teams decide whether to add a branch or reorder questions, then re-test. The lesson: a decision rule can look complete and still fail at the edges, so you test it against cases it didn’t expect. Apply the same to any confident automated recommendation — an app, a policy, an AI tool: what case breaks it, and who would it hurt?

TRANSFER — forward + plugged twin

  • Forward: the same map-it-then-test-the-edges discipline is how engineers, scientists, and policymakers build the rules a community is governed by — and these students could be the ones who design those systems and make sure they’re fair to everyone they touch.
  • Plugged twin: see Model the Question — turn the rule into a spreadsheet model.

What to listen for

Use the Post prompt — “Which question mattered most? What happens if you ask it first vs. last?” — plus the edge case from Check the Machine.

  • Proficient: names the highest-impact question and a case the tree breaks on. “If we ask ‘is it an emergency?’ last, a real emergency waits — so ask it first.” / “A student with no money AND an emergency falls through; we added a branch.”
  • Getting there: builds a working tree but can’t find a case it fails. Hand them the surprise scenario and trace it together.
  • Not yet: treats the decision as one gut call. Reframe: it’s a sequence of yes/no conditions, and their order changes the outcome.

Proficient when a team traces a new scenario down the tree, identifies a case it gets wrong, and revises it (adds a branch or reorders questions) so it handles that case.

Differentiation

  • 6-8 support: provide a 3-branch skeleton and scenario; students fill questions/outcomes.
  • Extension: add probabilities/costs and compute an expected value for each path.

3-2-1 Review

3 branches in your tree · 2 outcomes you mapped · 1 case your tree got wrong.

Family / community connection

“Map a family decision (where to eat, how to split chores) as a yes/no tree. Find the question that decides it.”

Standards alignment

Tap any code to see what it covers.

CSTA K-12 Computer Science Standardsreference ↗

The national computer-science learning standards from the Computer Science Teachers Association.

2-AP-11

Algorithms & Programming strand, grades 6–8

CS/Technology:CSTA 2-AP-11 and 2-AP-13 cover control structures (if/else conditionals) and using variables in algorithms. In plain terms: a program 'decides' by checking conditions in order and taking the first one that's true, so the order of conditions matters — an early, too-broad condition can swallow cases meant for a later branch.

2-AP-13

Algorithms & Programming strand, grades 6–8

CS/Technology:CSTA 2-AP-11 and 2-AP-13 cover control structures (if/else conditionals) and using variables in algorithms. In plain terms: a program 'decides' by checking conditions in order and taking the first one that's true, so the order of conditions matters — an early, too-broad condition can swallow cases meant for a later branch.

2-AP-17

Algorithms & Programming strand, grades 6–8

ISTE Standards for Studentsreference ↗

Standards for how students use technology to learn, from the International Society for Technology in Education.

ISTE-5c

Computational Thinker (Standard 5)

ISTE-7b

Global Collaborator (Standard 7)

Common Core State Standards — English Language Artsreference ↗

The Common Core reading, writing, speaking, and language standards.

W.6.1

Writing, grade 6

argument

View this standard ↗
SL.6.1

Speaking & Listening, grade 6

ELA:W.6.1 asks students to write an argument that states a clear claim and backs it with reasons and relevant evidence; SL.6.1 is collaborative discussion where students build on one another's reasoning. In plain terms: take a position, defend it with 'because' statements, and reason together out loud rather than trading opinions.

View this standard ↗

Keep going

Related free lessons

Share this lesson

You just read a free Math lesson. There are 31 more, going deeper.

The Educator plan ($9/mo) unlocks the standards-aligned Math library for your grade band — extended lessons, slides, answer keys, and standards maps. Advanced adds PD contact-hour certificates for license renewal.