AI Engineering Curriculum Languages: Python, TypeScript, Rust, and Julia Explained

The AI Engineering curriculum supports exactly four programming languages—Python, TypeScript, Rust, and Julia—with strict dependency constraints defined in the repository's AGENTS.md policy file to enforce a stdlib-first learning approach.

The rohitg00/ai-engineering-from-scratch repository defines its language support through a rigorous governance model outlined in AGENTS.md. This curriculum deliberately restricts implementations to a concise set of languages and dependencies, ensuring learners focus on algorithmic fundamentals rather than framework-specific shortcuts. Each language serves distinct purposes within the learning path, from numerical computing to performance-critical systems and web-based agents.

Supported Languages and Dependency Allowlists

According to the AGENTS.md Dependencies table, the curriculum permits only four languages with carefully curated third-party package allowances. This constraint forces implementations to remain portable and focused on core concepts.

Python

Python implementations may use the standard library plus five specific packages: numpy, torch, h5py, zstandard, and safetensors. This restriction appears explicitly in the Dependencies table of AGENTS.md. Most algorithmic lessons use Python as the primary implementation language, particularly for machine learning and linear algebra foundations.

TypeScript

TypeScript is permitted for web-based agents and user interfaces. The allowlist includes hono, zod, ws (reserved strictly for WebSocket requirements), and @hono/node-server, alongside the Node.js 20+ standard library. This configuration supports modern serverless architectures while maintaining strict boundary enforcement.

Rust

Rust implementations must compile using single-file rustc --edition 2021 with no external crates. The curriculum restricts Rust to the pure standard library, making it ideal for performance-critical components where zero-cost abstractions matter without dependency overhead.

Julia

Julia is supported for numerical-science explorations using only standard library modules: Random, Statistics, LinearAlgebra, and Printf. These built-in packages provide sufficient functionality for mathematical foundations without requiring external dependencies.

How Language Constraints Are Enforced

The curriculum enforces these language restrictions through lesson-level metadata and file structure validation. Each lesson's frontmatter includes a Languages field that must match the allowed set defined in AGENTS.md.

For example, the "Linear Algebra Intuition" lesson located at phases/01-math-foundations/01-linear-algebra-intuition/docs/en.md declares Python, Julia in its frontmatter metadata. This declaration drives the validation of accompanying code files and ensures consistency across the repository.

Implementation Structure and Code Examples

Every lesson follows a consistent file layout where implementations reside in code/main.<ext> with mandatory header comments citing the lesson documentation. Below are minimal "Hello, World" examples following the curriculum's lesson contract.

Python Example

# Linear Algebra Intuition – Python implementation

# docs/en.md: https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/01-math-foundations/01-linear-algebra-intuition/docs/en.md

def hello():
    print("Hello, AI Engineering (Python)")

if __name__ == "__main__":
    hello()

TypeScript Example

// Agent Workbench – TypeScript implementation
// docs/en.md: https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/14-agent-engineering/42-agent-workbench-capstone/docs/en.md

export function hello(): void {
  console.log("Hello, AI Engineering (TypeScript)");
}

if (require.main === module) {
  hello();
}

Rust Example

//! Agent Harness – Rust implementation
//! docs/en.md: https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/14-agent-engineering/42-agent-workbench-capstone/docs/en.md

fn main() {
    println!("Hello, AI Engineering (Rust)");
}

Julia Example

# Linear Algebra Intuition – Julia implementation

# docs/en.md: https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/01-math-foundations/01-linear-algebra-intuition/docs/en.md

function hello()
    println("Hello, AI Engineering (Julia)")
end

hello()

Summary

• The rohitg00/ai-engineering-from-scratch curriculum supports exactly four languages: Python, TypeScript, Rust, and Julia.
• Language constraints are centrally defined in the AGENTS.md Dependencies table, which specifies allowed third-party packages for each ecosystem.
• Python allows numpy, torch, h5py, zstandard, and safetensors; TypeScript permits hono, zod, ws, and @hono/node-server; Rust is restricted to the standard library only; Julia may use Random, Statistics, LinearAlgebra, and Printf.
• Each lesson declares its languages via frontmatter metadata (the Languages field in lesson markdown files), and implementations must follow the code/main.<ext> structure with proper header comments linking to the documentation.

Frequently Asked Questions

What programming languages does the AI Engineering curriculum support?

The curriculum supports Python, TypeScript, Rust, and Julia. These languages are explicitly listed in the AGENTS.md policy file and enforced through lesson metadata, with each language serving specific pedagogical purposes from numerical computing to systems programming.

Why does the curriculum restrict third-party dependencies?

The stdlib-first approach ensures learners understand core algorithms and data structures without relying on framework-specific abstractions. By limiting external packages—such as restricting Rust to pure rustc --edition 2021 or Python to specific scientific computing libraries—the curriculum maintains focus on fundamental AI engineering concepts rather than library-specific APIs.

How are language requirements enforced in individual lessons?

Each lesson's markdown frontmatter includes a Languages field that must match the allowed set. For example, phases/01-math-foundations/01-linear-algebra-intuition/docs/en.md lists Python, Julia. Code files must be placed in code/main.<ext> with header comments linking back to the lesson documentation, creating a validation chain from metadata to implementation.

Can I use external libraries not listed in AGENTS.md?

No. The AGENTS.md Dependencies table serves as the sole authority for allowed packages. Using libraries outside the specified allowlist—such as additional crates in Rust or extra npm packages in TypeScript—would violate the curriculum's lesson contract and break the validation rules enforced by the repository's governance structure.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}