AI engineering from scratch learning path: the repo curriculum

AI engineering from scratch learning path: 542 MIT-licensed lessons, three ways to start and an agent-trace workshop for SRE teams to adopt.
AI engineering from scratch parcours IA : le cursus du dépôt

AI engineering from scratch is an AI engineering learning path published under the MIT licence in the rohitg00/ai-engineering-from-scratch repository. The README presents it as a free, open-source curriculum: implement model internals, retrieval pipelines and agent runtimes, test them, inspect failures, and keep the code and evaluation results. The repository shows about 72,200 stars in mid-October 2026.

The project is neither a tool to install in production nor a service: it is a learning programme. This article describes the path as the repository presents it, explains how to start according to the README, and offers a team angle: using the curriculum to train engineers in agent observability.

span.observer did not follow this path or run its code for this article. The excerpts and the figure come from the repository, under the MIT licence.

AI engineering from scratch: what the repository says

  • Author and licence: the README says it is maintained by Rohit Ghumare and the community; MIT licence, “use it however you want”.
  • Figures read on 22 October 2026 on the repository page: about 72,200 stars, about 12,700 forks, 2,107 commits on the main branch.
  • Announced size: 542 lessons across 20 phases, in Python, TypeScript, Rust and Julia (README badges and quote).
  • Three ways to learn: on the aiengineeringfromscratch.com website, with a coding agent as tutor, or by running the code locally.
  • Sponsors: the README shows a sponsor banner and a support page; it says lesson content stays free.

The repository is not a Dynatrace product. It still touches our topic: one phase covers infrastructure and production, and one project deals with agent traces. What follows applies to Dynatrace SaaS and Dynatrace Managed in the sense that training comes before the observability tool.

The path: phases and learning routes

The README organises the twenty phases as a stack: mathematics as the floor, agents and production as the roof. It lists among others Setup and tooling (phase 0), Math (1), ML (2), Deep learning (3), Vision, NLP, Audio, Transformers, GenAI, LLMs from scratch (10), LLM Engineering (11), Tools and protocols (13), Agent Engineering (14), Autonomous systems (15), Multi-agent (16), Infrastructure and production (17), Ethics and alignment (18) and capstone projects (19).

So that you do not have to scan 542 lessons, the README offers routes by goal with estimated times: about 306 hours for a complete beginner starting at phase 0, about 60 hours for a senior engineer who only wants phase 14 (agents), about 23 hours 15 minutes for the MCP path alone. Those durations are the repository’s, not span.observer measurements.

The first figure comes from the README: a gradient descent demo on a quadratic loss, where twenty starting points converge and the mean loss falls at each step. It illustrates the curriculum’s style, which favours visualisations whose parameters you can adjust.

Figure from the ai-engineering-from-scratch README: gradient descent on a quadratic loss, starting points converging towards the minimum and a curve of the mean loss falling per step
Source : github.com

Every lesson follows the same tree: a code/ folder for implementations, docs/en.md for the narrative, outputs/ for the prompts, skills, agents or MCP servers produced. The README describes six beats (motto, problem, concept, hand-written “Build It”, library-based “Use It”, “Ship It”).

Excerpt from the ai-engineering-from-scratch README: lesson tree with code, docs and outputs, and git clone, verify.py and vectors.py commands to run the code locally
Source : github.com

Getting started step by step

Option 1: on the website

Open a lesson on aiengineeringfromscratch.com; according to the README, there is no setup and no cloning.

Option 2: run the code locally

The README asks you to clone the repository, then run the environment check and a first dependency-free lesson.

git clone https://github.com/rohitg00/ai-engineering-from-scratch.git
cd ai-engineering-from-scratch
python3 phases/00-setup-and-tooling/01-dev-environment/code/verify.py --route beginner
python3 phases/01-math-foundations/01-linear-algebra-intuition/code/vectors.py

The README describes the check as separating requirements needed now from those needed later, with a corrective command for each failure.

Option 3: a coding agent as tutor

With Node.js, npx and a skill-capable agent, the README suggests:

npx skills add rohitg00/ai-engineering-from-scratch

The installer asks for the host and scope. The skills provided include start-learning (placement quiz and plan saved to LEARNING.md), learn, course-guide and check-understanding; the invocation syntax depends on the host (/start-learning in Claude Code).

Excerpt from the ai-engineering-from-scratch README: npx skills add command, skill invocation syntax in Claude Code and Codex, and project_test.py commands of the agent-trace-debugger project
Source : github.com

Projects: one example focused on agent traces

The README offers three projects with local graders. The “Agent Trace Debugger” (TypeScript, Node.js 22.18 or newer, Python 3 grader) starts from a supplied trace where duration stays at 100 ms but total token usage rises by 200 and one span fails. It asks you to parse JSONL, validate parents, compute intervals, then produce an HTML timeline and a JSON regression report. The README says to keep exclusive per-span token counts so parent and child usage are not counted twice.

It is a good workshop base for an SRE team: it reuses the trace and span logic described in observing MCP agents with OpenTelemetry, but on the exercise’s own format, not on OpenTelemetry itself. The third project, “Tool Call Firewall” (Rust), works on role checks and approval receipts; the README states it provides no persistent authorisation and no operating-system sandbox.

Limits and open points

  • Volume: 542 lessons is a programme of several hundred hours; pick a route.
  • No release: the content changes continuously; note the commit your team follows.
  • Possibly uneven quality: the content is community-driven; check critical lessons against a primary source.
  • Prerequisites: the README expects you can write code, Python helping.
  • Data and keys: some lessons call models or APIs; use test keys and never write them into the cloned repository.

Observing and monitoring the work on the curriculum

There is nothing to monitor on the repository side: it hosts no service. If you use the tutor through a coding agent, the trace comes from the client:

How to check that it works

  1. verify.py --route beginner ends with no required failure.
  2. vectors.py runs without dependencies and prints its output, which the README invites you to keep as first evidence.
  3. With the tutor, your agent lists the installed skills (start-learning) at the location chosen during installation.

Best practices

  • Choose one route per person rather than the whole curriculum.
  • Follow the repository’s rule: run, keep the evidence (command, output, artefact), then change one detail.
  • Work in a dedicated clone on a machine without production secrets.
  • Review each skill installed with npx skills add before enabling it: a skill is text that drives your agent.

Frequently asked questions

Where should I start if I already know Python?

The README suggests phase 1 (mathematics) if you are new to ML, or phase 14 if you only want agents.

Do I need an account or a subscription?

The README describes it as free and open source; some lessons may use third-party APIs, to check lesson by lesson.

Does the curriculum cover MCP?

Yes: the README lists a 17-lesson MCP path. For the basics, see our explanation of the Model Context Protocol.

Conclusion

AI engineering from scratch is an ambitious, open curriculum whose strength is making you write the simple version of each component first. For a team, the right approach is to extract a few targeted routes and pair the workshops (such as the trace debugger) with your observability practice. Source: rohitg00/ai-engineering-from-scratch repository.

span.observer is an independent community blog, not affiliated with Dynatrace LLC, with the projects cited or with Anthropic. Trademarks belong to their owners. Tools change quickly: check commands and options in their official documentation.

Total
0
Shares
Leave a Reply

Your email address will not be published. Required fields are marked *

Previous Post
Anthropic financial services agents : structure et supervision

Anthropic financial services agents: structure and monitoring

Next Post
ECC optimisation harnais agents : skills, hooks et sécurité

ECC agent harness optimization: skills, hooks and security

Related Posts