Orbit

My agent says done. Did it break something?

Chris Rupp

Your agent says done… you open your app, and the page is blank. no error, nothing, just white. After some digging it turns out the agent renamed something in one file, but another file is still using the old name. Everything looked finished, so how could you have known without opening the app and finding out the hard way?

The answer is checks.

What the heck is a check?

A check is a program that reads your code and flags mistakes… without ever running your app. It just reads the files, the same way you’d proofread an essay without reading it out loud. (Checking code by reading it like this is called static analysis, if you ever hear that term thrown around.)

There are two kinds you’ll hear about constantly.

The linter

A linter flags sloppy code. The classic example is something you made and never used… a variable the agent created, then rewrote the code around and forgot about. On its own that might not break anything, but it’s clutter, and clutter is where confusion starts. Agents make a ton of these cuz they rewrite things in big chunks and don’t always clean up what they left behind.

The type checker

A type checker flags pieces that don’t fit. That’s our blank page. One file asks for something by the old name, the other file doesn’t have anything by that name anymore, and the type checker notices right away. Think of it like puzzle pieces… the type checker doesn’t care what picture is on them, it just checks that every tab has a slot that fits it.

Why not just trust “done”?

“Done” only means your agent thinks it’s finished. It’s not lying to you, it just didn’t notice.

Here’s why that happens. An agent edits a lot of files in one go, and it’s juggling all of them at once. It renames something in file A, updates file B and C, and file D, which it never opened during this task, is still asking for the old name. From where the agent is sitting, every file it touched looks right. The broken one is the one it didn’t look at. And it’s the same agent that wrote the change deciding whether the change worked, so it’s checking against its own idea of what it did… not against what’s actually in every file.

Checks don’t have that problem. They don’t get tired or distracted, and they don’t have a plan they’re hoping was right. They read every file, every time, and point to the exact line that’s wrong. That also makes the fix easy, cuz you can hand that error straight back to your agent and it knows exactly where to look instead of guessing.

How do I actually use them?

Start simple

Ask your agent to run the linter and type checker before it says done. Something like:

“before you tell me you’re done, run the linter and the type checker and show me the results. if anything fails, fix it first.”

If your project doesn’t have them set up yet, your agent can set them up. Just ask.

Better yet, GitHub Actions

Asking every time works, but you’ll forget (I do). So have your agent set up GitHub Actions, which means GitHub runs your checks for you every time you push code up. After each push you’ll see one of two things:

Your agent will call this CI. It’s the same checks you’d run by hand, just running automatically on every push, so it doesn’t depend on anyone remembering. That’s the whole point… the check happens whether the agent thought to do it or not.

One catch: green isn’t the same as “works”

Checks read your code, they don’t use your app. A green check means the pieces fit, not that every button does the right thing. A button can be wired up perfectly and still send people to the wrong page, and no linter or type checker will ever know, cuz technically nothing is broken. The code is fine… it just does the wrong thing.

So still try it yourself. Click through the thing you asked for before you call it finished. The checks catch the stuff you’d never spot by eye, and you catch the stuff a program reading code can’t.

How Orbit helps

In Orbit, the program I built to run my agents, you don’t have to ask. When an agent finishes a task, Orbit runs your project’s checks, plus a few of its own that work across all your projects, and shows pass or fail right on the Pipeline. Orbit is in Alpha and free right now if you wanna try it: https://orbitdev.app

The rest of these words, like static analysis and CI/CD, are in the Learning Atlas if you want to go deeper: https://orbitdev.app/docs/atlas/qa-signal-lane/

I’m still learning a lot of this as I go… what do you have your agents run before you trust a “done”? I’d honestly love to hear what’s working for you.