Three career paths over a shared foundation, so three ladders. Pick the path first — the AI-engineer projects need no maths and ship fast; the ML-engineer and data-scientist ones need a dataset and patience.

Difficulty: 🟢 starter (hours–days) · 🟡 intermediate (a week or two) · 🔴 ambitious / portfolio-grade. ⭐ = highest signal.

AI Engineer

Your strongest applied area (AI SDK / MCP). These produce shippable, demoable products — high portfolio value.

  • 🟢 ⭐ RAG over this vault — a chatbot that answers questions about this knowledgebase: chunk the markdown, embed it, store in pgvector/Chroma, retrieve + answer with citations. Dogfoods your own notes and is a perfect RAG project.
  • 🟡 Build an MCP server — wrap a real system (your notes, a database, an API) as an MCP server with tools + resources, and use it from an MCP host. You already use MCP — building one closes the loop.
  • 🟡 An agent with real tools + an eval set — an agent (via the AI SDK’s agent loop) that does a multi-step task with 2–3 tools, plus an eval set measuring success rate as you change the prompt/model. The evals are what make it engineering, not a demo.
  • 🟡 Structured extraction pipeline — feed scanned docs/receipts to a vision model, extract typed JSON with structured output, validate against a schema. A genuinely useful, sellable tool.
  • 🟢 Model bake-off via OpenRouter — same prompt/eval set across 5 models through OpenRouter, compare quality/latency/cost. Cheap, fast, and teaches model selection.
  • 🔴 Prompt-injection red-team — build a small agent, then try to break it (direct + indirect injection); document what worked and the mitigations. Rare, valuable security-adjacent signal.

ML Engineer

The modeling half — needs a dataset and patience. Kaggle is the fastest source of real data.

  • 🟢 Tabular ML done right — take a Kaggle tabular dataset, do EDA, train gradient boosting vs logistic regression, with proper cross-validation + tuning. Prove the boosting-beats-deep-learning-on-tabular point yourself.
  • 🟢 Implement it from scratch in NumPy — write linear regression (gradient descent) and k-means using only NumPy, no scikit-learn. The fastest way to make the math and vectorization click.
  • 🟡 Image classifier with transfer learning — fine-tune a pretrained CNN (transfer learning) on a custom image set. Small, satisfying, and teaches the PyTorch loop.
  • 🟡 Fine-tune a small open model — LoRA-fine-tune a small model from Hugging Face on a narrow task, and honestly compare it to just prompting a bigger model (the RAG vs fine-tuning decision, tested).
  • 🔴 ⭐ End-to-end MLOps project — train a model, track experiments with MLflow, serve it behind a FastAPI endpoint in a container, and add drift monitoring. This is the whole engineer half of ML engineering, and it reuses your DevOps skills.

Data Scientist

The analysis/inference half — the deliverable is a trustworthy answer, well communicated.

  • 🟢 A real EDA + statistical report — take a dataset you care about, do a full EDA, compute descriptive stats, and write up findings with honest visualizations. Practice the “numbers + a picture + a takeaway” discipline.
  • 🟡 ⭐ A/B test analysis, done rigorously — take (or simulate) experiment data and analyze it properly: hypothesis test, effect size and confidence interval, check for the pitfalls (SRM, peeking, Simpson’s paradox). The core data-scientist skill.
  • 🟡 Causal case study — pick a question where correlation ≠ causation and attempt a difference-in-differences or regression-discontinuity analysis, stating your assumptions honestly. Rare, high-value reasoning.
  • 🟢 Power analysis calculator — a small tool that computes required sample size for an A/B test given a minimum detectable effect. Cements power/significance.
  • 🟡 A stakeholder dashboard — turn an analysis into a clean, honest dashboard (a BI tool or a notebook), tuned for a decision-maker, not a data person. Communication reps.

The foundation rep, whichever path

  • 🔴 ⭐ Build your own neural network — the guide: 10-your-own-neural-network. Forward pass → loss → backprop by hand → gradient checking → a tiny autodiff engine. Done when: loss.backward() stops being magic. This is the guide ai-ml’s ~98 notes never had.

If you only do one

RAG over this vault. It dogfoods your own notes, it’s the single most transferable AI-engineering pattern, and the retrieval quality problem it exposes is the real lesson.

And if you want the layer underneath it: build your own LLM — a transformer trained from scratch, the sequel to the neural network guide. Attention, tokenisation, temperature and the KV cache stop being API parameters.

↑ Back to AI & ML