Klaviyo Flows Written by Claude Code: Welcome, Abandon, Winback Templates (2026)

You can generate a complete Klaviyo lifecycle email program in Claude Code with one command. EcomKit's /ecom flows writes the full flow architecture — triggers, splits, exit conditions — then produces all five core flows (welcome, abandoned-cart, browse-abandon, post-purchase, winback) with subject lines, preview text, full body copy, and CTAs in your brand voice. The output is structured flow documents you build directly in Klaviyo, not vague email ideas. Total cost: roughly 46K tokens for 15 emails plus SMS, in about 18 minutes.

What are the five Klaviyo flows EcomKit generates?

Lifecycle email is where DTC stores leave the most money on the table. Not because the flows are technically hard, but because writing five well-structured sequences with correct triggers, proper segmentation, and good copy is genuinely time-consuming. EcomKit ships each flow as a dedicated skill, so /ecom flows is not improvising from a blank slate.

The five core flows:

1. Welcome — First-purchase nurture series for new subscribers, with offer logic tuned to the first-timer segment.
2. Abandoned-cart — Three-touch cart sequence with escalating urgency. Exits when the profile places an order.
3. Browse-abandon — For visitors who viewed a product but never added to cart. Lighter touch than cart abandonment.
4. Post-purchase — Order confirmation, shipping update, delivery check-in, and a timed review request across four emails.
5. Winback — Lapsed-customer reactivation segmented by recency: 60-day cold, 90-day very cold, 180-day at-risk.

Each flow skill carries a measured token cost (counted with a tiktoken-compatible counter at ~4 chars/token). The welcome skill runs ~820 tokens, abandoned-cart ~780, browse-abandon ~640, post-purchase ~760, winback ~720. These numbers print in your terminal when you install EcomKit — no guessing at context costs.

Supporting skills add more capability: segment-targeting defines entry and suppression logic per flow, and sms-flow-copy adds compliant SMS at the cart and winback steps if your store has SMS consent.

Why does flow architecture have to come before copy?

The single most important design choice in /ecom flows is that flow architecture is defined before any copy gets written. The reason is straightforward: the structure — which trigger fires which flow, how profiles split, when someone exits — determines whether copy lands at the right moment for the right person.

The command starts with a flow-architecture step (~1,100 tokens) that locks in:

• Triggers — what event starts each flow. Checkout-started fires the cart flow. Viewed-product fires browse-abandon. Fulfilled-order fires post-purchase.
• Splits — behavioral branches. First-timer vs. repeat vs. lapsed. SMS-consented vs. email-only.
• Exit conditions — when a profile leaves a flow. Placing an order exits the cart flow so you stop sending urgency emails to someone who already bought.

Only after architecture is set does copy get written. That sequencing is why the welcome series knows it is writing for a brand-new subscriber and the winback knows it is targeting someone who has not purchased in 90 days. Copy without this scaffolding is generic. Copy inside it is targeted.

What does a generated flow document actually contain?

The output for each flow type goes into out/flows/<type>/ with three files per flow:

out/flows/welcome/messages.md     ← every email: subject, preview, body, CTA
out/flows/welcome/triggers.md     ← trigger event + timing per message
out/flows/welcome/segments.md     ← entry and suppression segment definitions

messages.md for the welcome flow contains the actual copy you paste into Klaviyo, message by message. For a three-email welcome series that means three subject lines with scored alternates, preview text, full body copy in your brand voice, and a CTA per email. triggers.md specifies the entry event and wait step before each message. segments.md defines who enters and who is suppressed.

The copy reads in your voice because EcomKit's bootstrap (/ecom flows reads STORE.md, CATALOG.md, and CUSTOMER.md) runs once and every copy step references those files. The welcome email references your actual brand tone and product line. You set the voice once; every flow inherits it.

How does the /ecom flows command orchestrate from start to finish?

Here is the literal orchestration sequence when you run /ecom flows all --platform klaviyo:

1. store-onboarder confirms CUSTOMER.md segments (first-timer, repeat, lapsed).
   Blocking — nothing runs until segments exist.
 
2. flow-architecture + segment-targeting run.
   Defines triggers, splits, and exit conditions.
   Blocking — no copy until structure is locked.
 
3. email-copywriter writes all five flows in parallel:
   welcome-flow, abandoned-cart-flow, browse-abandon-flow,
   post-purchase-flow, winback-flow.
   sms-flow-copy writes SMS for cart and winback steps in parallel.
 
4. email-subject-lab scores subject/preview-line variants per message.
 
5. Every message is verified against a quality threshold.
   Any message below 90 loops back for a revision pass (max 3 per flow).
 
6. Output: out/flows/<type>/messages.md, triggers.md, segments.md.

Step 3 fans out all five flows simultaneously, which is why the runtime stays around 18 minutes for 15 emails. Sequential writing would take much longer. Step 5 is what makes the output shippable rather than a rough draft — each message is scored and iterated before the command exits.

The published EcomKit workflow makes the scale honest: a DTC founder with zero automations runs one command; the architecture step designs the full program; copywriting fans out across all five flows; and the verification pass gates every individual message. Final output: 15 emails plus SMS, ready to build in Klaviyo's editor.

Can you generate just one flow instead of the full program?

Yes. The command accepts a single flow type:

/ecom flows abandoned-cart --platform klaviyo

This runs the same orchestration scoped to one flow. Useful when you already have a welcome series and only need the cart sequence, or when you want to iterate on one flow's copy without regenerating the rest. The architecture step still runs because the system needs to know the cart flow's triggers and exit conditions, but the fan-out and verification pass apply only to that flow's messages.

