Claude with Orbit vs Claude without: same model, one of them can check its work

Any comparison that makes the baseline look stupid is selling something, so start with the fair version.

Without any extension at all, Claude is a strong lifecycle collaborator. It writes better subject lines than most teams ship, argues with your segmentation logic and turns out to be right, and will take a messy brief and give you back a programme — trigger, audience, sequence, exit criteria — in about two minutes. The structure will be sound. Ask why your reactivation flow is flat and you get the three questions a good CRM lead would ask. Orbit improves none of that.

Checking is the gap. Opening the email it just wrote, reading your ESP's API — your email service provider, the platform you actually send from, like Braze or Klaviyo — to find out whether the toggle it just described exists on your plan, telling a working Liquid tag from one that silently renders as an empty string: all of that sits outside the chat window. So when the model doesn't know, it does what language models do. It produces the most plausible-looking answer, in the same confident register it uses when it's right.

Worth being precise about the mechanism, because the marketing version of this claim is usually nonsense: Orbit adds no intelligence. It adds things to look at — a rendering engine, the platform's documented behaviour, your own template — so that "I don't know, let me check" becomes an available move.

These are the jobs a lifecycle person does in a normal week.

1. "Build me the welcome email."

Without Orbit: clean HTML, sensible structure, decent copy, and no eyes on it. Yours or the model's. You paste it into your ESP, send a test, and start the loop — spot something, describe it in chat, get a revision, paste, test again. Four rounds of clipboard tennis, and you only catch the problems that happen to be visible on whichever device you picked up.

With Orbit: the email gets opened. The render gate loads the compiled HTML in a real browser at 640 pixels — desktop inbox width — then again at 390, which is an iPhone. It measures what a reviewer squints at: whether the call-to-action has wrapped to a second line, whether a heading left one orphaned word stranded, whether tap targets are big enough for a thumb, whether text contrast genuinely passes rather than looking like it probably does, and whether total byte size crosses Gmail's clipping threshold. The failures arrive before the email does.

2. "Write the personalisation so it degrades properly."

Without Orbit: you get Liquid — the templating language most ESPs use to drop user data into a message — and it will look correct. Trouble is, personalisation is a set of branches, and every branch is a different email: the one where first name is present, the one where it's missing, the one where somebody typed theirs in lowercase at 2am. The happy path gets written confidently. The fallback branch is the one nobody renders until a customer receives "Hi ," with a space before the comma.

With Orbit: the branches get enumerated and each renders as its own document, so you read the email your lowercase-2am user actually receives. Missing-value fallbacks stop being something you intended and become something you looked at.

3. "How do I actually do this in Braze?"

Without Orbit: a confident answer describing a menu path, an API field, or a Canvas step. Often exactly right. Occasionally describing the platform as it stood two years ago, or blending two products' behaviour into one plausible hybrid. The failure is quiet — you find out when you go hunting for a setting that was never there.

With Orbit: the answer comes out of a loaded platform skill rather than recall, and it states which operations Orbit can execute against your platform and which it cannot. An honest "that one you'll have to do in the UI" beats a confident wrong click path every time. The next section is entirely about this, because it removes the docs-tab round trip that interrupts the work ten times a day.

4. "Build the win-back segment."

Without Orbit: good strategic reasoning about recency and frequency, expressed against attribute names the model has guessed. Logic sound; field names fictional until somebody checks them against your workspace.

With Orbit: same reasoning, run against what your workspace contains. The thinking doesn't improve. The attributes exist.

5. "Is this ready to send?"

Without Orbit: you'll be told it looks good, because from where the model sits it does. Most expensive moment on this list. Anything that cannot inspect the artefact has no mechanism for saying no, and "looks good" is what fluency produces when evidence is absent.

With Orbit: a gate that can fail. Rendered checks, contrast, size against the clipping threshold, dark-mode behaviour.

Orbit carries the platform documentation with it. The knowledge ships inside the extension as dedicated platform skills — eight at the time of writing, covering Braze, Klaviyo, Iterable, Salesforce Marketing Cloud, Mailchimp, Customer.io, HubSpot and PostHog — and loads on demand when a conversation turns to one of them. Nothing is fetched from the web mid-answer.

In practice you stop leaving the conversation. Think about the normal loop for "what's the rate limit on this endpoint", or "which trigger types can a Canvas entry accept", or "how do I express this cohort in PostHog". Open a docs tab. Search. Skim three pages. Discover the answer is on a fourth. Come back having lost the thread of whatever you were doing. That round trip is most of the friction in lifecycle work, and it fires ten times a day.

These are substantial rather than summary — the PostHog skill alone runs to several hundred lines of platform behaviour, with Braze, HubSpot and Iterable in the same range. They cover what documentation is worst at surfacing: which operations are genuinely available versus plan-gated, where two features interact badly, and which API field names differ from the labels printed in the UI.

Each one also states its own limits, which is the property that makes it usable at all. Every platform skill spells out which operations Orbit can execute for you and which are UI-only, so you learn the boundary up front instead of discovering it after a failed call.

Once platform knowledge is in the room, your own questions get better. "Can Braze do X" turns into "what breaks if I do X this way" — the question that was always the useful one, and the one nobody asks while the cost of checking is a fifteen-minute documentation detour.

An honest comparison includes the ceiling.

Your business stays unknown to it. Orbit has no idea that Tuesday sends underperform because your audience is B2B and half of them are in standups, or that legal has opinions about the word "free". Whether the programme should exist at all is not a question it can answer. Strategy remains yours; execution is what gets checked.

Platforms also hide things. Some data is simply not available through any API — certain Braze reporting cuts among them — and where that's true you get told so rather than given an estimate. Useful, and still a limit: expect to hear "check that one in the dashboard" regularly.

Sending yourself a test remains necessary. What goes away is sending yourself five, because the obvious failures surface before the first one. Final judgement is still a human opening an email on their own phone.

Never touch a real ESP? Use Claude for strategy, copy and structure, and skip Orbit entirely. Claude is already good at that work, and installing an extension to fix something that isn't broken is how people end up with a stack instead of a workflow.

If you ship email — if there's a moment each week where you paste HTML into a platform and hope — then checking is the gap, and checking is the entire product. Orbit is free, needs no licence key, and unlocks every tool at install.

Run the honest test. Take the last email you shipped, the one you felt good about, and put it through the render gate before writing anything new. Most people find at least one thing. The finding isn't the interesting part — the interesting part is that the email had already gone out, and nothing anywhere had mentioned it.