Basics
Core concepts in plain language: tokens, context, agents and prompts — no jargon, no formulas.
What is SSH — how to log into someone else's computer without a password in the open
SSH is a secure login into a remote computer. Here's what SSH is, why the safest login uses no password at all, and where you'll run into it.
What is hashing — why a website doesn't know your password
Hashing is a one-way fingerprint of data. Here's what a hash is, why a site stores not your password but its imprint, and how hashing differs from encryption.
What is a race condition — the bug that shows up only sometimes
A race condition is a bug that fires every other time and vanishes when you look. Here's what a race condition is, why code 'runs ahead,' and how to fix it.
Docker or a virtual machine — the difference, and what a beginner should pick
Docker and a virtual machine both promise 'runs the same everywhere,' but differently. We compare Docker vs VM on weight, speed and isolation — and what to choose.
What is WebSocket — and why a chat updates itself without a page reload
WebSocket is an open pipe between the browser and the server: data flows both ways on its own. Here's how it works and when plain HTTP isn't enough.
What is technical debt — and why it piles up faster with AI
Technical debt isn't "bad code" — it's the price of "fast now". Here's how it grows interest, why AI speeds it up, and when it's time to pay it back.
What is hosting — someone else's computer that never gets switched off
Hosting is a computer where your site lives 24/7. Here's how it differs from your laptop and which kind of hosting to pick for your first project.
What is YAML — the format where Norway turns into false
YAML is the config format where indentation is syntax. How to read YAML, why one space can break the file, and how to dodge the famous Norway problem.
What is a linter — the robot that finds bugs without running your code
A linter reads your code as text and catches mistakes before you run it: typos, dead variables, suspicious spots. How it works and how to turn it on.
What is a CLI — why the top AI tools look like a black window
A CLI is a program with no windows or buttons, driven by text. Learn to read any command with one simple pattern — and why AI agents live in CLIs.
JSON vs YAML — how to choose when they're almost one format
JSON and YAML aren't rivals: YAML formally includes JSON. An honest comparison — comments, strictness, error styles — and one simple rule for choosing.
What is web scraping — and is it even allowed?
Web scraping is a program reading websites for you and saving the data into a table. How it works, where the limits are, and how AI changed the game.
What version 1.0.0 means — and why projects break on their own
A version like 1.0.0 isn't a counter — it's a promise about what breaks on update. Semver explained: the ^ in package.json and lock files.
What are logs — and why your console.log prints somewhere else
Logs are your program's diary: what happened and when. Where to read them on the frontend, backend and hosting — and how to feed them to AI properly.
SQLite vs Postgres — which one for your first project
SQLite is a database in a single file next to your code; Postgres is a separate server. An honest comparison: setup, deploys, users — and what to pick.
What is refactoring — why change code that already works
What is refactoring in plain words: editing code so that nothing changes on the outside. Why touch working code at all, and how to ask AI to do it safely.
What is Markdown — the language you already write in
What is Markdown in plain words: every AI answer is written in it. Here are the six markup symbols that cover almost everything you'll ever need.
What is an IP address — and why 127.0.0.1 means "you"
What is an IP address in plain words: mail for computers, external vs internal addresses — and how to open your project on your phone using the terminal URL.
Authentication vs authorization — the difference, and why 401 isn't 403
Authentication answers "who are you", authorization — "what are you allowed to do". A table, examples, and which error means what: 401 vs 403.
What is a database migration — it's git for your schema, not moving data
A database migration isn't moving data — it's a version of your table structure. What it is, how it works, and why you need one even solo.
What is a cookie — and why the site remembers you logged in
What a cookie is in plain words: the server doesn't remember you, and a cookie is the coat-check ticket it recognizes you by. And why it isn't spying.
What is npm — why one command pulls in thousands of files
npm is a warehouse of ready-made JavaScript code plus the command that installs it. What npm is in plain words, what npm install does, and why it's both handy and risky.
What is Node.js — how JavaScript escaped the browser
Node.js is how you run JavaScript outside the browser: on a server, in the terminal, anywhere. Here's what Node.js is in plain words, and why you'll need it.
What is an eval — why topping a benchmark won't solve your task
An eval is a small exam you write for a model, tuned to your task. What an eval is in plain words, how it differs from a benchmark, and how to build your own in an evening.
What is top-p — and why the newest models ripped that knob out
top-p cuts off the model's tail of unlikely words. What top-p means in plain words, how it differs from temperature, and why turning both knobs at once is a mistake.
What is LoRA — fine-tuning where 0.01% of the weights learn
LoRA freezes the model and trains two tiny matrices on top. What LoRA means in plain words: why it trains thousands of times fewer parameters, and why adapters matter.
What is a tokenizer — why the model never sees letters, and Russian costs more
A tokenizer slices your text into chunks before the model ever sees it — and non-English text makes more chunks. What a tokenizer is, and why it drives cost.
What is a port — why the :3000 in localhost:3000 is a door, not an address
A port isn't an address — it's a «door» on your computer: the :3000 in localhost:3000 says which program to knock on. What a port is, and why there are thousands.
What is a Git commit — why it's a snapshot of the whole project, not a file save
A Git commit isn't «save this file» — it's a snapshot of your whole project with a note on why. What a commit is made of, and why it's so hard to lose.
What is Docker — and why “works on my machine” stops being an excuse
Docker packs your app together with its whole environment into a container that runs the same on your laptop and on the server. Here's what Docker is and why you'd want it.
What is DNS — and why your domain didn't “kick in” right away
DNS is the phone book of the internet: it turns a site's name into a server's address. Here's what DNS is and why your site didn't open instantly after you connected the domain.
What is a stack trace — and how to find the line that broke everything
A stack trace is the map of calls that led to an error. Here's how to read a stack trace and find the line in your own code where it crashed in 10 seconds, even as a beginner.
What is open source — and why it doesn't mean 'free'
Open source doesn't mean free, and it doesn't mean 'do whatever you want.' Here's what open source actually is — and why the license decides everything.
What is a Git branch — and why it isn't a copy of your files
A Git branch isn't a copy of your code folder — it's a lightweight bookmark to one commit. Here's what a branch is, why you need it, and why it's instant.
What is a rollback — the undo button for a broken production
You shipped an update and the site went down. A rollback restores the last working version in seconds while you calmly find the cause. Here's what rollback is.
What is a model card — the AI's passport you read before, not after
A model card is a model's passport: license, training data, limits. What a model card is and why you can't drop a free model into a product blind.
What is a library — and why one import carries someone else's responsibility
A library is someone else's code you call by name. What a library is, how it differs from a framework, and why every import is worth checking.
What is AGI — and why nobody agrees whether it's here yet
AGI is an AI that can do everything a human can. Sounds simple, but there's no single definition. Here's what AGI actually means and why the finish line keeps moving.
What is a foundation model — and why an LLM is just one kind of it
A foundation model is one big neural net trained on everything at once, then adapted to any task. Here's what a foundation model is and how the LLM fits in.
What is middleware — the layer every request passes through
Middleware is the code between 'a request arrived' and 'you responded.' Here it is on a conveyor belt: where login, logs and CORS live — and why you need next().
What is async — why your data shows up later, not right away
Async code doesn't wait: it moves on while the answer is still in transit. That's why your data is undefined even though it clearly arrives — and how await fixes it.
What is an ORM — working with a database without writing SQL
An ORM is a translator between your code and your database: you write user.save() instead of an SQL query. Here's what it's for — and where its big catch hides.
What is machine learning — and why nobody wrote the rule for “this is a cat”
Machine learning is when you don't program the rules — you teach with examples. Here's what machine learning actually is, in plain words, and where it lives.
What is a repository — and why it's not a GitHub folder, but a time machine
A repository is your project plus its whole history of changes. What a repo is, how it differs from GitHub, and why there's a hidden .git folder.
What is a dataset — and why dirty data breaks even a smart model
A dataset is the set of examples a model learns from. What a dataset is, why it's split into three parts, and why garbage in means garbage out.
What is semantic search — how to find things in other words
Semantic search finds by meaning, not exact words. Ask one thing, find the same thing phrased differently. Here's how it works and how to build your own.
What is latency — why AI feels slow even when the model is fast
Latency is how long you wait for an answer. With AI it splits into two parts, and one of them ruins the whole feeling of 'fast'. Let's find where the seconds go.
What is RLHF — why AI is polite and does what you ask
A raw model from the internet is rude and useless — humans rating answers make it polite. What RLHF is in plain words, and why it makes AI a bit of a flatterer.
What is Git — and why it's not GitHub or the cloud
Git stores not the latest version of your code but every step of it — and works offline. Here's what Git is in plain words, and why you need it.
What is an AI wrapper — and why 'just a wrapper around GPT' isn't an insult
'It's just a wrapper around GPT' sounds like a verdict, but that's how half of all useful AI products are built. Here's what an AI wrapper is and why it's fine.
What is a small language model (SLM) — and why it runs without the internet
An SLM is a small language model that fits on a phone and works offline. Here's what an SLM is, how it differs from an LLM, and when to reach for one.
What are HTTP status codes — what 200, 404 and 500 from the server mean
Every site answers with a three-digit code: 200 is OK, 404 is not found, 500 is the server broke. Here's what HTTP codes are and how to read them by the first digit.
What is the terminal — the black window nobody should fear
The terminal looks like a hacker window from the movies. It's really just a chat with your computer: you type a command, it replies. Let's demystify it.
What is streaming — why AI types its answer word by word
An AI doesn't reveal a finished answer — it births it one token at a time and hands it straight to you. Here's what streaming is and why it exists.
What is HTTPS — and what the padlock in your browser really means
The padlock next to the address doesn't mean 'this site is trustworthy.' It means only one thing. Here's what HTTPS is and what it actually protects.
What is a package manager (npm) — and where the node_modules folder comes from
One line — 'npm install' — and a folder weighs more than your whole project. Here's what a package manager is, and why it's both a superpower and a risk.
RAG vs fine-tuning — how to give a model your own knowledge
Want your bot to know your documents? Beginners reach for fine-tuning, but you almost always need RAG. Compared on cost, freshness, and complexity.
What is JSON — in plain words, and why every program understands it
JSON isn't code, it's data: two kinds of brackets and a colon. Learn what JSON is, how to read one, and why it shows up in every API response and config file.
What is frontend and backend — in plain words, and where your secret key lives
What frontend and backend are, how they differ, and why an API key on the frontend leaks in a minute. The two halves of any app, explained simply.
What Is Caching — Why the Second Time Is Always Faster (and Cheaper)
A cache is a pocket for data you already fetched, so you don't fetch it twice. Here's what caching is, why clearing the cache helps, and how it saves money on AI.
What Is a Container (Docker) — and Why "Works on My Machine" Is Dead
A container packages a program together with its environment so it runs the same everywhere. Here's what a Docker container is — and why it isn't a VM.
What is model distillation — how a big AI teaches a small one
A small model on your laptop answers almost like a giant. Distillation is when the big model personally tutors the small one.
What is a mixture of experts (MoE) — why a model is huge yet fast
A model has 600 billion parameters, but only a small slice fires per word. That's MoE — here's how one router keeps a giant nimble.
What is a knowledge cutoff — and why the model lies about yesterday
A knowledge cutoff is the line past which a model knows nothing. Here's why it confidently makes up recent events, and how to work around it.
REST or GraphQL — which to pick as a beginner, and why
REST or GraphQL — the real difference and what to use for a first project. We compare on what matters: learning curve, request count, flexibility — and call it straight.
What is a reasoning model — and why you pay for thoughts you never see
A reasoning model thinks to itself first, then answers. Those hidden thoughts cost money and time — here's how it works and when it's actually worth it.
What is a diffusion model — why AI images are born from noise
A diffusion model doesn't paint an image pixel by pixel — it develops it out of pure noise, removing static step by step. Here's how it works, in plain words.
What is an SDK — and how it differs from an API in plain words
An SDK is a ready-made toolkit for a service: a code library plus tools. Here's what an SDK is, how it differs from an API, and why you'd want one.
What is a rate limit — why an API answers 429 and asks you to wait
A rate limit caps how often you can call an API. Here's why a service answers 429, why it isn't a bug in your code, and how to live with it.
What is a framework — and how it differs from a library
A framework is a ready-made app skeleton. Here's what a framework is, how it differs from a library, and why you don't call it — it calls you.
What is a transformer — the 'T' in GPT, and why it guesses instead of understands
A transformer is the engine behind every AI like ChatGPT. Here's what a transformer is — and why it doesn't read text the way you do.
What are model parameters — the 7B and 70B in the name
Llama 70B, Qwen 7B — what's the B? It's billions of parameters. Here's what model parameters are, and why bigger doesn't always mean smarter.
What is a GPU — and why AI runs on graphics cards built for games
A GPU is the graphics card almost all AI runs on. Here's what a GPU is, how it differs from a CPU, and why neural networks can't live without it.
What is serverless — and why "no server" actually has a server
Serverless isn't "no server" — it's a server that sleeps until called. Here's what serverless is, what you pay for, and what a cold start really is.
What is a CDN — and why your site is slow even on a powerful server
It's not always a weak server — sometimes it's distance. Here's what a CDN is, how a network of copies speeds up a site, and why you need one early.
What is inference — and why you pay for every AI answer again
Inference is a trained model working for you right now. Here's why every answer costs money each time, and what drives its speed and price.
What is an AI benchmark — and why #1 isn't the best for you
A benchmark is a standardized exam for AI models. Here's how to read leaderboards without the illusions, and why your own mini-test beats any ranking.
What is multimodality — how AI 'sees' an image when it has no eyes
A multimodal model doesn't look at an image the way you do — it turns it into the same numbers as text. How AI works with photos, sound and text at once.
What is fine-tuning — and why it barely teaches a model new facts
Fine-tuning teaches a model style and behavior, not new facts. Here's how it differs from RAG and why a beginner should care about the difference.
What are open weights — and why it's not the same as open source
Open weights are a model's ready-made 'brain' you can download and run. But it's not open source: you don't get the recipe or the data. Here's the difference.
React or plain HTML — what to pick for your first site, no dogma
Not everyone needs React. For a landing page or blog, plain HTML is lighter and faster; React pays off when the interface is live. We compare and call it straight.
What is the DOM — and why the page's 'source code' lies to you
The DOM is the live tree of the page the browser builds from your HTML. In plain words: how it differs from the source, and why your element 'isn't found.'
What is a REST API — and why the server forgets you every time
A REST API isn't a technology — it's a set of good manners for programs talking over the internet. In plain words: four verbs, addresses, and why the server never remembers you.
What is React — and why you stop touching the page by hand
React is a library where you describe how the screen should look, and it redraws it for you. In plain words: components, state, and the one trick that changes everything.
What is CORS — and why that console error is protection, not a bug
CORS isn't 'your server broke.' It's the browser hiding the response to protect you. Here's why the CORS error happens and how to fix it honestly.
What is a JWT — and why the server doesn't remember you but lets you in anyway
A JWT is a pass you carry with you, not an entry in the server's logbook. Here's how the server lets you in while storing nothing about you — and where the trap is.
What is 2FA — and why it saves you even after your password is stolen
2FA is a second key to your account that changes every 30 seconds. Here's why it holds even when your password has long leaked into someone else's database.
What is SEO — and why nobody finds your finished site
Your site works, but it's nowhere in search. SEO isn't marketing magic — it's how you tell Google what your page is about. Explained plainly, no jargon.
What is OAuth — and why 'Sign in with Google' never gives away your password
The 'Sign in with Google' button never hands your password to the site — that's the whole point. OAuth explained plainly: how it works, why it exists, where you've met it.
What are meta tags — and why search sees them but your page doesn't
Title and description are the only thing a person sees about your page BEFORE clicking. They're hidden in the code, not on screen. Which ones matter and how to write them.
Open or closed AI models — which to pick as a beginner and why
A closed model is a taxi, an open one is your own car. We compare on price, privacy and the learning curve, and say plainly who should pick which — and when to switch.
What does deploy mean — and how it differs from “it works on my machine”
“Works on my computer” isn't the same as “available to people.” Deploy moves your app to where it lives without you. Here's what it really means.
What is an environment variable — and why you never put a key in the code
Write an API key into your code, push to GitHub, and bots steal it in minutes. Environment variables keep secrets out of the code. Here's how.
What is a vector database — and why it finds “dog” when you type “puppy”
A vector database searches by meaning, not exact words: it finds the right thing even when you don't guess the phrasing. Here's how it works.
SQL or NoSQL — which to pick for a first project, no dogma
SQL is strict tables with relations, NoSQL is flexible document-cards. We compare them where it counts and say plainly what a beginner should take.
What is SQL — in plain words, and why a 50-year-old language is still alive
SQL is the language you use to ask a database for the rows you want. Explained simply: what it's for, how it reads, and why everyone still learns it.
What is an API — in plain words, and why you ping a hundred of them daily
An API is the window through which one program asks another to do something or hand over data. Explained simply, no jargon, with real examples.
What is a database — in plain words, and why nothing sticks without one
A database is an app's memory that survives a restart. Explained simply: what it's for, how it's built, and when you actually need one.
What is an LLM, in plain words (and why it guesses instead of knows)
An LLM isn't a knowledge base — it's a text-continuation machine. Here's what a large language model really is, and why it's so confidently wrong.
What is a neural network — in plain words (and why nobody programmed it)
A neural network doesn't memorize examples or follow rules — it turns millions of knobs until it guesses right. Here's the plain-words version, no formulas.
What is temperature in a model — the slider between boring and wild
One setting decides whether the AI answers dull and identical or creative and risky. At zero it's by-the-book; turn it up and it writes poetry, but it may also make things up.
What is RAG — letting an AI peek at your cheat sheet
The model never trained on your documents — yet it answers from them. The trick is that it gets handed the right snippets right before answering. That's RAG.
What is MCP — the single port that gives AI its 'hands'
MCP is USB for AI agents. One common port, and an agent can reach your browser, your database and your files — no custom adapter for each.
What is a context window — and why AI forgets the start of a conversation
In a long chat, old messages get pushed out of the model's memory — that's why it loses the thread. Explained with a simple picture.
What is an AI hallucination — and why the model isn't lying when it makes things up
The model confidently spat out nonsense. Feels like a lie. But it can't lie — it has no idea what truth even is. Let's see how it works and how to catch it.
What is a token — and why Russian costs more than English
The same sentence costs a model more in Russian than in English. Tokens are why — let's see what they are and how to pay less.
What is a prompt — and why it's a brief, not a question
A prompt feels like a question you ask the AI. It's really a brief for a worker. Flip that, and the answers stop surprising you.
What are embeddings — and how AI knows that 'cat' and 'kitten' mean the same
AI turns words into coordinates on a map of meaning. Close meanings land near each other — so it searches by meaning, not by exact words.
Reading Code You Didn't Write: Understanding Your Own AI-Built Project
The AI wrote it, but it is your product now. You do not need to write code by hand to understand it — you need to read it. Here is how to actually do that.
Database Basics for Vibe Coders: Designing Data Without a CS Degree
A database is just a set of well-labelled lists. Get the data model right and the rest of your app falls into place. Get it wrong and you fight it forever.
What is KODiQ? Learn to build with AI, one lesson at a time
KODiQ is a free mobile app that teaches you to build real things with AI — vibe coding, prompting and AI literacy in short daily lessons. Here's how it works.