Guide · stage 03 · agents & skills
An agent is a loop. Skills are what it's allowed to do.
In the next fifteen minutes you'll run a coding agent in this page, watch it hit the wall of its own capabilities, hand it a new skill, and watch the same task succeed. Then you'll fire a prompt you customized yourself. Nothing here is a screenshot — every block executes.
01 · The idea
Plan, act, observe — repeat.
Strip away the vendor language and a coding agent is a small machine: a model plans the next step, acts by calling a tool, observes what came back, and loops until the task checks out. The model supplies judgement. Everything else — reading files, running tests, editing code — happens through skills: named, described capabilities the agent is explicitly given.
That's the whole trick, and it's also the safety model: an agent can only do what its skills allow. You'll feel that boundary first-hand in a moment.
Decide the step
The model reads the task and the transcript so far, and picks the next move.
Call a skill
Not "do anything" — invoke one named capability, with arguments.
Read the result
Tool output goes back into context. Errors are information, not failure.
Done or loop
Verified against the goal — tests pass, output matches — or plan again.
↺ not done? the loop continues with everything it just learned
02 · The lab
Run the agent. Then hit the wall.
Below is a live editor. The left pane defines the two things you own: the skills the agent may use, and the task. The demo repo behind it has a failing test — pricing.js adds a discount instead of subtracting it. Press ▸ Run agent and watch the loop work.
The planner in this sandbox is scripted so the demo stays predictable — but the skills are real code you can edit, and the agent genuinely calls them. Break one and watch the transcript change.
03 · Fire in place
Now write the prompt like you mean it.
Everything the agent did started from a task statement. A good one names the goal, the verification, and the boundaries — the same three things you just watched matter in the loop. This template is live: the dashed fields are yours to type in. Fire it here, or copy it into your own agent.
You are a coding agent working in . Fix . Before changing anything, reproduce it with . Make the smallest change that passes, and do not touch . When done, show the diff and the passing run.
04 · Where this goes next
The loop scales through three open protocols.
The lesson you just ran is one agent, one repo, one screen. In production the same loop composes outward — and the pieces you'd reach for are open, documented protocols, not vendor magic. This lesson's design is grounded in all three:
Agent2Agent Protocol
When one agent isn't enough, agents delegate to each other — discovering capabilities via Agent Cards and exchanging tasks. The "skills as explicit grants" idea you just used is how A2A agents describe themselves too.
a2a-protocol.org → MCP-UIInteractive UI over MCP
MCP standardizes how agents call tools; MCP-UI lets those tools answer with live interface, not just text — the way this page's lab answers your run with a transcript panel.
mcpui.dev → A2UIAgent-to-User Interface
A declarative format agents use to render rich, safe UI for humans mid-task — checkpoints, forms, approvals. The human-in-the-loop half of everything you just watched.
github.com/google/A2UI →This was one lesson. A techday is a room full of them.
Same format — your codebase, your tasks, live models — with a tutor woven into every step. Bring your team; leave with running agents.