AutomateEdge · AI Generalist · Skills

AI Generalist Skills Matrix: 2026 Proficiency Ladder

The AI Generalist skill map below is calibrated against 2026 hiring signals — specifically, the skills that appear in ≥30% of junior-to-mid AI postings across the AutomateEdge jobs pipeline over the last 90 days. Proficiency levels follow a four-step ladder: Beginner (can follow tutorials), Intermediate (can build a solution to a new problem), Advanced (can debug production issues), Expert (can design systems from first principles). A generalist clears Intermediate across every category by week 24; Advanced follows specialization.

Programming foundations

Python is non-negotiable for AI work — every major library, every training framework, every inference runtime has a Python surface. Strong Python means fluent async I/O, type hints, virtual environments, and the standard-library tools (subprocess, pathlib, concurrent.futures) you will reach for when wiring models into applications.

SkillTarget levelNote
Python 3.11+ syntax and semantics Advanced match-case, positional-only args, walrus, structural typing; rule of thumb — you can read and write it without googling daily.
NumPy array operations Intermediate broadcasting, slicing, einsum, random generators, axis semantics.
pandas dataframes Intermediate groupby, merge, pivot, vectorised ops. Avoid iterrows — it's the #1 junior-interview trap.
Async / await Intermediate FastAPI handlers, httpx streaming, asyncio.gather. Critical once you ship AI APIs.
Type hints + mypy Intermediate Generics, TypedDict, Protocols. Shrinks debugging time dramatically.
Testing with pytest Intermediate fixtures, parametrize, monkeypatch, pytest-asyncio. At least 60% line coverage on every portfolio project.
Git + GitHub workflow Advanced branching, rebase, squash, resolving conflicts, PR etiquette. Hiring managers read git history.
Unix shell + Docker basics Beginner grep, awk, ssh, docker build/run. Enough to debug a VPS deploy without panic.

Mathematics for AI

The math you actually use as a generalist is thinner than most curricula imply. Linear algebra and probability do 80% of the work; calculus appears only through the autograd abstraction you mostly trust. Skip real analysis, skip measure theory — come back for them only if you deep-dive into research.

SkillTarget levelNote
Linear algebra — vectors, matrices, SVD Intermediate dot product as similarity, matrix as linear transform, SVD as the 'what's really there' operation.
Probability + Bayes' rule Intermediate joint/conditional/marginal, expectation, variance, the 'likelihood × prior' shape of every learning algorithm.
Calculus — gradients + chain rule Beginner You will rarely differentiate by hand, but you must read a gradient expression and know what it's saying.
Statistics — hypothesis testing, confidence Beginner p-values, power, t-test vs chi-square. Needed the moment you A/B-test a model.
Optimization — gradient descent variants Intermediate SGD, Adam, AdamW, learning-rate schedules, momentum. Not just 'which optimizer' — why each exists.
Information theory basics Beginner Entropy, cross-entropy, KL divergence. Core to understanding every loss function.

Classical machine learning

Classical ML is where every generalist builds intuition. Before you can evaluate an LLM response or debug a deep-net loss curve, you need to have trained, over-fit, regularised, and cross-validated on tabular data. It remains the right tool for 60% of real business problems.

SkillTarget levelNote
scikit-learn API mastery Advanced pipelines, ColumnTransformer, cross_val_score, GridSearchCV, the fit/transform contract.
Linear + logistic regression Intermediate regularisation (L1/L2), multicollinearity, interpreting coefficients.
Tree ensembles — RF, XGBoost, LightGBM Intermediate Still the winning algorithm on most Kaggle tabular competitions. Learn feature importance + SHAP.
Clustering + dimensionality reduction Beginner k-means, DBSCAN, PCA, t-SNE, UMAP. Knowing when to reach for each.
Evaluation metrics across tasks Intermediate accuracy, precision, recall, F1, ROC-AUC, PR-AUC, RMSE, MAE. Pick the metric that matches the business cost.
Feature engineering Intermediate categorical encoding, feature crosses, date-time features, target encoding pitfalls.
Train/val/test discipline Advanced Stratified splits, time-series splits, leakage prevention, the #1 source of silent bugs.

Deep learning

PyTorch is the field's lingua franca in 2026. JAX has a loyal niche but if you learn one, learn PyTorch — every paper ships a PyTorch reference implementation. Focus on the primitives (tensors, autograd, nn.Module) before reaching for higher-level wrappers.

