Skip to main content
AIDevOps
  • Learn
  • Learning Paths
  • Practice
  • Open Source
  • Books
  • Engineering

    AI DevOpsThe full map of building and operating AI servicesLLMOpsLLM deployment Β· evaluation Β· observabilityHands-on ProjectsBuild AI Agent projects

    Knowledge

    DocsTechnical documentationBlogEngineering articlesPloggerDevelopment log feed

    Validate

    Certification3-level skills certification Β· coming soon
AI Models
LlamaTutorial|MistralTutorial|GemmaTutorial|DeepSeekTutorial|QwenTutorial
🧠 AI Core
AI Intro & RoadmapML FundamentalsLLM Fundamentals|Python AIC++|PyTorchTensorFlowJAX
πŸ€– AI Applied Development
Applied AI Intro & RoadmapHugging FaceLangChainLlamaIndexLLMOps|LangGraphMCPMulti-AgentAgent Evaluation
🧠 AI Agent Development
Finance AI AgentLLM API ServerStock Investing AgentAIOps AI AgentEducation AI AgentCoding AI Agent
🌱 Spring Cloud
Spring Intro & RoadmapSpring Cloud GatewaySpring BootJava|Spring AISpring SecuritySpring BatchSpring JPA
🐳 DevOps
DevOps Intro & RoadmapLinuxDockerCI/CD|Kubernetes BasicsK8s AdvancedPrometheusGrafana
🧱 Infrastructure
Infrastructure Intro & RoadmapNginxRedis
☁️ Cloud
Cloud Intro & RoadmapAWSGCPAzureNCPCloudflare
🎨 Frontend
Frontend Intro & RoadmapJavaScriptTypeScript|ReactNext.js|VueNuxt|Electron
πŸ“± Mobile
Mobile Intro & RoadmapKotlinAndroidFlutter
βš™οΈ Backend
Backend Intro & RoadmapPython BasicsFastAPIDjangoFlask|CGoGinNode.js
πŸ’Ύ Database
DB Intro & RoadmapCore SQLOracleMySQLPostgreSQL|MongoDBVector DB
πŸ§ͺ Testing
k6JMeternGrinder
AIDevOps

Engineering AI. From Code to Production.
An engineering learning platform for building and operating AI and AI Agents

Learn

  • All Guides
  • Learning Paths
  • AI Tutorial
  • Practice
  • Books

Resources

  • AI DevOps
  • LLMOps
  • Hands-on Projects
  • Docs
  • Blog
  • Plogger
  • Open Source
  • Certification (coming soon)

Start Here

  • AI Core Roadmap
  • AI Applied Development Roadmap
  • Spring Cloud Roadmap
  • DevOps Roadmap
  • Infrastructure Roadmap

Β 

  • Cloud Roadmap
  • Frontend Roadmap
  • Mobile Roadmap
  • Backend Roadmap
  • Database Roadmap
Β© 2026 AIDevOps. All rights reserved.
Terms of ServicePrivacy PolicySitemaptestforge.kr
  1. Home
  2. Learn
  3. AI Core
  4. AI Intro & Roadmap
The first guide for newcomers to AI

🧭 AI Intro & Roadmap Complete Guide

Visitors

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.

  • AI Foundations β†’
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

Related frameworks & environments

πŸ“ML Fundamentalsβ†’πŸ§ LLM Fundamentalsβ†’πŸPython AIβ†’LCLangChainβ†’βš‘FastAPIβ†’

Contents

0 / 18
  1. How to use this guide
  2. Architecture diagrams
  3. What AI is
  4. AI history at a glance
  5. How AI learns
  6. Map of AI fields
  7. Generative AI and LLMs
  8. Your first LLM API call
  9. AI service tech stack
  10. Map of AI roles
  11. Before you start
  12. Step-by-step learning roadmap
  13. 12-week study plan
  14. Starter project ideas
  15. Common beginner mistakes
  16. Responsible use of AI
  17. Key terms
  18. Frequently asked questions
Contents 18 sections
  1. How to use this guide
  2. Architecture diagrams
  3. What AI is
  4. AI history at a glance
  5. How AI learns
  6. Map of AI fields
  7. Generative AI and LLMs
  8. Your first LLM API call
  9. AI service tech stack
  10. Map of AI roles
  11. Before you start
  12. Step-by-step learning roadmap
  13. 12-week study plan
  14. Starter project ideas
  15. Common beginner mistakes
  16. Responsible use of AI
  17. Key terms
  18. Frequently asked questions

How to use this guide

