Hello, I'm Maneshwar. I'm building git-lrc, a Micro AI code reviewer that runs on every commit. It is free and source-available on Github. Star git-lrc to help devs discover the project. Do give it a try and share your feedback.
For most of the internet's life, searching for something felt a bit like talking to a very literal-minded robot.
You'd type "comfy shoes for standing all day," and it would proudly hand you a page that contained the words "comfy," "shoes," and "all day" even if that page was a blog about how comfy it is to lie down all day and never wear shoes.
Technically correct.
Spiritually useless.
That robot has had a glow-up xD
It's called semantic search, and the short version is this: it cares about what you mean, not just the words you happened to type.
Meaning over spelling
Keyword search is a word-matching game.
It takes your query, hunts for documents containing those exact words (plus a few synonyms if it's feeling generous), and calls it a day.
It has no idea what any of it means.
It's a librarian who can find every book with "apple" on the cover but couldn't tell you whether you wanted a fruit or a phone.
Semantic search plays a different game entirely.
It asks, "What is this person actually trying to find?" and then goes looking for that, even if your exact words appear nowhere in the answer.
My favorite proof that meaning matters more than words: "chocolate milk" versus "milk chocolate." Same two words.
Swap the order and you've gone from a drink you sip to a bar you snap.
A keyword engine sees identical ingredients and shrugs.
Semantic search knows you've described two completely different snacks.
That little flip is the whole revolution in miniature.
Here's the same idea as a fork in the road one query, two very different philosophies:
So how does it pull this off? (Enter: embeddings)
Here's the part that sounds like magic but is really just clever math.
Computers don't understand words.
They understand numbers.
So semantic search takes every word, sentence, and document and converts it into a long list of numbers called an embedding essentially a coordinate that tells you where that meaning lives.
Picture a giant invisible map.
Not a map of places, but a map of meaning. On this map, "dog" and "puppy" sit practically on top of each other.
"Cat" is in the same neighborhood.
"Quantum mechanics" is on the other side of town, and "chocolate milk" is parked a respectful distance from "milk chocolate" or so I assumed. (Hold that thought; I tested it later and got humbled.)
Things that mean similar things end up close together; things that don't drift apart.
That's all an embedding is: a thing's address in meaning-space.
The beautiful part is that the machine learns these addresses on its own, by reading a staggering amount of text and noticing which words keep showing up in similar company.
Words that hang out in the same contexts get similar addresses.
Nobody hand-labels any of it.
Finding answers is just finding neighbors
Once everything lives on this map, search becomes wonderfully simple.
You type a query.
The engine drops your query onto the same map as a coordinate.
Then it just looks around and asks, "What's nearby?"
The technical name for "find the closest neighbors" is the k-nearest neighbor algorithm, but you can mentally file it under: grab the stuff parked closest to you.
The results that sit nearest your query in meaning-space are the ones that best match your intent and they get served up first.
Start to finish, the whole journey is just five steps:
This is why semantic search can hand you the perfect answer even when it shares zero words with your question.
You searched for "comfy shoes for standing all day" and it returns a guide to nursing clogs and anti-fatigue insoles barely any overlap in wording, but a bullseye on meaning, because all of those things live in the same corner of the map.
Context is the secret ingredient
Meaning isn't fixed, it bends depending on who's asking and where.
Take the word "football."
Type it in London and you almost certainly mean the sport with the round ball and the dramatic flopping.
Type it in Dallas and you mean helmets, touchdowns, and the round ball being illegal to touch with your hands.
Same word, two different sports, and a good semantic engine uses context, your location, your phrasing, even what you searched five minutes ago to figure out which one you meant.
Context is also about intent.
Are you trying to learn something, buy something, or go somewhere? "Best espresso machine" probably wants reviews and a buy button.
"How does an espresso machine work" wants an explanation, not a checkout page. Reading that difference is half the job.
I didn't just take my word for it
Talk is cheap, so I actually ran the numbers.
Using a real sentence-embedding model (all-MiniLM-L6-v2) and a tiny Python script, I tested the claims above against real cosine-similarity scores instead of vibes. (Exact numbers will shift a little with model version and normalization, but the shape holds.)
Here's the actual output:
$ p exp.py
Query: "chocolate milk"
------------------------------------------------------------
doc keyword overlap semantic similarity
chocolate_milk 2 0.751
milk_chocolate 2 0.727
comfy_shoes 0 0.130
puppy 0 0.111
quantum 0 0.058
football_uk 0 0.058
football_us 0 -0.056
Query: "milk chocolate"
------------------------------------------------------------
doc keyword overlap semantic similarity
milk_chocolate 2 0.758
chocolate_milk 2 0.733
puppy 0 0.117
comfy_shoes 0 0.101
quantum 0 0.073
football_uk 0 0.034
football_us 0 -0.078
Query: "comfy shoes for standing all day"
------------------------------------------------------------
doc keyword overlap semantic similarity
comfy_shoes 2 0.583
football_uk 0 0.066
puppy 0 0.051
milk_chocolate 0 0.043
football_us 0 0.042
chocolate_milk 0 0.002
quantum 0 -0.078
Direct pairwise similarity (no corpus, just the two phrases):
"chocolate milk" <-> "milk chocolate": 0.980
"dog" <-> "puppy": 0.804
"dog" <-> "quantum mechanics": 0.214
(The puppy row is just a filler document I tossed into the corpus to make sure the model wasn't ranking everything highly, it sits near the bottom every time, which is what you want. And yes, cosine similarity can dip slightly below zero; that just means two things point in mildly opposite directions in meaning-space.)
The comfy-shoes example held up perfectly. I searched "comfy shoes for standing all day" against a handful of candidate documents, including one about nursing clogs and anti-fatigue insoles.
Semantic similarity scored that document 0.583 miles ahead of the next-best match at 0.066.
Keyword search caught only two generic words ("all," "day") while completely missing the actual concept the searcher cared about: comfort and shoes.
The meaning was obvious; the literal words were not.
Chocolate milk vs. milk chocolate held up too — but barely. I wrote one sentence describing each ("Milk chocolate is a sweet snack bar...", "Chocolate milk is a cold drink...") and searched both queries against the pair.
Keyword search ties them exactly, scoring an identical word-overlap count no matter which query you run, the exact failure this post opened with.
Semantic search broke the tie correctly both times, but only by about 0.02–0.03. Real, but not dramatic.
Here's the part that surprised me, and the "hold that thought" from earlier: when I dropped the sentences entirely and embedded just the two bare phrases "chocolate milk" and "milk chocolate," nothing else they came back 0.980 similar.
Practically the same point on the map.
So "a respectful distance apart" oversold it badly.
Two words alone don't give the model enough to go on; it's the sentence around them that tells it which one you mean.
Context isn't a nice-to-have here for short phrases like this, it's the only thing keeping "drink" and "candy bar" from collapsing into the same coordinate.
For comparison, "dog" and "puppy" alone came back at 0.804 (genuinely close neighbors) and "dog" vs "quantum mechanics" at 0.214 (genuinely far apart) so the map metaphor holds fine in general.
It's specifically short, ambiguous, word-order-flip pairs that need real context to pull apart.
Why any of this matters
Beyond just being clever, semantic search quietly makes everything less annoying.
You don't have to guess the magic keywords a database is hiding behind.
You can ask like a human like messy, conversational, half-formed and still land on what you wanted.
Over time these systems also learn, watching which results people actually click and stick with, and nudging themselves to do better.
It's the difference between a search bar that judges your spelling and one that actually gets the gist. And honestly? After years of arguing with literal-minded robots, "it gets the gist" feels like a small miracle.
So next time you type something vague and lazy into a search box and it returns exactly the thing rattling around in your head that's not luck.
That's a map of meaning, a fistful of coordinates, and a robot that finally learned to read between the lines.
Disclaimer: This article was written by me; AI was used to fix grammar and improve readability.
AI agents write code fast. They also silently remove logic, change behavior, and introduce bugs — without telling you. You often find out in production.
git-lrc fixes this. It hooks into git commit and reviews every diff before it lands. 60-second setup. Completely free.
Any feedback or contributors are welcome! It's online, source-available, and ready for anyone to use.
⭐ Star it on GitHub:
HexmosTech
/
git-lrc
Free, Micro AI Code Reviews That Run on Git Commit
| 🇩🇰 Dansk | 🇪🇸 Español | 🇮🇷 Farsi | 🇫🇮 Suomi | 🇯🇵 日本語 | 🇳🇴 Norsk | 🇵🇹 Português | 🇷🇺 Русский | 🇦🇱 Shqip | 🇨🇳 中文 | 🇮🇳 हिन्दी |
git-lrc
Free, Micro AI Code Reviews That Run on Commit
GenAI today is a race car without brakes. It accelerates fast -- you describe something, and large blocks of code appear instantly. But AI agents silently break things: they remove logic, relax constraints, introduce expensive cloud calls, leak credentials, and change behavior -- without telling you. You often find out in production.
git-lrc is your braking system. It hooks into git commit and runs an AI review on every diff before it lands. 60-second setup. Completely free.
In short, git-lrc helps Prevent Outages, Breaches, and Technical Debt Before They Happen
At a glance: 10 risk categories · 100+ failure patterns tracked · every commit…
