Changelog

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.