A free AI engineering course that needs no credit card
A new open-source curriculum teaches RAG, agents and evals from raw API calls on Colab's free tier. Here's why the no-card requirement matters more than the syllabus.
A free AI engineering course that runs end to end without a credit card is rarer than it should be, and AI Engineer Notebooks by calmrocks is one. It landed on Hacker News yesterday with almost no attention.
I went through the repository structure and the README. The syllabus is good. But the part I think actually matters for anyone reading this from Sri Lanka is buried in a bullet point about billing.
💳 The payment barrier is the real barrier
Most "free" LLM tutorials are free to read and cost money to run. You get three notebooks in, hit openai.api_key, and discover you need a card that works for USD charges plus a minimum prepaid top-up.
This repo runs everything on the free Groq API, explicitly "no credit card". Setup is three steps: get a key, paste it into Colab's secrets panel, run the notebook top to bottom.
Key takeaway: For a student or self-funded engineer here, the binding constraint on learning applied AI has rarely been tuition or talent. It's having a payment instrument that a US API vendor accepts. A curriculum that removes that step is worth more than one with better content behind a $5 minimum.
Two sections can't run on a hosted API at all: LoRA fine-tuning (section 06) and self-hosted serving (section 09), because both need a GPU. The author's answer is to teach them concept-first with optional Colab-GPU appendices, which the README says were verified on a real Colab T4. That's an honest way to handle it rather than pretending a free tier covers everything.
🛠️ Framework-free is a hiring argument, not a purity argument
The stated philosophy is that you write the agent loop, RAG, and evals from raw API calls before reaching for LangChain or LlamaIndex. The README's line: "Patterns are durable; wrappers churn."
I agree, but for a more selfish reason than the author gives. If you are applying for remote work from Colombo against candidates in Berlin and Bangalore, "I used LangChain" is not evidence of anything. It's evidence you can install a package. Being able to explain why your retrieval step returns garbage on 20% of queries is evidence.
The distinction shows up concretely in what you build:
| What you learn | Framework-first | Raw-API-first |
|---|---|---|
| Agent loop | AgentExecutor(...) |
You write the while-loop, stop conditions, and tool dispatch |
| Retrieval failure | Swap the retriever class | You diagnose chunking vs embedding vs reranking |
| Cost control | Whatever the wrapper defaults to | You budget tokens per turn yourself |
| Portability | Tied to that framework's version | OpenAI-compatible, ports to Anthropic with small changes |
The notebooks are OpenAI-compatible throughout, so the patterns move to other providers. That matters because Groq's free tier is a learning surface, not a production plan.
📚 What's actually in it
Counting the tables in the README, there are 33 notebooks across 13 sections (00 through 12). Each is self-contained, installs its own dependencies, and ends with exercises. Licence is MIT.
| Section | Notebooks | Covers |
|---|---|---|
| 00 Setup | 1 | Keys via Colab secrets, spend guards |
| 01 Model APIs | 5 | Prompting, structured output, tool calling, streaming, caching |
| 02 Evals I | 1 | Golden sets, "measure before you tune" |
| 03 RAG | 5 | Embeddings, hybrid search, reranking, chunking, failure diagnosis |
| 04 Evals II | 3 | LLM-as-judge, regression evals as CI |
| 05 Agents | 6 | Agent loop, tool design, guardrails, MCP, skills, harness engineering |
| 06 Adaptation | 1 | Fine-tune vs RAG vs prompt |
| 07 Security | 1 | Prompt injection, trust boundaries, OWASP LLM Top 10 |
| 08 Operations | 3 | Observability, fallbacks, MLflow tracking |
| 09 Serving | 2 | vLLM, TGI, Triton; batching, KV cache, quantization |
| 10 System design | 1 | Inference-service design interview, worked |
| 11 Customer craft | 1 | Scoping a vague ask into an evaluable system |
| 12 Case studies | 3 | Support assistant, pipeline-vs-agent, red-team benchmark |
The weighting tells you what the author thinks is undervalued. Evals get four notebooks. Agents get six. Fine-tuning gets one. That ratio is roughly correct for the work people actually get paid to do, and roughly the inverse of what most YouTube tutorials cover.
Section 11 is the unusual one: turning a vague customer request into a scoped, measurable system. Nobody teaches that, and it's most of the job at a small consultancy.
⚠️ Where I'd push back
Three honest caveats before you commit a month to this:
- One vendor is still one vendor. Learning entirely on Groq's free tier means your intuitions about latency and rate limits are calibrated to Groq. Run at least one notebook against a second provider before you claim the patterns transferred.
- Free tiers change. Nothing in the README promises Groq's terms are permanent, and I wouldn't assume they are. If you plan to ship, price the real thing early with our LLM API price comparison and AI free tier comparison.
- Colab free tier disconnects. Long-running cells on an unstable connection are a real problem on Sri Lankan home broadband. Save intermediate state to Drive or you'll re-run embeddings three times.
The capstone brief is where the actual value is. Case studies teach; a deployed repo with a serving component and an eval report is what a hiring manager can verify.
🗓️ How I'd actually run this
If you have evenings and weekends only, don't go strictly top to bottom. This order gets you something demonstrable fastest:
- Week 1 — Sections 00–02. Get keys working, do all five Model API notebooks, then the evals notebook. Do not skip 02.
- Week 2 — Section 03 (RAG) plus section 04. Build the retrieval system, then measure it. Sanity-check your chunk sizes against our RAG chunk size calculator and price the pipeline with the RAG cost calculator.
- Week 3 — Section 05 (agents) and section 07 (security). Six agent notebooks is the heaviest week.
- Week 4 — Case study B (pipeline vs agent), then start the capstone. Skip 09 and 10 on a first pass unless you're interviewing for infrastructure roles.
Sections 06, 08, 09 and 10 are worth returning to once you've shipped something. They read differently after you've had a production regression.
💡 What this means for you
If you are a backend or full-stack engineer in Sri Lanka who keeps meaning to "get into AI" and keeps stalling at the billing page, this removes your last excuse. The cost is your time, not your forex allowance.
If you already ship LLM features, the sections worth your evening are 04 (evals), 07 (security) and 11 (scoping). Those three are where most local teams I've seen are weakest, and they're the ones that don't get fixed by a better model.
And if you're building rather than studying, one habit from this repo is worth adopting on its own: write the eval before you tune the prompt. Everything else is downstream of that.