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.

Day 10 · ~12 min●

You want a name and an email out of a free-text intake message. What is the fragile way to do that?

Regex on the string, or .split(",") and hope the model formats it the same way every time?

Both break the moment the model rephrases. PydanticAI has a cleaner move: define a Python class describing the shape you want, and hand it to the agent as result_type. The agent guarantees the output matches that class:

python

from pydantic import BaseModel
class Contact(BaseModel):
    name: str
    email: str
result = Agent(model, result_type=Contact).run_sync(text)
print(result.output.name, result.output.email)

result.output is a Contact instance, not a string. The .name and .email attributes are already extracted and typed.

So when result_type is set, result.output is a Pydantic object instead of a string?

Exactly. The type of result.output always matches whatever you pass to result_type. Pass a Contact class, get a Contact object. PydanticAI builds a JSON schema from the class, tells the model to produce JSON that fits, then validates and parses it for you. You never write a parser:

python

def extract_contact(text: str) -> dict:
    result = Agent(model, result_type=Contact).run_sync(text)
    return result.output.model_dump()

Why .model_dump() at the end? Can I just return the Contact object?

You could, but the function type is dict — .model_dump() converts a Pydantic model into a plain Python dict. That makes it easy to JSON-serialize, insert into a database, or pass to a downstream function that expects a plain dict.

And if a field is missing from the input the model does its best — invents a placeholder or leaves it empty?

Right — the model will do its best; strict input validation is your job afterwards. For this lesson every test input has both a name and an email, so the extraction is clean. Write extract_contact(text) now: define the Contact class at the top, build the agent with result_type=Contact, return the dict from model_dump().

Typed Output with Pydantic

TL;DR: pass a Pydantic class as result_type — result.output is an instance of that class.

class Contact(BaseModel) — defines the fields and types you want
Agent(model, result_type=Contact) — forces output to fit the class
.model_dump() — converts a model instance into a plain dict

What the type does

`result_type`	`result.output` type
none	`str`
`Contact`	`Contact` instance
`list[str]`	`list` of strings

PydanticAI builds a JSON schema from the class, validates the model's response, and retries on shape mismatches.

Day 10 · ~12 min●

You want a name and an email out of a free-text intake message. What is the fragile way to do that?

Regex on the string, or .split(",") and hope the model formats it the same way every time?

Both break the moment the model rephrases. PydanticAI has a cleaner move: define a Python class describing the shape you want, and hand it to the agent as result_type. The agent guarantees the output matches that class:

python

from pydantic import BaseModel
class Contact(BaseModel):
    name: str
    email: str
result = Agent(model, result_type=Contact).run_sync(text)
print(result.output.name, result.output.email)

result.output is a Contact instance, not a string. The .name and .email attributes are already extracted and typed.

So when result_type is set, result.output is a Pydantic object instead of a string?

Exactly. The type of result.output always matches whatever you pass to result_type. Pass a Contact class, get a Contact object. PydanticAI builds a JSON schema from the class, tells the model to produce JSON that fits, then validates and parses it for you. You never write a parser:

python

def extract_contact(text: str) -> dict:
    result = Agent(model, result_type=Contact).run_sync(text)
    return result.output.model_dump()

Why .model_dump() at the end? Can I just return the Contact object?

You could, but the function type is dict — .model_dump() converts a Pydantic model into a plain Python dict. That makes it easy to JSON-serialize, insert into a database, or pass to a downstream function that expects a plain dict.

And if a field is missing from the input the model does its best — invents a placeholder or leaves it empty?

Right — the model will do its best; strict input validation is your job afterwards. For this lesson every test input has both a name and an email, so the extraction is clean. Write extract_contact(text) now: define the Contact class at the top, build the agent with result_type=Contact, return the dict from model_dump().

Typed Output with Pydantic

TL;DR: pass a Pydantic class as result_type — result.output is an instance of that class.

class Contact(BaseModel) — defines the fields and types you want
Agent(model, result_type=Contact) — forces output to fit the class
.model_dump() — converts a model instance into a plain dict

What the type does

`result_type`	`result.output` type
none	`str`
`Contact`	`Contact` instance
`list[str]`	`list` of strings

PydanticAI builds a JSON schema from the class, validates the model's response, and retries on shape mismatches.

Day 10 · ~12 min●

You want a name and an email out of a free-text intake message. What is the fragile way to do that?

