Your first workbook, start to finish — Learning Center

Let's not talk about how this works. Let's just watch someone do it, start to finish, and you'll have built the same thing in your head by the end.

Meet Dana. Dana runs marketing at a small company. Dana cannot code — not a little, not secretly, not "took one class once." What Dana can do is describe what she wants, clearly, the way she'd brief a sharp new hire. That turns out to be the whole skill. By the end of this page, Dana has shipped a small, real tool that her team uses. You'll see every step: the thing she typed, what the agent did, what came back, and how she knew it was right.

The thing she's building is unglamorous on purpose: a little UTM link builder. Her team keeps hand-typing campaign tracking links into spreadsheets, getting them wrong, and breaking their analytics. She wants one small page where you fill in a few boxes and it spits out a correct link. That's it. Small enough to finish, real enough to matter.

the firSt thiNg she Types

Dana doesn't write a spec. She writes the brief she'd give a person. Here's the actual prompt:

Dana's prompt: "Build me a small page where someone fills in a website URL, a campaign source, a medium, and a campaign name — and it builds the correct UTM tracking link and shows a Copy button. Keep it simple and friendly. My team are marketers, not engineers."

Notice what's not there. No mention of a framework, a database, a hosting account, a build step. She described the outcome and the audience, and stopped. This is the right altitude to brief from, and it's worth saying plainly: you are allowed to not know the how. The how is the agent's job.

What comes back isn't a wall of code. The agent answers like a colleague who's about to start:

The agent's reply: "Got it. I'll make a single workbook — one file with the form, the link-building logic, and the Copy button all inside it. Quick check before I build: should the link update live as they type, or only when they press a button? And do you want the source/medium fields to be free text, or a dropdown of the common ones (google, facebook, email, etc.)?"

This is the collaborator showing up. It didn't silently guess and vanish. It read your brief, found the two decisions that actually change the result, and asked. Dana answers in one line — "live as they type, and dropdowns" — and the agent goes to work.

what "it buIlds" actUally loOks like

While the agent works, you're not staring at a spinner praying. You can watch it move. It writes the form. It writes the small piece of logic that assembles the link. It tries the result against an example to make sure the link comes out correctly formed. If something's off, it sees that and fixes it before handing anything to you — because, as you'll learn in a later unit, an agent is just a loop: it does something, looks at what happened, and goes again until the work is actually done.

When it's finished, it tells you in plain terms what it made:

The agent's reply: "Done. It's one file — utm-builder.html. Open it and you'll see four fields, two of them dropdowns. Type a URL and pick a source and the tracking link builds itself underneath, with a Copy button. I tested it with example.com and a Google / CPC campaign and the link came out right. Want to take a look?"

Here's the quietly important part. What the agent handed back is a workbook — a single file that holds the whole tool: the screen, the logic, everything. There's no server it's secretly tethered to, no account to log into. Dana can open it, and later email the file to a teammate, and it just works for them too. That isn't a bonus feature; it's what made this finishable in one sitting.

you review — eVen though You can't reAd the code

This is the step people assume they can't do, and it's the most important one. Dana does not read the code. She doesn't need to. She reviews the way you review any work: against what she asked for.

She opens the file. She types her real campaign in. She checks three things, out loud:

Does it do the thing I asked? She fills in the form. A link appears. Good.
Is the link actually correct? She pastes it in her browser. It goes to the right page with the tracking attached. Good.
Would my team understand it without me? She looks at the labels. One says "medium" — jargon her team doesn't use. Not good enough.

That third one is the whole game. You don't judge the code; you judge the result — and you're more qualified to do that than the agent, because you know your team and it doesn't. So she sends it back like any draft:

Dana's prompt: "Close. Two things: rename the 'medium' field to 'where it'll appear' since my team doesn't say medium, and add a little line under the link that says 'paste this anywhere you'd normally use your link.' Then I think it's good."

The agent makes both changes and confirms. Dana checks again. This back-and-forth — describe, review against the goal, send notes, repeat — is the entire job. It's not a fallback for when the AI fails. It is the work, and you're the one steering it.

the three Levels, hiDing in plAin sight

You just watched the agent grow up across this one tiny project, and it's worth naming the climb, because you'll feel it on everything you build.

Level 1 — it answers. At the very start, the agent took a plain-English brief and turned it into something real. You said what you wanted; it produced a working thing. That alone would have been science fiction a few years ago.

Level 2 — it checks itself. It didn't just generate and dump. It tested the link before handing it over, caught its own mistakes, and only showed you something it believed actually worked. You'll lean on this more as the work gets bigger: an agent that can tell whether it succeeded is worth ten that just produce confident-looking output.

Level 3 — it works with you over time. It asked the right questions up front, took your revision notes, and carried the project forward across several rounds without losing the thread. That's where everything in this Learning Center is heading: not a vending machine you poke once, but a collaborator you direct.

The honest framing, which we'll keep all the way through: this is software built in workbooks — by you and an agent, together. The pitch is never "a tool that runs itself while you sleep." Direction stays human. The agent does the building; you decide what's worth building and whether it's right.

and thEn shE shiPs it

Dana's tool is a single file, so "shipping" has two easy shapes, and she uses both.

The quick one: she emails the file to her team. Because the whole tool lives in that one file, it just opens and works for them — no install, no account, no "request access." That's the fastest path from built to used, and for a small internal tool it's often all you need.

Later, she wants it at a real web address the whole company can bookmark. That's a bigger step with a proper lesson of its own — but the short version is that putting a workbook on the internet is closer to flipping one setting than to the white-knuckle "deploy" engineers dread. The thing that ran on her laptop is the same thing that runs on the web; going live mostly means changing where it runs, not rebuilding it. For now, know the path exists and it's calm.

That's a complete build, and nothing in it required Dana to read or write a line of code. She described an outcome. The agent built it and checked its own work. She reviewed it against her goal and sent notes. It carried her changes through. Then it shipped — first as a file in an email, eventually as a page on the web. Every later lesson is just this same loop, on bigger and more interesting things. You've now seen the whole shape of it once. The next time, the person describing the outcome is you.