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 actions over a list — Automation Foundations

Day 26 · ~12 min●

You have 3 channels you want to post a status update to. Three different channels, same message body. The shape:

python

channels = ["#status", "#daily", "#updates"]
for channel in channels:
    toolset.execute_action(Action.SLACK_SEND_MESSAGE, {
        "channel": channel,
        "text": "build green",
    })

For loop over the list. The tool call inside is the same shape each time, only channel varies.

Same as Python L13 (for loops) — just with a tool call as the body?

Exactly. A tool call is just another expression. for doesn't care what's inside.

What if one fails partway through? The first one posted, the second crashes — now I have partial state.

Right, batch + errors gets tricky. Two strategies:

python

# Strategy A: stop on first failure (default behaviour — exception propagates)
for channel in channels:
    toolset.execute_action(...)    # if this raises, loop ends

# Strategy B: continue, collect failures
failures = []
for channel in channels:
    try:
        toolset.execute_action(...)
    except Exception as e:
        failures.append((channel, str(e)))

if failures:
    print(f"failed: {failures}")

Strategy A is fine when the items are independent and you want loud failure. Strategy B is right when you'd rather process as many as possible and log the rest.

Batch — the simplest scaling pattern

python

for item in items:
    do_action(item)

That's it. The list might come from a tool read ("all unread emails"), a hardcoded list, or a file. Each iteration performs one action.

Common batch shapes

python

# Same arg shape, different value
for email in ["a@x", "b@y", "c@z"]:
    send_invite(email)

# Iterate a list of dicts
for user in users:
    notify(user["name"], user["email"])

# Iterate the result of a previous tool call
emails = fetch_emails(20)
for email in emails:
    classify_and_route(email)

Batch + idempotency = safe re-run

Batch jobs often re-run on the same list (cron retries, manual re-runs). Combine with the dedup pattern from week 2 L14:

python

seen = set(load_already_processed())
for item in items:
    if item["id"] in seen:
        continue    # skip already-processed
    process(item)
    seen.add(item["id"])
    save_already_processed(seen)

Now re-running a half-completed batch finishes the rest, doesn't re-do the done ones. Production batch jobs always have this safety net.

Batch + retry per item

python

for item in items:
    for attempt in range(3):
        try:
            process(item)
            break
        except Exception:
            time.sleep(2 ** attempt)
    else:
        print(f"gave up on {item}")

Nested loop. Outer = items. Inner = retries per item. The else on the inner for runs if no break (all 3 attempts failed) — log and move to the next item rather than crashing the whole batch.

Continue vs stop on failure

Critical question for batch jobs: should one failure stop the whole batch, or should you process every item you can?

Mode	When to use
Stop on first failure	Items must succeed in order; later items depend on earlier ones
Continue, collect failures	Items are independent; "do as many as possible"

Don't batch when the tool batches

Some tools accept multiple items in one call — send_bulk_email([list]), update_many_rows([list]). Always prefer one call with a list over a Python loop with N calls. Fewer round trips, often required for rate-limit reasons.

Day 26 · ~12 min●

You have 3 channels you want to post a status update to. Three different channels, same message body. The shape:

python

channels = ["#status", "#daily", "#updates"]
for channel in channels:
    toolset.execute_action(Action.SLACK_SEND_MESSAGE, {
        "channel": channel,
        "text": "build green",
    })

For loop over the list. The tool call inside is the same shape each time, only channel varies.

Same as Python L13 (for loops) — just with a tool call as the body?

Exactly. A tool call is just another expression. for doesn't care what's inside.

What if one fails partway through? The first one posted, the second crashes — now I have partial state.

Right, batch + errors gets tricky. Two strategies:

python

# Strategy A: stop on first failure (default behaviour — exception propagates)
for channel in channels:
    toolset.execute_action(...)    # if this raises, loop ends

# Strategy B: continue, collect failures
failures = []
for channel in channels:
    try:
        toolset.execute_action(...)
    except Exception as e:
        failures.append((channel, str(e)))

if failures:
    print(f"failed: {failures}")

Strategy A is fine when the items are independent and you want loud failure. Strategy B is right when you'd rather process as many as possible and log the rest.

Batch — the simplest scaling pattern

python

for item in items:
    do_action(item)

That's it. The list might come from a tool read ("all unread emails"), a hardcoded list, or a file. Each iteration performs one action.

Common batch shapes

python

# Same arg shape, different value
for email in ["a@x", "b@y", "c@z"]:
    send_invite(email)

# Iterate a list of dicts
for user in users:
    notify(user["name"], user["email"])

# Iterate the result of a previous tool call
emails = fetch_emails(20)
for email in emails:
    classify_and_route(email)

Batch + idempotency = safe re-run

Batch jobs often re-run on the same list (cron retries, manual re-runs). Combine with the dedup pattern from week 2 L14:

python

seen = set(load_already_processed())
for item in items:
    if item["id"] in seen:
        continue    # skip already-processed
    process(item)
    seen.add(item["id"])
    save_already_processed(seen)

Now re-running a half-completed batch finishes the rest, doesn't re-do the done ones. Production batch jobs always have this safety net.

Batch + retry per item

python

for item in items:
    for attempt in range(3):
        try:
            process(item)
            break
        except Exception:
            time.sleep(2 ** attempt)
    else:
        print(f"gave up on {item}")

Nested loop. Outer = items. Inner = retries per item. The else on the inner for runs if no break (all 3 attempts failed) — log and move to the next item rather than crashing the whole batch.

Continue vs stop on failure

Critical question for batch jobs: should one failure stop the whole batch, or should you process every item you can?

Mode	When to use
Stop on first failure	Items must succeed in order; later items depend on earlier ones
Continue, collect failures	Items are independent; "do as many as possible"

Batch — the simplest scaling pattern

Common batch shapes

Batch + idempotency = safe re-run

Batch + retry per item

Continue vs stop on failure

Don't batch when the tool batches

Batch — the simplest scaling pattern

Common batch shapes

Batch + idempotency = safe re-run

Batch + retry per item

Continue vs stop on failure

Don't batch when the tool batches

Batch — the simplest scaling pattern

Common batch shapes

Batch + idempotency = safe re-run

Batch + retry per item

Continue vs stop on failure

Don't batch when the tool batches

Sign up to practice

Batch — the simplest scaling pattern

Common batch shapes

Batch + idempotency = safe re-run

Batch + retry per item

Continue vs stop on failure

Don't batch when the tool batches

Sign up to practice