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.

Privacy Terms

Day 24 · ~12 min●

L11 retried on regex mismatch. Today: any custom predicate. The pattern is the same; the validator is whatever Python check you need.

python

import json
from pydantic_ai import Agent

def valid(parsed):
    if not isinstance(parsed, dict):
        return False, "output is not a JSON object"
    needed = ("red", "green", "blue", "total")
    for k in needed:
        if k not in parsed:
            return False, f"missing key {k!r}"
    s = parsed["red"] + parsed["green"] + parsed["blue"]
    if s != parsed["total"]:
        return False, f"red+green+blue ({s}) != total ({parsed['total']})"
    return True, "ok"

base = (
    'Generate a JSON object with keys "red", "green", "blue" (each a positive integer 1-9) '
    'and "total" equal to red+green+blue. Return only the JSON.'
)
prompt = base

for attempt in range(3):
    out = Agent(model).run_sync(prompt).output.strip()
    try:
        parsed = json.loads(out)
    except json.JSONDecodeError:
        prompt = base + f'\nThe previous answer {out!r} was not valid JSON. Return ONLY a JSON object, no prose.'
        continue
    ok, why = valid(parsed)
    if ok:
        break
    prompt = base + f'\nThe previous answer was rejected: {why}. Try again, ensure red+green+blue equals total.'
else:
    raise ValueError(f"could not produce valid output after 3 attempts: {parsed!r}")

print(parsed)

The validator returns (ok, why). The retry message includes why so the model knows what to fix.

Right. Custom predicates can express anything: numeric consistency, set membership, length bounds, cross-field equality, schema match. The discipline is the same — pure-Python check, capped retry, specific feedback.

Why not pydantic-AI's output_type= with a model validator?

You can — model_validator(mode='after') does this exact thing inside pydantic. We hand-roll today to make the pattern visible. Once you see the loop, switch to typed outputs in production. They're shorter and the auto-retry uses the same mechanism.

Retry on bad output — extended

python

for attempt in range(MAX):
    out = call(prompt)
    parsed = parse_or_default(out)
    ok, reason = validate(parsed)
    if ok:
        break
    prompt = clarify(prompt, reason)
else:
    raise ValueError("all attempts produced invalid output")

What can `validate` check?

Anything you can write as Python:

Check	Code
Required keys present	`all(k in parsed for k in NEEDED)`
Cross-field consistency	`parsed['a'] + parsed['b'] == parsed['total']`
Numeric range	`1 <= parsed['score'] <= 10`
String format	`re.fullmatch(PATTERN, parsed['code'])`
Set membership	`parsed['label'] in ALLOWED_LABELS`
Custom rule	`parsed['end'] > parsed['start']` (date range)

The validator returning (bool, reason) makes the retry feedback specific.

Two layers of failure

python

try:
    parsed = json.loads(out)
except json.JSONDecodeError:
    # Layer 1: not valid JSON at all — retry with stricter format request
    ...

ok, reason = validate(parsed)
if not ok:
    # Layer 2: valid JSON but wrong shape — retry with content-specific feedback
    ...

Different feedback for different failures. "Not JSON" needs a structural retry; "red+green+blue != total" needs an arithmetic retry.

Cap it loudly

After MAX attempts, raise. Silent failure (returning a default, swallowing the error) makes broken prompts invisible. Loud failure forces you to fix the prompt.

Why hand-roll vs use `output_type=`

Learning. The pattern is the same as pydantic-AI's internal auto-retry — same loop, same feedback shape. Once you've written the loop yourself, you understand what output_type= is doing under the hood. Then in production, prefer output_type= for the brevity.

Today

A generated JSON with an arithmetic constraint (sum of three colour fields = total). Validate. Retry on mismatch. Bind the validated dict to parsed.

Sign up to practice

Create a free account to get started. Paid plans unlock all tracks.

or

Day 24 · ~12 min●

L11 retried on regex mismatch. Today: any custom predicate. The pattern is the same; the validator is whatever Python check you need.

python

import json
from pydantic_ai import Agent