SkillTarget levelNote
PyTorch tensors + autograd Intermediate device placement, gradient accumulation, custom backward functions.
nn.Module + training loops Intermediate forward, loss, backward, optimizer step — write it manually at least once before using Lightning.
CNNs for image tasks Beginner conv, pool, batchnorm. Fine-tune a pretrained resnet on your own dataset.
RNN + transformer basics Intermediate Why attention replaced recurrence. Multi-head attention, positional encoding, causal masks.
Transfer learning + fine-tuning Intermediate Freeze / unfreeze, LoRA basics, data augmentation strategy.
Training diagnostics Intermediate Loss curves, gradient norms, weight histograms. Catching divergence before it wastes a GPU-week.

LLMs + generative AI

LLMs are the fastest-moving surface in the field. A generalist does not need to pre-train one, but must be fluent at wiring hosted models into applications, building retrieval systems, evaluating outputs, and knowing when a smaller classical model would win.

SkillTarget levelNote
Prompting strategy + templating Intermediate system/user/assistant turns, few-shot, chain-of-thought, structured output, Pydantic-validated JSON.
Retrieval-augmented generation (RAG) Intermediate chunking, embeddings, vector DBs (pgvector / Pinecone / Weaviate), hybrid search, re-ranking.
Evaluation of generative output Intermediate automatic evals (exact match, rouge, BLEU, LLM-as-judge), rubric-based, pairwise preference.
Agent + tool-use patterns Beginner Function calling, Anthropic/OpenAI tool APIs, the ReAct loop, when agents are the wrong answer.
Cost + latency engineering Intermediate Context size vs cost, prompt caching, streaming, model routing, when to distill to a smaller model.
Safety + guardrails Beginner PII redaction, jailbreak patterns, refusal classifiers, content moderation APIs.

Production + deployment

A generalist who cannot deploy is 60% of a hire. Your portfolio projects must live on the public internet — a Docker Compose VPS is a complete, cost-controlled answer. Employers read 'I shipped it' as a hard multiplier on every other skill.

SkillTarget levelNote
FastAPI + async backends Intermediate routers, dependencies, Pydantic models, background tasks, WebSockets for streaming.
Docker + Docker Compose Intermediate multi-stage builds, volume persistence, health checks, reverse-proxy routing.
SQL + one DB in depth Intermediate Postgres or SQLite. Indexes, transactions, migrations (alembic), explain plans.
Observability basics Beginner Structured logging, request IDs, prompt/response logs with PII redaction, uptime monitoring.
CI/CD fundamentals Beginner GitHub Actions lint + test on PR. A failing test blocks merge — non-negotiable.

Suggested learning sequence

How long to 'Intermediate' across the board?

Full-time learner: 5-6 months to Intermediate across all categories. Part-time (8-10 h/week): 9-12 months. What matters most for hiring is not speed but shipped artifacts — a well-documented GitHub with three deployed projects beats a completion certificate from a six-month bootcamp.

Frequently asked questions

Do I need to memorise calculus before starting?

No. You need gradient descent intuition — 'the model nudges its weights in the direction that reduces loss.' Formal derivatives appear rarely in a generalist's daily work. Revisit calculus if you specialise in research or optimization.

Should I learn TensorFlow or PyTorch?

PyTorch. ~95% of new research code, almost every Hugging Face model, and most production serving stacks are PyTorch-first in 2026. TensorFlow remains entrenched in large-enterprise MLOps stacks — learn it later if you hit a role that requires it.

How much math is 'enough'?

Linear algebra through SVD, probability through Bayes, calculus through the chain rule, optimization through Adam. That set covers 95% of generalist work. Beyond that, math is field-specific — NLP needs information theory, vision needs Fourier, RL needs dynamic programming.

Is Kaggle a good use of time for a generalist?

For weeks 1-12, yes — Kaggle tabular competitions teach feature engineering and evaluation discipline better than most courses. After that, diminishing returns. Shift to deploying personal projects that employers can actually click.

What if I skip classical ML and start with LLMs?

You will plateau within four months. Classical ML teaches the concepts that make LLM work legible — overfitting, regularisation, evaluation, baselines. LLM-first learners routinely fail debugging questions about why a model is wrong.

How do I know I have actually cleared Intermediate?

Three markers: (1) you can build a solution to a problem you have never seen a tutorial for, (2) you can read any blog post in the category without needing to pause for definitions, (3) you can explain the trade-offs of your choice to a non-technical stakeholder in two sentences.

Do I need a GPU?

Not at first. For weeks 1-14, Colab Free or Kaggle Notebooks is enough. For weeks 15-24, rent by the hour on Lambda / Vast / RunPod (~$0.30-$2/hr for a useful GPU). Owning a GPU is a hobby, not a requirement.

Continue on the AI Generalist track