Changelog

Someone told us they kept asking for hints not because the code was hard but because they could not tell what the step wanted. That is a writing problem, so the fix is in the writing. There is a Tutor voice setting on the study screen now, and it changes how lessons are worded as well as how your work is reviewed. Plain is the new default and it is exactly what it sounds like: short sentences, a term defined the first time it turns up, and a task you can act on without asking what it meant. If you want something else, Coach notices what improved since your last attempt, the Analogist reaches for an everyday comparison before it reaches for jargon, the Socratic hardliner answers almost nothing and just keeps asking, and the drill sergeant is as blunt as it sounds and will not pretend unfinished work is fine. OG model turns all of it off and leaves the model talking the way it normally does. Your pick is saved to your account, so the local agent uses it too.

The start screen had a topic box and a repo box stacked on top of each other, with the repo read-depth options showing underneath both of them even when you had not typed a repo. You had to read the placeholder text to work out which half of the page was yours. There is a switch at the top now, and it shows you one door at a time. Language, model, tutor voice, difficulty and guidance always applied to both doors, but they rendered below the repo box and read like repo settings, so they have moved into one Options group that stays out of the way until you open it. Popular topics and the full course map are still there under everything, always. The screen remembers which door you used last.

Two things, and the second one is a bug we should have caught sooner. The rules about what each runtime can do were only ever shown to the model that writes a lesson, never to the one reviewing your code mid-lesson. So a tutor could walk you through requiring lodash in a browser runtime that has no module system at all, which is not something you could have done and was never your mistake. It has both halves of that now. If you do try an import in the browser runtime you get a sentence explaining there is no module system rather than a parser error about module declarations. And because some lessons really are about a library, there is a Node option that runs on the server where require works, with lodash and dayjs installed. The tutor is told exactly which packages exist, so it will not send you after one that does not.

Bring-your-own-key now takes a Google Gemini API key alongside Anthropic, Amazon Bedrock, OpenRouter, Ollama and any OpenAI-compatible endpoint. The local agent takes one too. Google also renamed Vertex AI to the Gemini Enterprise Agent Platform, so that option is relabelled, and both entries now say which credential they want: the enterprise one runs Claude on your own Google Cloud project and needs service-account JSON, while a plain API key only ever works with Gemini. Separately, the model picker used to hide the experimental models from other labs unless you were already paying, which meant the one place you would naturally find out about them said nothing. They are listed for everyone now, marked as needing Pro.

The switch for putting your name on lessons you contribute governed a name you had never been shown and could not edit. It came from your sign-in once, at account creation, and often was not there at all, so plenty of people were turning on an attribution they could not predict. There is a name field beside the switch now, and a line under it showing the exact sentence a lesson will print, fallback included. Feedback got the same treatment from the other side: both the dashboard form and the report button inside a lesson start with a short template asking what you did, what you expected and what happened instead. Every line is editable and you can delete any of it. Switching between bug and feature never overwrites something you have already started typing.

The first lesson used to open with five explanation boxes about the screen and then go quiet, which left you looking at a file of code with no particular reason to think pressing Run was the next move. It is a walkthrough now. Three short boxes cover the brief, the editor and the Run button, and after that it responds to what you actually do: it points at Run, then at the output once there is output to read, then it notices when you have written the line the step asked for and tells you to try it. What it says about your work comes from watching your code run, never from guessing, so it only sounds certain when it has seen the thing happen. If you go quiet for a minute it reminds you what the step wanted, and if you are still stuck it shows you where to ask. It is marked as a tutorial throughout, and there is a way to replay the tour if you skipped it.

Three things. The walkthrough used to live on one lesson, so whichever of the four starting lessons you picked decided how much help you got; all four now run the same way, worded for their own first step. It also waits for a finished line before it says anything, rather than piping up halfway through one being typed. And it watches what your runs actually do: run the code twice without getting there and it tells you what is still missing, and if that does not land it shows you where to ask, which is the one place it will explain the idea without writing the line. Milestones arrive as you go, so you can see how much of the lesson is behind you.