def valid(parsed):
    if not isinstance(parsed, dict):
        return False, "output is not a JSON object"
    needed = ("red", "green", "blue", "total")
    for k in needed:
        if k not in parsed:
            return False, f"missing key {k!r}"
    s = parsed["red"] + parsed["green"] + parsed["blue"]
    if s != parsed["total"]:
        return False, f"red+green+blue ({s}) != total ({parsed['total']})"
    return True, "ok"

base = (
    'Generate a JSON object with keys "red", "green", "blue" (each a positive integer 1-9) '
    'and "total" equal to red+green+blue. Return only the JSON.'
)
prompt = base

for attempt in range(3):
    out = Agent(model).run_sync(prompt).output.strip()
    try:
        parsed = json.loads(out)
    except json.JSONDecodeError:
        prompt = base + f'\nThe previous answer {out!r} was not valid JSON. Return ONLY a JSON object, no prose.'
        continue
    ok, why = valid(parsed)
    if ok:
        break
    prompt = base + f'\nThe previous answer was rejected: {why}. Try again, ensure red+green+blue equals total.'
else:
    raise ValueError(f"could not produce valid output after 3 attempts: {parsed!r}")

print(parsed)

The validator returns (ok, why). The retry message includes why so the model knows what to fix.

Right. Custom predicates can express anything: numeric consistency, set membership, length bounds, cross-field equality, schema match. The discipline is the same — pure-Python check, capped retry, specific feedback.

Why not pydantic-AI's output_type= with a model validator?

You can — model_validator(mode='after') does this exact thing inside pydantic. We hand-roll today to make the pattern visible. Once you see the loop, switch to typed outputs in production. They're shorter and the auto-retry uses the same mechanism.

Retry on bad output — extended

python

for attempt in range(MAX):
    out = call(prompt)
    parsed = parse_or_default(out)
    ok, reason = validate(parsed)
    if ok:
        break
    prompt = clarify(prompt, reason)
else:
    raise ValueError("all attempts produced invalid output")

What can `validate` check?

Anything you can write as Python:

Check	Code
Required keys present	`all(k in parsed for k in NEEDED)`
Cross-field consistency	`parsed['a'] + parsed['b'] == parsed['total']`
Numeric range	`1 <= parsed['score'] <= 10`
String format	`re.fullmatch(PATTERN, parsed['code'])`
Set membership	`parsed['label'] in ALLOWED_LABELS`
Custom rule	`parsed['end'] > parsed['start']` (date range)

The validator returning (bool, reason) makes the retry feedback specific.

Two layers of failure

python

try:
    parsed = json.loads(out)
except json.JSONDecodeError:
    # Layer 1: not valid JSON at all — retry with stricter format request
    ...

ok, reason = validate(parsed)
if not ok:
    # Layer 2: valid JSON but wrong shape — retry with content-specific feedback
    ...

Different feedback for different failures. "Not JSON" needs a structural retry; "red+green+blue != total" needs an arithmetic retry.

Cap it loudly

After MAX attempts, raise. Silent failure (returning a default, swallowing the error) makes broken prompts invisible. Loud failure forces you to fix the prompt.

Why hand-roll vs use `output_type=`

Learning. The pattern is the same as pydantic-AI's internal auto-retry — same loop, same feedback shape. Once you've written the loop yourself, you understand what output_type= is doing under the hood. Then in production, prefer output_type= for the brevity.

Today

A generated JSON with an arithmetic constraint (sum of three colour fields = total). Validate. Retry on mismatch. Bind the validated dict to parsed.

Sign up to practice

Create a free account to get started. Paid plans unlock all tracks.

or

Retry on bad output — extended

What can validate check?

Two layers of failure

Cap it loudly

Why hand-roll vs use output_type=

Today

Sign up to practice

Retry on bad output — extended

What can validate check?

Two layers of failure

Cap it loudly

Why hand-roll vs use output_type=

Today

Sign up to practice

What can `validate` check?

Why hand-roll vs use `output_type=`

What can `validate` check?

Why hand-roll vs use `output_type=`