A starting point for anyone new to AI. In one place it covers what AI, machine learning, deep learning, and generative AI are and how they connect, a full map of the technology stack behind an AI service, the math and programming you need, career paths by role, and a step-by-step learning roadmap from step 0 through real deployment.
Beginner
Updated Oct 1, 2026
~16 min read
15 sections
2 code examples
Learning Paths that include this guide
This guide is one step in the paths below. Study it together with the steps before and after.
Get the big picture of AI conceptsFull map of the AI tech stackPlan your learning order and roadmapExplore AI roles and careersStart your first AI project
Understanding AI Intro & Roadmap as a real-world workflow
A starting point for anyone new to AI. In one place it covers what AI, machine learning, deep learning, and generative AI are and how they connect, a full map of the technology stack behind an AI service, the math and programming you need, career paths by role, and a step-by-step learning roadmap from step 0 through real deployment. Rather than listing concepts, this guide is organized so you can follow the content in the order you have to make decisions on a real project.
Key perspective
AI / LLM systems
Look beyond the model and the prompt: connect the data flow, evaluation, and post-deployment operating metrics in one view.
Get the big picture of AI conceptsFull map of the AI tech stackPlan your learning order and roadmapExplore AI roles and careersStart your first AI project
Architecture diagrams
To make what you read stick, it helps to capture the flow as a picture first. The two diagrams below are reference maps you can keep coming back to while learning AI Intro & Roadmap.
Learning flow
Rendering diagramβ¦
Architecture view
Rendering diagramβ¦
What AI is: four concentric circles
When you first open AI Intro & Roadmap, the big picture matters more than individual commands. This section starts with the problems the concepts ahead were created to solve.
Artificial intelligence (AI) refers to the whole field of trying to build "systems that see, hear, judge, and create like people". The AI in the news today mostly means machine learning (ML) within it, more specifically deep learning (DL), and generative AI, which uses deep learning to produce text, images, and code. LLMs (large language models) such as ChatGPT, Claude, and Gemini are the leading examples of generative AI.
The key difference is "who writes the rules". In a traditional program, a person writes the if condition then action rules directly. In machine learning, a person supplies data and answers and the computer finds the rules itself. Instead of writing 1,000 spam rules by hand, you show it 100,000 spam and normal emails and let it learn how to tell them apart.
Layer
One-line definition
Typical examples
AI (artificial intelligence)
The whole range of systems that perceive, judge, and act like people
Chess engines, route finding in navigation, voice assistants
ML that learns complex patterns with multi-layer neural networks
Face recognition, speech recognition, self-driving perception
Generative AI / LLM
Deep learning models that produce new text, images, code, and audio
ChatGPT, Claude, Gemini, Stable Diffusion
AI history at a glance: 70 years of progress
AI history at a glance: 70 years of progress is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
AI did not appear overnight. The paradigm shifted three major times β "rule-based β data-based β large-scale deep learning β generative and Agent" β and each shift happened when three things matured at once: the amount of data, computing power (GPUs), and algorithms.
Period
Milestone
Significance
1950s
The Turing test is proposed; the term "AI" is coined at the Dartmouth workshop
The start of AI as a field
1970s-80s
Expert systems (rule-based AI), two "AI winters"
Hit the limit of people having to write every rule
1990s-2000s
Statistical machine learning such as SVMs and random forests spreads
Learning rules from data becomes mainstream
2012
AlexNet wins an image recognition competition by a wide margin
The GPU + deep learning era begins
2016
AlphaGo defeats Go champion Lee Sedol
Reinforcement learning enters public awareness
2017
The Transformer paper "Attention Is All You Need"
The architecture behind modern LLMs appears
Late 2022
ChatGPT is released
Generative AI goes mainstream
2024 onward
Multimodal models, reasoning models, and AI Agents spread
AI goes beyond answering to using tools and carrying out tasks
How AI learns: data β training β inference
Here you look at How AI learns: data β training β inference alongside real code. Rather than copying the example as-is, read it with an eye on the inputs, the outputs, and the parts most likely to change.
Every machine learning model has the same skeleton. You prepare β data (inputs and answers), choose β‘ a model (a function with adjustable numbers, that is, parameters), repeat β’ training (nudging the parameters to reduce the "loss", the gap between prediction and answer), and then do β£ inference (predicting on inputs it has never seen).
As an analogy, training is "working through a problem book, grading it, and fixing the mistakes", and inference is "the real exam". Just as a student who only memorized the answers fails the exam, a model that only memorized the training data performs poorly on new data, which is called overfitting. That is why data is always split into a training set and an evaluation set.
first_model.pyPYTHON
# pip install scikit-learnfrom sklearn.datasets import load_irisfrom sklearn.model_selection import train_test_splitfrom sklearn.tree import DecisionTreeClassifierfrom sklearn.metrics import accuracy_score# β Data: petal/sepal sizes (inputs) and species (answers) of 150 iris flowersX, y = load_iris(return_X_y=True)# Split 80% for training / 20% for evaluation (the evaluation set is never used for training)X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# β‘ Choose a modelmodel = DecisionTreeClassifier(max_depth=3)# β’ Training: it finds the rules from the data by itselfmodel.fit(X_train, y_train)# β£ Inference & evaluation: test on data it has never seenpred = model.predict(X_test)print(f"Accuracy: {accuracy_score(y_test, pred):.2%}") # about 100%# Predict one new flowerprint(model.predict([[5.1, 3.5, 1.4, 0.2]])) # [0] β the setosa species
Map of AI fields: by what they work with
Map of AI fields: by what they work with is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
AI divides into several fields by the kind of data involved. The boundaries are blurring as multimodal models that handle text, images, and audio together become common, but knowing the core problems and techniques of each field makes news, papers, and job postings much easier to read.
Writing, image generation, code generation, AI Agents
LLM, Diffusion, RAG, Tool Use
Generative AI and LLMs: 10 concepts you must know
Generative AI and LLMs: 10 concepts you must know is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
An LLM is a model trained, an enormous number of times over internet-scale text, on "guessing the next word (token)". It sounds like a simple task, but in the course of training on trillions of tokens it picks up grammar, knowledge, and even reasoning patterns. For developers, most of the work is not building an LLM but calling it through an API and connecting your own data and tools to turn it into a service. The 10 terms below show up in every LLM document.
Concept
In plain words
Why it matters
Token
The smallest unit (a piece of a word) an LLM reads and writes
Both pricing and the input length limit are counted in tokens
Prompt
The instructions and input given to the LLM
The same model gives very different quality depending on the prompt
Context window
The maximum number of tokens it can read at once
With long documents you have to design what goes in and what stays out
Temperature
The setting that controls randomness (creativity) of answers
Low for accurate answers, high for brainstorming
Hallucination
Producing answers that sound plausible but are not true
The first risk to guard against in an LLM service
Embedding
The meaning of a sentence turned into a vector of numbers
The basis of meaning-based search, recommendation, and classification
RAG
Retrieving documents related to the question and putting them in the prompt
Lets it answer from internal documents and fresh information, and reduces hallucination
Fine-tuning
Further training an existing model on your own data
Used to specialize in a particular tone, format, or domain
Tool Use / Function Calling
Letting the LLM call external functions and APIs
Does what the LLM cannot do alone: search, DB lookups, calculation
AI Agent
An LLM system that takes a goal, plans by itself, and uses tools repeatedly
The stage beyond a simple chatbot, where real work is automated
Your first LLM API call: an AI app in 10 lines
Here you look at Your first LLM API call: an AI app in 10 lines alongside real code. Rather than copying the example as-is, read it with an eye on the inputs, the outputs, and the parts most likely to change.
The first step in LLM application development is an API call. Get an API key from a model provider (OpenAI, Anthropic, Google, and so on), put it in an environment variable, send a list of messages, and an answer comes back. The structure of setting the role and rules with a system message and passing the question in a user message is the same in almost every LLM API.
hello_llm.pyPYTHON
# pip install openai# In the terminal first: export OPENAI_API_KEY="sk-..." (never put the key directly in code!)from openai import OpenAIclient = OpenAI() # reads the OPENAI_API_KEY environment variable automaticallyresponse = client.chat.completions.create( model="gpt-4o-mini", temperature=0.3, messages=[ {"role": "system", "content": "You are a friendly AI tutor helping a beginner developer. Answer in 3 sentences or fewer."}, {"role": "user", "content": "Explain the difference between machine learning and deep learning."}, ],)print(response.choices[0].message.content)print("Tokens used:", response.usage.total_tokens) # get in the habit of checking cost
AI service tech stack: 6 layers
AI service tech stack: 6 layers is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
A real AI service does not end with one model. Six layers stacked from the bottom up have to work together to give users a reliable service. With this map in your head, you can immediately classify any new tool or framework by asking "which layer does this belong to".
Map of AI roles: what kind of work do you want to do
Map of AI roles: what kind of work do you want to do is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
The phrase "AI developer" mixes together roles that are quite different in nature. The depth of math needed, the tools used most, and the learning order all depend on the target role, so settling on a rough direction first raises learning efficiency a great deal.
Role
Main work
Core skills
Math required
AI application / Agent engineer
Building chatbot, RAG, and Agent services on LLM APIs
Python, prompting, RAG, LangChain/LangGraph, API design
Low to medium
ML engineer
Building model training, optimization, and serving pipelines
PyTorch, data pipelines, model serving, GPUs
Medium to high
MLOps / LLMOps engineer
Automating model deployment, monitoring, managing cost and quality
Docker, Kubernetes, CI/CD, observability
Low to medium
Data scientist
Data analysis, predictive models, deriving business insight
Statistics, Pandas, scikit-learn, visualization
Medium to high
Data engineer
Building data collection, cleaning, and storage pipelines
SQL, Spark, Airflow, cloud
Low
AI researcher
Researching new model architectures and training methods
Linear algebra, probability, optimization, implementing papers
Very high
Before you start: math, programming, development environment
Before you start: math, programming, development environment is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
"Do I have to be good at math to do AI?" is the question beginners ask most. The answer is that it depends on your goal. Building services with LLMs can be started perfectly well with high-school math, filling in the concepts you need whenever you get stuck. To design or research models yourself, on the other hand, linear algebra and probability are essential.
When understanding embeddings and neural network structure
Probability & statistics
Mean, variance, probability distributions, conditional probability
Conceptual understanding
Model evaluation, understanding sampling (temperature)
Calculus
What a gradient means
Intuition
Understanding how models learn through gradient descent
Developer tools
Git, terminal, VS Code, Jupyter/Colab
Required
Labs and project management
Step-by-step learning roadmap: from step 0 to real deployment
Step-by-step learning roadmap: from step 0 to real deployment is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
The roadmap below is the order that takes a complete beginner to the level of building and deploying an LLM-based AI service on their own. Each step builds on the previous one, so going in order is recommended, but for steps you already know you can just check the done item and move on. The links in each step lead to the detailed guides on this site.
12-week study plan: 1-2 hours a day is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
A realistic schedule that assumes a working professional or student investing 1-2 hours a day. The key is to leave behind one "deliverable" each week. Put the deliverables on GitHub and they become your portfolio as they are.
Week
Topic
Deliverable for the week
Weeks 1-2
Python basics, Git, Jupyter/Colab environment
A script that reads a CSV file and prints summary statistics
Week 3
Working with data in NumPy and Pandas
A notebook that cleans and visualizes one open dataset
A scikit-learn predictive model + an evaluation report
Week 6
How LLMs work: tokens, embeddings, prompts
Experiment notes comparing 5 prompts on the same task
Week 7
Using LLM APIs and structured output
A review analyzer that returns its results as JSON
Week 8
Building an AI API server with FastAPI
A chatbot API that supports streaming responses
Weeks 9-10
RAG: embeddings, vector DB, retrieval quality
A Q&A chatbot that answers from your own documents (PDFs, notes)
Week 11
Agents and Tool Use
A simple Agent that uses web search and a calculator
Week 12
Evaluation, Docker deployment, retrospective
A deployed service URL + README + notes on improvements
Starter project ideas by difficulty
Starter project ideas by difficulty is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
The best learning is building "something I actually want to use". Pick one of the ideas below, start small, and grow it by adding one feature at a time. Getting a version that works end to end first matters more than polish.
Difficulty
Project
What you learn
β ββ
Movie review sentiment classifier (scikit-learn)
Data splitting, text vectorization, metrics
β ββ
LLM translation and summarization CLI tool
API calls, prompt design, token cost
β β β
Meeting notes β automatic to-do list extractor
Structured output (JSON), input validation
β β β
Q&A chatbot over your own blog and notes
RAG, embeddings, vector DB, source citation
β β β
Work automation Agent (email summary + calendar booking)
7 common beginner mistakes is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
AI learning is broad and changes quickly, so it is easy to lose direction. Many beginners stall at similar points, and most of them can be avoided if you know about them in advance.
Mistake
Why it is a problem
Do this instead
Trying to perfect the math and theory first
Easy to burn out and quit with nothing built
Run it in code first and fill in the principles when needed
Only watching lectures without coding yourself
Leaves just "the illusion of knowing"
Keep a ratio of 2 hours of coding per 1 hour of lectures
Trying to keep up with every new paper and tool
New tools appear every week; there is no end
Focus on the fundamentals (Python, APIs, RAG, evaluation)
Trying to train a model yourself from the start
Very high cost in GPUs, data, and time
Start by using existing model APIs and open-source models
Trusting LLM answers as they are
Hallucinations put wrong information into your service
Check sources, add verification logic, build an evaluation dataset
Hard-coding API keys in code
A huge bill and a security incident if leaked
Use environment variables or .env + .gitignore
Judging by "it seems to work" without evaluation
No objective way to know whether it improved
Compare every time against a small set of test questions
Responsible use of AI: what to take care of from the start
Responsible use of AI: what to take care of from the start is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
AI is powerful, which also means misuse does real damage. A developer building a service should carry the four items below as a basic checklist alongside the feature work. In particular, privacy laws (such as GDPR and CCPA) and AI-specific laws and guidelines keep evolving, so make a habit of checking the latest rules before a real launch.
Item
Risk
Basic response
Personal data
Customer information may be sent to external APIs or used for training
Mask sensitive data, check data usage policies, collect the minimum
Bias
Prejudice in the training data shows up directly in the results
Validate results across diverse user groups
Copyright
Generated output may resemble existing works
Check licenses and terms before commercial use
Security
Prompt injection bypasses instructions, data leaks
Key terms: 30-second explanations of words you will meet often
Key terms: 30-second explanations of words you will meet often is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
When you hit an unfamiliar term while reading a guide or document, come back to this table. Each term is covered in more detail in later guides.
Term
One-line explanation
Parameter
An internal number the model adjusts through training. A "7B model" has 7 billion parameters
Hyperparameter
A setting a person chooses before training (learning rate, number of layers, and so on)
Loss function
A score for how far the prediction is from the answer. Lower is better
Gradient descent
The training method that nudges parameters in the direction that reduces the loss
Epoch
One full pass over the entire training data
Overfitting
Memorizing the training data and becoming weak on new data
Inference
Using a trained model to predict on new input
Pre-training
The stage of first learning general ability from large-scale data
RLHF
Training that refines the answer style of the model with human preference feedback
Quantization
Lowering the numeric precision of a model to make it smaller and faster
Multimodal
A model that handles several kinds of data together, such as text, images, and audio
Vector DB
A database that stores embedding vectors and quickly finds items with similar meaning
MCP
A protocol that standardizes how LLMs connect to external tools and data
GPU
Hardware that accelerates deep learning training and inference by doing huge numbers of matrix operations in parallel
AI Intro & Roadmap: frequently asked questions
How do AI, machine learning, deep learning, and LLMs differ?
AI is the whole field of getting machines to do intellectual work, and machine learning is the part of it that learns rules from data. Deep learning is a branch of machine learning that uses neural networks with many layers, and an LLM is a deep learning model trained on a large amount of text. Think of it as nested sets: AI β machine learning β deep learning β LLM.
Do developers have to study math before starting with AI?
If the goal is to build AI services, you do not need to start with math. Calling model APIs, writing prompts, RAG, and evaluation can all be started with ordinary development skills. Training models yourself or analyzing their performance needs the basics of linear algebra, probability, and calculus, and it is efficient to fill those in when you get there.
Do I have to train a model myself to build an AI service?
Usually not. The common approach is to take an already trained model, through an API or as an open model, and shape its behavior with prompts and retrieval (RAG). Training or fine-tuning is worth considering when existing models do not reach the required quality, or when cost, latency, or data-residency constraints call for a small dedicated model.