How to read it

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.
LayerOne-line definitionTypical examples
AI (artificial intelligence)The whole range of systems that perceive, judge, and act like peopleChess engines, route finding in navigation, voice assistants
ML (machine learning)The AI methodology of learning rules from dataSpam filters, credit scores, product recommendations
DL (deep learning)ML that learns complex patterns with multi-layer neural networksFace recognition, speech recognition, self-driving perception
Generative AI / LLMDeep learning models that produce new text, images, code, and audioChatGPT, Claude, Gemini, Stable Diffusion

Tip

  • AI βŠƒ ML βŠƒ DL βŠƒ generative AI: each is a more specific concept than the last. At the beginner stage, getting this containment right is enough to read most articles and documents.
  • "AI thinks" is a metaphor. Current AI is a function that has learned statistical patterns from vast data, and holding that view makes both the strengths and the limits of AI easier to understand.

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.
PeriodMilestoneSignificance
1950sThe Turing test is proposed; the term "AI" is coined at the Dartmouth workshopThe start of AI as a field
1970s-80sExpert systems (rule-based AI), two "AI winters"Hit the limit of people having to write every rule
1990s-2000sStatistical machine learning such as SVMs and random forests spreadsLearning rules from data becomes mainstream
2012AlexNet wins an image recognition competition by a wide marginThe GPU + deep learning era begins
2016AlphaGo defeats Go champion Lee SedolReinforcement learning enters public awareness
2017The Transformer paper "Attention Is All You Need"The architecture behind modern LLMs appears
Late 2022ChatGPT is releasedGenerative AI goes mainstream
2024 onwardMultimodal models, reasoning models, and AI Agents spreadAI 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-learn
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

# β‘  Data: petal/sepal sizes (inputs) and species (answers) of 150 iris flowers
X, 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 model
model = DecisionTreeClassifier(max_depth=3)

# β‘’ Training: it finds the rules from the data by itself
model.fit(X_train, y_train)

# β‘£ Inference & evaluation: test on data it has never seen
pred = model.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, pred):.2%}")   # about 100%

# Predict one new flower
print(model.predict([[5.1, 3.5, 1.4, 0.2]]))            # [0] β†’ the setosa species

Tip

  • The 15 lines above compress all of machine learning. Deep learning and LLMs only scale it up; the "data β†’ model β†’ training β†’ evaluation β†’ inference" flow is the same.
  • To run it right away with nothing to install, open a new notebook in Google Colab (colab.research.google.com) and paste it in.

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.
FieldDataTypical tasksKey techniques
Natural language processing (NLP)TextTranslation, summarization, chatbots, sentiment analysis, searchTransformer, LLM, embeddings
Computer vision (CV)Images and videoObject detection, face recognition, medical image readingCNN, ViT, YOLO, Diffusion
SpeechAudioSpeech recognition (STT), speech synthesis (TTS)Whisper, speech Transformers
Recommender systemsUser behavior logsProduct and content recommendation, personalizationCollaborative filtering, embeddings, ranking models
Tabular data analysisTable (spreadsheet, DB) dataDemand forecasting, fraud detection, churn predictionXGBoost, LightGBM, regression
Reinforcement learning (RL)Interaction with an environmentGame AI, robot control, LLM alignment (RLHF)PPO, DQN, reward models
Generative AIText, images, code, audioWriting, image generation, code generation, AI AgentsLLM, Diffusion, RAG, Tool Use

Tip

You do not need to study every field from the start. Industry demand is currently greatest for generative AI (using LLMs) and tabular data analysis, and the roadmap in this guide is built around development with LLMs as the main goal.

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.
ConceptIn plain wordsWhy it matters
TokenThe smallest unit (a piece of a word) an LLM reads and writesBoth pricing and the input length limit are counted in tokens
PromptThe instructions and input given to the LLMThe same model gives very different quality depending on the prompt
Context windowThe maximum number of tokens it can read at onceWith long documents you have to design what goes in and what stays out
TemperatureThe setting that controls randomness (creativity) of answersLow for accurate answers, high for brainstorming
HallucinationProducing answers that sound plausible but are not trueThe first risk to guard against in an LLM service
EmbeddingThe meaning of a sentence turned into a vector of numbersThe basis of meaning-based search, recommendation, and classification
RAGRetrieving documents related to the question and putting them in the promptLets it answer from internal documents and fresh information, and reduces hallucination
Fine-tuningFurther training an existing model on your own dataUsed to specialize in a particular tone, format, or domain
Tool Use / Function CallingLetting the LLM call external functions and APIsDoes what the LLM cannot do alone: search, DB lookups, calculation
AI AgentAn LLM system that takes a goal, plans by itself, and uses tools repeatedlyThe stage beyond a simple chatbot, where real work is automated

Tip

  • The textbook order for solving problems is "improve the prompt β†’ RAG β†’ fine-tuning". Most problems are solved in the first two steps, and fine-tuning is the last resort because of its cost and maintenance burden.
  • The LLM Fundamentals guide goes deeper into how LLMs work inside: the Transformer, tokenizers, decoding strategies, and more.

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 OpenAI

