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.

Batch over a list — Ai Foundations

Day 23 · ~12 min●

You have a list of 5 short sentences and you want each classified as positive or negative. Same prompt shape, different input each call.

The for loop from Python L13 — body is the LLM call:

python

from pydantic_ai import Agent

sentences = [
    "This is the best day ever.",
    "I hate this.",
    "It's fine, I guess.",
    "Absolutely amazing.",
    "Terrible experience.",
]

results = []
for s in sentences:
    prompt = f'Classify the sentiment of this sentence as either "positive" or "negative". Reply with only that single word.\n\nSentence: {s}'
    result = Agent(model).run_sync(prompt)
    results.append(result.output.strip().lower())

for s, r in zip(sentences, results):
    print(f"{r}: {s}")

Five separate LLM calls. Five quota slots.

Right. Each call is one quota slot. A 5-item batch = 5 slots. A 100-item batch = 100 slots. Plan for it. We'll cover cost-aware batching in L26.

Could I cram all 5 sentences into one call?

Yes. Ask for a JSON array of 5 labels in one call. Cheaper (1 slot vs 5) but more failure-prone — the model might mis-count, return malformed JSON, or skip some. Trade-off: per-item calls are reliable; batch-in-prompt calls are cheap. Most production code mixes both — bulk in batches of 10-20, fall back to per-item if parsing fails.

Batch — one LLM call per item

python

results = []
for item in items:
    prompt = TEMPLATE.format(item=item)
    result = Agent(model).run_sync(prompt)
    results.append(result.output)

Clean. One call, one slot, per item. The output list aligns with the input list — same length, same order.

Cost grows linearly

5 items = 5 slots. 100 items = 100 slots. If you have 10,000 items to classify, this is a lot of API calls. Two mitigations:

Bulk-in-prompt — ask for N classifications in one call ("Classify each of these 10 sentences. Return JSON array of 10 labels."). 10× cheaper, but requires careful parsing.
Cache — if the same input appears more than once, store the previous result and look it up before calling.

Per-item batch is the safe default

Use it when:

You have a few dozen items, not thousands.
Per-item failure is acceptable (one bad output, the rest still work).
You'll iterate on the prompt — debugging one bad call is much easier than debugging one bad bulk call.

Move to bulk-in-prompt when:

Volume hits hundreds or thousands.
Budget matters more than per-item resilience.
The task structure is uniform enough that the model can reliably emit a list.

Continue on per-item failures

python

results = []
for item in items:
    try:
        result = Agent(model).run_sync(make_prompt(item))
        results.append(result.output)
    except Exception as e:
        results.append(None)
        print(f"failed on item: {item} ({e})")

The whole batch shouldn't crash because one item failed. None placeholders preserve list alignment so you can retry just the missing slots later.

Don't loop more than you need

If you've already classified ["foo", "bar"] and run again with ["foo", "baz"], only "baz" needs a new call. Cache the lookup:

python

cache = {}
for item in items:
    if item in cache:
        results.append(cache[item])
        continue
    out = Agent(model).run_sync(...).output
    cache[item] = out
    results.append(out)

Free quota saved per re-run. Composes with everything else.

Day 23 · ~12 min●

You have a list of 5 short sentences and you want each classified as positive or negative. Same prompt shape, different input each call.

The for loop from Python L13 — body is the LLM call:

python

from pydantic_ai import Agent

sentences = [
    "This is the best day ever.",
    "I hate this.",
    "It's fine, I guess.",
    "Absolutely amazing.",
    "Terrible experience.",
]

results = []
for s in sentences:
    prompt = f'Classify the sentiment of this sentence as either "positive" or "negative". Reply with only that single word.\n\nSentence: {s}'
    result = Agent(model).run_sync(prompt)
    results.append(result.output.strip().lower())

for s, r in zip(sentences, results):
    print(f"{r}: {s}")

Five separate LLM calls. Five quota slots.

Right. Each call is one quota slot. A 5-item batch = 5 slots. A 100-item batch = 100 slots. Plan for it. We'll cover cost-aware batching in L26.

Could I cram all 5 sentences into one call?

Batch — one LLM call per item

python

results = []
for item in items:
    prompt = TEMPLATE.format(item=item)
    result = Agent(model).run_sync(prompt)
    results.append(result.output)

Clean. One call, one slot, per item. The output list aligns with the input list — same length, same order.

Cost grows linearly

5 items = 5 slots. 100 items = 100 slots. If you have 10,000 items to classify, this is a lot of API calls. Two mitigations:

Bulk-in-prompt — ask for N classifications in one call ("Classify each of these 10 sentences. Return JSON array of 10 labels."). 10× cheaper, but requires careful parsing.
Cache — if the same input appears more than once, store the previous result and look it up before calling.

Per-item batch is the safe default

Use it when:

You have a few dozen items, not thousands.
Per-item failure is acceptable (one bad output, the rest still work).
You'll iterate on the prompt — debugging one bad call is much easier than debugging one bad bulk call.

Move to bulk-in-prompt when:

Volume hits hundreds or thousands.
Budget matters more than per-item resilience.
The task structure is uniform enough that the model can reliably emit a list.

Continue on per-item failures

python

results = []
for item in items:
    try:
        result = Agent(model).run_sync(make_prompt(item))
        results.append(result.output)
    except Exception as e:
        results.append(None)
        print(f"failed on item: {item} ({e})")

The whole batch shouldn't crash because one item failed. None placeholders preserve list alignment so you can retry just the missing slots later.

Don't loop more than you need

If you've already classified ["foo", "bar"] and run again with ["foo", "baz"], only "baz" needs a new call. Cache the lookup:

python

cache = {}
for item in items:
    if item in cache:
        results.append(cache[item])
        continue
    out = Agent(model).run_sync(...).output
    cache[item] = out
    results.append(out)

Free quota saved per re-run. Composes with everything else.

Batch — one LLM call per item

Cost grows linearly

Per-item batch is the safe default

Continue on per-item failures

Don't loop more than you need

Batch — one LLM call per item

Cost grows linearly

Per-item batch is the safe default

Continue on per-item failures

Don't loop more than you need

Batch — one LLM call per item

Cost grows linearly

Per-item batch is the safe default

Continue on per-item failures

Don't loop more than you need

Sign up to practice

Batch — one LLM call per item

Cost grows linearly

Per-item batch is the safe default

Continue on per-item failures

Don't loop more than you need

Sign up to practice