AI & Machine Learning resources for developers

A working engineer's grounding in modern AI: what a model actually does, how transformers and embeddings work, what training and fine tuning involve, and where the current limits are. Written for people who need to build with this technology rather than publish papers about it.

System design for AI backed products, covering retrieval pipelines, vector stores, model serving, evaluation, cost control and the latency budget that makes or breaks the user experience. This round is now appearing in loops that had no AI content two years ago.

Using AI tools deliberately across a job search: sharpening a resume against a specific posting, preparing for interviews, researching companies and drafting outreach that does not read as generated. Practical, and unusually concrete about where the tools help and where they hurt you.

Practice interviews with an AI interviewer that asks follow up questions and gives structured feedback, available whenever you are free rather than whenever a human is. Cheaper and more repeatable than human mocks, and a sensible first stage before you book one.

From the author of The Illustrated Transformer, so the diagrams do a lot of the teaching. It goes from tokens and embeddings through search, classification and fine tuning, ending at agent patterns, with code you can run at each step. The best paper book for someone who wants intuition rather than equations.

Three and a half hours that replace a shelf of blog posts. Karpathy walks the whole training stack, pretraining through post training, and explains why models hallucinate, why they are bad at counting letters, and what a token really is. If you build on top of models, this is the clearest explanation of what is underneath.

The gap between an agent that works in a notebook and one that runs for real is memory, deployment, monitoring, cost control and security. This repository is a set of hands on tutorials for exactly that layer, which almost nothing else covers properly.

Dozens of agent implementations as Jupyter notebooks, from a simple conversational bot up to multi agent workflows, each one small enough to read in a sitting. The value is in the range: you can compare how the same problem is solved five different ways instead of trusting one tutorial.

A maintained map of the agent ecosystem: frameworks, platforms, open source projects and the companies behind them. The field moves fast enough that a curated list beats searching. Use it to find prior art before you build something that already exists.

Most teams reach for multiple agents too early and pay for it in cost, latency and debugging. This argues the other side clearly: when splitting work across agents genuinely helps, and when a single agent with better tools would have done the job. Short, and it will save you a rewrite.

A side by side comparison of the ways you can arrange multiple agents: sequential, concurrent, group chat, handoff and magentic. Each one gets its tradeoffs stated plainly, which is rarer than it should be. Use it as a decision aid rather than a tutorial.

Google's open source framework for building and deploying agents, with support for MCP and agent to agent communication built in. The docs are worth reading even outside Google Cloud because they treat deployment, evaluation and safety as part of the build rather than an afterthought.

A plain convention: put a markdown file at the root of your repository telling coding agents how to build, test and behave in that project. Tens of thousands of repositories now carry one. Adding it takes ten minutes and it is the cheapest way to stop an agent guessing at your build commands.

A small Python framework with only a few concepts to learn: agents, handoffs between them, guardrails on input and output, and tracing so you can see what happened. The docs are short enough to read end to end in an evening, which makes them a decent way to learn agent vocabulary even if you never use the SDK.

Agents fail at tools far more often than they fail at reasoning, and it is usually the tool's fault. This covers naming, parameter design, what to put in a description, and how to evaluate whether a model can actually use what you built. If you are writing an MCP server or a function schema, this is the piece to read first.

A real engineering write up of a shipped multi agent system: a lead agent that plans and subagents that search in parallel. Useful for the failure modes it admits to, like agents duplicating each other's work and token cost growing faster than the quality does. Read it before you decide you need more than one agent.

The single highest leverage thing you can learn once your agent basically works. Prompt tweaking gets you a little; deciding what is allowed into the context window and what gets left out gets you a lot. This explains how to think about that budget, and why long context models did not make the problem go away.

First party courses on the Claude API, prompting, Claude Code, MCP and agent skills. Vendor material, but the good kind: it explains the reasoning behind the design instead of listing features, and most of what you learn about tool design and context handling transfers to any model you use.

Andrew Ng on the four patterns that keep showing up in agent design: reflection, tool use, planning and multi agent collaboration. Short, clearly explained, and unusually honest about when a simpler approach beats an agent. Watch this before you commit an architecture to something agentic.

Once an agent has more than a couple of steps, the hard part stops being the prompt and becomes state: what is remembered, what happens on failure, and where a human gets to approve something. This course is about exactly that, built around LangGraph but teaching patterns you will reuse whatever framework you land on.

University lectures from the researchers doing the work, released free with slides and recordings. Heavier going than the tutorial style courses and worth it: you get reasoning, planning, code generation and agent safety treated as open problems rather than solved features. Take it after you have built an agent and hit the limits yourself.

Three roadmaps in one repository: the maths and architecture underneath a model, how to fine tune and quantise one, and how to actually ship an application on top. Every section links to Colab notebooks you can run without a GPU of your own. This is the resource to open when you want to stop treating the model as a black box.

The Model Context Protocol is how an AI app talks to your tools and data without a custom integration for every one. This walks through building both sides of it, a server and a client, with working examples in Python, TypeScript, Java, .NET and Rust. Worth a weekend if you have ever wired an LLM to an internal system by hand and hated it.

The course to take before the agent courses. Twenty one lessons on what a model is doing when it answers you, how prompting changes the output, why embeddings and search go together, and where the whole thing quietly goes wrong. Code samples run against several providers, so you are learning the ideas rather than one vendor's SDK.