Module 7: AI Engineering - The New Role

4. AI Engineer Skills: What You Need to Know (and What You Don't)

Next →

Description

The key question: What skills do I need to be an AI Engineer?

Good news: You do NOT need a PhD, advanced math or to train models from scratch.

You need: Python, to understand LLMs conceptually, to design systems (RAG, agents), to optimize prompts.

In this lesson you'll understand:

  • The technical skills required (Python, APIs, LangChain, vectors).
  • The conceptual skills required (LLMs, embeddings, prompts).
  • The skills you do NOT need (advanced math, training from scratch).

Required Skills (Tier 1 - Must Have)

1. Python

Why:

  • LangChain, the OpenAI SDK, LlamaIndex → all in Python.
  • The majority of the AI ecosystem is in Python.

What you need:

  • Variables, functions, classes.
  • Lists, dictionaries, loops.
  • Async/await (for APIs).
  • Basic debugging.

What you do NOT need:

  • Advanced metaprogramming.
  • C extensions.

How to learn it: Python basics (3-6 months if you're a beginner).

2. APIs and HTTP

Why:

  • GPT-4, Claude → everything via API (HTTP requests).
  • Your app calls APIs to generate text.

What you need:

  • Making HTTP requests (the requests library, fetch).
  • Understanding REST APIs (GET, POST, headers, body).
  • Handling API keys and authentication.
  • Error handling (retry logic, timeouts).

What you do NOT need:

  • GraphQL (nice to have, but not critical).
  • WebSockets (nice to have).

How to learn it: API basics (1-2 months).

3. LLMs (Conceptual)

Why:

  • You need to understand how LLMs work in order to use them effectively.

What you need:

  • What an LLM is (a decoder-only transformer, pre-trained).
  • Tokenization (text → tokens, cost per token).
  • Parameters (temperature, top_p, max_tokens).
  • The context window (the memory limit).
  • Embeddings (vectors of meaning).

What you do NOT need:

  • Implementing a Transformer from scratch.
  • The math of the attention mechanism.

How to learn it: This guide (Modules 4-5).

4. Prompt Engineering

Why:

  • Output quality depends on prompts.
  • Optimizing prompts saves cost and improves quality.

What you need:

  • System prompts, user prompts, roles.
  • Few-shot learning (examples in the prompt).
  • Chain-of-Thought prompting (reasoning).
  • Structured outputs (JSON mode).

What you do NOT need:

  • Advanced "prompt hacking" (jailbreaks, etc.).

How to learn it: Practice (1-2 months experimenting).

5. Vector Databases (Conceptual)

Why:

  • RAG (Retrieval-Augmented Generation) requires searching for relevant documents.
  • Documents are converted into embeddings (vectors) → you search by similarity.

What you need:

  • What an embedding is (a vector of meaning).
  • Cosine similarity (measuring similarity between vectors).
  • Vector DBs (Pinecone, Weaviate, Chroma) → how to use them.

What you do NOT need:

  • Implementing a vector DB from scratch.
  • Indexing algorithms (HNSW, etc.).

How to learn it: Practice with RAG (1-2 months).

Important Skills (Tier 2 - Should Have)

6. LangChain / LlamaIndex

Why:

  • Frameworks that make RAG, agents, chains easier.
  • They avoid boilerplate (connecting LLMs, vectors, memory).

What you need:

  • Chains (sequences of prompts).
  • Agents (the LLM decides which tool to use).
  • Memory (multi-turn conversation).

How to learn it: Practice with projects (2-3 months).

7. Backend Development

Why:

  • Your AI feature needs an API/backend to expose it to the frontend.

What you need:

  • A backend framework (FastAPI, Express.js).
  • REST API design.
  • Authentication (API keys, JWT).
  • Deployment (Docker, cloud).

How to learn it: Backend basics (3-6 months).

8. SQL and Databases

Why:

  • RAG requires storing documents.
  • Apps require storing conversations, user data.

What you need:

  • Basic SQL (SELECT, INSERT, UPDATE).
  • Relational databases (PostgreSQL).
  • NoSQL (MongoDB) for documents.

How to learn it: SQL basics (1-2 months).

Optional Skills (Tier 3 - Nice to Have)

9. Self-Hosting (Llama 3, Mistral)

Why:

  • Privacy, cost (high volume), control.

What you need:

  • Docker (to run the models).
  • GPUs (NVIDIA, setup).
  • Ollama, LM Studio, vLLM (tools for serving).

When to learn it: When you need privacy or when self-hosting is cheaper (post-MVP).

10. Fine-Tuning

Why:

  • Adapting a model (Llama 3, Mistral) to a specific case.

What you need:

  • Preparing a dataset (in the correct format).
  • Using the tools (the OpenAI fine-tuning API, Hugging Face).

When to learn it: When base models (GPT-4, Claude) aren't enough (rare).

Skills You Do NOT Need

❌ 1. Advanced Math

You don't need:

  • Linear algebra (matrices, eigenvalues).
  • Calculus (derivatives, integrals, gradients).
  • Implementing backpropagation.

Why: The APIs do the heavy lifting (training, inference). You just call the APIs.

❌ 2. Training from Scratch

You don't need:

  • PyTorch, TensorFlow (for training).
  • Distributed training (multi-GPU).
  • Hyperparameter optimization.

Why: You use pre-trained models (GPT-4, Claude, Llama 3).

❌ 3. MLOps

You don't need:

  • MLflow, Kubeflow (training tracking).
  • Model versioning (weights).
  • A/B testing of (trained) models.

Why: You use APIs (OpenAI, Anthropic) that handle that.

Learning Roadmap (3-6 months)

Months 1-2: Fundamentals

  • ✅ Python basics (variables, functions, classes).
  • ✅ APIs and HTTP (requests, REST).
  • ✅ LLMs conceptually (this guide, Modules 4-5).

Months 3-4: Practice with LLMs

  • ✅ The OpenAI API (integrating it into a simple app).
  • ✅ Prompt engineering (system prompts, few-shot).
  • ✅ A simple project: A basic chatbot (GPT-3.5 + FastAPI).

Months 5-6: RAG and Advanced

  • ✅ Embeddings and vectors (conceptually).
  • ✅ RAG (LangChain + Pinecone).
  • ✅ A project: A Q&A system over documentation.

Why this matters for an AI Engineer

1. Focusing on the right things

Without clarity:

  • You study PyTorch, advanced math (unnecessary for an AI Engineer).

With clarity:

  • You study LangChain, RAG, prompts (critical for an AI Engineer).

2. A realistic career path

The correct expectation:

  • An AI Engineer does NOT train from scratch (they use APIs).
  • If that frustrates you → consider ML Engineer (training models).

Summary

Required skills (Tier 1):

  1. Python.
  2. APIs and HTTP.
  3. LLMs (conceptual).
  4. Prompt engineering.
  5. Vector databases (conceptual).

Important skills (Tier 2):

  1. LangChain / LlamaIndex.
  2. Backend development.
  3. SQL and databases.

Optional skills (Tier 3):

  1. Self-hosting (Llama 3, Mistral).
  2. Fine-tuning.

Skills you do NOT need:

  • Advanced math (linear algebra, calculus).
  • Training from scratch (PyTorch, TensorFlow).
  • MLOps (MLflow, Kubeflow).

Roadmap: 3-6 months to be job-ready (Python → APIs → LLMs → RAG).

Next step: Lesson 05: The Day to Day — What an AI Engineer does at companies.

← Previous3. AI Engineer vs Data Scientist: Different GoalsNext →5. The Day to Day: What an AI Engineer Does at Companies