How to Pin a Course Environment: Tool Versions, Images and Assignment Bundles ​

We · November 2026

This is the fifth article in the "AI Learning Environment" series, written for curriculum teams and instructors. The previous four stand with students and admissions: Check This Table Before Enrollment covers what machine each of six tracks needs, Five Things That Stall Week One covers why a finished install still doesn't work, From Script to Final Cut splits one comic-drama into six stops, and How to Explain Computer Requirements Before Enrollment has admissions finish the sentence before taking payment. This article takes the next link in the chain: inside an institution, who sets this information, how often it moves, and what gets tested before anyone touches it.

This article is method only. It evaluates no institution: no names, no comparisons, no pricing, and no business or legal advice. The version and configuration statements come from the system requirements carried on app detail pages, the verbatim hardware requirements on our workflow pages, and the PC client documentation, compiled in November 2026 — a reference, not a guarantee.

1. Which problem this article solves ​

Start with the most common sentence in any course group: "Teacher, what mine shows doesn't match yours."

Public complaint platforms carry consumer reports of exactly this: the course was recorded in advance, the software delivered later looks a little different from the interface in the video, students can't match the clicks, and asking doesn't resolve it. We treat that as a process problem rather than an attitude problem, for a plain reason: tools update monthly, course videos get re-recorded quarterly, and the two are bound to drift apart.

What version pinning does is turn three things into one: what the teacher demos in class, what is installed on the student's machine, and what the teaching assistant sees when a question arrives. Let one of the three drift and support shifts from "how do I do this step" to "why is yours different from mine". The second question involves no technology at all and consumes the most teaching hours.

This article won't repeat earlier ones. How to read an error, and how four version layers fall out of line, are covered in section four of article two; what's added here is who should have written those four layers into a document before the course opens. Building the lab, batch deployment and support rotas belong to academic operations and IT, and are covered in article six. How far non-NVIDIA cards get is left to the later article "It Is Not NVIDIA or Nothing" — everything in this article holds on the NVIDIA line only.

2. "Pinning the version" really means five things written down ​

One sentence like "we use ComfyUI" isn't enough, because there are five separate things that deserve to be called a version. The table below can be copied straight into a pinning record.

Two of the five rows are the most overlooked and the most valuable.

Row two: switching environment changes speed, not result. Our page Deploying ComfyUI with One Click: Choosing the Right Runtime Environment answers two questions. First, image quality is identical across the four environments — the profile only governs speed, GPU temperature and VRAM use, not whether the output is right. Second, if the current environment runs steadily without errors, don't switch it on purpose; day to day there is no functional difference. Put those two sentences into the course description and you remove a whole class of suspicion: "the teacher's torch is newer than mine, so am I doing it wrong?" The only cost is that switching environments re-checks dependencies and takes time, so fixing one tier in the assignment bundle beats letting the whole class try all four.

Row five can only be pinned by the institution. A stale screenshot isn't a software problem, it's a courseware problem — but it happens to be the first thing students notice and the one they report with feeling. "How far this machine gets" depends on the machine; "whether it matches the click the teacher made" depends entirely on whether you dated your screenshots. In a group chat those two look identical, and they get fixed in completely different places.

3. Why it always drifts: three kinds of change, three ways to handle them ​

Two reminders.

Don't move environment and nodes in the same change. The maintenance advice in the same client documentation states that the two highest environment tiers need a current graphics driver or CUDA may fail to come up, and that the newer the environment, the likelier a plugin last updated before 2024 will error — when loading fails, look first at the old plugins in custom_nodes.

The teacher's demo machine should match the assignment bundle that went out, not the newest release. This comes from watching our own support traffic, not from inferring it out of complaints: instructors like to be current, they install a new environment, get one run working and record against it, while students still hold the bundle from six months ago. The two produce different error text, the assistant answers from the teacher's machine, and the student ends up more confused than before.

One more word on the capability row. Whether something new enters the course is a scheduling decision and has nothing to do with "the environment doesn't match"; that content itself was covered stop by stop in article three, so it isn't repeated here. Mixing them into one to-do list is how institutions end up with an impossible requirement: "re-record the entire course every term".

