← Plugin catalog
Creativity

Email Love

Email Love v4.11.3

Build HTML Emails in Figma

Create a free account to save this plugin.

From the developer

Declared capabilities

  • Interactive
  • Write

Not specified in the available declarations: limitations, pricing & account requirements.

Onboarding example

Build an export-ready email in my Figma file.
Sources & dates

Developer declarations; not independently tested. Listing last checked Nov 21, 2026. Package observed Nov 21, 2026.

View package source →

Description

From the marketplace listing

Four Figma skills cover Email Love email building, template repair, design-system migration, and quality gates. Ten ESP skills cover Braze Liquid, Customer.io Liquid, HubSpot HubL, Iterable Handlebars, Klaviyo Django, Marketo Velocity, MoEngage Jinja, Sailthru Zephyr, Salesforce Marketing Cloud AMPscript, and Zeta ZML. The ESP skills write, review, and debug personalization in any email HTML, whether or not it came from Email Love, without requiring an MCP connection. This is a skills-only package and does not bundle MCP configuration. Canvas work requires compatible Figma write tools connected separately. Inspiration research, conversion, design-system access, headless export verification, and previews require the relevant Email Love MCP tools connected and authenticated separately. Available Figma workflows depend on the tools exposed in your environment. Conversion begins with a Figma design or supplied screenshot; it is not a free-form HTML generator for chat.

Language: English · Automatically detected from descriptions.

What changed

Similar plugins

Finding similar plugins… Results will appear here automatically.

Browse plugins →

Keywords

Files & skills

File archives

Plugin package118 files · 1.08 MBBrowse files →
Skill instructions
braze-liquid19.6 KB

View saved version →

---
name: braze-liquid
description: Write, review, and debug Liquid personalization in Braze email, push, in-app message, SMS, WhatsApp, Content Card, and Banner templates. Use this skill whenever someone is writing Braze personalization tags or Liquid logic, asks why a Braze message rendered blank or was aborted, is building abandoned-cart or catalog product loops, is working with Connected Content, Content Blocks, catalogs, or Canvas entry properties, hits an "Unexpected end token" error or an unexplained abort in the Message Activity Log, or shares Braze template code and wants it checked. Trigger on "Braze Liquid", "custom_attribute", "connected_content", "abort_message", "Canvas entry property", or Braze campaign and Canvas personalization questions even when Liquid is not named. Braze-only, and do not apply it to Shopify, Customer.io, or other Liquid platforms, whose tag sets and variable syntax differ. Works on any email HTML, not only Email Love exports; also covers Braze emails built in Figma with the Email Love plugin.
---

# Braze Liquid

Braze runs **Shopify Liquid up to and including Liquid 5**, but with two things layered on top that break naive Liquid instincts:

1. **A non-standard variable syntax.** Attribute references are wrapped in `${...}` inside the braces: `{{${first_name}}}`, `{{custom_attribute.${plan}}}`. Nothing else in the Liquid world looks like this.
2. **A partial implementation.** Braze's own words: *"Braze currently doesn't support 100% of Shopify's Liquid, only certain portions."* Several standard filters and, critically, **parentheses in conditionals** are unsupported.

So the failure mode is code that reads like correct Liquid, saves fine, and misbehaves at send time.

## The restriction that trips up everyone

Braze restricts **where** operators and filters may appear. This is the highest-frequency source of Braze Liquid bugs and has no analogue in other platforms:

| Context | Operators | Filters |
|---|---|---|
| `{% assign %}` | ❌ **not supported** | ✅ supported |
| `{% if %}` `{% elsif %}` `{% unless %}` | ✅ supported | ❌ **not supported** |
| `{% case %}` `{% when %}` | equality only | ❌ **not supported** |
| `{% for %}` | ❌ | ❌ |
| Array access `[ ]` | ❌ | ❌ |

So `{% if my_array | size > 3 %}` is invalid. You must `{% assign n = my_array | size %}` first, then `{% if n > 3 %}`. And `{% assign is_vip = total > 100 %}` is invalid the other way — assign can't hold an operator.

**There are also no parentheses.** *"Parentheses are invalid characters in Liquid and prevent your tags from working."* `(a and b) or c` has to become nested `{% if %}` blocks or intermediate variables.

## The three failure classes

1. **Missing attribute → renders blank.** Braze does not error or print the raw tag. `{{ x | default: 'y' }}` is the fix — but note `default` fires on *empty* (`""`) and not on *blank* (`" "`).
2. **Malformed Liquid → the message is aborted at send time.** Logged as `template_parse_error` in Currents, "Liquid syntax error" in Messaging Diagnostics. Braze does not appear to block saving on bad Liquid, so this surfaces only on send.
3. **Deliberate or cascading abort → no send, no delivery record.** `{% abort_message %}`, an exhausted Connected Content `:retry`, or a `required=true` lookup miss.

## Reference files

Read the one you need.

| File | Read it when |
|---|---|
| `references/syntax.md` | You need exact tag or filter syntax, the personalization-tag forms, or what Braze doesn't support. **Read before writing any filter you haven't used in this conversation** — Braze's filter set diverges from Shopify's in specific, non-obvious ways (`money`, `as_json_string`, no `to_json`). |
| `references/data-sources.md` | You need field paths: standard vs custom attributes, event properties, Canvas context, API-triggered properties, catalogs, Connected Content, Content Blocks, cart data. |
| `references/troubleshooting.md` | You're diagnosing a symptom, decoding an abort reason, or want th

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 6 — file references are metadata, not package contents.

customerio-liquid19 KB

View saved version →

---
name: customerio-liquid
description: Write, review, and debug Liquid personalization in Customer.io emails, SMS, push, in-app messages, webhooks, and snippets. Use this skill whenever someone is writing Liquid for Customer.io, asks why a Customer.io message shows as Failed or Undeliverable, is building loops over event or object data, is working with snippets, layouts, journey attributes, collections, or trigger data, hits a composer error like "if tag was never closed" or "Unidentified method", or shares Customer.io template code and wants it checked. Trigger on "Customer.io liquid", "customer.attribute", "trigger data", "journey attribute", "cio_link", or Customer.io campaign and broadcast personalization questions even when Liquid is not named. Customer.io-only, and do not apply it to Braze, Shopify, or Klaviyo, whose namespaces, tags, and error behavior differ. Works on any email HTML, not only Email Love exports; also covers Customer.io emails built in Figma with the Email Love plugin.
---

# Customer.io Liquid

Two things make Customer.io different from every other Liquid platform, and both change the answer to almost any question.

## 1. There are two Liquid engines, set per message

