When an agent makes a change,

you’ll want to review it, run it, and see it.

The good news is that you can do all three

without leaving the app.

Normally, those three jobs would mean

bouncing between your editor,

a terminal window, and a web browser.

Here, they live side by side as built-in panels,

so checking an agent’s work is quick

instead of a chore.

Let’s tour them one at a time.

A diff shows exactly what changed,

with additions in green and deletions in red,

so nothing is a mystery.

If you’re new to the word,

a diff is simply a before and after comparison,

the lines that were added, removed, or changed,

usually colored so that they jump out.

And you’re not just a passive reader.

You can accept changes, leave comments,

or ask Copilot to adjust.

This is where you stay the decision maker,

and nothing is final until you say so.

Now, reading code is good, but running it is better.

The terminal panel lets you

run commands right inside the session.

If a terminal looks intimidating, relax.

Here, you’re mostly just running

the project’s own commands

and reading the results.

For Tailspin Toys, I’ll start the app.

We can do it here by hand,

or we can configure it as a script,

and then always have it available

with the ‘Run’ button.

So here, I’ve added the ‘Dev server’ script

that opens the client folder

and then runs ‘npm run dev’.

If we click ‘Run’,

this will start the server for the website.

So the ‘Run’ action opened a new terminal window,

but we still have our existing terminal window

as another tab.

So we can jump back if we want to,

to continue running commands.

For anything with a user interface,

the browser panel closes the loop.

Tailspin Toys is a website, so I can open it,

and actually use the new feature

the same way a real user would.

Here, if I wanted to keep iterating,

I can use the ‘Pick & Polish’ tool

to select this element

and then continue to work with the agent

because I’ve added it as context.

So now we can run our dev server again,

after I’ve made any changes,

and then we’d be able to see the fix.

So we were able to review the diff,

run it in the terminal, and see it in the browser,

and immediately iterate over it

to get a working sort feature.

There’s no tab hopping, no switching apps,

no losing your place.

That’s the tight loop and the whole point.

The faster you can go from change to confidence,

the more comfortable you’ll be letting agents help.

Once we’re happy,

we can accept the change right here

and create a PR, and move on.

Having review, run, and preview side by side

is exactly what makes agent-made changes

feel safe instead of scary,

because you’ve seen the proof

with your own eyes.

Together, these built-in panels

answer the three questions

you should always ask about an agent’s work:

What changed?

Does it run?

And does it actually work?

Make this your habit.

Next time an agent edits your code,

open the diff, run the tests, and preview it live,

before you accept.

Give it a try with GitHub Copilot app at gh.io/app.