4. How tight to lock: three approaches, decided by one question ​

Which one to use comes down to one question: does this course hand in assignments. If not, loose is enough. If yes, use medium. If the work goes out publicly or gets assessed, or students must train a model on their own material, use tight.

Training-type courses add one row: a file list. Training apps usually state their threshold in its own sentence on the detail page — Kohya-ss, for example, states Windows 10/11 64-bit, NVIDIA with 8GB+ VRAM and 32GB RAM advised. That sentence is a different question from "can the software open", and it should be archived together with the version.

One honest sentence up front: none of these three approaches guarantees anything will run. What pinning buys is the ability to say, when something breaks, exactly which setup this cohort uses. It will not turn a 6GB-VRAM machine into one that runs the video tier — that's what article one answers — and it is no substitute for a downgrade plan, which is column six of article four.

5. Three carriers: lab image, environment package, assignment bundle, each covering one stretch ​

Once pinned, it has to become something copyable, or it lives only on the instructor's laptop. Only three things are copyable, and each cures a different kind of mismatch.

These aren't three rungs to climb; three problems need three carriers to catch them. Images alone control the several dozen lab machines and not the laptop in the dorm — and the homework all happens on the dorm laptop. Environment packages alone work well in year one, and in year two, once upstream redesigns, "I installed exactly what the teacher sent but the interface is different" starts appearing. The assignment bundle is the cheapest of the three: it touches no software and builds no image — one page and two files, and it catches precisely the two categories of change that hurt the experience most.

For the lab layer itself — how to build images, how to batch deploy and restore — the Vocational College AI Lab Construction Guide and the AI Teaching Environment Selection Guide cover it thoroughly, so it isn't repeated here. For day-to-day maintenance one thing is worth flagging: the image's restore point has to line up with the assignment bundle's version. If a restore puts the machine back six months and the bundle says this term, the group chat ends up running two accounts of the truth at once.

The external-drive cell needs stating plainly, because it gets misunderstood. Putting apps and models on an external drive is standard practice and nothing to avoid — models run to tens of gigabytes and an internal disk fills fast. What to choose is the format: exFAT is convenient for shuttling assets between Windows and Mac, but if an app is installed and run from the drive long-term, don't use exFAT. The example in article two applies: the drive clearly had room, yet the install script reported No space left on device, and because these installs pull code from upstream with git, on exFAT the very first step fails. To run long-term off a portable drive, use NTFS on Windows and APFS on Mac — the same recommendation the SSD Formatting Guide makes for the "AI software and model storage" case.

One more cell has to be named: packaging model files and sending them to students is a license question, not an environment question. That layer is for the institution's legal and curriculum teams to confirm; we don't draw legal conclusions for institutions inside course material, and the per-item statements live in Model Licenses Explained. This article raises it and doesn't expand.

A last line for internal use, and it can be copied as a sentence pattern — how we draw the line "up to which layer does an update follow". The After-Sales Notice for Installation Services states: the one-click install build is made against the app versions at a particular point in time; during maintenance, official minor updates are handled by updating on the original app detail page; when a major iteration or architecture change requires redoing the work, a separate fee may apply. The point isn't the charge — it's that it states which layer it follows up to. When an institution tells a student "we keep the environment updated" and never adds "up to this layer", that sentence will be heard by mid-term as "everything on my machine should be new".

6. Six things in an assignment bundle, one test for each ​

Every row asks the same question: can a student open and check it themselves, and can a teaching assistant reproduce from it.

Row ① deserves honesty: not every app detail page carries a version number, and our own catalog hasn't finished adding them either. So the basis for pinning rests on three things: the date copied, the verbatim detail-page text, and a screenshot of the app's About page. That is exactly why row ⑥ exists — when the statement is incomplete, writing plainly what is known not to work beats supplying a flattering number.

Row ② is the most valuable, because a workflow is itself a file. Local AI Images and Video: Why ComfyUI Keeps Coming Up makes the case: model files can be carried between programs, while a workflow file records "how you intended to do this thing" — it can be handed to a colleague and re-run unchanged on a different machine. For an institution that's the cheapest way to store a course asset: one exercise, one workflow file, which costs less than a screen recording and travels with the student.