| Version | Engine | Who has it |
|---|---|---|
| **Latest** | **LiquidJS** | All accounts created on or after **Nov 28, 2023**, and **all Design Studio messages regardless of account age** |
| **Legacy** | **Ruby (Shopify) Liquid** | Accounts created before Nov 28, 2023, unless upgraded |

The version is set **per message**, not per account. You check it by hovering the "last saved" date in the message editor. Snippets and layouts have **no version of their own** — they render using the version of whichever message includes them.

This matters because the same code behaves differently:

- **`escape` no longer URL-encodes** in latest. Upgrading silently breaks every URL that relied on it. Use `url_encode`.
- **Timezone offsets changed from hours to minutes.** `timezone: '-8'` in legacy is `-480` in latest.
- **`timezone` and `htmlencode` are deprecated** in latest (use `date`'s second argument and `escape`).
- `default`, `break`, `json_array_uniq`, and `== empty` for arrays **only exist in latest**.
- `sort` no longer throws on null-containing arrays; `modulo` always returns positive; `sum` casts to number instead of concatenating.

**So: ask which version the message is on before answering anything involving `escape`, timezones, or `default`.** If they can't check, write the version-agnostic form and say which you assumed.

## 2. A missing attribute does not render blank — it fails the message

This is the opposite of most ESPs and the single most important behavioral fact:

> *"If your liquid statements don't evaluate properly — like if a profile doesn't have a `first_name` attribute — the message won't send. This is to prevent profiles from receiving incomplete messages! You'll see `Failed` in your message logs."*

So Customer.io is fail-safe rather than fail-blank. Every unguarded attribute reference is a deliverability risk for the slice of your audience that lacks it. Fallbacks aren't cosmetic here; they're what gets the message out the door.

**The dangerous exception:** referencing a *namespace* that doesn't exist for that workflow type (e.g. `{{trigger.x}}` on an event-triggered campaign) renders **empty with no error** and the message sends. Wrong-prefix bugs are the silent ones.

## Reference files

| File | Read it when |
|---|---|
| `references/syntax.md` | You need exact tag or filter syntax, Customer.io-specific tags, or the legacy-vs-latest differences. **Read before writing any filter you haven't used in this conversation** — several behave differently between versions. |
| `references/data-sources.md` | You need namespaces and field paths: customer, event, trigger, objects, relationships, journey attributes, collections, meta keys. |
| `references/troubleshooting.md` | You're diagnosing a symptom, decoding a delivery s

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 6 — file references are metadata, not package contents.

email-love-design-system-migration15.1 KB

View saved version →

---
name: email-love-design-system-migration
description: Audit and migrate an entire legacy email design system or library into an Email Love Figma design system. Use when the user asks to assess migration readiness, inventory legacy email modules, determine source fidelity or scale, create Email Love foundations, convert a legacy library in batches, or migrate templates from Figma, a local folder, cloud storage, or a supported ESP. The source remains read-only and all conversion happens in a separate target Figma file. Do not use for building one campaign email; use email-love-figma-builder for that.
---

# Email Love Design System Migration

Audit a legacy email library from Figma, files, cloud storage, or a supported ESP, establish
its trustworthy foundations, and convert it into a reviewable Email Love design system in a
separate Figma target file.

## Non-negotiable boundaries

- Keep every source read-only at all times. Never edit a source Figma file, local folder,
  cloud folder, ESP template, campaign, automation, or message.
- Build only in a separate target file.
- Never convert an unaudited library.
- Never convert the entire library in one unreviewed pass.
- Never invent Email Love structure from visual intuition. Use the design-converter worker
  and the packaged render rules.
- Never start conversion while required human gates remain unresolved.
- Never present an individual module as a complete design system.

## Which model to run this with

If your environment lets you choose a model tier or reasoning-effort setting, use your
strongest available option for this skill. A migration runs once per customer and holds a
large rule set at once (the render references alone are tens of thousands of tokens); a
dropped rule becomes a component that silently breaks on export later, for someone who was
not in this conversation to catch it. The extra cost is small next to the cost of getting
it wrong. This is a different budget from the routine campaign builds a customer does
afterward against an already-verified design system, where a faster model is usually fine.

## Before doing anything

1. Identify where the source emails live and select the source adapter in Phase 0 (ask only when the request has not already named or linked the source).
2. For a Figma source, confirm the official remote Figma MCP exposes `get_metadata` and
   `get_screenshot`. For conversion, also confirm it exposes `use_figma`.
3. Before calling `use_figma`, read the Figma MCP's current `figma-use` skill or equivalent
   instructions in full.
4. If `use_figma` is missing, limit work to the read-only audit and a precise migration
   report. Do not promise conversion.
5. Confirm whether the user wants:
   - audit only;
   - foundations only after an accepted audit;
   - a specific conversion batch; or
   - the complete staged migration.
6. Obtain the source link, path, folder, or account scope required by the selected adapter.
   For conversion, obtain or create a separate target Figma file link.

Do not ask the user to disable the sandbox or bypass all approvals. Use normal tool
approvals. For unattended work, recommend a trusted isolated environment with narrowly
scoped permissions.

## Load references by phase

Read references completely before acting in the corresponding phase:

- **Audit:** [audit.md](references/audit.md)
- **The selected non-Figma source only:** load its adapter from
  [`references/sources/`](references/sources/)
- **Any run longer than a couple of minutes:** [progress.md](references/progress.md)
- **Conversion entry and gates:** [conversion-overview.md](references/conversion-overview.md)
- **Foundations:** [foundations.md](references/foundations.md)
- **Module batches:** [module-conversion.md](references/module-conversion.md)
- **Before any module transcription, all three render references:**
  - [render-geometry.md](references/render-geometry.md)
  - [render-nodes.md](references/render-nodes.md)
  - [render-components-validati

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 21 — file references are metadata, not package contents.

email-love-figma-builder12 KB

View saved version →

---
name: email-love-figma-builder
description: Build export-ready marketing and lifecycle emails inside Figma using Email Love components or the Email Love design-converter workflow. Use whenever the user asks to create, assemble, draft, convert, or build an email or email campaign in Figma; mentions Email Love, email design systems, mj-wrapper frames, ESP export, or AI Import; shares an email campaign brief with a Figma file; or asks to turn an existing email or Figma comp into an exportable email. Supports both customers with an existing Email Love design system and customers creating their first email without one. Do not use for migrating an entire legacy email design system; use email-love-design-system-migration for that.
---

# Email Love Figma Builder

Build real, export-ready Email Love emails in the user's Figma file. Treat the underlying
Email Love structure as production code: canvas appearance alone does not prove that the
email will export.

## Non-negotiable rule

Never invent Email Love structure from memory.

Structure comes from exactly two places:

- **Path A:** instances of published components from the customer's Email Love design system.
- **Path B:** measured conversion output returned by `emaillove_convert_design` for a
  customer-owned Figma source when that MCP tool is available, otherwise MJML JSON from the
  Email Love design-converter worker. Transcribe either result according to the packaged render
  references.

The only structure created without either source is an empty email root and, when explicitly
required, the narrowly defined `mj-raw` ESP token block. If neither path can produce a
section, stop and ask the user.

## Which model to run this with

The two paths carry very different risk, so if your environment lets you choose a model tier
or reasoning-effort setting, they deserve different budgets.

**Path B, and the design-system-migration skill, deserve your strongest available model.** That
work holds a large rule set at once (the render references alone run tens of thousands of
tokens) and a dropped rule becomes a component that silently breaks on export later, for
someone who was not in this conversation to catch it. This is also work a customer does once,
not daily, so the extra cost is small next to the cost of getting it wrong.

**Path A, once a design system is already synced and verified, is a smaller job.** Instance a
component, load its font, set text, done. A faster or lower-effort model handles routine
campaign builds reliably here, because mistakes are cheap and obvious: wrong copy in a button
is visible the moment you look at it.

## Before doing anything

1. Confirm the official remote Figma MCP exposes `use_figma`, `get_metadata`, and
   `get_screenshot`.
2. Before calling `use_figma`, read the Figma MCP's current `figma-use` skill or equivalent
   instructions in full.
3. If `use_figma` is missing, say that the connection is read-only and do not promise a
   canvas build. Offer:
   - an email plan with copy and subject lines; or
   - for Path B, a converter-assisted handoff where the user pastes the render into Figma
     and runs AI Import in the Email Love plugin.
4. Confirm the Email Love plugin is installed. Path A also requires a synced Email Love
   design system.
5. Check whether the Email Love MCP tools (`emaillove_convert_design`,
   `emaillove_export_figma`, `emaillove_preview_email`) are available, and tell the user in
   one line which of Figma writing, conversion, and export verification this session
   actually has. When they are absent, distinguish an unconfigured server, one awaiting
   authorization, and unavailable tools before prescribing a remedy; a skills-only install
   carries no MCP configuration, so never send it straight to a login command.
6. Treat a request to audit or migrate a whole legacy library as a different job. Use
   `$email-love-design-system-migration`.

Do not ask the user to disable the sandbox or bypass all approvals. Work through

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 8 — file references are metadata, not package contents.

email-love-figma-quality-gates5.51 KB

View saved version →

---
name: email-love-figma-quality-gates
description: Audit an Email Love Figma design-system migration batch or reusable module before it is approved. Use for independent QA, completion review, or regression checks involving mobile icon geometry, real image fills, cropped social icons, component-property semantics, source fidelity, Email Love structure, or differences between the Figma canvas and the Email Love plugin Preview/export. Do not use this skill to build, migrate, or repair the modules themselves; route those tasks to the Email Love Builder, Design System Migration, or Template Repair skill first, then return here for acceptance.
---

# Email Love Figma Quality Gates

Treat this as an independent acceptance layer. The builder's report is evidence to inspect, not proof that a module is ready.

## Route before reviewing

1. A whole library, legacy inventory, foundations, tokens, or several component categories
   is a design-system migration. Use `email-love-design-system-migration` for the work.
2. One new campaign or sequence assembled from an existing library is builder work. Use
   `email-love-figma-builder`.
3. One existing module or template with a rendering defect is repair work. Use
   `email-love-template-repair`.
4. Use this skill after any of those workflows to accept or reject the result.

If scope expands during a build, reroute immediately. Do not let a campaign build silently
turn into a library migration.

## Load only the relevant references

- Read [quality-gates.md](references/quality-gates.md) for every audit.
- Read [snapshot-schema.md](references/snapshot-schema.md) when producing or validating the
  machine-readable audit snapshot.
- Read [run-learnings.md](references/run-learnings.md) when explaining why these gates exist
  or reviewing a similar failure pattern.

## Audit workflow

### 1. Establish the authority

Record the source reference for each module and which design is authoritative. If the
source is missing or ambiguous, return `audit incomplete, missing source authority`. Do not
approve from memory or from a prose build report.

### 2. Enforce the proof batch

Before a normal migration batch, require a proof batch of no more than four modules. Cover
as many of these risk classes as the source contains:

- a full-width or deliberately cropped photo;
- a grouped icon-and-text row;
- a multi-column module with component properties;
- a footer or social-icon row.

Do not release later modules until every proof module passes production desktop and mobile Preview/export. If the exporter is unavailable, stop after the proof batch and request the
human Preview check. Canvas evidence cannot waive this gate.

### 3. Capture an audit snapshot

Create one JSON snapshot using [snapshot-schema.md](references/snapshot-schema.md). Measure
the actual nodes and component-property bindings; do not copy claims from a report. Include
the selected mobile viewports and separate desktop and mobile exporter status.

### 4. Run the structural and geometry validator

```bash
python3 scripts/validate_batch_snapshot.py path/to/audit-snapshot.json
```

Treat every reported error as a failed gate. Warnings need a written disposition. The
validator fails closed: missing inventories, an empty module list, a census mismatch, or a
measurement that is not a finite number are all errors, never silent defaults. It is
deliberately conservative about grouped icons: it subtracts both section and column padding
before comparing the resolved mobile box to the asset's natural width. Documented
render-contract exceptions (top-aligned multi-column axes, bordered-group headroom) are
declared in the snapshot, not waived by the checker. A passing snapshot is snapshot
validation only, never production acceptance.

### 5. Inspect icon and social assets

Export each icon node at 2x as a PNG, then run:

```bash
python3 scripts/check_icon_perimeter.py path/to/icon.png path/to/social-icon.png
```

The check is a heuristic with four outcom

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 6 — file references are metadata, not package contents.

email-love-template-repair11.2 KB

View saved version →

---
name: email-love-template-repair
description: Diagnose and repair an existing Email Love email template or reusable module in Figma when the plugin rejects it, the canvas and export disagree, content flattens into images, Outlook clips text, mobile stacking or spacing is wrong, links or images fail, dark mode breaks, or component properties stop working. Use for targeted repair of Email Love structures that already exist. Do not use to create a new campaign, convert an ordinary Figma comp, or migrate a legacy library; route those to email-love-figma-builder or email-love-design-system-migration.
---

# Email Love Template Repair

Repair the smallest proven defect in an existing Email Love template or module, preserve what
already works, and verify the result through the production exporter before calling it fixed.

## Non-negotiable boundaries

- Diagnose before writing. Reproduce the reported failure and identify the node, breakpoint,
  and mechanism.
- Establish source fidelity before writing. Treat a failure screenshot as symptom evidence unless
  the user explicitly identifies it as the intended design. Name the visual authority and the
  structural authority separately. Never derive intended geometry from the broken canvas when an
  original comp, migration audit, supplied HTML, or approved source render exists.
- Preserve the original. For a campaign template, repair a duplicate unless the user explicitly
  authorizes editing the original. For a library module, ask whether to repair the source component
  in place, which updates its instances, or create a replacement.
- Never detach an instance, rewrite design-system foundations, rename pages or tokens, or clear
  deliberate dark-mode overrides.
- Never build unknown `mj-section`, `mj-column`, or leaf scaffolding from memory. Replace a broken
  component with an intact library instance, or reconstruct converter-built structure strictly from
  the packaged render contract.
- Never treat a clean plugin-data read-back or a good canvas screenshot as proof of a good email.
  Desktop and mobile exporter renders are the arbiter.
- Never say `fixed` when exporter verification is deferred. Say exactly what remains unverified.

## Route the request

Classify the target by MEASURED evidence of Email Love provenance, not by intact markers alone.
Missing or incorrect markers are themselves supported repair defects (see the symptom matrix),
so a damaged template must not be bounced to Builder just because the damage reached its markers.

Intact provenance, route to repair directly:

- A whole email has a root with `nodeType = mainFrame` and Email Love wrappers below it.
- A reusable module is a COMPONENT tagged `mj-wrapper` and carries no `mainFrame` marker.
- An Email Love component instance surfaces its main component's plugin data.

Damaged provenance, still repair: when the root marker is missing, wrong, or misplaced, look for
surviving evidence before rerouting: `mj-*` tags or Email Love plugin data anywhere in the
subtree, an ancestry of wrappers/sections/columns in the Email Love shape, the plugin's display
names, a sibling or main component that carries the data, or the user stating it exported before.
Any of those makes it a broken Email Love template with a marker defect; repair the marker per
the symptom matrix.

No provenance at all, reroute: a frame with zero Email Love tags anywhere, no tagged ancestry,
and no history of exporting is an ordinary comp, however email-shaped it looks. Use
`email-love-figma-builder` for one ordinary Figma comp or new campaign, and
`email-love-design-system-migration` for a legacy library.

Ambiguous provenance: ask the user one focused question (did this ever export through the Email
Love plugin?) or run a focused read-only inspection before any mutation. Do not assume every
email-shaped frame is an Email Love template, and do not mutate anything to settle the question.

## Check the tools

Before promising a repair, confirm the Figma to

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 4 — file references are metadata, not package contents.

hubspot-hubl23.6 KB

View saved version →

---
name: hubspot-hubl
description: Write, review, and debug HubL personalization in HubSpot marketing email — coded templates, custom modules, and programmable email. Use whenever someone writes HubSpot personalization tokens or HubL logic, asks why a token rendered blank, why a filter on a contact token did nothing in an email, or why an email template will not publish, is building crm_object / crm_objects / crm_associations loops, is working with programmable email, single-send API customProperties, smart content, or the CAN-SPAM footer tokens, or shares HubSpot template code to be checked. Trigger on "HubL", "personalization_token", "crm_objects", "isEnabledForEmailV3Rendering", "programmable email", or "Jinjava", even when HubL is not named. HubL is Jinjava, HubSpot's Java fork of Jinja2 — it reads like Jinja2 or Liquid but is neither. HubSpot-only; not for MoEngage Jinja, Braze or Shopify Liquid, or Customer.io. Works on any email HTML, not only Email Love exports; also covers HubSpot emails built in Figma with the Email Love plugin.
---

# HubSpot HubL

HubL is **Jinjava** — *"HubSpot's extension of Jinjava, a templating engine based on Jinja."* A Java reimplementation, not stock Jinja2, and nothing to do with Liquid. HubSpot states plainly that HubL *"uses a fair amount of markup that is unique to HubSpot and does not support all features of Jinja."*

Marketing email is the context where it behaves least like the language it resembles, because of one documented inversion that has no analogue anywhere else.

## The inversion that trips up everyone

From HubSpot's own filters reference:

> *"You can apply HubL filters to personalization tokens, such as contact and company tokens, on HubSpot CMS and blog pages, but **not** in emails."*

So the line every Jinja-trained model writes first is wrong in the one place it matters:

| Where | `{{ contact.firstname\|default("there") }}` | The correct email idiom |
|---|---|---|
| CMS page / blog post | ✅ documented to work | either form |
| **Marketing email** | ❌ **documented not to apply** | `{{ personalization_token("contact.firstname", "there") }}` |

`personalization_token(property, default)` is a **function**, not a filter, and it is the fallback mechanism that survives the email renderer. Fallbacks can also be set outside the code entirely — globally at Settings → Marketing → Email → Personalization, or per-token in the editor's **Fallback value** field.

**HubSpot contradicts itself here**, and you should know it before a user quotes it back at you: the programmable-content guide builds a CRM query in an email out of `"price__lte="~contact.budget_max|int~"&price__gte="~contact.budget_min|int`, applying `|int` to contact tokens in an email template. Both pages are current. Treat the filters-reference rule as the safe one, verify anything that depends on the other with a preview as a dedicated seed or test contact, and say which you assumed.

## The three failure classes

1. **Unknown contact or empty property → renders blank.** No error, and the email still sends. The global default or the token's fallback fires if one is set; otherwise you ship "Hi ,".
2. **Template will not publish.** Missing required CAN-SPAM variables, or a HubL function limit exceeded — *"New emails exceeding the HubL function limit will prompt an error notification in the Review Panel and will not be published."* This is the loud one, and the only one caught before send.
3. **The email is dropped at send, per recipient.** Over the function limit at send time, *"it will be dropped for that email recipient. The web version will return a 500 error if the limit is exceeded."* Not a bounce, not a suppression — the recipient simply gets nothing.

## Reference files

Read the one you need.

| File | Read it when |
|---|---|
| `references/syntax.md` | You need exact tag, filter, or function syntax, operators and expression tests, whitespace and escaping, or the "does not exist in HubL" list. **Read before wri

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 6 — file references are metadata, not package contents.

iterable-handlebars21 KB

View saved version →

---
name: iterable-handlebars
description: Write, review, and debug Handlebars personalization code for Iterable email, SMS, push, in-app, and snippet templates. Use whenever someone writes merge tags or dynamic content for Iterable, asks why a personalization renders blank or shows raw {{curly braces}} in a sent message, is building abandoned-cart or product-recommendation loops over shoppingCartItems, catalogs, collections, or data feeds, needs conditional or date-based content in an Iterable template, hits a HandlebarsExecutionError or an unexplained send skip, or shares an Iterable template snippet and wants it checked. Trigger even when the user just says "Iterable merge tag", "why isn't my first name showing", "dynamic content in Iterable", or pastes Handlebars alongside an Iterable question, without naming Handlebars. Iterable-only — do not use it for Klaviyo, Customer.io, or Braze, which use Liquid-style templating. Works on any email HTML, not only Email Love exports; also covers Iterable emails built in Figma with the Email Love plugin.
---

# Iterable Handlebars

Iterable runs **handlebars.java (jknack)**, not JavaScript Handlebars. Most syntax you know carries over, but the helper set is Iterable's own and several standard idioms are missing. Writing "normal" Handlebars in Iterable is the single most common source of broken templates — so work from the helper reference in this skill rather than from memory.

The stakes are unusual for a templating language: some mistakes render blank, some render as literal `{{curlyBraces}}` in a customer's inbox, and some silently **stop the message from sending at all**. Knowing which failure class you're looking at is most of the debugging work.

## The two jobs

Most requests are one of these. Identify which before you start.

**Authoring** — someone wants dynamic content: a personalized greeting, a cart loop, a conditional block, a countdown, a recommendation grid. Go to [Writing Handlebars](#writing-handlebars).

**Debugging** — something already renders wrong, or the send skipped. Go to [Debugging Handlebars](#debugging-handlebars).

If a request is both ("here's my template, fix it and add X"), debug first — a fix that sits on top of a broken data assumption doesn't hold.

## Reference files

Read the one you need; don't load all three. Each is a lookup table, not a narrative.

| File | Read it when |
|---|---|
| `references/helpers.md` | You need exact helper names, argument order, or named arguments. **Read this before writing any helper you haven't used in this conversation** — argument order varies between helpers and guessing produces code that saves fine and fails at send time. |
| `references/data-sources.md` | You need field paths: user vs event vs profile precedence, `shoppingCartItems` variants, catalogs and collections, data feeds, built-in merge tags, snippets. |
| `references/troubleshooting.md` | You're diagnosing a symptom, decoding a send-skip reason, or want the full failure-mode catalogue. |
| `references/figma-export.md` | The email is being designed in **Figma with the Email Love plugin** and exported from there. **Read before advising on placement** — the nesting rule for paired Code Blocks, the link-field quoting trap, and the specifics of this platform's export target are all Figma-only, and none of them are visible in the plugin's preview. |

---

## Writing Handlebars

### 1. Pin down the data contract first

Handlebars can only render what's actually in scope at send time, and the most common "bug" is code that references a field that was never going to be there. Before writing anything, establish:

- **Where does this field live?** User profile, triggering event, catalog, or data feed. These have different syntax and different precedence.
- **What's the exact field name, including case?** Field names are case-sensitive. `firstName` and `FirstName` are different fields.
- **Can it be missing or empty?** For most real-world lists the honest answer i

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 6 — file references are metadata, not package contents.

klaviyo-django18.6 KB

View saved version →

---
name: klaviyo-django
description: Write, review, and debug personalization code in Klaviyo email, SMS, and push templates. Use this skill whenever someone is writing merge tags, conditionals, or dynamic blocks in Klaviyo, asks why a personalization renders blank or why a template will not preview, is building abandoned-cart or product loops over event data or catalog items, needs conditional show/hide logic or date formatting in a Klaviyo template, hits "Could not parse the remainder" or a skipped send, or shares Klaviyo template code and wants it checked. Trigger on "Klaviyo variable", "Klaviyo personalization", "Klaviyo dynamic block", "event.extra.line_items", or Klaviyo flow and campaign template questions, even when the templating language is not named. Klaviyo-only, and note that Klaviyo uses Django templates, NOT Liquid, so do not apply this skill to Braze, Customer.io, Shopify, or other Liquid platforms. Works on any email HTML, not only Email Love exports; also covers Klaviyo emails built in Figma with the Email Love plugin.
---

# Klaviyo Templating

**Klaviyo runs the Django template language, not Liquid.** This is the single most important fact in this skill, and getting it wrong is the most common way Klaviyo templates break.

Klaviyo's own documentation says so — the developer page is slugged `django_message_design` and links out to the Django built-ins reference. Verified empirically against Klaviyo's render API:

| Written as | Result |
|---|---|
| `{% elsif %}` | **HTTP 400 — hard error.** Django uses `{% elif %}` |
| `{% assign x = 1 %}` | **HTTP 400 — hard error.** No `assign`; use `{% with %}` |
| `{{ items.size }}` | Renders empty. Use `{{ items\|length }}` |
| `{{ p \| lookup: 'Name' }}` | **HTTP 400.** A space after the colon is fatal |

The confusion is understandable and worth explaining to anyone who asks: Klaviyo bolted **Liquid-named filter aliases** (`append`, `prepend`, `upcase`, `downcase`, `truncate`, `plus`, `minus`, `uniq`, `map`) onto a Django engine. The filters read like Liquid; the tags and control flow are Django. So Liquid instincts produce code that looks right and hard-errors.

Treat Klaviyo as: **Django templates + a Klaviyo tag library + a Liquid-named filter alias set.**

## The three failure classes

Klaviyo fails in three distinct ways, and naming the class is most of the debugging:

1. **Missing property → silent blank.** An undefined variable renders as an empty string and the message sends anyway. Inside `{% if %}` it evaluates falsy. Nothing is logged. This is the quiet one, and it's why fallbacks matter.
2. **Malformed tag → the template won't render at all.** Unknown tag, unknown filter, space after a filter colon, unclosed block. Preview shows *"Message displayed without tags or variables"*; the API returns HTTP 400; custom-HTML upload says *"Could not parse the remainder"*. One bad tag replaces the **whole** preview, so every tag in the message shows unfilled — when a user reports that preview warning, connect it to this whole-template behaviour explicitly rather than treating it as a per-tag problem.
3. **Catalog or coupon lookup failure → the send is skipped.** A `{% catalog %}` block that can't find its item skips the entire message. So does a coupon with no codes left. These show under Analytics → Recipient Activity → Other.

## Reference files

Read the one you need. Each is a lookup table.

| File | Read it when |
|---|---|
| `references/syntax.md` | You need exact tag or filter syntax, argument order, or the Django-vs-Liquid mapping. **Read before writing any filter you haven't used in this conversation** — argument shapes are irregular (`find_replace` takes one pipe-delimited string) and a wrong guess hard-errors. |
| `references/data-sources.md` | You need field paths: profile vs event vs organization vs object, and the per-integration cart paths for Shopify, WooCommerce, Magento, BigCommerce. |
| `references/troubleshooting.md` | You're diagnosing a symptom, 

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 6 — file references are metadata, not package contents.

marketo-velocity20.4 KB

View saved version →

---
name: marketo-velocity
description: Write, review, and debug personalization in Adobe Marketo Engage emails — tokens and Velocity email scripting. Use this skill whenever someone is writing Marketo tokens or an Email Script token, asks why a token renders literally or a default value is ignored, is looping over custom objects or opportunities, needs conditional or date-formatted content in a Marketo email, hits a Velocity compile error or an email that fails to send, or shares Marketo template code and wants it checked. Trigger on "Marketo token", "my token", "Velocity", "email script token", "{{lead.", "$lead", "custom object in Marketo", or Marketo email personalization questions even when the mechanism is not named. Marketo Engage only — do not apply it to Salesforce Marketing Cloud, Iterable, Klaviyo, Braze, or Customer.io. Works on any email HTML, not only Email Love exports; also covers Marketo emails built in Figma with the Email Love plugin.
---

# Marketo Engage personalization

Marketo has **two entirely separate personalization systems** that look similar, live in different places, and behave in opposite ways. Almost every Marketo personalization question is really a question about which one applies.

| | **Tokens** | **Velocity email scripting** |
|---|---|---|
| Syntax | `{{lead.First Name}}`, `{{my.X}}` | `$lead.FirstName`, `#if`, `#foreach` |
| What it is | String substitution on a named variable | Apache Velocity template execution |
| Where it lives | Typed inline anywhere in the asset | **Only inside an Email Script My Token** |
| Where it works | Emails, landing pages, snippets, SMS, push, some flow steps, alerts | **Emails only**, invoked via `{{my.token name}}` |
| Logic | None — no conditionals, loops, or math | Full conditionals, loops, math, dates, sorting |
| Data reach | Person, Company, Program Member, Program, Campaign, Trigger, System | Person, **Opportunities, Custom Objects**, Mobile App, `$TriggerObject` |
| Missing-value fallback | `:default=` suffix | `#if`/`#else` — **`:default=` does NOT work** |
| HTML | Values are **auto-encoded** | Output is **NOT encoded** |

**Five things force the switch to Velocity.** Anything else should stay a plain token, because Velocity is materially more fragile:

1. Data from an **opportunity or custom object** — tokens cannot reach these at all.
2. **Conditional content** finer than a Segmentation or Dynamic Content segment.
3. **Looping** over multiple records — order lines, events, product interests.
4. **Computation** — date math, arithmetic, string manipulation, sorting.
5. **Emitting raw HTML** from a field value, since tokens escape it.

There's a sixth in practice: **there is no formatting option on a date token.** `{{lead.SomeDate}}` renders Marketo's stored string. Reformatting a date requires Velocity, and it's one of the most common reasons people end up there.

## The reserved-word trap — affects every Marketo email

This one is worth knowing before anything else, because it breaks emails that contain no scripting at all.

**Every Marketo email is assembled using Velocity under the hood.** So these 13 strings are reserved *anywhere* in an email, including plain body copy and URL fragments:

```
#if  #else  #elseif  #foreach  #end  #set  #define
#macro  #include  #parse  #break  #stop  #evaluate
```

Real breakage: a link to `https://example.com/legal/#end-user-privacy-policy`, or body text reading "all the way to the #end". Both cause fatal validation errors.

**Fixes:** in a URL, percent-encode the first character after `#` — `#end` → `#%65nd`, `#if` → `#%69f`. In visible text, insert a word joiner — `#⁠end`.

If someone reports an email that won't validate and contains no scripting, check for these first.

## Reference files

| File | Read it when |
|---|---|
| `references/tokens.md` | You need the token families, exact names, where each works, `:default=` rules, or My Token scoping and inheritance. |
| `references/velocity.md` | You're

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 6 — file references are metadata, not package contents.

moengage-jinja27.2 KB

View saved version →

---
name: moengage-jinja
description: Write, review, and debug Jinja personalization in MoEngage email campaigns, plus push, SMS, WhatsApp, and on-site messages where the behaviour differs. Use this skill whenever someone is writing MoEngage Jinja, asks why a MoEngage campaign reached fewer users than the segment, says users dropped from a campaign or the message was not sent to some users, is choosing a fallback, is looping a ProductSet or recommendation, or is calling a Content API. Trigger on "MOE_NOT_SEND", "UserAttribute", "EventAttribute", "ProductSet", "ContentApi", "getAuxData", "personalization failed", "After Personalization Removal", or MoEngage campaign personalization questions even when Jinja is not named. MoEngage-only. It looks like stock Jinja2 and like HubSpot HubL, so do not apply it to HubSpot, Braze, or Customer.io, whose namespaces, fallback forms, and null handling are different. Works on any email HTML, not only Email Love exports; also covers MoEngage emails built in Figma with the Email Love plugin.
---

# MoEngage Jinja

MoEngage runs Jinja. The syntax is ordinary Jinja2 and that is exactly the problem, because **one behaviour is not ordinary and it governs everything else**:

> *"In the MoEngage email templates, a message containing a null value will not be sent."*

A missing attribute does not render blank the way it does on almost every other platform. It **removes that user from the send**. No error, no bounce, no delivery row — the campaign just reaches fewer people than the segment, and the difference is invisible unless you go looking for it in the delivery funnel.

So the first question on any MoEngage template is never "what does this render?" It is **"what happens to the users who do not have this attribute?"**

## The rule that decides every template

Every value you print must have a decided answer for null. MoEngage documents **five fallback forms** — three offered by the personalization overlay, two written in Jinja — and a sixth construct, the `MOE_NOT_SEND` tag. They differ in what they do to the send *and* to your reporting:

| Form | Where | On null | Analytics |
|---|---|---|---|
| **No fallback** | UI overlay (type `@`) | Value is removed / substituted with an empty string; message still sends | Nothing |
| **Replace text** | UI overlay | Substituted with your text; message sends | Nothing |
| **Do not send** | UI overlay | Message not sent to that user | Counted under *Personalization Failed* |
| `\|default('Guest')` | Jinja | Substituted with the literal; message sends | Nothing |
| `\|default('MOE_NOT_SEND')` | Jinja | *"will suppress the message from going out"* | Counted under *Personalization Failed*, unlabelled |
| `{% MOE_NOT_SEND("reason") %}` | Jinja | Message not sent to that user | **Your reason string, with a user count, in the Error breakdown** |

There is also `{% if x %}…{% else %}…{% endif %}`, MoEngage's documented alternative to a default — it sends alternative copy rather than suppressing.

**Those rows describe two different mechanisms, not one dial.** A value referenced in **raw Jinja** with nothing decided hits the email null rule: the unresolved null can suppress the message for that user. The email UI's **No fallback** option is a different mechanism on a different surface: it removes the unresolved value and the message **still sends**, as `Hi ,`. The same missing attribute therefore drops the user or ships a blank depending on which surface the token was written on — name both when you explain a fallback choice, and never present one as the default behaviour of the other.

**Reach for `{% MOE_NOT_SEND("reason") %}`.** It is the only form that tells you afterwards *why* a user was dropped. `default('MOE_NOT_SEND')` suppresses the same send and leaves you guessing; "No fallback" ships `Hi ,` to the inbox. Write one `MOE_NOT_SEND` per distinct failure, with independent `{% if %}` blocks rather than an `elif` chain, so the preview pane aggregates all of them

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 6 — file references are metadata, not package contents.

sailthru-zephyr24.6 KB

View saved version →

---
name: sailthru-zephyr
description: Write, review, and debug Zephyr personalization in Zeta Engage by Sailthru — HTML and Visual templates, campaigns, transactional and triggered sends, subject lines, code snippets, hosted pages, and Lifecycle Optimizer. Use whenever someone writes Sailthru template code, asks why a Sailthru email went out empty or never went out at all, is looping over or filtering a data feed, or shares Sailthru template code and wants it checked. Trigger on "Zephyr", "Sailthru template", "content library", "Lifecycle Optimizer", "empty email sent", `{foreach}`, `{if}`, `{* *}`, `assert()`, `cancel()`, `filter_content()`, `personalize()`, or `profile.vars` even when the language is not named. Zephyr and Sailthru only. Do not apply it to Zeta Marketing Platform, whose ZML language is Liquid-derived and uses double braces and percent tags, and do not apply it to Liquid, Handlebars, or Django platforms. Works on any email HTML, not only Email Love exports; also covers Sailthru emails built in Figma with the Email Love plugin.
---

# Sailthru Zephyr

Zephyr is the templating language in **Zeta Engage by Sailthru**. It resembles nothing else in email. Two facts account for most wrong-by-instinct code:

1. **Single braces do everything.** Output, conditionals, loops, assignment, comments: `{name}`, `{if x}…{/if}`, `{foreach content as c}…{/foreach}`, `{x = 1}`, `{* note *}`. There is no `{{ }}`-for-output / `{% %}`-for-logic split, because there are no statement tags at all — a control structure is just an expression in braces.
2. **There is no `|` filter operator.** Zephyr has *functions*, not filters. `{name|upper}` is not a thing. It is `{upper(name)}`. Every Liquid, Django, and Handlebars reflex about pipes produces code that does not run.

Zeta ships a second email platform with a different language. **Zeta Marketing Platform uses ZML**, which is Liquid-derived and uses `{{ }}` and `{% %}`. Nothing in this skill applies there. If the braces are doubled and the tags are `{% %}`, you are not in Zephyr.

## The traps that break templates before any logic does

**A space after the opening brace kills it.** Sailthru's own words: *"Be sure not to include a space immediately following your opening bracket. If you do, your code won't be recognized as Zephyr."* `{ name }` ships as literal text.

**`{single}` vs `{{double}}` is creation time vs send time, not output vs statement.** In *dynamic* mode they behave identically. In *static* mode, single braces evaluate **once, at campaign creation**; double braces evaluate **per user, at send**. Sailthru's example: a static-mode `Hello, {profile.vars.first_name}.` renders `Hello, .` — the profile does not exist yet. Per-user values in a static campaign need `{{ }}`.

**Double quotes are not supported in Email Composer.** *"Use single quotes in Email Composer so your Zephyr renders properly."* Single quotes are the safe default everywhere.

**Line breaks inside a function call are only documented as safe for `personalize()`.** *"Line breaks are supported within the `personalize` function… however, this is not the case for other Zephyr functions."* Keep every other call on one line.

## The three failure classes

1. **A missing variable is falsy, and renders as nothing you can rely on.** *"If a var doesn't exist it will return false"*, so `{if first_name}` works as a guard. What an undefined variable *prints* has no documented general rule — one incidental example shows blank. Use the Elvis operator: `{first_name ?: 'valued customer'}`.
2. **A thin or empty content feed still sends.** Sailthru documents exactly one feed condition that stops a send: a Content Feed configured to *"Return a 404 (not found) error"*, which *"would prevent a scheduled campaign from sending."* The alternative setting, "Go further back in time," explicitly *"return[s] a feed with fewer content items than the minimum."* Nothing stops an email whose loop had nothing to loop over. **This is the singl

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 6 — file references are metadata, not package contents.

sfmc-ampscript21.6 KB

View saved version →

---
name: sfmc-ampscript
description: Write, review, and debug AMPscript, Guide Template Language, and personalization strings in Salesforce Marketing Cloud emails, CloudPages, SMS, and push. Use whenever someone writes SFMC personalization or dynamic content, asks why subscribers show as Errored or NotSent, is building Data Extension lookups or product loops, is working with Journey Builder data bindings, content blocks, or sendable Data Extensions, hits an error code like 100, 103, 104, or 111, or shares SFMC template code and wants it checked. Trigger on "AMPscript", "SFMC", "Marketing Cloud personalization", "LookupRows", "personalization string", "Journey Builder data binding", "%%=", or Salesforce Marketing Cloud email content questions even when the language is not named. Salesforce Marketing Cloud only — do not apply it to Iterable, Klaviyo, Braze, or Customer.io, whose syntax is unrelated. Works on any email HTML, not only Email Love exports; also covers Salesforce Marketing Cloud emails built in Figma with the Email Love plugin.
---

# Salesforce Marketing Cloud personalization

SFMC is the only platform in this family where **a personalization mistake usually means the email is never built at all.** Not a blank space, not a broken link — the subscriber lands in Errored/NotSent, nothing enters the MTA, and it doesn't appear as a bounce. Diagnosing SFMC starts from that fact.

## Three languages, and which one to use

| Language | Delimiters | Use it for |
|---|---|---|
| **AMPscript** | `%%[ ]%%`, `%%=Fn()=%%`, `%%field%%` | Per-subscriber personalization, IF/ELSE, Data Extension lookups, formatting. The default for message content |
| **SSJS** | `<script runat="server">` | Arrays, JSON, try/catch, REST calls with parsing, admin/API work |
| **GTL** | `{{ }}` | Declarative, logic-light templates and cross-channel layouts; iterating a collection into repeated markup |

Salesforce's own guidance: *"AMPscript simply and efficiently handles inline personalization or simple IF ELSE statements"* and *"has a shorter learning curve than SSJS."* Reach for SSJS only when AMPscript genuinely can't do it — arrays, JSON, try/catch. All three coexist in the same content, and GTL can call AMPscript functions and read AMPscript variables.

Most requests are AMPscript. Say so if a user is reaching for SSJS to do something AMPscript handles.

## Two substitution engines — the biggest source of bugs

`%%…%%` and `{{…}}` are resolved by **different systems at different times**, and they follow opposite rules:

| | Personalization strings / AMPscript | Journey Builder data binding |
|---|---|---|
| Syntax | `%%FieldName%%`, `%%=Fn()=%%` | `{{Contact.Attribute.Set.Field}}`, `{{Event.<key>.<field>}}` |
| Resolved by | The email compiler, at send/build time | The Journey Builder engine, **before** the message reaches the compiler |
| Case sensitivity | **Case-INsensitive** | **Case-SENSITIVE** |
| Names with spaces | `[First Name]` (square brackets) | `"Product Name"` (double quotes) |

So `%%firstname%%` and `%%FirstName%%` are the same thing, while `{{Contact.Attribute.Person.firstName}}` and `{{...FirstName}}` are not. Mixing up which rule applies is routine and produces a blank that looks like missing data.

AMPscript cannot evaluate `{{ }}` bindings — the JB engine has already substituted them by the time AMPscript runs.

## The failure classes

1. **Field exists but is null/empty → renders blank, message sends.** This is the benign one.
2. **Field does not exist in the sending context → runtime error, message not built.** Subscriber shows Errored/NotSent. This is why `AttributeValue()` exists.
3. **A function raises → error 100 or 103, message not built.**
4. **`RaiseError()` fires.** With `true` as the second argument it skips only that subscriber; **with the default `false` it stops the entire job.**
5. **Silent exclusion — no error, no delivery, no bounce.** Non-active subscribers, suppression lists, and List Detective all drop rec

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 6 — file references are metadata, not package contents.

zeta-zml21.6 KB

View saved version →

---
name: zeta-zml
description: Write, review, and debug ZML (Zeta Markup Language) personalization in Zeta Marketing Platform email, SMS, and push templates. Use whenever someone writes or pastes ZMP template code, asks why a Zeta campaign errored or why messages were skipped, or is working with {% resources %}, {% recommendation %}, {% event %}, {% feeds %}, {% media_asset %}, {% coupon %}, {% segments %}, or {% skip_message %}. Trigger on "Zeta campaign error", "message skipped", liquid_internal, custom_skip, email_subject_missing, elsif, or a resource query returning wrong rows. Zeta ships two email platforms with different languages; routing matters. This skill is Zeta Marketing Platform (ZMP) and ZML only. Zeta Engage by Sailthru uses Zephyr, whose single-brace {if} and {foreach} syntax has no filters, never route Sailthru here. Not for Shopify, Braze, or Customer.io Liquid, which ZML resembles but is not. Works on any email HTML, not only Email Love exports; also covers Zeta emails built in Figma with the Email Love plugin.
---

# Zeta ZML

## First, confirm which Zeta this is

Zeta Global sells **two email platforms with two unrelated templating languages**, and "we use Zeta" identifies neither.

| Platform | Language | Looks like |
|---|---|---|
| **Zeta Marketing Platform (ZMP)** | **ZML** — this skill | `{{ first_name }}`, `{% if %}`, `{% elsif %}`, filters with `\|` |
| **Zeta Engage by Sailthru** | **Zephyr** | Single-brace `{if …}` / `{foreach …}`, **no filter pipeline** |

If the code you were shown uses single braces, or the person mentions Sailthru, Zeta Engage, or Zephyr, **stop and say so**. Do not "fix" `{if}` into `{% if %}` — that is not a syntax error, it is a different platform, and rewriting it silently converts a working template into a broken one. Name both platforms and ask which they are on. The `sailthru-zephyr` skill covers the other one.

Everything below is ZMP/ZML.

## ZML is a subset of Liquid, and the missing pieces fail silently

ZML *"is based on the open-source template language Liquid created by Shopify."* Objects in `{{ }}`, tags in `{% %}`, filters after `|`. A model that knows Shopify Liquid will write ZML that mostly works — and the parts that do not work rarely announce themselves.

**Three things you must get right before anything else:**

1. **`elsif`.** Zeta states it: *"Note the missing 'e' in `elsif`; it is intentional."* `{% elseif %}` and `{% elif %}` are not ZML tags. This is the single most common way a generated Zeta template ships broken.
2. **Query operators are UPPERCASE, and `{% resources %}` has an allowlist.** *"Lowercase like `after` will be silently dropped."* So is `BETWEEN`. The query runs; the constraint disappears; you get the wrong rows and no error.
3. **Nil renders as nothing.** *"Tags or outputs that return `nil` will not print anything."* A misspelled property and an absent one are indistinguishable at render time. Zeta's own example output is `Hello !`.

## The three failure classes

1. **Silent wrong output.** A dropped operator, a nil value, an empty string that passed a truthiness check, a filter inside `{% global %}` stored as literal text. Nothing is logged. This is most of the work.
2. **Per-recipient errors at generation time.** `liquid_internal` for bad ZML, `email_subject_missing` when the subject line's merge tag resolved to empty. Part of the audience drops; the campaign keeps sending.
3. **Deliberate suppression.** `{% skip_message %}` records a Message Skipped event with `reason = custom_skip` and your `reason_detail`. It fires **before** personalization and it suppresses the **person on every channel in that campaign**.

There is also a fourth surface that is not a send-time failure at all — `liquid_syntax_error` blocks campaign activation. What that check validates is undocumented, so a template that activates is not a template that renders.

## Reference files

Read the one you need.

| File | Read it when |
|---|---|
| `references/syntax.

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 6 — file references are metadata, not package contents.

Package details

Publisher declarations from the archived package. These are separate from our research and the live service's terms.

Package license
MIT
Package author
Email Love
Keywords
See keywords

Declared capabilities

  • Interactive
  • Write

Package observed Nov 21, 2026.

Technical details
First seen
Sep 30, 2026 · 22:02 UTC
Last seen
Nov 21, 2026 · 12:00 UTC
Collection status
Collected

plugins_6a739f43c3b48191b1281a9b2d48b409

Download plugin data (JSON)

Plugin details: freshly prepared. Prepared . Refreshed when plugin data changes or after 6 hours. Your account and Follow status are live.