Regex on the string, or .split(",") and hope the model formats it the same way every time?

Both break the moment the model rephrases. PydanticAI has a cleaner move: define a Python class describing the shape you want, and hand it to the agent as result_type. The agent guarantees the output matches that class:

python

from pydantic import BaseModel
class Contact(BaseModel):
    name: str
    email: str
result = Agent(model, result_type=Contact).run_sync(text)
print(result.output.name, result.output.email)

result.output is a Contact instance, not a string. The .name and .email attributes are already extracted and typed.

So when result_type is set, result.output is a Pydantic object instead of a string?

Exactly. The type of result.output always matches whatever you pass to result_type. Pass a Contact class, get a Contact object. PydanticAI builds a JSON schema from the class, tells the model to produce JSON that fits, then validates and parses it for you. You never write a parser:

python

def extract_contact(text: str) -> dict:
    result = Agent(model, result_type=Contact).run_sync(text)
    return result.output.model_dump()

Why .model_dump() at the end? Can I just return the Contact object?

You could, but the function type is dict — .model_dump() converts a Pydantic model into a plain Python dict. That makes it easy to JSON-serialize, insert into a database, or pass to a downstream function that expects a plain dict.

And if a field is missing from the input the model does its best — invents a placeholder or leaves it empty?

Right — the model will do its best; strict input validation is your job afterwards. For this lesson every test input has both a name and an email, so the extraction is clean. Write extract_contact(text) now: define the Contact class at the top, build the agent with result_type=Contact, return the dict from model_dump().

Typed Output with Pydantic

TL;DR: pass a Pydantic class as result_type — result.output is an instance of that class.

class Contact(BaseModel) — defines the fields and types you want
Agent(model, result_type=Contact) — forces output to fit the class
.model_dump() — converts a model instance into a plain dict

What the type does

`result_type`	`result.output` type
none	`str`
`Contact`	`Contact` instance
`list[str]`	`list` of strings

PydanticAI builds a JSON schema from the class, validates the model's response, and retries on shape mismatches.

Day 10 · ~12 min●

You want a name and an email out of a free-text intake message. What is the fragile way to do that?

Regex on the string, or .split(",") and hope the model formats it the same way every time?

Both break the moment the model rephrases. PydanticAI has a cleaner move: define a Python class describing the shape you want, and hand it to the agent as result_type. The agent guarantees the output matches that class:

python

from pydantic import BaseModel
class Contact(BaseModel):
    name: str
    email: str
result = Agent(model, result_type=Contact).run_sync(text)
print(result.output.name, result.output.email)

result.output is a Contact instance, not a string. The .name and .email attributes are already extracted and typed.

So when result_type is set, result.output is a Pydantic object instead of a string?

Exactly. The type of result.output always matches whatever you pass to result_type. Pass a Contact class, get a Contact object. PydanticAI builds a JSON schema from the class, tells the model to produce JSON that fits, then validates and parses it for you. You never write a parser:

python

def extract_contact(text: str) -> dict:
    result = Agent(model, result_type=Contact).run_sync(text)
    return result.output.model_dump()

Why .model_dump() at the end? Can I just return the Contact object?

You could, but the function type is dict — .model_dump() converts a Pydantic model into a plain Python dict. That makes it easy to JSON-serialize, insert into a database, or pass to a downstream function that expects a plain dict.

And if a field is missing from the input the model does its best — invents a placeholder or leaves it empty?

Right — the model will do its best; strict input validation is your job afterwards. For this lesson every test input has both a name and an email, so the extraction is clean. Write extract_contact(text) now: define the Contact class at the top, build the agent with result_type=Contact, return the dict from model_dump().

Typed Output with Pydantic

TL;DR: pass a Pydantic class as result_type — result.output is an instance of that class.

class Contact(BaseModel) — defines the fields and types you want
Agent(model, result_type=Contact) — forces output to fit the class
.model_dump() — converts a model instance into a plain dict

What the type does

`result_type`	`result.output` type
none	`str`
`Contact`	`Contact` instance
`list[str]`	`list` of strings

PydanticAI builds a JSON schema from the class, validates the model's response, and retries on shape mismatches.

Privacy Terms

Sign up to practice

Create a free account to get started. Paid plans unlock all tracks.

or

Sign up to practice

Create a free account to get started. Paid plans unlock all tracks.

or