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.

Final integration — Ai Foundations

Day 28 · ~12 min●

Last code lesson. Five week-4 + earlier patterns into one script:

Helper — ask_json(prompt) wraps the LLM call (L24).
Retry on bad output — JSON parse failures retry with a clarifying message (L25 + L12).
Batch — loop over a list, classify each item (L23).
Cost tracking — sum total tokens across the batch (L27).
Structured output — JSON with label and confidence keys (L11-L13).

python

import json
from pydantic_ai import Agent

FINAL_USAGE = {"total": 0}

def ask_json(prompt, max_attempts=2):
    base = prompt + '\n\nReply with ONLY valid JSON. No prose around it.'
    p = base
    for _ in range(max_attempts):
        result = Agent(model).run_sync(p)
        FINAL_USAGE["total"] += result.usage().total_tokens
        text = result.output.strip().strip("`").strip()
        try:
            return json.loads(text)
        except json.JSONDecodeError as e:
            p = base + f'\nThe previous response was not valid JSON ({e}). Try again — JSON only.'
    raise ValueError("could not parse JSON after retries")

items = ["I love this!", "Total disaster.", "It was fine."]
results = []
for item in items:
    parsed = ask_json(
        f'Classify the sentiment of "{item}" as positive, negative, or neutral. '
        f'Reply with JSON: {{"label": "<one of the three>", "confidence": <0-1 float>}}'
    )
    results.append({"input": item, **parsed})
    print(f'{parsed["label"]} ({parsed["confidence"]:.2f}): {item}')

print(f'\ntotal tokens: {FINAL_USAGE["total"]}    items: {len(results)}')

Every line uses something from earlier in the track.

That's the point. No new tools. Just composition. This is what "writing AI scripts" looks like in practice — small primitives, deliberately stacked. Once each piece is reflexive, building a new script feels like assembly, not engineering.

What this synthesis demonstrates

No new technique. Composition of week-4 + earlier patterns into one shape that's representative of real LLM scripts.

Layer-by-layer reading

python

def ask_json(prompt, max_attempts=2):
    base = prompt + '\n\nReply with ONLY valid JSON. No prose around it.'

→ Helper (L24). System-level instruction baked in once.

python

    p = base
    for _ in range(max_attempts):
        result = Agent(model).run_sync(p)
        FINAL_USAGE["total"] += result.usage().total_tokens

→ Cost tracking (L27) inside the helper — every call site gets accumulation for free.

python

        text = result.output.strip().strip("`").strip()
        try:
            return json.loads(text)
        except json.JSONDecodeError as e:
            p = base + f'\nThe previous response was not valid JSON ({e}). Try again — JSON only.'

→ Retry on bad output (L25 + L12). Catch the parse error, tell the model what went wrong, retry.

python

    raise ValueError("could not parse JSON after retries")

→ Hard fail after cap. Don't loop forever; surface the bug.

python

for item in items:
    parsed = ask_json(...)
    results.append({"input": item, **parsed})

→ Batch (L23). Loop over input, accumulate output.

python

print(f'\ntotal tokens: {FINAL_USAGE["total"]}    items: {len(results)}')

→ Diagnostic logging. Run summary after the batch.

Why a real script looks like this

Production LLM scripts that feel big are usually doing this. Small primitives stacked. Once each individual piece is reflexive — ask_json, retry-on-bad-output, batch, cost track — building a new script feels like assembly, not engineering.

What you can extend this into

System prompt for tone/persona (L17). Pass into ask_json.
Self-consistency over the classification (L26). Call N times, vote.
Conditional dispatch (Auto L26 if you've done it). Route results to Slack vs email by label.
Persist the results to a CSV or JSON file (Py L27). Re-runnable batch jobs.

The shape stays the same. Add layers as the requirements need them.

Day 28 · ~12 min●

Last code lesson. Five week-4 + earlier patterns into one script:

Helper — ask_json(prompt) wraps the LLM call (L24).
Retry on bad output — JSON parse failures retry with a clarifying message (L25 + L12).
Batch — loop over a list, classify each item (L23).
Cost tracking — sum total tokens across the batch (L27).
Structured output — JSON with label and confidence keys (L11-L13).

python

import json
from pydantic_ai import Agent

FINAL_USAGE = {"total": 0}

def ask_json(prompt, max_attempts=2):
    base = prompt + '\n\nReply with ONLY valid JSON. No prose around it.'
    p = base
    for _ in range(max_attempts):
        result = Agent(model).run_sync(p)
        FINAL_USAGE["total"] += result.usage().total_tokens
        text = result.output.strip().strip("`").strip()
        try:
            return json.loads(text)
        except json.JSONDecodeError as e:
            p = base + f'\nThe previous response was not valid JSON ({e}). Try again — JSON only.'
    raise ValueError("could not parse JSON after retries")

items = ["I love this!", "Total disaster.", "It was fine."]
results = []
for item in items:
    parsed = ask_json(
        f'Classify the sentiment of "{item}" as positive, negative, or neutral. '
        f'Reply with JSON: {{"label": "<one of the three>", "confidence": <0-1 float>}}'
    )
    results.append({"input": item, **parsed})
    print(f'{parsed["label"]} ({parsed["confidence"]:.2f}): {item}')

print(f'\ntotal tokens: {FINAL_USAGE["total"]}    items: {len(results)}')

Every line uses something from earlier in the track.

What this synthesis demonstrates

No new technique. Composition of week-4 + earlier patterns into one shape that's representative of real LLM scripts.

Layer-by-layer reading

python

def ask_json(prompt, max_attempts=2):
    base = prompt + '\n\nReply with ONLY valid JSON. No prose around it.'

→ Helper (L24). System-level instruction baked in once.

python

    p = base
    for _ in range(max_attempts):
        result = Agent(model).run_sync(p)
        FINAL_USAGE["total"] += result.usage().total_tokens

→ Cost tracking (L27) inside the helper — every call site gets accumulation for free.

python

        text = result.output.strip().strip("`").strip()
        try:
            return json.loads(text)
        except json.JSONDecodeError as e:
            p = base + f'\nThe previous response was not valid JSON ({e}). Try again — JSON only.'

→ Retry on bad output (L25 + L12). Catch the parse error, tell the model what went wrong, retry.

python

    raise ValueError("could not parse JSON after retries")

→ Hard fail after cap. Don't loop forever; surface the bug.

python

for item in items:
    parsed = ask_json(...)
    results.append({"input": item, **parsed})

→ Batch (L23). Loop over input, accumulate output.

python

print(f'\ntotal tokens: {FINAL_USAGE["total"]}    items: {len(results)}')

→ Diagnostic logging. Run summary after the batch.

Why a real script looks like this

What you can extend this into

System prompt for tone/persona (L17). Pass into ask_json.
Self-consistency over the classification (L26). Call N times, vote.
Conditional dispatch (Auto L26 if you've done it). Route results to Slack vs email by label.
Persist the results to a CSV or JSON file (Py L27). Re-runnable batch jobs.

The shape stays the same. Add layers as the requirements need them.

What this synthesis demonstrates

Layer-by-layer reading

Why a real script looks like this

What you can extend this into

What this synthesis demonstrates

Layer-by-layer reading

Why a real script looks like this

What you can extend this into

What this synthesis demonstrates

Layer-by-layer reading

Why a real script looks like this

What you can extend this into

Sign up to practice

What this synthesis demonstrates

Layer-by-layer reading

Why a real script looks like this

What you can extend this into

Sign up to practice