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.

Chain Two Agents: Summarize Then Classify — Ai For Beginners

Day 7 · ~12 min●

You have a summarizer agent and a sentiment classifier agent. What happens if you feed the output of the first one directly into the second?

You'd get sentiment based on the summary instead of the full text — a classifier reading a condensed version of the input?

Exactly. And here is the key point — there is no special "pipeline" syntax for this. It is Python variables. You run the first agent, store its output, then pass that string to the second agent's run_sync:

python

summary = summarize_agent.run_sync(text).output
label = classify_agent.run_sync(summary).output

Two calls, two outputs, one variable connecting them. That is the entire pattern.

Two separate Agent objects, not one reused?

Two separate ones because they have different roles — one summarizes, one classifies. Each Agent holds a system_prompt, so one agent per role keeps the prompts distinct. The calls themselves are independent; agents do not share memory across run_sync:

python

def summarize_then_classify(text: str) -> str:
    summarize_agent = Agent(model, system_prompt="Summarize the text in 1-2 sentences. Return only the summary.")
    summary = summarize_agent.run_sync(text).output
    classify_agent = Agent(model, system_prompt="Classify the sentiment of the text. Reply with exactly one word: positive, neutral, or negative.")
    return classify_agent.run_sync(summary).output.strip().lower()

Why summarize first? Can't the classifier read the full text?

It can, but accuracy drops on noisy input. A five-paragraph complaint has timestamps, order numbers, pleasantries — a lot of signal the classifier has to wade through. Summarizing first strips the noise so the classifier sees a clean 1-2 sentence version. Cheaper and more accurate.

So this is the building block for any multi-step AI pipeline — any number of agents wired in series?

Every complex AI pipeline in production is built from this shape: run an agent, store the output, pass it to the next. Write summarize_then_classify(text) now — two agents, two run_sync calls, the summary flowing into the classifier.

Pipeline = Python Variables

TL;DR: chain agents by passing one's .output as the next one's input.

Summarize agent — system_prompt reduces text to 1-2 sentences
Classify agent — system_prompt constrains output to one word
Wiring — a plain Python variable carries the result between them

Two agents, one function

Step	Call	Output
1	`summarize_agent.run_sync(text)`	summary string
2	`classify_agent.run_sync(summary)`	sentiment label
3	`.strip().lower()` on label	clean string

Each run_sync is stateless — agents never see each other's conversations.

Day 7 · ~12 min●

You have a summarizer agent and a sentiment classifier agent. What happens if you feed the output of the first one directly into the second?

You'd get sentiment based on the summary instead of the full text — a classifier reading a condensed version of the input?

python

summary = summarize_agent.run_sync(text).output
label = classify_agent.run_sync(summary).output

Two calls, two outputs, one variable connecting them. That is the entire pattern.

Two separate Agent objects, not one reused?

python

def summarize_then_classify(text: str) -> str:
    summarize_agent = Agent(model, system_prompt="Summarize the text in 1-2 sentences. Return only the summary.")
    summary = summarize_agent.run_sync(text).output
    classify_agent = Agent(model, system_prompt="Classify the sentiment of the text. Reply with exactly one word: positive, neutral, or negative.")
    return classify_agent.run_sync(summary).output.strip().lower()

Why summarize first? Can't the classifier read the full text?

So this is the building block for any multi-step AI pipeline — any number of agents wired in series?

Pipeline = Python Variables

TL;DR: chain agents by passing one's .output as the next one's input.

Summarize agent — system_prompt reduces text to 1-2 sentences
Classify agent — system_prompt constrains output to one word
Wiring — a plain Python variable carries the result between them

Two agents, one function

Step	Call	Output
1	`summarize_agent.run_sync(text)`	summary string
2	`classify_agent.run_sync(summary)`	sentiment label
3	`.strip().lower()` on label	clean string

Each run_sync is stateless — agents never see each other's conversations.

def summarize_then_classify(text: str) -> str: summarize_agent = Agent(model, system_prompt="Summarize the text in 1-2 sentences. Return only the summary.") summary = summarize_agent.run_sync(text).output classify_agent = Agent(model, system_prompt="Classify the sentiment of the text. Reply with exactly one word: positive, neutral, or negative.") return classify_agent.run_sync(summary).output.strip().lower()

Pipeline = Python Variables

TL;DR: chain agents by passing one's .output as the next one's input.

Summarize agent — system_prompt reduces text to 1-2 sentences

Classify agent — system_prompt constrains output to one word

Wiring — a plain Python variable carries the result between them

Two agents, one function

Step	Call	Output
1	`summarize_agent.run_sync(text)`	summary string
2	`classify_agent.run_sync(summary)`	sentiment label
3	`.strip().lower()` on label	clean string

Each run_sync is stateless — agents never see each other's conversations.

Pipeline = Python Variables

TL;DR: chain agents by passing one's .output as the next one's input.

Summarize agent — system_prompt reduces text to 1-2 sentences

Classify agent — system_prompt constrains output to one word

Wiring — a plain Python variable carries the result between them

Two agents, one function

Step	Call	Output
1	`summarize_agent.run_sync(text)`	summary string
2	`classify_agent.run_sync(summary)`	sentiment label
3	`.strip().lower()` on label	clean string

Each run_sync is stateless — agents never see each other's conversations.

Pipeline = Python Variables

Two agents, one function

Pipeline = Python Variables

Two agents, one function

Pipeline = Python Variables

Two agents, one function

Sign up to practice

Pipeline = Python Variables

Two agents, one function

Sign up to practice