AI can help learners turn a practical problem into a clear procedure, explore alternative approaches and test what happens when a rule changes. The educational work begins before code appears: decide which information matters, describe an acceptable result and make the decisions precise enough for someone else to follow. A program that runs is useful evidence about an implementation, but the learner still needs to explain why its procedure answers the intended question.
This article develops a complete original fictional task: arranging numbered display strips in trays without exceeding their capacity or changing their order. Learners specify the inputs, trace a working algorithm, inspect executable Python, choose boundary tests and compare a new possibility proposed with AI assistance. A later task introduces spacing between strips and asks the learner to revise the procedure independently. All objects, data, suggestions and results are invented teaching materials; the sequence is a proposed learning design, not a report of measured AI effectiveness.
- State the inputs, required outputs and constraints before asking for code.
- Represent objects so that repeated values do not erase their separate identities.
- Explain each decision and the information that must remain correct after every step.
- Choose tests for ordinary inputs, exact boundaries and inputs the procedure must reject.
- Use AI to expand possible approaches, then compare them under clearly stated rules.
- Check whether learners can adapt the reasoning when a relevant condition changes.
Choose your reading route
Read from the beginning, or start with the question that matters to you. The full teaching chapters remain open below.
Chapter index
Chapters 1–4 · Specify and represent the task
Chapters 5–8 · Build and trace the procedure
Chapters 9–12 · Test rules and compare resources
Chapters 13–15 · Explore alternatives and retain decisions
Chapters 16–19 · Adapt the rule and explain the result
CHAPTER 1 OF 19 · Specify and represent the task
1. Make computational thinking visible before the program
An instruction such as “pack these strips efficiently” hides several questions. Must every strip be used? May their order change? Can a strip be divided? Does efficiency mean fewer trays, less unused space or less handling? Different answers create different problems, even if the same objects appear on the table.
Jeannette Wing’s 2006 viewpoint on computational thinking connects problem solving with ideas such as abstraction, decomposition and choosing representations. It distinguishes the broader reasoning from programming alone. This is a conceptual argument, not evidence that a particular AI lesson improves achievement. The activity below gives those ideas a specific, inspectable form.
A learner can begin with numbered cards, spoken instructions or a written trace. They should be able to say which decision comes next and why. Code then offers one way to execute the procedure consistently and inspect many examples; it does not remove the need to decide what the procedure should do.
The curriculum progression article develops the related question of what a learner needs before delegating. Here, useful foundations include comparing whole numbers, keeping a running total, following a sequence and explaining an if–then decision. Teach a missing foundation directly rather than interpreting unfamiliar programming notation as a general lack of reasoning.
CHAPTER 2 OF 19 · Specify and represent the task
2. Agree on inputs, outputs and rules
The fictional kit contains numbered strips placed in a single row inside each tray. A strip occupies a positive whole number of slots. Every tray has the same positive whole-number capacity. In the initial model, adjoining strips need no extra gap. There is no overlapping, cutting or sharing of one strip between trays, and spare trays are available whenever needed.
Read the completed trays in the order they were opened, and read strips within each tray from left to right. That reading must reproduce the original strip sequence exactly. Each tray therefore contains a consecutive part of the input. Once the procedure moves to the next tray, it does not return to an earlier one.
The inputs are an ordered list of widths and a capacity. The output names the strip numbers in each tray, records each tray’s occupied slots and reports total unused slots. Strip number means the item’s original position, starting at one. This makes two equally wide strips distinguishable.
Accept an empty list: there is then nothing to pack and no tray is required. Reject a nonpositive capacity, a noninteger width, or a width outside one through the capacity. The implementation below accepts an ordinary Python list of ordinary integers and rejects Boolean values. These are explicit choices for this small lesson, not requirements for every packing application.
CHAPTER 3 OF 19 · Specify and represent the task
3. Read the complete fictional inventory
The initial capacity is ten slots per tray. The seven widths, in their required order, are [6, 4, 6, 3, 2, 5, 4]. The table gives the complete inventory; there are no additional objects or hidden dimensions to consider.
| Strip number | Width (slots) | Running input total (slots) |
|---|---|---|
| 1 | 6 | 6 |
| 2 | 4 | 10 |
| 3 | 6 | 16 |
| 4 | 3 | 19 |
| 5 | 2 | 21 |
| 6 | 5 | 26 |
| 7 | 4 | 30 |
The total width is 6 + 4 + 6 + 3 + 2 + 5 + 4 = 30 slots. That total is useful, but it does not determine a valid arrangement by itself. Thirty slots could fill three ten-slot trays only if the strips could be grouped appropriately under the rules. The required order can prevent a grouping that looks attractive when only the total is considered.
Keep strip identity separate from width. Strip 1 and Strip 3 both occupy six slots, but they have different positions in the sequence. If a program stores only a set of widths, repeated values can disappear from the representation. The result would no longer describe the seven supplied objects.
Ask the learner to reconstruct the ordered widths from the table and point to the two four-slot strips. This short check establishes what each number means before introducing an algorithm. It also shows why a compact representation needs enough information to preserve the distinctions relevant to the task.
CHAPTER 4 OF 19 · Specify and represent the task
4. Divide the task without losing its meaning
The work separates into validation, placement and reporting. Validation checks that the supplied input belongs to the problem the procedure promises to solve. Placement decides whether the next strip fits in the current tray. Reporting describes the arrangement and calculates unused capacity from the resulting loads.
For this version, validate the complete list before placing any strip. If the final entry is too wide, the function raises an error instead of returning an apparently complete arrangement for only the earlier entries. A different application might deliberately accept part of a request, but it would need to specify what a partial result means. That is not the contract here.
The placement decision needs very little changing information: the next strip number, its width, the current tray and that tray’s current load. The output retains the already placed strip numbers and the loads of earlier trays. Colour and decorative pattern are omitted because no initial rule depends on them.
This is a useful abstraction only while those omitted features remain irrelevant. If a later rule says two colours must not share a tray, the input and procedure need revision. Ask students to name one discarded detail that is harmless under the current rules and one possible new requirement that would make it matter. Abstraction is a reasoned choice about the question being answered.
CHAPTER 5 OF 19 · Build and trace the procedure
5. Write the placement rule in ordinary language
Process strips in the supplied order. If there is no current tray, open one. Otherwise, add the next width to the current load and compare that proposed load with the capacity. Keep the strip in the current tray when the sum is at most the capacity. If it would exceed capacity, open a new tray and put the strip there.
The phrase “at most” includes an exact fit. A tray loaded to six slots can accept a four-slot strip when capacity is ten. Starting another tray in that situation would follow a different procedure. This small language choice should be settled before translating the rule into symbols.
The following is pseudocode: a language-neutral description of the decisions, not text to paste directly into Python. Its validation step refers to the complete contract already stated.
Validate the whole input before placement.
Start with no trays and no recorded loads.
For each strip, in input order:
If there is no tray, open an empty tray.
Otherwise, if current load + strip width exceeds capacity:
Open an empty tray.
Put this strip number in the current tray.
Increase its load by the strip width.
Report trays, loads and total unused capacity.
Have another learner follow the description literally with the inventory cards. If they must ask whether exact fits are allowed or where an oversized strip goes, return to the specification. Clarifying a procedure before implementation is productive work, not a delay in beginning the “real” computing task.
CHAPTER 6 OF 19 · Build and trace the procedure
6. Trace the state after each strip
Start with no tray. Strip 1 opens Tray 1 and brings its load to six. Strip 2 fits exactly beside it, bringing the load to ten. Strip 3 cannot enter that full tray, so it opens Tray 2. The same decision repeats for each remaining strip.
| Strip number | Width | Current load before | Decision | Current tray and load after |
|---|---|---|---|---|
| 1 | 6 | No tray | Open Tray 1 | Tray 1: 6 |
| 2 | 4 | 6 | Keep Tray 1: 6 + 4 = 10 | Tray 1: 10 |
| 3 | 6 | 10 | Open Tray 2: 10 + 6 > 10 | Tray 2: 6 |
| 4 | 3 | 6 | Keep Tray 2: 6 + 3 = 9 | Tray 2: 9 |
| 5 | 2 | 9 | Open Tray 3: 9 + 2 > 10 | Tray 3: 2 |
| 6 | 5 | 2 | Keep Tray 3: 2 + 5 = 7 | Tray 3: 7 |
| 7 | 4 | 7 | Open Tray 4: 7 + 4 > 10 | Tray 4: 4 |
The final arrangement is Tray 1: [1, 2], Tray 2: [3, 4], Tray 3: [5, 6], and Tray 4: [7]. Their loads are 10, 9, 7 and 4. Four trays provide forty slots, so unused capacity is 40 − 30 = 10 slots. The gaps left in individual trays are 0, 1, 3 and 6, which also sum to ten.
The trace column records the load of the current tray, not the total width placed so far. Confusing those quantities would make later decisions wrong even if every addition were accurate. Ask a learner what happens immediately before Strip 5: the current load is nine, the incoming width is two, and eleven exceeds ten.
A trace is most useful when it exposes a decision that can be checked. Copying all seven rows after seeing the final answer may show careful transcription. Predicting the next row, explaining the comparison and checking the result gives stronger evidence about whether the learner understands the procedure.
CHAPTER 7 OF 19 · Build and trace the procedure
7. Read a complete executable implementation
This Python 3 function implements the stated contract. It uses no imported package. The keys in its returned record are trays, loads and unused; strip numbers in trays are positions in the original input, not widths. The code does not change the supplied list.
def pack_ordered(widths, capacity):
if type(capacity) is not int:
raise TypeError("capacity must be an integer")
if capacity <= 0:
raise ValueError("capacity must be positive")
if type(widths) is not list:
raise TypeError("widths must be a list")
for width in widths:
if type(width) is not int:
raise TypeError("every width must be an integer")
if width < 1 or width > capacity:
raise ValueError("each width must be from 1 to capacity")
trays = []
loads = []
for number, width in enumerate(widths, start=1):
if not trays or loads[-1] + width > capacity:
trays.append([])
loads.append(0)
trays[-1].append(number)
loads[-1] += width
return {
"trays": trays,
"loads": loads,
"unused": len(trays) * capacity - sum(loads)
}
Calling pack_ordered([6, 4, 6, 3, 2, 5, 4], 10) returns the four groups and loads from the trace, with unused equal to ten. The negative index -1 selects the last list entry. The first part of the condition handles the empty starting state before the code needs a last load.
Ask why the returned group [3, 4] has a load of nine rather than seven. Its numbers identify Strip 3, whose width is six, and Strip 4, whose width is three. Adding the labels would calculate something the output does not mean. A learner who can connect the returned record back to the inventory is showing an essential part of understanding the implementation, even before explaining every line.
The official Python tutorial on errors and exceptions distinguishes syntax errors from exceptions during execution and explains how raise signals an exception deliberately. Here, the validation messages identify rejected inputs. They do not establish that every possible defect in the procedure has been found. Learners can investigate the same algorithm through the trace without first mastering every feature of Python syntax.
After each placement, every processed strip should appear exactly once, in the original order. Each recorded load should equal the sum of the widths assigned to that tray, and no load should exceed capacity. These statements describe conditions the procedure must preserve; computer scientists often call such conditions invariants.
Consider why they hold at the start: there are no processed strips and no trays, so nothing has been omitted, duplicated or overloaded. At a placement step, the procedure appends only the next strip number. It therefore preserves the processed order. It adds the same width to the tray’s load, keeping the record aligned with the contents.
The capacity check protects an existing tray. When a new one is opened, validation has already established that the strip itself fits. These two cases explain why placing the next item preserves the capacity condition. The learner is connecting rules with consequences rather than relying only on several successful examples.
The procedure also stops. A finite list supplies a finite number of strip entries, and each placement step advances to the next one. There is no instruction to retry an oversized item forever; such an item is rejected before placement. For the seven-strip input there are seven placement steps. Correctness and stopping are separate questions, and both deserve a plain explanation.
CHAPTER 9 OF 19 · Test rules and compare resources
9. Choose tests that examine different decisions
A test needs an input, an expected result and a reason for including it. Repeating the main example several times does not examine how the procedure behaves with no strips, an exact fit or an invalid width. Select examples that put pressure on different parts of the contract.
| Widths | Capacity | Expected outcome | Decision examined |
|---|---|---|---|
| [] | 10 | No trays; no loads; unused 0 | Valid empty inventory |
| [10] | 10 | Groups [1]; load 10; unused 0 | A single full-width strip |
| [6, 4] | 10 | One group [1, 2]; load 10; unused 0 | Exact fit stays in the tray |
| [6, 5] | 10 | Groups [1] and [2]; loads 6 and 5; unused 9 | A strip that would exceed capacity |
| [4, 4, 4] | 10 | Groups [1, 2] and [3]; loads 8 and 4; unused 8 | Repeated widths retain separate identities |
| [1, 1] | 1 | Groups [1] and [2]; loads 1 and 1; unused 0 | The smallest valid capacity |
| [0] | 10 | ValueError; no successful arrangement | Zero is outside the width contract |
| [11] | 10 | ValueError; no successful arrangement | One strip is wider than a tray |
| [3.5] | 10 | TypeError; no successful arrangement | Fractional widths are outside this model |
| [True] | 10 | TypeError; no successful arrangement | Boolean values are not width entries |
| [] | 0 | ValueError; no successful arrangement | Capacity must remain positive even for an empty list |
Write the expected result before running the function. Otherwise students may simply treat whatever appeared on the screen as the answer. For [6, 5] at capacity ten, the expected loads are six and five in separate trays; the unused total is twenty minus eleven, or nine. That arithmetic can be checked without executing the program.
For an invalid input, the expected outcome is an error, not an empty successful arrangement. An empty list at a valid capacity is different: it is a valid request with no work to perform. The distinction matters because a caller needs to know whether there were no objects or whether the supplied data could not be processed under the rules.
A useful test collection supports specific conclusions. These cases exercise important branches of this small function; they are not a promise that testing has proved every property of every possible extension. The explanation in the previous chapter and the tests contribute different kinds of evidence.
CHAPTER 10 OF 19 · Test rules and compare resources
10. Use a small counterexample to understand a defect
Suppose a suggested implementation opens a new tray whenever current load plus width is greater than or equal to capacity. It can still produce plausible arrangements, and no tray will overflow. However, it starts a new tray when an exact fit should be accepted. The input [6, 4] at capacity ten exposes that disagreement immediately.
The intended rule produces one tray containing both strips. The altered rule produces two trays, with loads six and four. Their total unused capacity is ten, although the agreed procedure needs none. The defect is a changed boundary condition, not a failure of addition.
Ask the learner to identify the smallest relevant decision, state the expected behaviour and revise the comparison. Then repeat the exact-fit test and a test that really must open another tray, such as [6, 5]. The second check matters because a change that accepts everything would remove one symptom while breaking the capacity rule.
This constructed variation could come from a learner, an adult or AI. Its educational value lies in making a relationship between wording and behaviour visible. A short counterexample can be more informative than an elaborate explanation that never identifies the input on which two procedures disagree.
CHAPTER 11 OF 19 · Test rules and compare resources
11. Notice the resources a procedure uses
For valid input, the function scans every width once during validation and once during placement. With seven input entries, that means seven validation iterations and seven placement iterations. Each placement considers only the current tray. It does not search every previous tray because returning to an earlier tray is outside the agreed procedure.
For a valid list of n entries, those two loops each have n iterations. This describes how the number of iterations changes with input length. It is not a measured running time: actual execution also involves the programming environment, operations and representation. Students can discuss growth without making an unsupported claim about how quickly a particular device will finish.
The output stores every strip number, so a longer inventory also requires a longer result. If the user only wanted the number of trays and total unused capacity, a different implementation might keep less output information. It would then answer a different reporting request and could not display the complete placement record.
These are design choices a learner can reason about. Before asking AI to make a function “faster,” identify which work is costly, what output is required and what may change. Removing validation or dropping strip identities is not an acceptable improvement when those features are part of the contract.
CHAPTER 12 OF 19 · Test rules and compare resources
12. Establish what fewer trays would mean
The NIST Dictionary of Algorithms and Data Structures describes bin packing as a family of problems involving objects, capacity constraints and objectives, with several variants. That technical framing helps explain why changing a constraint can change the problem. This lesson adds its own explicit order rule and fictional data; no general performance guarantee is borrowed from the glossary.
The initial strips occupy thirty slots, so two ten-slot trays cannot hold them. Three trays are a lower bound based on total capacity. A lower bound is not automatically an arrangement: it tells us what would be impossible to improve upon if a valid arrangement achieved it.
For three trays to hold exactly thirty occupied slots, every tray would have to be full. Under the required order, the first tray must contain Strips 1 and 2 to reach ten. The remaining widths begin [6, 3, 2, 5, 4]. Their successive prefix totals are 6, 9, 11, 16 and 20; none is ten. Therefore the second tray cannot be full while preserving the sequence, so three trays are impossible under these rules.
The four-tray arrangement is consequently minimal for this particular ordered case. This is a reasoned conclusion about the specified input, not a claim established by a convincing program name. The mathematical reasoning article develops the distinction between examples, models and justified conclusions.
CHAPTER 13 OF 19 · Explore alternatives and retain decisions
13. Use AI to open a different possibility
A constructive request to AI could be: “Suggest another arrangement if the order restriction is relaxed. Keep every strip whole, use each strip once and retain ten-slot trays. Show the strip numbers and explain what rule changed.” This gives the tool a useful exploratory task while making the boundary of that exploration explicit.
Consider this original constructed proposal: put Strips [1, 2] in one tray, [3, 7] in another, and [4, 5, 6] in a third. The loads are 6 + 4 = 10, 6 + 4 = 10, and 3 + 2 + 5 = 10. Every strip appears once. Three trays now achieve the total-capacity lower bound, so this arrangement is minimal for the relaxed version of this instance.
The learner should notice the cost of the change. Reading the trays in order gives [1, 2, 3, 7, 4, 5, 6], which does not preserve the original sequence. The proposal is useful if order may change. It cannot replace the initial answer while claiming to obey the original order requirement.
The AI contribution is an expanded option that students can inspect and discuss. They might now ask why the order rule exists, whether rearranging the display is acceptable, or whether the strips could be renumbered for a genuinely different activity. Those questions extend the problem without pretending that a better result under revised rules automatically settles the original task.
CHAPTER 14 OF 19 · Explore alternatives and retain decisions
14. Compare outcomes using a stated objective
Fewer trays and less unused capacity are different measures when tray size can change. Keep the original strip order but increase each tray’s capacity to fifteen. The same placement procedure produces groups [1, 2], [3, 4, 5] and [6, 7], with loads ten, eleven and nine. It uses three trays, whose combined capacity is forty-five slots.
Unused capacity is now 45 − 30 = 15 slots. The original ten-slot version used four trays and left ten slots unused. The larger-tray scenario therefore reduces the number of trays while increasing unused slots. Which result is preferable depends on the purpose of the comparison, not on a single word such as “efficient.”
An AI assistant could help generate a list of candidate objectives: tray count, unused capacity, ease of following the sequence or the work of preparing the display. Students should select the relevant objectives and identify which are actually represented by the available data. No costs or handling times have been supplied, so the numerical examples do not establish those outcomes.
This comparison also gives the learner a productive planning choice. They can keep the ten-slot constraint, examine a larger-tray scenario or investigate whether order is negotiable. These are separate proposals. Record the changed condition alongside each result so that a reader can see which problem each procedure has solved.
CHAPTER 15 OF 19 · Explore alternatives and retain decisions
15. Keep the learner’s decisions within the workflow
AI can translate a learner’s pseudocode into a programming language, propose a clearer variable name or generate candidate tests. Choose one purpose at a time. A request that simultaneously decides the requirements, writes the function and announces that it is optimal can conceal several decisions the learner was meant to practise.
For example, ask the tool for three test inputs without their expected outputs. The learner can predict the outcomes and explain which rule each case examines. Alternatively, let the learner state an expected output and ask for a competing interpretation of an ambiguous requirement. The teacher can then help settle the requirement before either interpretation becomes code.
The AI-powered assignments article develops this relationship between assistance and the work left for the student. Here, a short record can name the rule the learner wrote, the suggestion they considered and the reason for accepting or revising it. A complete conversation transcript is not necessary to make those decisions discussable.
Do not require learners to reject a suggestion merely to demonstrate independence. Accepting a sound simplification with an explanation can show judgement. The important evidence is that the student can connect the adopted step to the task and can predict what changes when one of its conditions changes.
CHAPTER 16 OF 19 · Adapt the rule and explain the result
16. Give the learner a changed individual task
Now supply a new fictional inventory, [3, 4, 2, 5, 1], in that order, with capacity eight. Add one new physical rule: two neighbouring strips within the same tray require one empty separator slot between them. There is no separator before the first strip or after the last strip in a tray. All other requirements remain: whole strips, original order and no returning to earlier trays.
Ask the learner to adapt the placement decision, produce the strip groups and calculate each tray’s load. Count required separator slots as reserved capacity in that load. Unused capacity means slots remaining beyond the strips and their required separators. Ask for one test that checks the first strip in a new tray and another that checks an exact fit after allowing for a separator.
Provide the input and rules before showing the worked answer in the next chapter. A calculator, accessible input table or reading support can remain when those supports do not supply the target decision. Record a hint about adding separators separately from the learner’s initial attempt, because it directly assists the new reasoning.
The task asks for a small but meaningful adaptation. Simply changing the capacity argument in the original function will not implement the new spacing rule. The learner must explain when an additional slot is needed and why moving to a fresh tray changes that calculation.
CHAPTER 17 OF 19 · Adapt the rule and explain the result
17. Check the changed rule and the result
When a tray is empty, placing a strip adds only its width. When a tray already contains a strip, another placement would add one separator slot plus the incoming width. If that combined addition will not fit, start a new tray and recalculate the addition as the width alone. Carrying the separator into the new tray would invent a leading gap that the rules do not require.
Strips 1 and 2 require 3 + 1 + 4 = 8 slots in Tray 1. Strips 3 and 4 require 2 + 1 + 5 = 8 in Tray 2. Strip 5 occupies one slot in Tray 3. The groups are [1, 2], [3, 4] and [5], with loads eight, eight and one. The widths total fifteen and the two separators reserve two more, so used or reserved capacity is seventeen. Three eight-slot trays provide twenty-four slots, leaving seven unused.
Two trays could not suffice under this spacing rule, even if order were relaxed: five strips spread across two nonempty trays would require three separators, making 15 + 3 = 18 required slots, beyond their combined capacity of sixteen. The three-tray result therefore achieves the minimum for this changed instance.
An exact-fit test is widths [3, 4] with capacity eight and a one-slot separator: both belong in one tray. A new-tray test is [8, 1] under the same rule: its loads should be eight and one, with no leading separator in the second tray. Together they examine the new boundary and the reset decision.
CHAPTER 18 OF 19 · Adapt the rule and explain the result
18. Make participation and teaching manageable
Learners can work with large-print inventory cards, a tactile row of slots, a spoken trace or an accessible text table. These formats can preserve the same identities, widths and decisions. Avoid relying on colour alone to distinguish strips. Keep their numbers available across representations so that communication support does not introduce a new identification puzzle.
The educational access article distinguishes support that enables participation from assistance that supplies the reasoning being checked. Dictating a rule may preserve the student’s decision. Receiving a completed trace changes what the teacher can infer about independent tracing. State the target and record the relevant support rather than treating every aid as equivalent.
A teacher can use one prepared inventory and a shared constructed AI proposal for the whole class. Begin with a physical placement and one boundary decision before introducing the full code. Students can rotate the roles of rule writer, tracer and checker, but each should later explain a consequential step or solve a changed case individually.
Parents can ask, “What does the procedure remember?” or “What would make it open another tray?” They need not write a more advanced program for the child. A manageable learning record contains the agreed rules, one meaningful trace and a changed-case explanation. These give the next teaching conversation a clearer starting point than the length or appearance of a generated program.
CHAPTER 19 OF 19 · Adapt the rule and explain the result
19. Recognise a procedure the learner can defend
A capable response connects the task, representation, decisions and checks. The learner can explain why strip identity matters, why an exact fit stays in the current tray and why an oversized input is rejected. They can distinguish a valid arrangement from a claim that it uses the fewest trays, and they can show which rule changed in the three-tray alternative.
The learning transfer article explains why evidence should be interpreted at the scope it supports. Adapting the separator task provides evidence about a related procedure under the recorded conditions. It does not establish independent programming across unfamiliar languages, data structures or problem domains. Further learning will require further knowledge and opportunities to apply it.
Keep the next step specific. A learner who understands placement but loses a strip number may need work on representations. Someone who traces accurately but cannot revise the separator condition may need practice connecting requirements to state changes. Someone who finds a valid alternative can be challenged to justify an objective or a lower bound.
AI can widen the available possibilities and help turn an idea into something executable. The educational result becomes visible when the learner explains the rules, predicts consequential behaviour and changes the procedure for a reason they understand. That is work a polished output alone cannot show.
Sources and scope
- Jeannette M. Wing (March 2006), Computational Thinking, Communications of the ACM, 49(3), 33–35. Original conceptual viewpoint used for abstraction, decomposition, representation and the distinction from programming alone; not an AI intervention study.
- Paul E. Black, bin packing problem, NIST Dictionary of Algorithms and Data Structures, entry modified 2 November 2020. Primary technical definition used to distinguish constraints, variants and objectives; no algorithmic performance claim is imported.
- Python Software Foundation, Errors and Exceptions, official Python 3 tutorial. Used for the limited distinction between syntax errors and execution exceptions and the role of
raise. It does not validate the proposed teaching sequence.
Sources were checked on 16 November 2026, Singapore time. The kit, inventories, AI suggestions, test cases and learning activities are original fictional materials. The arithmetic and supplied implementation were checked separately; the examples describe the stated model rather than an actual packing operation or observed student outcome.
Continue the AI, Education and Civilisation series
Follow the argument from human learning into the institutions that shape shared life. Each article develops its own questions through practical examples and clear evidence limits.
Learning and human capability
- AI and the Paradigm Shift in Education | How Superintelligence Can Boost Human Intelligence
- AI-Powered Assignments | How Students Can Use AI to Expand Their Intelligence
- From the Centre to the Edge | How Teachers Can Teach Discovery with AI
- The Future of Education and Civilisation | How Human-AI Coexistence Expands Discovery
Culture and shared life
- AI and the Paradigm Shift in Culture | Human Creativity, Cultural Memory and New Frontiers
- AI and the Paradigm Shift in Society | From Passive Systems to Collective Intelligence
- AI and the Paradigm Shift in News | From Information Distribution to Verified Understanding
- AI and the Paradigm Shift in War | From Faster Conflict to Prevention, Accountability and Human Security
Knowledge and public institutions
- AI and the Paradigm Shift in Museums | From Preserving Objects to Expanding Human Discovery
- AI and the Paradigm Shift in History | From Recording the Past to Discovering Its Hidden Connections
- AI and the Paradigm Shift in Science | From Applying Knowledge to Discovering the Unknown
- AI and the Paradigm Shift in Government | From Administrative Automation to Public Intelligence
Economics, organisations and work
- AI and the Paradigm Shift in Economics | From Faster Output to Shared Capability and Opportunity
- AI and the Paradigm Shift in Business | From Faster Tasks to Organisations That Learn
- AI and the Paradigm Shift in Finance | From Faster Answers to Accountable Financial Judgement
- AI and the Paradigm Shift in Work | How People Build Expertise Alongside AI
Learning design and participation
- AI and Learning Transfer | Can Students Use What They Learn in a New Situation?
- AI and Curriculum Progression | What Learners Need Before They Delegate
- AI and Collaborative Learning | How Students Build Shared Understanding
- AI and Educational Access | Designing Learning That More Students Can Use
Assessment, feedback and school practice
- AI and Assessment | What Schools Should Recognise as Learning
- AI and Feedback | How Learners Use Advice to Improve
- AI and School Leadership | Turning Classroom Trials into Reliable Practice
- AI and Learning Continuity | Carrying Understanding Across Teachers and Stages
Subject reasoning and inquiry
- AI and Reading | How Students Build Meaning from Difficult Texts
- AI and Mathematical Reasoning | Checking Models, Assumptions and Proof
- AI and Scientific Inquiry | From Plausible Explanation to Testable Evidence
- AI and Historical Reasoning | Context, Corroboration and Uncertainty
Expression, place and creative practice
- AI and Writing | Building an Argument the Learner Can Defend
- AI and Geographical Reasoning | Place, Scale and Spatial Evidence
- AI and Language Learning | From Supported Practice to Independent Communication
- AI and Creative Practice | From Generated Possibilities to Intentional Choices
