PME means professional military education. The Classroom version is also available for high school.
Two students in a programming class get the same docs and the same time limit to build a feature with a library new to them. The class allows AI, and both say they used it. One takes an AI's code as written, without asking how it works. The other asks the AI only how things work, then writes the code, breaks it once and fixes it. The first route is premature synthesis: the model connects the material before anyone has built the map. What separates them is engaging with how the code works: asking, trying, breaking it and seeing why. Writing it yourself is one way to do that. In the study, the top group had the AI write the code, then asked it follow-up questions to understand it. This example suits computer-science classes. Illustration based on Shen & Tamkin (2026), a study of developers learning a new library; the students, the class and the task are constructed.
Classroom edition. PME is the example from the original essay, linked below.
An animated figure. A red dot stands for a student with an example task: using a library new to them, fetch three records at the same time. Six cards stand for sections of the library's docs: retry on error, task groups, timeouts, error handling, fetching records and channels. The student reads each section closely, then has an AI write the code, which joins the sections with five grey connections at once. The student takes the code as written, without asking how it works, and hands it in, titled "Fetch all three records in one task group", whose main link is between sections 2 and 5, with a note that AI helped with the code. A second student, with the same docs and the same time limit, asks the AI only how cancellation works. The AI explains that in a task group one error cancels all the other tasks, and writes no code. The student writes three connections of their own, then a fourth, between sections 1 and 2, that breaks, with the note "Bug: when one fetch failed, the group canceled the rest." The student fixes it alone: each fetch catches its own error (1 to 4), and a timeout counts as an error (3 to 4). Both hand in the same code within the time limit. In class, with the code closed, both sketch the same connections: the first redrawn from the AI's code, the second built, broken once and fixed. The teacher points to the connection between sections 2 and 5, the task group and the fetches: what would make that fail? The first student says, "It fetches all three in one group. If the group fails, they all fail." The second, remembering the bug, says, "A missing record. Its fetch fails, so the group cancels the other two." The figure ends on the teacher’s check, with the source under the picture. Each beat is listed below with what is on screen.
0Premature synthesis · Failure mode 3 of 7
On screen: the name, "Premature synthesis", appears large over the stage with "Failure mode 3 of 7" above it, then moves into the top-left corner, where it stays.
1A student in a programming class must build a feature with a new library.
On screen: a task card appears at the top right: "Example task: Using a library new to you, fetch three records at the same time." A red dot labelled Student appears on the left. Six numbered cards for sections of the library's docs appear one at a time: 1 Retry on error, 2 Task groups, 3 Timeouts, 4 Error handling, 5 Fetching records, 6 Channels. Nothing joins them yet.
2The student reads the docs closely, then takes an AI's code without asking how it works.
On screen: the dot visits each card, and each opens to show notes. The dot pulses. Five dashed grey lines appear all at once, labelled "AI code", joining 1 to 4, 4 to 6, 3 to 4, 3 to 5 and 2 to 5.
3The code runs, and the student hands it in as written.
On screen: the dot pulses once and every grey line turns solid at the same moment: the student takes the code as written, with no questions about how it works. The dot goes straight to write up the code on the left, labelled "First student's code" and titled "Fetch all three records in one task group." As the title appears, the line from 2 to 5 turns heavy and is labelled "Main link". The first paragraph, tagged "Main", cites sections 2 and 5; the others cite 3, 4 and 5, and 1, 4 and 6. A grey note at the foot says "AI helped with the code".
4A second student, with the same docs and time limit, asks the AI only how it works, then writes the code.
On screen: the grey lines and the first dot leave, and the cards close. A second red dot labelled Second student visits each card the same way, and each opens to show notes. The dot returns and pulses. Beside it, in red: "How does cancellation work?" Under that, the AI's answer in grey: "AI: in a task group, one error cancels all the other tasks." The AI writes no code. The dot draws three red lines: 2 to 5, 3 to 5 and 4 to 6.
5One part breaks. That student works out why and fixes it.
On screen: the dot draws a fourth line, from 1 to 2, and goes back to both cards. A red cross appears on that line, with a red note: "Bug: when one fetch failed, the group canceled the rest." The line pulls back; the cross and the note stay. The cross brightens, and the dot draws the fix in red: 1 to 4, labelled "each fetch catches its own error", then 3 to 4, labelled "a timeout counts as an error".
6That student hands in the same code, within the same time limit.
On screen: the dot writes up the code under the first, labelled "Second student's code", with the same title, citations and grey note, and lines of different lengths. The cards, lines, note, question and answer leave. "What the teacher receives. The same code." appears above the two.
7With the code closed, both students sketch the same connections.
On screen: the two write-ups shrink and slide up into a strip at the top left, next to "Both say AI helped". "In class, code closed: Sketch how the pieces connect." appears. Each row is labelled: "First student: read, AI writes, hands in" and "Second student: read, asks AI, tries, fixes". Each student draws six numbered points joined by the same five lines, in the same ink. Under the first row: "Redrawn from the AI's code", in grey. Under the second: "Built, broken once, fixed", in red.
8The teacher asks what would make the main connection fail.
On screen: "Then the teacher asks: The task group and the fetches, 2–5: what would make that fail?" appears, and on both sketches the line from 2 to 5 is ringed. The first student says: "It fetches all three in one group. If the group fails, they all fail."
9The second student, who asked how it works and hit the bug, applies the rule.
On screen: in the second student's row, the ring pulses, and "What they learned" appears in red over the note: "When one fetch failed, the group canceled the rest." The second student says: "A missing record. Its fetch fails, so the group cancels the other two."
10Teacher’s check: Can they say why these connections matter? Point to one: what would make it fail?
On screen: the questions appear under the picture at the same size, with the source at the bottom left: "Illustration based on Shen & Tamkin, Anthropic (2026)." The two write-ups, the row labels, the sketches, both answers and the note stay in view.
Teacher’s check
Can they say why these connections matter?
Point to one: what would make it fail?
Both students can sketch the design. The second question separates them: the student who asked how it works, then hit the bug and fixed it, can name what would make one connection fail and what that breaks.
The study behind this example
Judy Hanwen Shen and Alex Tamkin at Anthropic ran a randomized experiment with 52 developers recruited online, most of them professional or freelance programmers: 29 had seven or more years of coding experience, 19 had four to six, and 4 had one to three. They were learning "a new asynchronous programming library", Trio. Each had up to 35 minutes for two short tasks, one of them a function that handles missing-record errors, then took a quiz on the library. Most of the study's participants were working developers; the students in the figure are constructed.
Developers given an AI assistant scored lower. The paper puts it this way: "For a 27-point quiz, this translates into a 17% score difference or 2 grade points" (Cohen's d = 0.738, p = 0.01). Anthropic's summary gives the averages as 50% with AI and about 67% by hand. The AI did not make them significantly faster. The average hides a split by how people used the AI: the top-scoring group also had the AI write code, then asked how it worked (below). The authors also note a limit: "there was not the same incentive to learn the library as if it were required for their actual job."
In an exploratory breakdown ("exploratory data analysis (not pre-registered)"), the largest score gap was on debugging questions. The authors' explanation is that the group without AI "encountered more errors during the task and became more capable at debugging."
How people used the AI mattered, in small groups the authors identified from screen recordings. Conceptual Inquiry, seven people: they "only asked conceptual questions and relied on their improved understanding to complete the task. Although this group encountered many errors, they also independently resolved these errors." They averaged 65%. AI Delegation, four people, "wholly relied on AI to write code and complete the task" and averaged 39%; they were the fastest, at 19.5 minutes on average to Conceptual Inquiry's 22. Iterative AI Debugging, four people, "relied on AI to debug or verify their code" and averaged 24%.
Who wrote the code wasn't the dividing line. The top group, Generation-Then-Comprehension, two people, "first generated code and then manually copied or pasted the code into their work. After their code was generated, they then asked the AI assistant follow-up questions to improve understanding." They averaged 86%. The authors note that this approach "looks nearly the same as the AI delegation group, but additionally uses AI to check their own understanding." In the figure, the first student follows AI Delegation, taking the code as written, and the second follows Conceptual Inquiry.
Limits: one session of two short tasks, about an hour, with the quiz straight after; 52 people, and groups of two to seven; and the incentive gap the authors note (above). The figure's question in class is constructed; the study measured a quiz. Other evidence points the other way: a field study of 5,172 customer support agents found "evidence that AI assistance facilitates worker learning" (Brynjolfsson, Li & Raymond, "Generative AI at Work").
From the original PME essay
Premature synthesis appears when a student asks AI to connect material before doing enough work to know what should be connected. The output links sources, themes, and concepts in ways that feel coherent. But if the student cannot reconstruct why those connections matter, the synthesis belongs to the model. The student has bypassed the developmental struggle of forming a mental map and inherited one instead.