client = OpenAI()  # reads the OPENAI_API_KEY environment variable automatically

response = 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

Tip

  • Pushing an API key to code or GitHub is the accident beginners cause most often. Always manage it with environment variables or a .env file (registered in .gitignore).
  • API charges are proportional to the number of tokens. An inexpensive small model is enough while you are learning, and setting a monthly usage limit in the provider console lets you experiment with peace of mind.

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".
LayerRoleTypical technologiesRelated guides
6. Operations (Ops)Deployment, monitoring, cost and quality trackingDocker, Kubernetes, Prometheus, LangSmithLLMOps, Docker
5. ApplicationThe API and UI the user meetsFastAPI, Next.js, StreamlitFastAPI
4. OrchestrationAssembling prompt, RAG, and Agent flowsLangChain, LangGraph, LlamaIndex, MCPLangChain, LangGraph, MCP
3. Data & retrievalDocument storage, embeddings, similarity searchVector DBs (Chroma, pgvector, Pinecone)Vector DB
2. ModelThe trained AI model itself (API or open source)GPT, Claude, Gemini, Llama, QwenLLM Fundamentals, Hugging Face
1. Framework & infrastructureModel training and inference engines and hardwarePyTorch, TensorFlow, JAX, CUDA, GPUPyTorch, TensorFlow

Tip

LLM application developers mostly work in layers 2-5; layer 1 (model training) belongs to researchers and ML engineers, and layer 6 to MLOps/LLMOps engineers. The layer you want to work in is your learning direction.

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.
RoleMain workCore skillsMath required
AI application / Agent engineerBuilding chatbot, RAG, and Agent services on LLM APIsPython, prompting, RAG, LangChain/LangGraph, API designLow to medium
ML engineerBuilding model training, optimization, and serving pipelinesPyTorch, data pipelines, model serving, GPUsMedium to high
MLOps / LLMOps engineerAutomating model deployment, monitoring, managing cost and qualityDocker, Kubernetes, CI/CD, observabilityLow to medium
Data scientistData analysis, predictive models, deriving business insightStatistics, Pandas, scikit-learn, visualizationMedium to high
Data engineerBuilding data collection, cleaning, and storage pipelinesSQL, Spark, Airflow, cloudLow
AI researcherResearching new model architectures and training methodsLinear algebra, probability, optimization, implementing papersVery high

Tip

If you have backend or web development experience, AI application engineer is the fastest way in. Your existing API, DB, and deployment skills carry over as they are, and you only add LLM techniques on top.

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.
AreaWhatHow muchWhen it is needed
ProgrammingPython syntax, functions, classes, package managementRequired β€” first of allThe base language for all AI work
Working with dataNumPy, Pandas, JSON, basic SQLRequiredData preprocessing, analyzing results
Linear algebraVectors, matrix multiplication, dot productConceptual understandingWhen understanding embeddings and neural network structure
Probability & statisticsMean, variance, probability distributions, conditional probabilityConceptual understandingModel evaluation, understanding sampling (temperature)
CalculusWhat a gradient meansIntuitionUnderstanding how models learn through gradient descent
Developer toolsGit, terminal, VS Code, Jupyter/ColabRequiredLabs and project management

Tip

  • Most people burn out halfway if they try to finish all the math before starting. The recommended order is "run it in code first β†’ fill in the principles you got curious about with math".
  • It is fine to have no GPU. Beginner labs run perfectly well on a laptop CPU, the free GPU in Google Colab, and LLM APIs.

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.
StepGoalWhat to learnGuidesDone check
0. PreparationDevelopment environment and Python basicsPython syntax, virtual environments, Git, JupyterPython Basics, LinuxWrite a simple file-processing script on your own
1. ConceptsUnderstand how AI and ML workLearning types, algorithms, neural networks, metrics, overfittingML FundamentalsTrain and evaluate a classifier with scikit-learn
2. Understanding LLMsUnderstand how an LLM worksTransformer, tokens, embeddings, prompts, hallucinationLLM FundamentalsExplain how results change as you vary the prompt
3. Building with LLMsImplement AI features through an APIAsync calls, structured output, streamingPython AI, FastAPIImplement a REST API server that calls an LLM
4. RAGAI that answers from your dataDocument splitting, embeddings, vector search, building chainsLangChain, LlamaIndex, Vector DBFinish a Q&A chatbot over PDF documents
5. AgentAI that uses toolsTool Use, state graphs, MCP, multi-agentLangGraph, MCP, Multi-AgentImplement an Agent that uses search and calculator tools
6. Evaluation & operationsInto a service you can trustQuality evaluation, deployment, monitoring, cost managementAgent Evaluation, Docker, LLMOpsDeploy with Docker and track quality metrics
7. Advanced (optional)Working with the model itselfDeep learning frameworks, fine-tuning, open-source modelsPyTorch, Hugging FaceLoRA fine-tune an open-source model

