How much does zuzu.codes cost?

The starter track is free — read all lessons and practice for free. Full access to every track (current and future) is $14.99/month. Cancel anytime.

How long does each track take?

Each track is designed as a 30-day challenge — one lesson per day, about 15 minutes each. Go at your own pace, but the structure is built around daily consistency.

What's the lesson format?

Each lesson is a student-teacher dialogue with code examples, followed by a hands-on code challenge in an in-browser editor. You read, you understand, then you write real code.

Do I need prior coding experience?

Our beginner track starts from absolute zero — no prior experience needed. Advanced tracks build on earlier ones, and the platform tells you exactly where to start.

How is zuzu.codes different from freeCodeCamp or Codecademy?

zuzu.codes uses a structured 30-day track format with dialogue-based teaching, an in-browser code editor, and gamification (XP, streaks, progress tracking). The format builds genuine understanding through daily practice.

Semantic search — Ai Mastery

Day 6 · ~11 min●

You have stored vectors. You have a query. Semantic search is one loop: embed the query, compute cosine against every stored vector, pick the top-k.

python

def top_k(query, store, embed_fn, k=2):
    qv = embed_fn(query)
    scored = []
    for cid, entry in store.items():
        sim = cosine(qv, entry["vector"])
        scored.append((cid, sim))
    scored.sort(key=lambda x: x[1], reverse=True)
    return scored[:k]

That's a linear scan over the whole store?

Yes. For 5 chunks, fast. For 5000 chunks, still milliseconds. For 5 million, you graduate to a vector database with an ANN index. The retrieval interface is identical — give a query, get top-k. Only the implementation changes.

And k? Why 2?

Tradeoff. Higher k = more context for the LLM, more tokens, more chance the real answer is in there. Lower k = tighter, cheaper, may miss the relevant chunk. Default 3–5 in production; tune against your eval suite.

Semantic search — top-k by cosine

python

def top_k(query, store, embed_fn, k=3):
    qv = embed_fn(query)
    scored = [
        (cid, cosine(qv, entry["vector"]))
        for cid, entry in store.items()
    ]
    scored.sort(key=lambda x: x[1], reverse=True)
    return scored[:k]

Line by line:

Embed the query into the same vector space as the stored chunks.
For every stored chunk, compute cosine similarity to the query vector.
Sort by similarity descending.
Return the top k entries (chunk id + score).

Returning the text too

Most of the time the caller wants the chunk text, not just the id, to feed into a prompt:

python

top_chunks = top_k(query, store, embed, k=3)
contexts = [store[cid]["text"] for cid, _ in top_chunks]

Threshold filtering

No match should rarely return the least bad — better to refuse:

python

top = top_k(query, store, embed, k=3)
if top[0][1] < 0.3:    # tune this against your data
    return "I don't have a relevant answer"

This is the foundation of RAG failure-mode handling (lesson L9 this week — RAG failure modes).

What this gives you

Before semantic search, you matched strings (substring, keyword). After: you match meaning. "How do I reset my password?" finds a chunk about "forgotten credentials" even though no word overlaps.

This is the unlock that makes RAG work.

Day 6 · ~11 min●

You have stored vectors. You have a query. Semantic search is one loop: embed the query, compute cosine against every stored vector, pick the top-k.

python

def top_k(query, store, embed_fn, k=2):
    qv = embed_fn(query)
    scored = []
    for cid, entry in store.items():
        sim = cosine(qv, entry["vector"])
        scored.append((cid, sim))
    scored.sort(key=lambda x: x[1], reverse=True)
    return scored[:k]

That's a linear scan over the whole store?

And k? Why 2?

Semantic search — top-k by cosine

python

def top_k(query, store, embed_fn, k=3):
    qv = embed_fn(query)
    scored = [
        (cid, cosine(qv, entry["vector"]))
        for cid, entry in store.items()
    ]
    scored.sort(key=lambda x: x[1], reverse=True)
    return scored[:k]

Line by line:

Embed the query into the same vector space as the stored chunks.
For every stored chunk, compute cosine similarity to the query vector.
Sort by similarity descending.
Return the top k entries (chunk id + score).

Returning the text too

Most of the time the caller wants the chunk text, not just the id, to feed into a prompt:

python

top_chunks = top_k(query, store, embed, k=3)
contexts = [store[cid]["text"] for cid, _ in top_chunks]

Threshold filtering

No match should rarely return the least bad — better to refuse:

python

top = top_k(query, store, embed, k=3)
if top[0][1] < 0.3:    # tune this against your data
    return "I don't have a relevant answer"

This is the foundation of RAG failure-mode handling (lesson L9 this week — RAG failure modes).

What this gives you

Before semantic search, you matched strings (substring, keyword). After: you match meaning. "How do I reset my password?" finds a chunk about "forgotten credentials" even though no word overlaps.

This is the unlock that makes RAG work.

Semantic search — top-k by cosine

Returning the text too

Threshold filtering

What this gives you

Semantic search — top-k by cosine

Returning the text too

Threshold filtering

What this gives you

Semantic search — top-k by cosine

Returning the text too

Threshold filtering

What this gives you

Sign up to practice

Semantic search — top-k by cosine

Returning the text too

Threshold filtering

What this gives you

Sign up to practice