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.

Agent observability — Ai Mastery

Day 27 · ~11 min●

Yesterday's cost log captured per-call metrics. Agent observability is one level up: per run, capture the sequence of tool calls, args, and outcomes. When something goes wrong, the trace is the audit trail.

python

class Trace:
    def __init__(self, run_id):
        self.run_id = run_id
        self.events = []

    def record(self, kind, name, **fields):
        self.events.append({"kind": kind, "name": name, **fields})

# Inside the agent
trace = Trace("run-abc")
trace.record("tool_call", "retrieve", query=q, k=3)
result = retrieve(q, k=3)
trace.record("tool_result", "retrieve", n_chunks=len(result))

trace.record("llm_call", "answer", prompt_chars=len(prompt))
answer = generate(prompt)
trace.record("llm_result", "answer", answer_chars=len(answer))

At run end: dump trace to a Sheet, JSON, or your observability platform.

This is a lot of code for one run.

Three lines per event. With a decorator, it's one line:

python

@traced(trace)
def retrieve(q, k=3): ...

Decorator records tool_call before, tool_result after, with the args and return value. Same shape, less boilerplate.

What does this catch?

Bugs that hide in the sequence: tool fired with wrong args, fallback fired when it shouldn't have, retry kept retrying past the cap. Without trace, you see "the agent failed". With trace, you see exactly which step failed.

Agent observability — trace the run

python

import uuid, time, json

class Trace:
    def __init__(self):
        self.run_id = uuid.uuid4().hex[:8]
        self.started_at = time.time()
        self.events = []

    def record(self, kind, name, **fields):
        self.events.append({
            "t": round(time.time() - self.started_at, 3),
            "kind": kind,
            "name": name,
            **fields,
        })

    def dump_json(self):
        return json.dumps({"run_id": self.run_id, "events": self.events}, indent=2)

Event kinds

Kind	When
`tool_call`	Before invoking a tool / function
`tool_result`	After the tool returned (with summary, not raw data)
`tool_error`	After the tool raised
`llm_call`	Before an LLM call (with version)
`llm_result`	After (with output summary)
`decision`	When the agent picked between options (route, recover, etc.)

Three-five kinds is plenty. Don't over-engineer the schema.

What goes in `**fields`

Summaries, not raw data:

python

# Bad — pollutes trace, leaks PII
trace.record("llm_call", "answer", prompt=full_prompt)

# Good — summary, no leakage
trace.record("llm_call", "answer", prompt_chars=len(full_prompt), version="v3")

Where the trace goes

Print at end of run — fastest path, useful for development
Append to in-memory list — single-process, single-run analytics
Tasks / Sheet / JSON file — persistable, shareable
Production: Langsmith, Helicone, Logfire — purpose-built agent observability with timeline UIs and filtering

Replay

A full trace lets you replay a run (with mocks for tools that already side-effected). Reproduce a bug deterministically by feeding the trace's tool-results into the same agent code. This is how production debugging on agent failures actually works.

Day 27 · ~11 min●

python

class Trace:
    def __init__(self, run_id):
        self.run_id = run_id
        self.events = []

    def record(self, kind, name, **fields):
        self.events.append({"kind": kind, "name": name, **fields})

# Inside the agent
trace = Trace("run-abc")
trace.record("tool_call", "retrieve", query=q, k=3)
result = retrieve(q, k=3)
trace.record("tool_result", "retrieve", n_chunks=len(result))

trace.record("llm_call", "answer", prompt_chars=len(prompt))
answer = generate(prompt)
trace.record("llm_result", "answer", answer_chars=len(answer))

At run end: dump trace to a Sheet, JSON, or your observability platform.

This is a lot of code for one run.

Three lines per event. With a decorator, it's one line:

python

@traced(trace)
def retrieve(q, k=3): ...

Decorator records tool_call before, tool_result after, with the args and return value. Same shape, less boilerplate.

What does this catch?

Agent observability — trace the run

python

import uuid, time, json

class Trace:
    def __init__(self):
        self.run_id = uuid.uuid4().hex[:8]
        self.started_at = time.time()
        self.events = []

    def record(self, kind, name, **fields):
        self.events.append({
            "t": round(time.time() - self.started_at, 3),
            "kind": kind,
            "name": name,
            **fields,
        })

    def dump_json(self):
        return json.dumps({"run_id": self.run_id, "events": self.events}, indent=2)

Event kinds

Kind	When
`tool_call`	Before invoking a tool / function
`tool_result`	After the tool returned (with summary, not raw data)
`tool_error`	After the tool raised
`llm_call`	Before an LLM call (with version)
`llm_result`	After (with output summary)
`decision`	When the agent picked between options (route, recover, etc.)

Three-five kinds is plenty. Don't over-engineer the schema.

What goes in `**fields`

Summaries, not raw data:

python

# Bad — pollutes trace, leaks PII
trace.record("llm_call", "answer", prompt=full_prompt)

# Good — summary, no leakage
trace.record("llm_call", "answer", prompt_chars=len(full_prompt), version="v3")

Where the trace goes

Print at end of run — fastest path, useful for development
Append to in-memory list — single-process, single-run analytics
Tasks / Sheet / JSON file — persistable, shareable
Production: Langsmith, Helicone, Logfire — purpose-built agent observability with timeline UIs and filtering

Agent observability — trace the run

Event kinds

What goes in `**fields`

Where the trace goes

Replay

Agent observability — trace the run

Event kinds

What goes in `**fields`

Where the trace goes

Replay

Agent observability — trace the run

Event kinds

What goes in `**fields`

Where the trace goes

Replay

Sign up to practice

Agent observability — trace the run

Event kinds

What goes in `**fields`

Where the trace goes

Replay

Sign up to practice

Agent observability — trace the run

Event kinds

What goes in **fields

Where the trace goes

Replay

Agent observability — trace the run

Event kinds

What goes in **fields

Where the trace goes

Replay

Agent observability — trace the run

Event kinds

What goes in **fields

Where the trace goes

Replay

Sign up to practice

Agent observability — trace the run

Event kinds

What goes in **fields

Where the trace goes

Replay

Sign up to practice

What goes in `**fields`

What goes in `**fields`

What goes in `**fields`

What goes in `**fields`