To understand how a computer chip is made, Laurentiu Raducu did not ask an LLM to write him a lesson.
He asked it to build a factory.
The result is ChipTycoon, a tiny semiconductor fab drawn like a RollerCoaster Tycoon park. A cart moves material from building to building, from quartz to a polished wafer, then around a lithography loop before testing, dicing, packaging and a final delivery to a data center.
The first guided run takes about nine minutes. There are 22 stops. The whole thing is drawn in Canvas, without a framework or network call.
That is a lot of generated machinery to avoid reading fourteen paragraphs beginning with "photolithography is a process that..."
The idea deserves something more useful than the usual "are LLMs good teachers?" argument.
Build the explanation instead of asking for one
Raducu describes a fairly simple workflow.
He starts in plan mode with Claude Code or OpenCode and asks the model to build foundational knowledge for a topic. He then asks it to review that knowledge base for accuracy. Next he asks for an interactive simulation, usually in the same low-poly management-game style. The result goes onto GitHub Pages, and he can add questions or challenges afterward.
The interesting shift is that an artifact forces an explanation to take a shape.
A sentence such as "chip fabrication repeats deposition, lithography and etching" can remain vaguely understood. In ChipTycoon, someone has to decide where the cart goes, what it carries, what changes at each station and why it returns to the loop.
The simulation makes relationships visible.
It also makes errors visible, if somebody bothers to look for them.
The "100% accurate" part breaks first
In his post, Raducu describes the generated animations as "100% accurate and free of hallucinations" after having the model review its own knowledge base.
That guarantee does not exist.
A second model pass can catch inconsistencies. It does not create an independent source. Several Hacker News commenters immediately challenged that leap, reasonably enough.
So I took ChipTycoon at its word and compared its route with process descriptions from the Semiconductor Industry Association and Intel.
The good news is that the broad structure is not fantasy.
Quartz and silicon purification, crystal growth, wafer slicing and polishing, masks, deposition, photoresist, lithography, etching, doping, interconnects, wafer testing, dicing and packaging are all real families of semiconductor manufacturing operations.
The more interesting problem is pedagogical: the park makes the process much more regular than it really is.
A real fab does not run the same six-stop loop sixty times
ChipTycoon's README says its third act is a ring because chip manufacturing means going through the same six buildings once per layer, around sixty times. The park shows four laps so the lesson does not become shift work.
As a mental picture, the loop works. Modern manufacturing really does repeat enormous numbers of operations on the wafer.
Taken literally, it is too neat.
The Semiconductor Industry Association describes hundreds of passes involving oxidation, thin-film deposition, photolithography, doping, metallization, etching, planarization and metrology. But every level does not run the same sequence in the same order.
Transistors are built in the front end of line. Contacts and interconnect structures continue through middle and back end of line. Ion implantation creates particular doped regions. Copper fill belongs to interconnect structures. They are not two universal stations every wafer necessarily visits after every mask.
The loop is therefore a pedagogical compression of several process families.
That does not make it useless. It means the learner is looking at a subway map, not an aerial photograph of the city.
One photoresist detail is enough to show the problem
ChipTycoon also explains that after exposure, liquid washes away the parts of photoresist that were hit by light.
That is a real positive-resist workflow.
The SIA describes the mechanism more carefully: depending on the resist and process, exposure can harden or soften the affected areas. In other words, the simulation chooses one common path and presents it as the behavior of photoresist.
It is a small simplification. It does not make ChipTycoon a bad learning artifact.
It is enough to kill the "100%" claim.
Even the layer count moves around. Intel describes a common chip as having roughly thirty layers of components and interconnects, while one older Intel 14 nm example required seventy masks. A mask, lithography step, physical layer and metal level are not interchangeable units.
A simulation has to choose numbers. The problem starts when the interface makes the choice disappear.
Research on AI learning tells two opposite-looking stories
This is where the research becomes useful.
In 2025, a randomized crossover study in a Harvard physics course compared in-class active learning with an AI tutor built specifically to teach the same material. The tutor used carefully designed prompts and pedagogical scaffolding. Students in the AI condition had significantly larger learning gains, with the reported median gain more than twice that of the classroom condition, while spending less time.
That shows a generative system can be a strong learning tool when the interaction is designed to produce learning.
A separate randomized study published in 2025 produces almost the reverse picture. Among 120 students learning AI concepts, the group allowed to use ChatGPT freely as a study aid scored 57.5% on a surprise retention test 45 days later, versus 68.5% for students using traditional study methods.
One trial does not cancel the other.
They are not studying the same intervention.
"Learning with AI" can mean a heavily scaffolded tutor that keeps asking the learner productive questions. It can also mean offloading effort as soon as an answer becomes available. Putting both under the same label hides what may be the central variable: what the tool still requires the learner to do.
The simulation gets better when it pushes back
Raducu's method has a useful intuition, but I would change the validation step.
Instead of:
- the LLM builds the knowledge base;
- the LLM checks its knowledge base;
- the LLM builds the simulation;
keep the agent for fast construction, then make the artifact contestable.
Each station could link to an external source. Approximations could be labeled as approximations. A compressed step could say which real operations it merges. More importantly, the simulation could ask the learner to predict what happens before playing the animation, then solve a few problems without it.
Raducu already suggests adding challenges and questions. That may be the part worth pushing furthest.
An animation gives a pleasant sense that everything fits together. Learning becomes more visible when you try to use the mental model without the animation and one of the pieces suddenly refuses to fit.
Having an LLM build an artifact is a good way to make an explanation inspectable. It only becomes dangerous when "inspectable" quietly turns into "true."