Tip

  • Step 3 is the heart of the roadmap. Interest fades easily when concept study (steps 1-2) drags on, so it also works well to skim steps 1-2, build something in step 3, and go back to fill in the concepts you need.
  • Learning paths organized by role are on the Learning Paths page (/learning-paths/).

12-week study plan: 1-2 hours a day

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.
WeekTopicDeliverable for the week
Weeks 1-2Python basics, Git, Jupyter/Colab environmentA script that reads a CSV file and prints summary statistics
Week 3Working with data in NumPy and PandasA notebook that cleans and visualizes one open dataset
Weeks 4-5Machine learning basics: classification, regression, metricsA scikit-learn predictive model + an evaluation report
Week 6How LLMs work: tokens, embeddings, promptsExperiment notes comparing 5 prompts on the same task
Week 7Using LLM APIs and structured outputA review analyzer that returns its results as JSON
Week 8Building an AI API server with FastAPIA chatbot API that supports streaming responses
Weeks 9-10RAG: embeddings, vector DB, retrieval qualityA Q&A chatbot that answers from your own documents (PDFs, notes)
Week 11Agents and Tool UseA simple Agent that uses web search and a calculator
Week 12Evaluation, Docker deployment, retrospectiveA 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.
DifficultyProjectWhat you learn
β˜…β˜†β˜†Movie review sentiment classifier (scikit-learn)Data splitting, text vectorization, metrics
β˜…β˜†β˜†LLM translation and summarization CLI toolAPI calls, prompt design, token cost
β˜…β˜…β˜†Meeting notes β†’ automatic to-do list extractorStructured output (JSON), input validation
β˜…β˜…β˜†Q&A chatbot over your own blog and notesRAG, embeddings, vector DB, source citation
β˜…β˜…β˜…Work automation Agent (email summary + calendar booking)Tool Use, state management, error handling
β˜…β˜…β˜…RAG chatbot quality evaluation dashboardEvaluation datasets, automatic grading, monitoring

Tip

More concrete step-by-step labs are on the Hands-on Projects page (/projects/).

7 common beginner mistakes

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.
MistakeWhy it is a problemDo this instead
Trying to perfect the math and theory firstEasy to burn out and quit with nothing builtRun it in code first and fill in the principles when needed
Only watching lectures without coding yourselfLeaves 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 toolNew tools appear every week; there is no endFocus on the fundamentals (Python, APIs, RAG, evaluation)
Trying to train a model yourself from the startVery high cost in GPUs, data, and timeStart by using existing model APIs and open-source models
Trusting LLM answers as they areHallucinations put wrong information into your serviceCheck sources, add verification logic, build an evaluation dataset
Hard-coding API keys in codeA huge bill and a security incident if leakedUse environment variables or .env + .gitignore
Judging by "it seems to work" without evaluationNo objective way to know whether it improvedCompare 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.
ItemRiskBasic response
Personal dataCustomer information may be sent to external APIs or used for trainingMask sensitive data, check data usage policies, collect the minimum
BiasPrejudice in the training data shows up directly in the resultsValidate results across diverse user groups
CopyrightGenerated output may resemble existing worksCheck licenses and terms before commercial use
SecurityPrompt injection bypasses instructions, data leaksInput validation, minimal tool permissions, output filtering

Tip

Build the assumption that "AI can be wrong" into the design. For important decisions (medical, financial, legal), a structure where a person makes the final check (human-in-the-loop) is the default.

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.
TermOne-line explanation
ParameterAn internal number the model adjusts through training. A "7B model" has 7 billion parameters
HyperparameterA setting a person chooses before training (learning rate, number of layers, and so on)
Loss functionA score for how far the prediction is from the answer. Lower is better
Gradient descentThe training method that nudges parameters in the direction that reduces the loss
EpochOne full pass over the entire training data
OverfittingMemorizing the training data and becoming weak on new data
InferenceUsing a trained model to predict on new input
Pre-trainingThe stage of first learning general ability from large-scale data
RLHFTraining that refines the answer style of the model with human preference feedback
QuantizationLowering the numeric precision of a model to make it smaller and faster
MultimodalA model that handles several kinds of data together, such as text, images, and audio
Vector DBA database that stores embedding vectors and quickly finds items with similar meaning
MCPA protocol that standardizes how LLMs connect to external tools and data
GPUHardware that accelerates deep learning training and inference by doing huge numbers of matrix operations in parallel

Tip

The next step is the ML Fundamentals guide. On top of the big picture from this guide, go one level deeper into how machine learning is actually trained and evaluated.

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.

Next guide β†’ML Fundamentals