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.

Two Agents, One Shared Context — Ai For Makers

Day 20 · ~12 min●

You have one brief — a paragraph describing the week's work. You want events extracted and tasks extracted from the same text. What is the clean way?

Two separate functions? Or one agent that returns both in a Pydantic shape?

Two specialized agents, one shared input. Each agent stays narrow; the orchestrator merges both outputs into one dict. The two extractors:

python

events_agent = Agent(model, result_type=list[str], system_prompt="Extract calendar events as short phrases.")
tasks_agent = Agent(model, result_type=list[str], system_prompt="Extract action items as short tasks.")
events = events_agent.run_sync(brief).output
tasks = tasks_agent.run_sync(brief).output

Same brief input goes into both — parallel calls, different roles, the results get combined at the end?

Exactly. The brief is the shared state; each agent reads its own slice. The orchestrator returns one dict holding both lists plus the original brief for traceability:

python

def orchestrate_calendar_and_tasks(brief: str) -> dict:
    events_agent = Agent(model, result_type=list[str], system_prompt="Extract calendar events as short phrases.")
    tasks_agent = Agent(model, result_type=list[str], system_prompt="Extract action items as short tasks.")
    out = {
        "brief": brief,
        "events": events_agent.run_sync(brief).output,
        "tasks": tasks_agent.run_sync(brief).output,
    }
    return out

Why include the brief in the returned dict? The caller already has it.

For traceability. When this dict lands in a log, a test, or a downstream system, the brief it came from is attached. Debugging becomes trivial — you see the input and both outputs together without chasing a separate variable.

So one shared context drives two specialized agents and comes back as a clean dict with everything the caller needs?

One input, two roles, one traceable output. This is the shape of every multi-agent orchestration — independent specialists sharing state through a plain Python value.

Two Specialists, Shared State

TL;DR: run two narrow list[str] agents over the same brief; return both lists plus the brief.

Shared input — the brief is the context for both calls
Narrow system_prompt per agent — one extractor per responsibility
Traceable dict — brief + events + tasks in the output

Why separate agents

Single agent	Two agents
Mixed prompt	Narrow roles
Harder to tune	Easy to adjust one

Specialist agents sharing one context produce cleaner, more reliable results than one agent asked to juggle two jobs.

Day 20 · ~12 min●

You have one brief — a paragraph describing the week's work. You want events extracted and tasks extracted from the same text. What is the clean way?

Two separate functions? Or one agent that returns both in a Pydantic shape?

Two specialized agents, one shared input. Each agent stays narrow; the orchestrator merges both outputs into one dict. The two extractors:

python

events_agent = Agent(model, result_type=list[str], system_prompt="Extract calendar events as short phrases.")
tasks_agent = Agent(model, result_type=list[str], system_prompt="Extract action items as short tasks.")
events = events_agent.run_sync(brief).output
tasks = tasks_agent.run_sync(brief).output

Same brief input goes into both — parallel calls, different roles, the results get combined at the end?

Exactly. The brief is the shared state; each agent reads its own slice. The orchestrator returns one dict holding both lists plus the original brief for traceability:

python

def orchestrate_calendar_and_tasks(brief: str) -> dict:
    events_agent = Agent(model, result_type=list[str], system_prompt="Extract calendar events as short phrases.")
    tasks_agent = Agent(model, result_type=list[str], system_prompt="Extract action items as short tasks.")
    out = {
        "brief": brief,
        "events": events_agent.run_sync(brief).output,
        "tasks": tasks_agent.run_sync(brief).output,
    }
    return out

Why include the brief in the returned dict? The caller already has it.

So one shared context drives two specialized agents and comes back as a clean dict with everything the caller needs?

One input, two roles, one traceable output. This is the shape of every multi-agent orchestration — independent specialists sharing state through a plain Python value.

Two Specialists, Shared State

TL;DR: run two narrow list[str] agents over the same brief; return both lists plus the brief.

Shared input — the brief is the context for both calls
Narrow system_prompt per agent — one extractor per responsibility
Traceable dict — brief + events + tasks in the output

Why separate agents

Single agent	Two agents
Mixed prompt	Narrow roles
Harder to tune	Easy to adjust one

Specialist agents sharing one context produce cleaner, more reliable results than one agent asked to juggle two jobs.

events_agent = Agent(model, result_type=list[str], system_prompt="Extract calendar events as short phrases.") tasks_agent = Agent(model, result_type=list[str], system_prompt="Extract action items as short tasks.") events = events_agent.run_sync(brief).output tasks = tasks_agent.run_sync(brief).output

def orchestrate_calendar_and_tasks(brief: str) -> dict: events_agent = Agent(model, result_type=list[str], system_prompt="Extract calendar events as short phrases.") tasks_agent = Agent(model, result_type=list[str], system_prompt="Extract action items as short tasks.") out = { "brief": brief, "events": events_agent.run_sync(brief).output, "tasks": tasks_agent.run_sync(brief).output, } return out

Two Specialists, Shared State

TL;DR: run two narrow list[str] agents over the same brief; return both lists plus the brief.

Shared input — the brief is the context for both calls

Narrow system_prompt per agent — one extractor per responsibility

Traceable dict — brief + events + tasks in the output

Why separate agents

Single agent	Two agents
Mixed prompt	Narrow roles
Harder to tune	Easy to adjust one

Specialist agents sharing one context produce cleaner, more reliable results than one agent asked to juggle two jobs.

Two Specialists, Shared State

TL;DR: run two narrow list[str] agents over the same brief; return both lists plus the brief.

Shared input — the brief is the context for both calls

Narrow system_prompt per agent — one extractor per responsibility

Traceable dict — brief + events + tasks in the output

Why separate agents

Single agent	Two agents
Mixed prompt	Narrow roles
Harder to tune	Easy to adjust one

Specialist agents sharing one context produce cleaner, more reliable results than one agent asked to juggle two jobs.

Two Specialists, Shared State

Why separate agents

Two Specialists, Shared State

Why separate agents

Two Specialists, Shared State

Why separate agents

Sign up to practice

Two Specialists, Shared State

Why separate agents

Sign up to practice