home / skills / gtmagents / gtm-agents / personalization-logic

personalization-logic skill

safe

/plugins/lead-nurture-orchestration/skills/personalization-logic

This skill helps you tailor dynamic nurture content by mapping personalization tokens to modular blocks across email, in-app, ads, and SDR aids.

npx playbooks add skill gtmagents/gtm-agents --skill personalization-logic

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

1.2 KB

---
name: personalization-logic
description: Use when defining dynamic content rules, tokens, and conditional offers
  inside nurture programs.
---

# Nurture Personalization Logic Skill

## When to Use
- Building dynamic content for lifecycle nurtures.
- Mapping personalization tokens (industry, role, behavior) to copy blocks.
- Coordinating personalization across email, in-app, ads, and SDR assists.

## Framework
1. **Segmentation Inputs** – persona, industry, product usage, lifecycle stage, engagement history.
2. **Content Blocks** – hero, proof, CTA, offer modules with variants per segment.
3. **Token Management** – define data sources, fallback values, formatting rules.
4. **Testing Plan** – structure A/B/C tests for personalization depth.
5. **Governance** – approval workflows, localization, compliance, expirations.

## Templates
- Personalization matrix (segment vs module vs asset).
- Token dictionary (field, source, fallback, formatting).
- QA checklist (seed records, fallback coverage, compliance notes).

## Tips
- Start with modular blocks so ops can update without rewriting entire emails.
- Document dependencies on upstream data hygiene.
- Pair with `copywriting` + `design` teams for brand consistency.

---

Overview

This skill defines robust personalization logic for nurture programs, including dynamic content rules, tokens, and conditional offers. It helps teams map segments to modular content blocks and coordinate personalization across email, in-app, ads, and SDR workflows. The goal is consistent, testable, and governable personalization that scales without breaking copy or brand.

How this skill works

The skill inspects segmentation inputs (persona, industry, lifecycle stage, usage, engagement) and maps them to content block variants like hero, proof, CTA, and offer modules. It enforces token management rules: data sources, fallbacks, and formatting, and produces templates for personalization matrices, token dictionaries, and QA checklists. It also generates a testing plan for A/B/C experiments and governance steps for approvals, localization, compliance, and expirations.

When to use it

Building dynamic emails, in-app messages, or ad creatives that change by persona or behavior.
Mapping personalization tokens (industry, role, account signals) to copy and assets.
Coordinating consistent personalization across channels and SDR outreach.
Setting up testing plans to validate personalization depth and performance.
Defining governance and expiration rules for time-bound offers and claims.

Best practices

Design modular content blocks so updates can be made without rewriting full messages.
Maintain a token dictionary with source, fallback, and formatting rules to avoid runtime errors.
Document upstream data dependencies and quality requirements before launching personalization.
Pair personalization rules with copywriting and design reviews for consistent brand voice.
Include QA seeds and fallback coverage in every release to catch missing data scenarios.

Example use cases

Serve a different hero image and CTA copy to enterprise vs. SMB segments based on industry token.
Switch offers dynamically for users who reached a usage milestone, using tokenized thresholds.
Localize subject lines and body copy by country token while preserving global compliance notes.
Run A/B/C tests to compare shallow (persona-only) vs. deep (behavior + usage) personalization.

FAQ

How do I handle missing token data?

Define explicit fallback values and formatting rules in the token dictionary and include seed records in QA to validate fallback behavior.

What degree of personalization should I start with?

Start modular and shallow: persona + lifecycle stage, then iterate to add behavior and usage tokens after validating data quality.