// about

Jason Newbury

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 to ensure 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 for myself 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. 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 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, this one is for code and web content audits: one piece of work, from the moment I initiate 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 review passes, 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 passes nothing ships without me (currently) Me Plan Execute Review Correct
Me Anything that needs a decision, and the final call on whether it ships. The AI never picks a fork on its own: it stops and asks.
Planning agent Works out what to do before anything is done. It gets a ranked list of models to try, not just one, so a bad day at one provider does not stall the job.
Execution agent Does the actual work. If a model is busy or drops out, the next one on the list takes over. If the result comes back malformed, the job fails rather than quietly carrying on.
Verifier, not an agent Models propose, code decides. This step is ordinary code, not AI: it checks the work is finished, and that every claim it makes matches the real file.
Fix agent Only if a check fails, and only once. The repair always runs on the strongest model: a network blip can never quietly hand it to a weaker one.

↺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.