How to Get Into AI in 2026 — The Free Starter Stack

I get this question every week. From engineers, from students, from people two years into a career change. The phrasing rotates — "where do I start with AI," "what should I learn first," "is it too late?" — but it's always the same question.

This is the answer I wish someone had handed me when I started, written in 2026 with what's actually free, useful, and not a course-seller's funnel.

No paid bootcamps. No 90-day intensives. Just the resources I'd hand my own younger sibling if they asked me tonight.

Who this is for

• You have some programming experience (Python helps, but JavaScript or any modern language is fine).
• You don't need a CS degree. I had one and a master's; the people I work with who don't are usually the strongest because they had to build their mental model from scratch and didn't take shortcuts.
• You have 6–8 hours a week for the next 12 weeks. That's it. The compounding starts when you show up; it doesn't matter what hour.
• You want to actually build something, not just collect certificates.

If that's you, here's the stack.

The frame: three tracks, 12 weeks

Most "learn AI" guides fail because they hand you 47 resources in random order. The fix is a simple frame:

  Weeks 1–4  →  TRACK 1: FOUNDATIONS    (what is ML, what is an LLM, what is a vector)
  Weeks 5–8  →  TRACK 2: BUILDING        (prompting, RAG, agents, tools)
  Weeks 9–12 →  TRACK 3: SHIPPING        (deploy, eval, scale)

You don't move on until you've shipped something at each tier. Even something tiny. That's the only rule that matters.

Track 1: Foundations (Weeks 1–4)

Your goal here is vocabulary and mental models. You should be able to read a paper abstract and have it not feel like another language.

1. Google — Machine Learning Crash Course (FREE, ~15 hours)

Link: https://developers.google.com/machine-learning/crash-course

This is the single best starter resource on the internet, and it's been steadily updated. Covers linear regression, classification, embeddings, neural networks. Includes interactive visualizations. Don't skip the exercises.

Time investment: 4–6 weekday evenings.

2. DeepLearning.AI — AI For Everyone (FREE on Coursera audit, ~6 hours)

Link: https://www.coursera.org/learn/ai-for-everyone

Andrew Ng's gentle conceptual primer. Even if you've taken the Google course, watch this for the vocabulary. Andrew is one of the few people on earth who can teach you how to think about AI, not just the math.

Time investment: one Saturday afternoon.

3. Google — Generative AI Learning Path (FREE, ~10 hours)

Link: https://www.cloudskillsboost.google/paths/118

A modular path that takes you from "what is generative AI" to "what is a transformer" to "what is prompt engineering." Free, official, and earns you a badge if that helps motivation.

Time investment: one weekend.

Track 1 ship-it goal: Build a Python script that calls an LLM API (Claude, Gemini, or OpenAI — they all have free tiers) and answers a question. Twenty lines of code. Commit it to GitHub. That's week 4.

Track 2: Building (Weeks 5–8)

Your goal here shifts from understanding to making. You'll touch real models, real prompts, and start to develop taste.

4. Anthropic — Build with Claude (FREE, official docs + cookbook)

Link: https://docs.anthropic.com Cookbook: https://github.com/anthropics/anthropic-cookbook

The Anthropic docs are unusually well-written. Start with the "Build with Claude" tutorials — prompt engineering, tool use, vision. The cookbook on GitHub has 30+ runnable notebooks: classification, RAG, agents, evaluations. Pick three and run them.

Time investment: 8–10 hours across two weeks.

5. DeepLearning.AI — Short Courses (FREE, ~1 hour each)

Link: https://learn.deeplearning.ai

Andrew Ng's team partners with every major lab to ship 1-hour focused courses. "Functions, Tools, and Agents with LangChain." "Building Systems with the ChatGPT API." "Building and Evaluating Advanced RAG." Each one is built around a runnable notebook. Take 4–6 of them.

Time investment: one short course per evening.

6. Hugging Face — NLP & LLM Courses (FREE)

Link: https://huggingface.co/learn

If you want to actually understand how the open-source side works — transformers, fine-tuning, deployment to Spaces — Hugging Face's free course is the canonical reference. Pair it with their model hub to play with real open models (Llama, Mistral, DeepSeek).

Time investment: 6–8 hours, can be spread across the track.

Track 2 ship-it goal: Build a small thing. A document Q&A bot, a tool-use agent that hits one API, an evaluator that scores LLM outputs. Put it on GitHub with a README. That's week 8.

Track 3: Shipping (Weeks 9–12)

Now the gap between hobbyist and engineer. Most courses stop before this. This is where the real game starts.

7. Meta — PyTorch Tutorials (FREE)

Link: https://pytorch.org/tutorials

PyTorch is the framework everything else is built on. The official tutorials walk you through training, fine-tuning, and deploying real models. You don't need to master it — but you need enough to read other people's code without panic.

Time investment: 6–10 hours, focus on the "Learn the Basics" and "Deploying PyTorch Models" sections.

8. Meta — Llama Cookbook / llama-recipes (FREE on GitHub)

Link: https://github.com/meta-llama/llama-cookbook

If you want to fine-tune or self-host an open-weight model, this is the canonical recipe collection. Quantization, LoRA, deployment — all reference implementations you can copy.

Time investment: pick one recipe, run it end-to-end. That's the lesson.

9. fast.ai — Practical Deep Learning for Coders (FREE)

Link: https://course.fast.ai

Jeremy Howard's contrarian top-down approach: build a working model in lesson 1, understand the theory by lesson 5. If you learn by doing first, start here instead of Track 1. Don't double up — pick fast.ai or the Google/DeepLearning.AI stack, not both.

Time investment: 30+ hours if you do it properly. Worth every one.

Track 3 ship-it goal: Deploy something. A working model, a working agent, a working RAG endpoint — accessible at a URL someone other than you can hit. That's week 12. From here, the rest of your career is iteration.

What to skip

• YouTube algorithm rabbit holes. Pick one teacher per topic. More voices = more confusion at this stage.
• Paid bootcamps. Everything in this post is free and made by people who actually build models. Pay for nothing in your first 12 weeks.
• Math-first deep dives. Linear algebra and probability matter eventually. Not on day one. Build first, fill in math as it bites.
• Trying every new model. Pick one (Claude, Gemini, GPT, or an open-source model) and learn it cold. Generalize later.
• Reading papers in week 2. You can't yet. Wait until week 6 — they'll suddenly start to make sense.

What to ignore when people tell you what to learn

• "You need a PhD to do AI." You don't. I work with people who left math undergrad to ship production AI.
• "It's too late." The frontier moves so fast that everyone is two years behind. Including the frontier.
• "AI will replace you anyway." The people who say this aren't the ones building. The people building are too busy compounding.

After week 12

Three honest paths:

If you liked the building part: read Anthropic's agent-engineering posts, Hugging Face's agents course, and start contributing to an open-source AI repo. Your portfolio is your CV.

If you liked the math/research part: start auditing CS papers on arXiv (cs.AI, cs.CL, cs.LG categories). One paper a week, summarized in your own blog. After a year you've built a research literacy nobody can fake.

If you liked the shipping part: pick a domain you understand (healthcare, finance, legal, retail) and build the AI tool for that domain. The domain depth + the AI literacy is the unicorn combination — and it's how most AI architects I know got their first role.

The one rule

Don't collect courses. Ship things.

A tiny working thing on GitHub beats 12 completed certificates with no commits. Always.

Good luck. If you build something off this list, send it to me. I read everything.

— Lakshman