You can also regenerate a single flow after changing your STORE.md — useful after a rebrand, a pricing change, or a new product launch that shifts the offer logic.

How does EcomKit compare to writing Klaviyo flows manually or using other AI tools?

Here is an honest comparison across the most common approaches:

The key difference versus generic AI prompting is context. EcomKit's bootstrap writes STORE.md once and every skill reads it. There is no re-explaining your brand voice, product catalog, or customer segments across sessions. The architecture step also produces triggers and exit conditions that generic prompting tends to skip, leaving you with copy but no structural plan.

The key difference versus Klaviyo's native AI is portability. The generated documents exist outside Klaviyo, so you can version-control them, adapt them for other platforms (Omnisend, Postscript), and repurpose the copy in other channels.

Where does /ecom flows sit in EcomKit?

EcomKit is the ecommerce operations kit in ClaudeKit's 2026 lineup — 20 commands, 3 skills, 2 read-only agents, 16,464 measured tokens. It covers the full operational spine of a store: catalog and PDPs, Amazon listings, ads, lifecycle email, cart recovery, reviews, margins, and the diagnostic /ecom no-sales command that triages a store against AOV-band benchmarks.

The complete v2 ClaudeKit lineup across all five kits:

EcomKit's agents are read-only specialists — a store auditor and a copy reviewer. They observe and report; they do not orchestrate or block the pipeline. The command always ends with evidence: the structured flow documents in out/flows/. That is the artifact contract. See the ecom operations manual for a deeper look at the full EcomKit command set.

How do you install EcomKit and run your first flow?

EcomKit installs through the claudekits CLI (v0.1.3 on npm) or via the Claude Code plugin marketplace.

Via CLI:

npm install -g claudekits
ck auth <your-license-key>
ck install ecom

The install prints a token ledger showing every skill's context cost. You can recount at any time with ck tokens ecom and diagnose issues with ck doctor.

Via plugin marketplace:

/plugin marketplace add Madni-Aghadi/claudekit-ecom

After install, bootstrap your store context first (this is the step most people skip and then wonder why the copy sounds generic):

/ecom flows all --platform klaviyo

If STORE.md, CATALOG.md, and CUSTOMER.md do not exist, the store-onboarder step prompts you through creating them before writing a single word of copy. This takes 5-10 minutes and pays off across every subsequent EcomKit command.

EcomKit pricing: $14.99/month for the single kit, $29.99/month Pro (any 3 kits, swap one per cycle), $49.99/month All-Access, or $99 one-time lifetime for EcomKit as shipped. All plans include a 14-day refund window and 3 device licenses. See the pricing page for the full breakdown.

FAQ

Does EcomKit connect directly to my Klaviyo account?

No, and the command does not pretend otherwise. /ecom flows generates flow documents — message copy, trigger specs, and segment definitions — that you build in Klaviyo's editor directly. The --platform klaviyo flag tunes the output structure to Klaviyo's trigger/split/exit model so the documents map cleanly onto it. You paste the copy; you set the delays; you build the flow. There is currently no direct API integration with Klaviyo.

Which flows does EcomKit generate and can I add more?

The five core flows are welcome, abandoned-cart, browse-abandon, post-purchase, and winback. You can generate all five with all or one at a time by naming the type. There is also a replenishment-flow skill for consumable products if your catalog needs reorder reminders. Custom flow types are not supported by default, but you can run /ecom flows on a specific type and then manually edit the output documents to adjust the structure.

Is the generated copy actually usable or just a starting outline?

It is usable copy, not an outline. Every message has a subject line with scored alternates, preview text, full body copy, and a CTA, all written from your STORE.md voice file. The verification pass scores each message and loops back on anything below 90, max three iterations per flow. You will still review offers against your margins and review for brand nuance, but the copy is structured and complete when the command exits.

How much does generating a full lifecycle program cost in tokens?

A complete 15-email program with SMS runs approximately 46K tokens in about 18 minutes, based on the published EcomKit workflow. Individual skill costs range from around 440 tokens for subject-line scoring to 1,100 tokens for flow architecture. You can see per-skill costs before running anything with ck tokens ecom. There are no hidden multipliers — the token ledger from ck install ecom shows the full context budget.

Can I use EcomKit for platforms other than Klaviyo?

The --platform flag currently supports Klaviyo and Omnisend. The underlying flow documents (triggers, splits, exits, copy) are platform-agnostic enough to adapt to other ESPs manually, but the structured trigger naming and segment syntax in the output files are tuned to Klaviyo by default. Postscript support for the SMS layer is on the roadmap.

Do I need the full EcomKit or can I just use the flows commands?

EcomKit installs as a unit — you get all 20 commands together. The ck install ecom command installs everything, and you use only what you need. There is no partial install for just the flows commands. Given that a single lifecycle program run pays for several months of the kit subscription in saved copywriting time, most users find the full kit worth having even if they start with just /ecom flows.

If you run a DTC store and want to get your full lifecycle email program built in a single working session, EcomKit is the fastest path. The five flows, the architecture step, the brand voice integration, and the structured output are all built in — you bring the license key and the store context.

For a broader look at what EcomKit covers beyond lifecycle email — including Amazon listings, ad copy, and the store triage command — read the Claude Code ecommerce operations manual. If you run a creator business alongside your store, the YouTube script architecture post covers MarketingKit's approach to long-form content in a similar pattern.