Some things are hard to say in a paragraph and easy to see. Two changes. A lesson can now start a step with a small diagram of how the pieces relate, which file calls which, what happens in what order, which is the thing you most want when the codebase is new to you. And when you submit, the review can come back with a picture next to the words: a trace you step through frame by frame to watch each value change, or a side by side of what your code did against what the step asked for. The diagram at the top names the parts and never the answer, exactly like the explanation above it always has. The picture that shows your values only arrives once you have written something, because working it out is the part that teaches you.

Account deletion used to mean emailing us and waiting. You can now do it yourself from Plan and billing, and it takes effect at once rather than joining a queue. Your lessons and everything you wrote inside them, your saved concepts and revision schedule, your API tokens, your linked devices and your name and email address are all erased. Anonymised usage totals stay, because they are our accounting records, with nothing identifying left attached to them. The privacy policy now spells out how long every category of data is kept, including how long a deleted lesson can still sit in a backup before it ages out.

There is a theme control in the header of every page now, including the study screen and this dashboard. It remembers your choice across the whole site, so picking light on the marketing pages and then signing in no longer drops you back into dark halfway through. Dark is still what you get by default. The dashboard also opens on a Learn tab holding your next lesson and this card, with plan, seats, keys and billing moved into their own tab, so the first thing you see when you arrive is the thing you came to do.

New accounts now start on a leaderboard whose top-three function passes its test and still scrambles which score belongs to which person. You find the damage, fix it without changing what the function returns, write the check that would have caught it in the first place, then go looking for the same trap in a different method. It replaces a print-a-greeting exercise as the first thing you meet, because sorting out a real defect in code that looks fine is closer to the work than printing Hello is. The beginner track is still there and still one click away if you are starting from zero.

JavaScript lessons run in your own browser, which is what keeps the free tier free, and that runtime has no package manager in it. Asking about a library used to produce a step that called that library, which then could not run. Those lessons now teach the idea the library implements and have you write it in plain JavaScript, checked against how the project's own source does it, which is the better lesson anyway: you understand what next() does by writing the chain, not by importing it. Python lessons are unchanged and still import anything Pyodide can load.

Everything on this card now also lives on a page anyone can read, at codetrain.ai/changelog, so you can point a teammate or a manager at what CodeTrain has actually done without them needing an account. Alongside it there is a roadmap drawn the same way the course map is, one line running from launch through what is shipped, what is in progress, and what is still being weighed up. Shipped items carry the date they went live and nothing ahead of today carries a date, because that would be a guess. If something you need is missing from the line, replying to say so genuinely moves the order.

The homepage carries a working lesson now. It is a real editor running real JavaScript in the visitor's own browser with real checks, on a bug that looks like it passed and did not, so a person can find out what a Socratic step actually feels like before deciding whether to sign up. The tutor's replies there are written in advance and the page says so plainly, because the one thing a preview must not do is pretend to be the model. Useful if you have ever tried to explain CodeTrain to a colleague and wished you could just hand them a link.

The Progress tab used to show every concept you had touched as one flat row of tags, which told you what you had seen but nothing about what you could still do. It now splits them three ways: due for review, still learning, and solid. Solid means you beat it in review, not that you met it once. Concepts also stop showing up twice because the tutor worded them slightly differently on two days, so the list is shorter and truer than it was. If you lead a team, the members table gains the same signal per person, showing how many concepts are due for review right now.

Opening CodeTrain for the first time used to mean a blank box asking what you wanted to learn, which is a hard question before you know what a lesson looks like. Now a new account gets three short beginner lessons to choose from, Python, JavaScript or the terminal, and while you work through the first one the editor, the Run button, the review and the checks are pointed out as you reach them. It is a real lesson, reviewed the same way every other lesson is, not a demo. We cover the cost of that first one, and it does not count against your ten free lessons a month. If you would rather just browse, the walkthrough is one click to skip and it will not ask again.

