Basics
Core concepts in plain language: tokens, context, agents and prompts — no jargon, no formulas.
What is the Shadow DOM — and why your CSS can't reach the widget
The Shadow DOM in plain words: why page styles don't apply inside a widget while fonts and colors leak in, and why querySelector can't find a button you can see.
What is optimistic locking — and where did the new price go
Optimistic locking in plain words: how two editors silently overwrite each other, and how a version column in your database catches the conflict before it lands.
What is a state machine — and why your spinner spins next to an error
A state machine in plain words: why three flags — isLoading, isError and data — give you eight states instead of four, and how a single status fixes it.
useState vs useRef — what's the difference, and why the counter is stuck at zero
useState vs useRef in React: which one triggers a re-render, when you see the new value, and where to keep a timer id. A simple rule for which to pick.
What is backpressure — and why your script ate all the memory
What backpressure is, in plain words: the receiver's “slow down” signal to a data source. Why your script eats memory without it, and how to fix it in Node.
What is a percentile (p50, p95, p99) — and why average response time lies
What a percentile is, in plain words: p50, p95 and p99 in speed metrics. Why average response time fools you, and how to calculate a percentile yourself.
What is a cache stampede — and how a cache can take down your database
What a cache stampede is: a hot key expires and hundreds of requests hit the database at once. Why it happens and three ways to prevent it in your app.
PUT vs PATCH — what's the difference, and why the name vanished after an avatar change
PUT vs PATCH in a REST API: full replacement vs partial update, idempotency, null in the body, and the fetch method: 'patch' trap. Which one to pick and when.
What is integer overflow — and why your counter suddenly went negative
What integer overflow is, in plain words: a number hits its ceiling and wraps into the negatives. Where 2,147,483,647 breaks real apps.
What is a sparse array — and why map won't fill Array(3)
What a sparse array is, in plain words: holes instead of elements. Why Array(3).map does nothing, and why the array's length lies to you.
What is a semaphore in programming — and why batching requests is slower
What a semaphore is, in plain words: a counter that lets at most N tasks use a resource at once. How to limit parallel requests with it and avoid 429s.
input vs change event — and why your search only fires after clicking away
input vs change in JavaScript: when each event fires, which one to use for search, sliders and checkboxes — and why React's onChange works differently.
What is a string in programming — and why "5" and 5 aren't the same
What a string is, in plain words: text in quotes. Why "2" + "2" gives "22", an emoji counts as two characters, and everything from a form arrives as a string.
What is return and a return value — and why console.log returns nothing
What return does in a function, in plain words: the answer a function hands back. Why console.log shows a number but your variable holds undefined.
What is a boolean — and why the string "false" is actually true
What a boolean is, in plain words: true or false. Why "false" in quotes counts as true, an empty array does too, and zero counts as false.
for loop or map — which to use, and why await inside map doesn't wait
for loop or map in JavaScript: what's the difference and which to pick. A comparison on five criteria, where forEach fits, and the await-inside-map trap.
What is scope in programming — and why a variable is "not defined" when it's right there
What scope is in programming, in plain words: where in code a variable exists and where it doesn't. Why is not defined happens and how to read curly braces.
What is null — and why its inventor called it a billion-dollar mistake
What null means in programming, in plain words: "deliberately empty." How null differs from undefined, where Cannot read properties of null comes from, and how to avoid it.
What is an object in programming — and why two identical objects aren't equal
What an object in programming is, in plain words: a card with labeled fields. How it works, where it shows up in AI-written code, and why {a:1} isn't {a:1}.
let vs const — which to use, and why AI writes const almost everywhere
let vs const in JavaScript: what the difference is and which to pick. A criteria breakdown, a one-second rule, and why const doesn't mean "can't change."
What is an array — and why it counts from zero
What is an array in plain words: a list that keeps its order. Why counting starts at zero, where the most common beginner bug comes from, and why an empty array matters.
What is a loop — and why it can run zero times
What is a loop in programming, in plain words: repeat one action for every item in a list. Why you almost never know the number of repeats in advance.
What is a callback — and why extra parentheses break your button
What is a callback in plain words: a function you hand over instead of calling. Why it works that way, where you've already written one, and which parentheses break everything.
Array or object — which one to pick for your data
Array vs object: how they differ and which to pick for your data. A one-sentence rule, a breakdown by criteria, and why searching an array is a thousand times slower.
What is a git worktree — and why keep a second folder of the same project
A git worktree is a second working folder on the same project history. Two branches open at once, no switching and no stashing half-finished work.
What is state — and why a button doesn't "turn" grey
State is everything your app remembers between two clicks. What state is in plain words, and why interfaces break wherever one truth is stored twice.
What is a regression — and why a fixed bug comes back
A regression is an old bug that came back. What a regression is in plain words, why someone else's edit usually brings it, and how to catch it for good.
What is a dependency — and why one library pulls in two hundred
A dependency is someone else's code running inside your project. What a dependency is in plain words, why there are hundreds, and when to just write it yourself.
What is a variable — and why a copy of a list changes together with the original
A variable isn't a box holding a value — it's a tag attached to one. That's the bug every beginner hits: you edit the copy of a list and break the original.
What is a diff — and why AI shows you minuses and pluses instead of the finished file
A diff isn't a report of what changed — it's a recipe for turning the old version into the new one. Learn to read minuses, pluses and those @@ marks in five minutes.
What is line-height — and why 1.5 and 150% give different results
What line-height is in plain words: how the browser builds a line box, why 1.5 and 150% inherit differently, and what value to use for body text.
What is a variable font — one file instead of eight
What a variable font is: how variation axes replace a dozen files with one, why font-weight 437 exists, and when this actually makes your site faster.
What are CSS variables — and why they live inside the browser
What CSS variables are in plain words: how var() works, why they inherit unlike Sass variables, and the three gotchas that trip up almost everyone.
em or rem — what's the difference and which to use
em vs rem in CSS: what each unit measures against, where em compounds and breaks, and why both ignore your html font-size inside media queries.
What is z-index — and why 9999 doesn't help
What z-index actually is: why a modal with z-index 9999 still slips under the header, what a stacking context is, and how to fix it without bigger numbers.
What is the CSS box model — and why your block is wider than you set
The CSS box model in plain words: why width 350px renders as 370px, what box-sizing border-box changes, and why four 25% columns don't fit on one line.
What is a container query — the media query that doesn't look at the screen
CSS container queries in plain words: why @media fails a component in a narrow sidebar, how @container works, and the two traps tutorials skip.
Flexbox or Grid — which to choose (and the sign you chose wrong)
Flexbox vs CSS Grid: the real difference, the criteria to choose on, and the one sign that tells you you picked the wrong layout. With examples and a verdict.
What is the safe area — and how one word in a meta tag hides your button under the notch
The safe area is the part of the screen no notch, rounded corner or gesture bar covers. How env() handles it in CSS and what viewport-fit turns off.
What is prefers-reduced-motion — and why less motion doesn't mean no animation
prefers-reduced-motion is the Reduce Motion system setting your site reads with one line of CSS. Which motion makes people sick and what you can keep.
What is forced colors mode — when Windows repaints your website
Forced colors is the high contrast mode where Windows swaps your site's colors for its own. What breaks, how to test it in a minute, and the CSS fixes.
object-fit: cover vs contain — which one stops images from squashing or getting cropped
object-fit: cover vs contain compared on cropping, empty bars, card grids and photos of people. Plus scale-down for logos and object-position.
What is tab order — and why CSS can't rearrange it
Tab order is the queue the Tab key follows through links and fields. Where it comes from, why CSS order breaks it, and which tabindex values are safe.
What is ARIA — and why pages that use it have more errors
What ARIA is in plain words: labels for screen readers that change only how an element sounds, not how it behaves. And why bad ARIA hurts more than none.
What is a mega menu — and why it shouldn't open instantly
A mega menu is a large dropdown panel with a site's sections. When it beats a regular dropdown, why a half-second pause matters, and Amazon's triangle trick.
display: none vs visibility: hidden — the difference, and what screen readers hear
display: none vs visibility: hidden compared on layout space, clicks, Tab, screen readers and animation. Plus a way to hide an element from eyes only.
What is infinite scroll — and why you can never reach the site footer
Infinite scroll loads more content as you scroll. Here's how it works, where it breaks — the footer, the Back button, Google — and when to use it.
What is a skip link — the hidden link that saves 40 Tab presses
A skip link is a hidden “Skip to main content” link that appears when you press Tab. Who needs it, how to build one in five minutes and how to test it.
What is a command palette — a search that finds actions, not pages
A command palette is a window you open with a shortcut: type what you want to do and hit Enter. How it works and whether your app actually needs one.
Link or button — which to use so Tab, new tabs and Google all work
Link vs. button compared on keyboard, opening in a new tab, Google Search and screen readers. A one-question rule — and what's wrong with a div with onclick.
What is client-side routing in an SPA — and what the browser stops doing for you
Client-side routing changes the page address without asking the server. How it works under the hood, and the four things the browser no longer does for you.
What is a hamburger menu — and what hiding your navigation actually costs
A hamburger menu is the three-line icon that hides a site's navigation. What the NN/g study found: on desktop, hidden menus get used about half as often.
What are breadcrumbs on a website — and why they're not your click history
Website breadcrumbs are the “Home > Section > Page” trail. Who they actually help, how to build them right, and what Google changed about them in 2025.
Tabs or an accordion — which to choose, and why Ctrl+F only finds one of them
Tabs vs. accordion compared on screen size, find-in-page, keyboard and code size. A straight verdict on when to use each — and when to hide nothing at all.
What is autofill — and why the browser doesn't recognize your fields
Autofill doesn't read your name or id — it reads the autocomplete attribute. Here's the word list browsers look for, and why you can't just switch it off.
What is an input mask — and why it usually gets in the way
An input mask types the brackets and dashes for you. Here's why it validates nothing, where pasting breaks it, and what to use instead in your forms.
What is a required field — and why the asterisk advice contradicts itself
A required field is the required attribute plus a marker for humans. Why NN/g and GOV.UK give opposite advice — and how to pick the rule for your own form.
Dropdown or radio buttons — which to use in a form
Dropdown vs radio buttons compared on the criteria a beginner can actually see: taps, visible options, small screens — plus a straight rule for choosing.
What is progressive disclosure — and why a hidden button makes an interface clearer
Progressive disclosure means deferring rare features to a second level. Here's why it speeds beginners up, the two conditions it needs, and where it breaks.
What is microcopy — and why one line next to a field kills a wave of errors
Microcopy is the small text in an interface: buttons, field labels, errors. Here's why one line beats a redesign, and the four places it matters most.
What is a dark pattern — and why interfaces now cost companies billions
A dark pattern is an interface that pushes you into a decision you didn't want. The types, the regulators' fines, and how not to ship one by accident.
Placeholder vs label — which to use in a form (and why grey text inside loses submissions)
A placeholder saves space but disappears as you type. We compare placeholder vs label on six criteria and give a straight answer on what to use.
What is optimistic UI — and why the like registers before the server answers
What optimistic UI means in plain words: the app shows the result before the server confirms it. Why teams do it, and how to roll it back without losing the user.
What is an empty state — and why it's the first screen every user sees
What an empty state is and how to design one: the three kinds of emptiness, the mistake beginners make, and what to write instead of "No data".
What is a toast notification — and why some people will never see it
What a toast notification is: a small panel that pops up and disappears on its own. When it fits, how long to keep it, and who never gets to read it at all.
Toast or inline error — where to show it so people actually fix it
Toast vs inline error, compared on visibility, accessibility and message length. A straight answer on where form errors belong and when a toast is the right call.
What is an AI detector — and why it flags careful humans more often than machines
An AI detector doesn't see AI. It measures how predictable your text is — which is why it flagged 61% of essays by non-native writers. Here's how it works.
What is a false positive — and why a 99% accurate filter is wrong half the time
A false positive is a system accusing someone innocent. Let's do the math on why a filter that's 99% accurate produces half its flags in error.
What is a confidence score — and why "97% sure" doesn't mean "true"
A confidence score is how sure a model is of its words, not of their truth. Where the number comes from, and why fine-tuning made it lie.
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.