Rows ③ and ④ need no invented format; the pages already have it. The workflow page for Wan2.2 Animate 14B replacement mode GGUF lists its custom nodes by node pack (video helpers, KJ nodes, the WanVideo wrapper, and so on) and lists model files by directory with names and sizes. The hardware requirement on the LTX-2 text-to-video fp4 quantized tier reads, verbatim: NVIDIA cards only, Blackwell or newer architecture, at least 16GB of VRAM, and ComfyUI must use torch 2.8.0 or above. Copy those into the bundle. They are both your locked list and the evidence you use to explain to a student why their machine can't do it.

7. When an update is actually due: four moments ​

After pinning, the hard part is restraint. The workable practice is to schedule updates at only four moments and leave everything else alone by default.

"Nothing mid-term" has a basis. What the client documentation tells users is two sentences: if it runs steadily, don't switch on purpose, and switching re-checks dependencies which costs time; Python and CUDA upgrade together, some earlier custom nodes may be briefly incompatible, so validate your workflows in a test environment first and only then return to daily use (see Deploying ComfyUI with One Click: Choosing the Right Runtime Environment). Translated into a curriculum process that's three rules: change one layer at a time; before changing it, run the class's workflows on a test machine; after changing it, update the version number and the date.

The fourth rule is how it gets communicated. After a change, publish "what changed and what didn't", and state clearly which machine tier this entry does not apply to. Our own announcement shows the pattern — Three Lite Voice AI Apps Are Live doesn't just say "three new apps shipped"; it lists which features are kept and which aren't, one by one. An institution issuing a course update note can reuse the same structure: what was added / does the previous version still work / which tier fails this time / what the student needs to do (usually nothing). Drop the second and third lines and old cohorts read an update notice as "my machine is obsolete".

8. When a returning student says "the interface looks different", three people need three answers ​

One thing deserves separate memorizing: an interface change does not justify re-recording. A three-column mapping table — position in the video, current name, one-line note — takes half an hour; re-recording one lesson takes two days. Only capability changes justify adding a new lesson; environment changes require no re-recording at all, only the version number and file list inside the assignment bundle.

Two sentences are worth deciding in advance never to write. One is "our environment is always the latest": the tool ecosystem changes monthly, so it can't be honored and only digs a hole for support three months out. The other is "using the newest version guarantees a good result": there is no such equality between version and learning outcome. The closing line of article three holds here too — version and configuration are entry conditions only; the work itself comes from script, storyboard, pacing and everything outside the toolset.

9. Four signals that it's time to keep a pinning record ​

If these appear in your group chat, what you're short of isn't support staff — it's a pinning record. Each one has a cheap fix.

The last of the four costs the most people and pays the most: it moves environment knowledge off a person and onto a file. A course that survives an instructor change does so because of that page, not because someone remembers which node pack installed which package.

10. Three sentences to carry away ​

What you write down isn't one version number; it's five things: the app itself, the runtime environment profile, custom nodes, model files, and the capture date on courseware screenshots. The first two are stated on the app page, the third and fourth on the workflow page, and the fifth only the institution can supply.

The three carriers each cover one stretch: the image buys consistency, the environment package buys installability, the assignment bundle buys matching. Buying the most expensive one doesn't give you all three stretches — and the assignment bundle happens to be the cheapest of the three.

Updates are the exception, not the default: change one layer at a time, run the class's workflows on a test machine first, update the version number and date afterwards, and note which machine tier failed this time.

The payoff of pinning isn't a faster install; it's being able to say the sentence. "This cohort uses this set" is checkable; "we keep the environment updated" is not.

Disclaimer: The version and configuration statements in this article come from the system requirements carried on app detail pages, the verbatim hardware requirements on our workflow pages, and the PC client documentation, compiled by us in November 2026. Software, models and custom nodes update weekly or monthly, and requirements and file lists may change; the figures and wording here are a reference for judgment, not a guarantee that any app or course will run or deliver on your device. This article refers to and evaluates no specific institution or course; the parts describing industry phenomena are drawn from consumer reports on public complaint platforms and illustrate categories of problem only. Licensing and authorization matters are flagged in this article and deliberately not expanded.