Close the tab and come back tomorrow, or pick the lesson up on another machine: your code is waiting. Every step you submit is saved, so resuming puts you back on the right step with your own work in the editor, and the earlier steps sit one click away under Your code from earlier steps. Your browser also holds on to whatever you typed but never submitted, so a reload in the middle of a thought no longer wipes it. Finishing a lesson clears that local copy.

When a review comes back with a check unticked, there is now an Ask about this button next to it. The tutor sees the check you pointed at, what it told you last time, your code and your last run output, so the answer lands on your actual problem instead of a guess at it. Questions also stop overwriting each other: everything you asked during the lesson stays readable under Questions you asked in this lesson, and it is still there when you resume.

Curated lessons no longer ask you to choose a model, because the lesson already knows what it needs. Straightforward steps use the quick model, which stretches your usage further. Lessons where the details bite, like the NumPy maths in How LLMs Actually Work, get the deeper model from the first attempt. If a step starts taking a few tries, CodeTrain brings in the deeper model on its own and says so, then drops back to the quick one on the next step. Hints and concept checks always use the quick model. You still pick the model for your own topics, repos and drills, and if you want a testing model on a curated lesson, choose it before you start.

Repo lessons now have a read-depth choice. Quick tour pulls a handful of key files and is the cheapest way to get the shape of a codebase. Deep read pulls far more of it, so the tutor can answer real questions about how things fit together. The surprising part: deep read costs more to start and then less per step, because once the context is large enough it gets reused between steps instead of re-sent in full every time. On a long lesson that works out cheaper than a tour. Both depths are available on the free tier, and the lesson header tells you which one you got and exactly which files it read.

While you work, the tutor notices which steps actually gave you trouble: where you needed hints, where you retried, where you skipped. Each of those becomes a tracked concept with a review date, and it comes back at widening intervals so it sticks instead of fading. Open Progress and any concept that's due has a Drill this button. The drill is a brand-new exercise built from what you specifically got wrong, not a replay of the lesson you already did. Get it clean and it moves further out; struggle again and it comes straight back tomorrow. Nail it enough times and it graduates to Beaten. If you also use the CodeTrain skill in Claude Code, both share one schedule.

Finish a lesson and you can download a receipt as JSON. It records which steps you wrote correctly first try with no help, where you took a hint or retried, which checks passed, and how long each step took. It is the honest version of a completion certificate: evidence of the work rather than a percentage. On Team plans, leads see the same numbers per member, including an Unaided column, because finishing a lesson and being able to do the thing are not the same claim.

There's a repo box on the study screen. Paste any public GitHub URL and the tutor reads a slice of the real source, then teaches you from that instead of a generic example. Type something in the topic box first and it aims there: 'how the API works', 'the auth flow', 'how tests are structured'. Leave the topic blank for a tour of the codebase. Secrets and lockfiles are never read, and the lesson shows you exactly which files it used. For private code, repo mode with the agent runs against your own checkout on your machine.

A hands-on path from a single neuron to a working transformer, all in pure NumPy that runs right in your browser. Four classes, 18 lessons: neural-net foundations, tokens and embeddings, the Transformer block, then training, sampling and fine-tuning. Along the way you get paper spotlights (Attention Is All You Need, GPT-2, InstructGPT) and interactive demos. Inspired by Syntax's video I Built an LLM From Scratch.

Lessons are more than code steps now. They can pull in a paper spotlight next to the concept it introduced, a history timeline, and small interactive demos like a tokenizer playground and an attention-weight heatmap you can poke at. Reading-only steps advance for free, so exploring the history never spends your monthly usage.

The starter courses are laid out like a transit map: each course is a line, each class is a stop, and every stop holds hands-on lessons you type yourself. Easier to see how the pieces fit and where to jump in. And you're never limited to the map: type any topic, or bring your own files, and CodeTrain builds a lesson on the spot.

Three new curated starters joined the catalog: Object-Oriented Python (classes, methods, and the dunder basics), JavaScript functions and closures, and a first taste of Linux and Bash that runs live in a real sandbox.