// about

Jason Newbury

The human-in-the-loop

If you've made it here, you've found one of the few parts of this site that's actually written by a person. The rest is a working experiment: as we build things, AI handles the documentation, and I do a quick check that it isn't AI slop.

why_this_site [01]

This site started as an excuse to experiment. I could see AI changing how software gets built, but reading about it wasn't enough. I needed real projects to find out where AI is genuinely useful, where it falls short, and what changes when you treat it less like a tool and more like a collaborator.

What emerged is a tangle of Salesforce, metadata, tooling, automation and AI. They're not so much separate projects as different threads of the same curiosity. Each one is a chance to watch a traditional enterprise platform collide with AI that changes month to month.

There's never enough time to build everything but AI promises to take some of the load, which raises its own questions: what can be handed off, what still needs a human, and what happens in the space between. Those questions turned out to be as interesting as the projects themselves.

I enjoy finding order in chaos: understanding complicated systems, connecting ideas that don't obviously belong together, and using technology to take a different run at things. Not necessarily because the old way is broken, but because "what if we did this differently?" is usually worth asking.

This site is a snapshot of that exploration. Some of it will work, some of it won't, and some might turn into something actually worth keeping. Regardless, let's ride.
the human in the loop

What can be handed off, and what still needs me? Below is one of the patterns I run: one piece of work, from the moment I intiate it to the moment it returns for my approval.

I open and close every cycle. The middle is delegated: planning, execution and the correction pass happen without me. Once complete, I choose to either ship or skip.

↺ how the loop gets enforced →
A loop of five steps. I hand off to plan, then execute, then review. Review branches: only if a gate fails does it reach correct, which returns to review, and the correction is taken at most once. When the review is complete, the loop returns to me. Plan, execute, review and correct all sit inside a handed-off zone; I sit outside it, and the loop both starts and ends with me. handed off only if a gate fails max 1x re-check nothing ships without me (currently) Me Plan Execute Review Correct
Me Every open question, every review disposition, and the ship call. The AI never resolves an open fork on its own: it stops and asks.
Planning agent Invoked with a model route, not a model. Five layers of precedence pick it, from a UI override down to the stage default. Reasoning models by default.
Execution agent Tool-reliable models. A 429, a 5xx or a dropped connection restarts the stage on the next model in the route. A schema failure is rethrown, not papered over.
Verifier, not an agent Models propose, code decides. A deterministic verifier rejects incomplete work, and a separately spawned reviewer is told to refute the design.
Fix agent Only when a gate fails. The fix stage runs its own route, Claude Sonnet 4.5 first with transport-only failover: a network blip can never hand a fix to a weaker model.

↺I hand off, then plan, execute and review run without me. Correction only when a gate fails. Nothing ships until the loop comes back to me.