Ready to supercharge your AI agents?

Install any skill in seconds. Free to start, no credit card required.

Churn Prevention · sickn33 | DecimalAI

Sales & Supportby sickn33

Churn Prevention

Reduce voluntary and involuntary churn with cancel flows, save offers, dunning, win-back tactics, and retention strategy.

Maintained

SkillScore

SkillScore87/100

Test results 87

Safety

3/3 safety checks passed

Code scan
Intent
Content

What it changes

70%87%of test cases passed +17 pts

Without skill16 of 23

With skill20 of 23

5 fixed15 passed either way2 still failing1 broke

Measured on gemini-3.6-flash8/8/2026v1 · latest is v2

This benchmark measured an earlier version of the skill.

Track record

Agent runs: 0; All time

See one task, with and without the skill

One test taskA user selects 'Not using the app enough right now' during cancellation. We want to allow them to pause their account for up to 12 months. What constraints and notifications should we set for our pause feature?

Without the skillMissed

With the skillPassed

Same model, same task. Answers are capped and redacted.

Use this skill

Your agent runs on

Adds every file the skill has, pinned so you can update it. No account needed.

pip install "decimalai>=0.15"
decimalai skills add sickn33-churn-prevention
claude --plugin-dir "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.agents"

The same install from Python, for a notebook or a setup script.

Install

pip install "decimalai>=0.15"

Add the skill

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("sickn33-churn-prevention")
if result.exit_code:
    raise SystemExit(result.problems)

print("Added. Start Claude Code with the command below.")

Start Claude Code with it

claude --plugin-dir "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.agents"

Type these in a Claude Code session. No account or API key. It writes the skill and any files it bundles, and asks first when its safety rating isn't Passed.

Add the DecimalAI plugin, once

/plugin marketplace add decimal-labs/decimalai-claude-plugins
/plugin install decimalai@decimalai

Install this skill

/decimalai:install sickn33-churn-prevention

The plugin needs python3 and curl on your machine.

No Python or account. Claude Code picks it up in its next session.

Save it into your project

curl -fsSL --create-dirs -o .claude/skills/sickn33-churn-prevention/SKILL.md https://app.decimal.ai/s/sickn33-churn-prevention/SKILL.md

Copy SKILL.md

Save it in your project, as

.claude/skills/sickn33-churn-prevention/SKILL.md

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Claude Code docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[claude-agent-sdk]"
decimalai skills add sickn33-churn-prevention

Add it to your agent

import asyncio

from claude_agent_sdk import ClaudeAgentOptions
from decimalai.claude_agent_sdk import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

async def main():
    question = "Hello!"
    async with support.run(question) as run:  # one user message, one run
        async for message in run.query(options=ClaudeAgentOptions(max_turns=6)):
            print(message)

# In a notebook or async code: await main()
asyncio.run(main())

Prefer its own loader? ClaudeAgentOptions(plugins=[skills_plugin()], skills="all") reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[claude-agent-sdk]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("sickn33-churn-prevention")
if result.exit_code:
    raise SystemExit(result.problems)

import asyncio

from claude_agent_sdk import ClaudeAgentOptions
from decimalai.claude_agent_sdk import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

async def main():
    question = "Hello!"
    async with support.run(question) as run:  # one user message, one run
        async for message in run.query(options=ClaudeAgentOptions(max_turns=6)):
            print(message)

# In a notebook or async code: await main()
asyncio.run(main())

Prefer its own loader? ClaudeAgentOptions(plugins=[skills_plugin()], skills="all") reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/sickn33-churn-prevention/SKILL.md

Give it to your agent

import asyncio
from pathlib import Path
from claude_agent_sdk import ClaudeAgentOptions, query

skill = Path(".agents/skills/sickn33-churn-prevention/SKILL.md").read_text()
options = ClaudeAgentOptions(system_prompt=f"You are a helpful agent.\n\n{skill}", max_turns=6)

async def main():
    async for message in query(prompt="Hello!", options=options):
        print(message)

# In a notebook or async code: await main()
asyncio.run(main())

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Claude Agent SDK docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[openai-agents]"
decimalai skills add sickn33-churn-prevention

Add it to your agent

from agents import Agent, Runner
from decimalai.openai_agents import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    name=support.name,
    instructions=support.instructions,  # your prompt, then the skill list
    tools=[*support.tools],             # your tools, then load_skill
)
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")

Using SandboxAgent? capabilities=[Shell(), decimalai.openai_agents.sandbox_skills()] points its own loader at the same folder.

Install

pip install "decimalai[openai-agents]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("sickn33-churn-prevention")
if result.exit_code:
    raise SystemExit(result.problems)

from agents import Agent, Runner
from decimalai.openai_agents import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    name=support.name,
    instructions=support.instructions,  # your prompt, then the skill list
    tools=[*support.tools],             # your tools, then load_skill
)
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")

Using SandboxAgent? capabilities=[Shell(), decimalai.openai_agents.sandbox_skills()] points its own loader at the same folder.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/sickn33-churn-prevention/SKILL.md

Give it to your agent

from pathlib import Path
from agents import Agent, Runner

skill = Path(".agents/skills/sickn33-churn-prevention/SKILL.md").read_text()
agent = Agent(name="support", instructions=f"You are a helpful agent.\n\n{skill}")
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

OpenAI Agents docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[openai]"
decimalai skills add sickn33-churn-prevention

Add it to your agent

import json

from openai import OpenAI
from decimalai.openai import agent_config

client = OpenAI()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your tools, as Chat Completions takes them, and what answers each.
TOOLS = [{"type": "function", "function": {
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters": {"type": "object", "properties": {"order_id": {"type": "string"}},
                   "required": ["order_id"]},
}}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    # run.system is your prompt, then the skill list.
    messages = [{"role": "system", "content": run.system}, run.message]
    while True:
        reply = client.chat.completions.create(
            model="gpt-5.4-mini",
            messages=messages,
            tools=[*TOOLS, *run.tools],  # your tools, then load_skill
        ).choices[0].message
        messages.append(reply)
        if not reply.tool_calls:
            break
        for call in reply.tool_calls:
            # load_skill is answered by the run; your own tools by FUNCTIONS.
            function = FUNCTIONS.get(call.function.name)
            messages.append(run.tool_result(call) or {
                "role": "tool", "tool_call_id": call.id,
                "content": function(**json.loads(call.function.arguments)) if function
                else f"There is no tool named {call.function.name!r}.",
            })
print(reply.content)

# The Responses API takes run.response_tools instead of run.tools.

Install

pip install "decimalai[openai]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("sickn33-churn-prevention")
if result.exit_code:
    raise SystemExit(result.problems)

import json

from openai import OpenAI
from decimalai.openai import agent_config

client = OpenAI()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your tools, as Chat Completions takes them, and what answers each.
TOOLS = [{"type": "function", "function": {
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters": {"type": "object", "properties": {"order_id": {"type": "string"}},
                   "required": ["order_id"]},
}}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    # run.system is your prompt, then the skill list.
    messages = [{"role": "system", "content": run.system}, run.message]
    while True:
        reply = client.chat.completions.create(
            model="gpt-5.4-mini",
            messages=messages,
            tools=[*TOOLS, *run.tools],  # your tools, then load_skill
        ).choices[0].message
        messages.append(reply)
        if not reply.tool_calls:
            break
        for call in reply.tool_calls:
            # load_skill is answered by the run; your own tools by FUNCTIONS.
            function = FUNCTIONS.get(call.function.name)
            messages.append(run.tool_result(call) or {
                "role": "tool", "tool_call_id": call.id,
                "content": function(**json.loads(call.function.arguments)) if function
                else f"There is no tool named {call.function.name!r}.",
            })
print(reply.content)

# The Responses API takes run.response_tools instead of run.tools.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/sickn33-churn-prevention/SKILL.md

Give it to your agent

from pathlib import Path
from openai import OpenAI

client = OpenAI()
skill = Path(".agents/skills/sickn33-churn-prevention/SKILL.md").read_text()
reply = client.chat.completions.create(
    model="gpt-5.4-mini",
    messages=[
        {"role": "system", "content": f"You are a helpful agent.\n\n{skill}"},
        {"role": "user", "content": "Hello!"},
    ],
).choices[0].message

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

OpenAI SDK docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[anthropic]"
decimalai skills add sickn33-churn-prevention

Add it to your agent

import anthropic
from decimalai.anthropic import agent_config

client = anthropic.Anthropic()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

question = "Hello!"
with support.run(question) as run:  # one user message, one run
    answer = client.beta.messages.tool_runner(
        model="claude-haiku-5-5",
        max_tokens=4096,
        system=run.system,     # your prompt, then the skill list
        tools=[*run.tools],    # your tools, then load_skill
        messages=[{"role": "user", "content": question}],
    ).until_done()

Install

pip install "decimalai[anthropic]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("sickn33-churn-prevention")
if result.exit_code:
    raise SystemExit(result.problems)

import anthropic
from decimalai.anthropic import agent_config

client = anthropic.Anthropic()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

question = "Hello!"
with support.run(question) as run:  # one user message, one run
    answer = client.beta.messages.tool_runner(
        model="claude-haiku-5-5",
        max_tokens=4096,
        system=run.system,     # your prompt, then the skill list
        tools=[*run.tools],    # your tools, then load_skill
        messages=[{"role": "user", "content": question}],
    ).until_done()

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/sickn33-churn-prevention/SKILL.md

Give it to your agent

from pathlib import Path
import anthropic

client = anthropic.Anthropic()
skill = Path(".agents/skills/sickn33-churn-prevention/SKILL.md").read_text()
reply = client.messages.create(
    model="claude-haiku-5-5",
    max_tokens=4096,
    system=f"You are a helpful agent.\n\n{skill}",
    messages=[{"role": "user", "content": "Hello!"}],
)

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Anthropic docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[google-genai]"
decimalai skills add sickn33-churn-prevention

Add it to your agent

from google import genai
from google.genai import types
from decimalai.google_genai import agent_config

client = genai.Client()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your functions, as declarations for the model, and what answers each.
TOOLS = [{"function_declarations": [{
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters_json_schema": {"type": "object", "properties": {"order_id": {"type": "string"}},
                               "required": ["order_id"]},
}]}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    config = types.GenerateContentConfig(
        system_instruction=run.system,     # your prompt, then the skill list
        tools=[*TOOLS, *run.tool_params],  # your functions, then load_skill
    )
    contents = [{"role": "user", "parts": [{"text": run.message}]}]
    while True:
        response = client.models.generate_content(
            model="gemini-3.5-flash", contents=contents, config=config,
        )
        if not response.function_calls:
            break
        contents.append(response.candidates[0].content)
        parts = []
        for call in response.function_calls:
            # load_skill is answered by the run; your own functions by FUNCTIONS.
            # A loop of your own rather than automatic function calling, which
            # raises KeyError when the model asks for a function you did not pass.
            function = FUNCTIONS.get(call.name)
            parts.append(run.tool_result(call) or {"function_response": {
                "name": call.name, "id": call.id,
                "response": {"result": function(**(call.args or {})) if function
                             else f"There is no function named {call.name!r}."},
            }})
        contents.append({"role": "user", "parts": parts})
print(response.text)

Install

pip install "decimalai[google-genai]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("sickn33-churn-prevention")
if result.exit_code:
    raise SystemExit(result.problems)

from google import genai
from google.genai import types
from decimalai.google_genai import agent_config

client = genai.Client()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your functions, as declarations for the model, and what answers each.
TOOLS = [{"function_declarations": [{
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters_json_schema": {"type": "object", "properties": {"order_id": {"type": "string"}},
                               "required": ["order_id"]},
}]}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    config = types.GenerateContentConfig(
        system_instruction=run.system,     # your prompt, then the skill list
        tools=[*TOOLS, *run.tool_params],  # your functions, then load_skill
    )
    contents = [{"role": "user", "parts": [{"text": run.message}]}]
    while True:
        response = client.models.generate_content(
            model="gemini-3.5-flash", contents=contents, config=config,
        )
        if not response.function_calls:
            break
        contents.append(response.candidates[0].content)
        parts = []
        for call in response.function_calls:
            # load_skill is answered by the run; your own functions by FUNCTIONS.
            # A loop of your own rather than automatic function calling, which
            # raises KeyError when the model asks for a function you did not pass.
            function = FUNCTIONS.get(call.name)
            parts.append(run.tool_result(call) or {"function_response": {
                "name": call.name, "id": call.id,
                "response": {"result": function(**(call.args or {})) if function
                             else f"There is no function named {call.name!r}."},
            }})
        contents.append({"role": "user", "parts": parts})
print(response.text)

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/sickn33-churn-prevention/SKILL.md

Give it to your agent

from pathlib import Path
from google import genai
from google.genai import types

client = genai.Client()
skill = Path(".agents/skills/sickn33-churn-prevention/SKILL.md").read_text()
response = client.models.generate_content(
    model="gemini-3.5-flash",
    contents="Hello!",
    config=types.GenerateContentConfig(system_instruction=f"You are a helpful agent.\n\n{skill}"),
)

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Gemini API docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[langchain]" langchain-openai
decimalai skills add sickn33-churn-prevention

Add it to your agent

from langchain.agents import create_agent
from decimalai.langchain import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = create_agent(
    "openai:gpt-5.4-mini",
    tools=[],                         # your tools; the middleware adds load_skill
    middleware=[support.middleware],  # your prompt, the skill list and load_skill
)
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

Install

pip install "decimalai[langchain]" langchain-openai

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("sickn33-churn-prevention")
if result.exit_code:
    raise SystemExit(result.problems)

from langchain.agents import create_agent
from decimalai.langchain import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = create_agent(
    "openai:gpt-5.4-mini",
    tools=[],                         # your tools; the middleware adds load_skill
    middleware=[support.middleware],  # your prompt, the skill list and load_skill
)
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/sickn33-churn-prevention/SKILL.md

Give it to your agent

from pathlib import Path
from langchain.agents import create_agent

skill = Path(".agents/skills/sickn33-churn-prevention/SKILL.md").read_text()
agent = create_agent("openai:gpt-5.4-mini", tools=[], system_prompt=f"You are a helpful agent.\n\n{skill}")
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

LangChain docs

CrewAI's own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" "crewai>=1.15.27"
decimalai skills add sickn33-churn-prevention

Add it to your agent

import decimalai.crewai
from crewai import Agent, Crew, Task

agent = Agent(
    role="Support", goal="Help the customer", backstory="A support agent.",
    llm=llm,                               # your own CrewAI LLM
    skills=decimalai.crewai.skills(),      # the installed folder
    tools=decimalai.crewai.skill_tools(),  # reads a skill's files, runs its scripts
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()

The same install from Python, for a notebook or a setup script. CrewAI's own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" "crewai>=1.15.27"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("sickn33-churn-prevention")
if result.exit_code:
    raise SystemExit(result.problems)

import decimalai.crewai
from crewai import Agent, Crew, Task

agent = Agent(
    role="Support", goal="Help the customer", backstory="A support agent.",
    llm=llm,                               # your own CrewAI LLM
    skills=decimalai.crewai.skills(),      # the installed folder
    tools=decimalai.crewai.skill_tools(),  # reads a skill's files, runs its scripts
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()

No DecimalAI package. CrewAI's own loader reads the folder, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/sickn33-churn-prevention/SKILL.md

Give it to your agent

from pathlib import Path
from crewai import Agent, Crew, Task

agent = Agent(
    role="Support", goal="Help the customer", backstory="A support agent.",
    llm=llm,                         # your own CrewAI LLM
    skills=[Path(".agents/skills")],
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

CrewAI docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[adk]"
decimalai skills add sickn33-churn-prevention

Add it to your agent

from decimalai.adk import DecimalAIPlugin, agent_config
from google.adk.agents import LlmAgent
from google.adk.apps import App

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = LlmAgent(
    name="support",          # ADK needs a Python identifier
    model="gemini-3.5-flash",
    instruction=support.instruction,  # your prompt, then the skill list
    tools=[*support.tools],           # your tools, then load_skill
)
# DecimalAIPlugin makes each invocation of runners built from this App one trace.
app = App(name="support", root_agent=agent, plugins=[DecimalAIPlugin()])

Prefer ADK's own loader? SkillToolset(skills=decimalai.adk.skills(), ...) reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

Install

pip install "decimalai[adk]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("sickn33-churn-prevention")
if result.exit_code:
    raise SystemExit(result.problems)

from decimalai.adk import DecimalAIPlugin, agent_config
from google.adk.agents import LlmAgent
from google.adk.apps import App

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = LlmAgent(
    name="support",          # ADK needs a Python identifier
    model="gemini-3.5-flash",
    instruction=support.instruction,  # your prompt, then the skill list
    tools=[*support.tools],           # your tools, then load_skill
)
# DecimalAIPlugin makes each invocation of runners built from this App one trace.
app = App(name="support", root_agent=agent, plugins=[DecimalAIPlugin()])

Prefer ADK's own loader? SkillToolset(skills=decimalai.adk.skills(), ...) reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/sickn33-churn-prevention/SKILL.md

Give it to your agent

from pathlib import Path
from google.adk.agents import LlmAgent

skill = Path(".agents/skills/sickn33-churn-prevention/SKILL.md").read_text()
agent = LlmAgent(
    name="support",
    model="gemini-3.5-flash",
    instruction=lambda context: f"You are a helpful agent.\n\n{skill}",
)

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Google ADK docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[pydantic-ai]"
decimalai skills add sickn33-churn-prevention

Add it to your agent

from pydantic_ai import Agent
from decimalai.pydantic_ai import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    "openai:gpt-4o-mini",
    name=support.name,
    tools=[],                 # your tools; the capability adds load_skill
    capabilities=[support],   # your prompt, the skill list and load_skill
)
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")

On the Pydantic AI harness, decimalai.pydantic_ai_harness.skills(project) uses its own loader instead.

Install

pip install "decimalai[pydantic-ai]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("sickn33-churn-prevention")
if result.exit_code:
    raise SystemExit(result.problems)

from pydantic_ai import Agent
from decimalai.pydantic_ai import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    "openai:gpt-4o-mini",
    name=support.name,
    tools=[],                 # your tools; the capability adds load_skill
    capabilities=[support],   # your prompt, the skill list and load_skill
)
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")

On the Pydantic AI harness, decimalai.pydantic_ai_harness.skills(project) uses its own loader instead.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/sickn33-churn-prevention/SKILL.md

Give it to your agent

from pathlib import Path
from pydantic_ai import Agent

skill = Path(".agents/skills/sickn33-churn-prevention/SKILL.md").read_text()
agent = Agent("openai:gpt-4o-mini", instructions=f"You are a helpful agent.\n\n{skill}")
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Pydantic AI docs

Deep Agents' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" deepagents
decimalai skills add sickn33-churn-prevention

Add it to your agent

import decimalai.deepagents
from deepagents import create_deep_agent

agent = create_deep_agent(model=model, **decimalai.deepagents.skills())
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

The default backend reads files but has no shell. To run a skill's scripts, pass skills(backend=LocalShellBackend(...)).

The same install from Python, for a notebook or a setup script. Deep Agents' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" deepagents

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("sickn33-churn-prevention")
if result.exit_code:
    raise SystemExit(result.problems)

import decimalai.deepagents
from deepagents import create_deep_agent

agent = create_deep_agent(model=model, **decimalai.deepagents.skills())
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

The default backend reads files but has no shell. To run a skill's scripts, pass skills(backend=LocalShellBackend(...)).

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/sickn33-churn-prevention/SKILL.md

Give it to your agent

from pathlib import Path
from deepagents import create_deep_agent

skill = Path(".agents/skills/sickn33-churn-prevention/SKILL.md").read_text()
agent = create_deep_agent(model=model, system_prompt=f"You are a helpful agent.\n\n{skill}")
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Deep Agents docs

Its own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" agent-framework
decimalai skills add sickn33-churn-prevention

Add it to your agent

import asyncio

from agent_framework import Agent
from decimalai.agent_framework import skills

agent = Agent(client=client, instructions="You are a helpful agent.", context_providers=[skills()])
asyncio.run(agent.run("Hello!"))

It caches skills by default, so restart the process after decimalai skills update.

The same install from Python, for a notebook or a setup script. Its own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" agent-framework

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("sickn33-churn-prevention")
if result.exit_code:
    raise SystemExit(result.problems)

import asyncio

from agent_framework import Agent
from decimalai.agent_framework import skills

agent = Agent(client=client, instructions="You are a helpful agent.", context_providers=[skills()])
asyncio.run(agent.run("Hello!"))

It caches skills by default, so restart the process after decimalai skills update.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/sickn33-churn-prevention/SKILL.md

Give it to your agent

import asyncio
from pathlib import Path
from agent_framework import Agent

skill = Path(".agents/skills/sickn33-churn-prevention/SKILL.md").read_text()
agent = Agent(client=client, instructions=f"You are a helpful agent.\n\n{skill}")
asyncio.run(agent.run("Hello!"))

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Microsoft Agent Framework docs

Strands' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" strands-agents
decimalai skills add sickn33-churn-prevention

Add it to your agent

from decimalai.strands import skills
from strands import Agent
from strands.vended_tools import file_editor, shell

agent = Agent(
    model=model,                # always pass one: the default is Amazon Bedrock
    system_prompt="You are a helpful agent.",
    tools=[file_editor, shell],
    plugins=[skills()],
)
agent("Hello!")

Strands loads an agent's skills once, so build the agent again after decimalai skills update.

The same install from Python, for a notebook or a setup script. Strands' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" strands-agents

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("sickn33-churn-prevention")
if result.exit_code:
    raise SystemExit(result.problems)

from decimalai.strands import skills
from strands import Agent
from strands.vended_tools import file_editor, shell

agent = Agent(
    model=model,                # always pass one: the default is Amazon Bedrock
    system_prompt="You are a helpful agent.",
    tools=[file_editor, shell],
    plugins=[skills()],
)
agent("Hello!")

Strands loads an agent's skills once, so build the agent again after decimalai skills update.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/sickn33-churn-prevention/SKILL.md

Give it to your agent

from pathlib import Path
from strands import Agent

skill = Path(".agents/skills/sickn33-churn-prevention/SKILL.md").read_text()
agent = Agent(model=model, system_prompt=f"You are a helpful agent.\n\n{skill}")
agent("Hello!")

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Strands docs

Adds every file the skill has, pinned so you can update it. Cursor, Copilot, Cline and Warp read this folder by themselves.

pip install "decimalai>=0.15"
decimalai skills add sickn33-churn-prevention

No Python or account. Cursor, Copilot, Cline and Warp read this folder by themselves.

Save it into your project

curl -fsSL --create-dirs -o .agents/skills/sickn33-churn-prevention/SKILL.md https://app.decimal.ai/s/sickn33-churn-prevention/SKILL.md

Copy SKILL.md

Save it in your project, as

.agents/skills/sickn33-churn-prevention/SKILL.md

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Cursor and other editors docs

Fetch the file and give its text to your model as instructions. No account or package needed.

Get the file

curl -fsSL https://app.decimal.ai/s/sickn33-churn-prevention/SKILL.md

Read the summary as JSON

curl -fsSL https://app.decimal.ai/s/sickn33-churn-prevention.json

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Other setups docs

You don't need a DecimalAI account.

Version: v2 (v1 tested 8/8/2026)
Source: sickn33/antigravity-awesome-skills ↗
License: MIT

Manage it in DecimalAI

Saved prompts and skills, pinned versions, and traces of this skill in your runs. DecimalAI does not run your agent.

Claude Code reads files from your project, so DecimalAI config does not apply there.

On Claude Agent SDK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On OpenAI Agents: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On OpenAI SDK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Anthropic: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Gemini API: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On LangChain: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On CrewAI: set DECIMAL_API_KEY and add decimalai.init(crewai=True) to record runs and skill use. The skill version stays in your repo.

On Google ADK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Pydantic AI: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Deep Agents: set DECIMAL_API_KEY and add decimalai.init(langchain=True) to record runs and skill use. The skill version stays in your repo.

On Microsoft Agent Framework: set DECIMAL_API_KEY and add decimalai.init(otel=True, agent_name="support") to record runs and skill use. The skill version stays in your repo.

On Strands: set DECIMAL_API_KEY and add decimalai.init(otel=True, agent_name="support") to record runs and skill use. The skill version stays in your repo.

Editors read files from your project, so DecimalAI config does not apply there.

Anywhere else: record a use with decimalai.log_skill_activation() inside a trace.

Use this skill

SKILL.md

Churn Prevention

You are an expert in SaaS retention and churn prevention. Your goal is to help reduce both voluntary churn (customers choosing to cancel) and involuntary churn (failed payments) through well-designed cancel flows, dynamic save offers, proactive retention, and dunning strategies.

When to Use

Use when churn is rising or cancellation behavior needs intervention.
Use when designing cancel flows, save offers, dunning, or retention programs.
Use when the user wants to reduce either voluntary or involuntary churn.

Before Starting

Check for product marketing context first: If .agents/product-marketing-context.md exists (or .claude/product-marketing-context.md in older setups), read it before asking questions. Use that context and only ask for information not already covered or specific to this task.

Gather this context (ask if not provided):

1. Current Churn Situation

What's your monthly churn rate? (Voluntary vs. involuntary if known)
How many active subscribers?
What's the average MRR per customer?
Do you have a cancel flow today, or does cancel happen instantly?

2. Billing & Platform

What billing provider? (Stripe, Chargebee, Paddle, Recurly, Braintree)
Monthly, annual, or both billing intervals?
Do you support plan pausing or downgrades?
Any existing retention tooling? (Churnkey, ProsperStack, Raaft)

3. Product & Usage Data

Do you track feature usage per user?
Can you identify engagement drop-offs?
Do you have cancellation reason data from past churns?
What's your activation metric? (What do retained users do that churned users don't?)

4. Constraints

B2B or B2C? (Affects flow design)
Self-serve cancellation required? (Some regulations mandate easy cancel)
Brand tone for offboarding? (Empathetic, direct, playful)

How This Skill Works

Churn has two types requiring different strategies:

Type	Cause	Solution
Voluntary	Customer chooses to cancel	Cancel flows, save offers, exit surveys
Involuntary	Payment fails	Dunning emails, smart retries, card updaters

Measure voluntary and payment-related churn in your own subscriber cohorts; their shares vary by product and payment mix.

This skill supports three modes:

Build a cancel flow — Design from scratch with survey, save offers, and confirmation
Optimize an existing flow — Analyze cancel data and improve save rates
Set up dunning — Failed payment recovery with retries and email sequences

Cancel Flow Design

The Cancel Flow Structure

An optional retention flow can follow this sequence, with a direct cancellation path available throughout:

Trigger → Survey → Dynamic Offer → Confirmation → Post-Cancel

Step 1: Trigger Customer clicks "Cancel subscription" in account settings.

Step 2: Exit Survey Offer an optional, skippable reason question. A customer must be able to complete cancellation without answering or seeing offers.

Step 3: Dynamic Save Offer Present a targeted offer based on their reason (discount, pause, downgrade, etc.)

Step 4: Confirmation If they still want to cancel, confirm clearly with end-of-billing-period messaging.

Step 5: Post-Cancel Set expectations, offer easy reactivation path, trigger win-back sequence.

Exit Survey Design

The exit survey is the foundation. Good reason categories:

Reason	What It Tells You
Too expensive	Price sensitivity, may respond to discount or downgrade
Not using it enough	Low engagement, may respond to pause or onboarding help
Missing a feature	Product gap, show roadmap or workaround
Switching to competitor	Competitive pressure, understand what they offer
Technical issues / bugs	Product quality, escalate to support
Temporary / seasonal need	Usage pattern, offer pause
Business closed / changed	Unavoidable, learn and let go gracefully
Other	Catch-all, include free text field

Survey best practices:

1 question, single-select with optional free text
5-8 reason options max (avoid decision fatigue)
Put most common reasons first (review data quarterly)
Don't make it feel like a guilt trip
"Help us improve" framing works better than "Why are you leaving?"

Dynamic Save Offers

The key insight: match the offer to the reason. A discount won't save someone who isn't using the product. A feature roadmap won't save someone who can't afford it.

Offer-to-reason mapping:

Cancel Reason	Primary Offer	Fallback Offer
Too expensive	Discount (20-30% for 2-3 months)	Downgrade to lower plan
Not using it enough	Pause (1-3 months)	Free onboarding session
Missing feature	Roadmap preview + timeline	Workaround guide
Switching to competitor	Competitive comparison + discount	Feedback session
Technical issues	Escalate to support immediately	Credit + priority fix
Temporary / seasonal	Pause subscription	Downgrade temporarily
Business closed	Skip offer (respect the situation)	—

Save Offer Types

Discount

Treat 20-30% off for 2-3 months as a test hypothesis, subject to margin and customer fairness
Avoid 50%+ discounts (trains customers to cancel for deals)
State genuine eligibility and duration; never invent an expiring offer to pressure cancellation
Show the dollar amount saved, not just the percentage

Pause subscription

1-3 month pause maximum (longer pauses rarely reactivate)
Measure pause return and subsequent paid retention; no universal return rate is established here
Disclose exact resume date, price and charging behavior; obtain agreement and send advance notice
Keep their data and settings intact

Plan downgrade

Offer a lower tier instead of full cancellation
Show what they keep vs. what they lose
Position as "right-size your plan" not "downgrade"
Easy path back up when ready

Feature unlock / extension

Unlock a premium feature they haven't tried
Extend trial of a higher tier
Works best for "not getting enough value" reasons

Personal outreach

For high-value accounts (top 10-20% by MRR)
Route to customer success for a call
Personal email from founder for smaller companies

Cancel Flow UI Patterns

┌─────────────────────────────────────┐
│  We're sorry to see you go          │
│                                     │
│  What's the main reason you're      │
│  cancelling?                        │
│                                     │
│  ○ Too expensive                    │
│  ○ Not using it enough              │
│  ○ Missing a feature I need         │
│  ○ Switching to another tool        │
│  ○ Technical issues                 │
│  ○ Temporary / don't need right now │
│  ○ Other: [____________]            │
│                                     │
│  [Continue]                         │
│  [Never mind, keep my subscription] │
└─────────────────────────────────────┘
         ↓ (selects "Too expensive")
┌─────────────────────────────────────┐
│  What if we could help?             │
│                                     │
│  We'd love to keep you. Here's a    │
│  special offer:                     │
│                                     │
│  ┌───────────────────────────────┐  │
│  │  25% off for the next 3 months│  │
│  │  Save $XX/month               │  │
│  │                               │  │
│  │  [Accept Offer]               │  │
│  └───────────────────────────────┘  │
│                                     │
│  Or switch to [Basic Plan] at       │
│  $X/month →                         │
│                                     │
│  [No thanks, continue cancelling]   │
└─────────────────────────────────────┘

UI principles:

Keep the "continue cancelling" option visible (no dark patterns)
One primary offer + one fallback, not a wall of options
Show specific dollar savings, not abstract percentages
Use the customer's name and account data when possible
Mobile-friendly (many cancellations happen on mobile)

For detailed cancel flow patterns by industry and billing provider, see references/cancel-flow-patterns.md.

Churn Prediction & Proactive Retention

The best save happens before the customer ever clicks "Cancel."

Risk Signals

Track these leading indicators of churn:

Signal	Risk Level	Timeframe
Login frequency drops 50%+	High	2-4 weeks before cancel
Key feature usage stops	High	1-3 weeks before cancel
Support tickets spike then stop	High	1-2 weeks before cancel
Email open rates decline	Medium	2-6 weeks before cancel
Billing page visits increase	High	Days before cancel
Team seats removed	High	1-2 weeks before cancel
Data export initiated	Critical	Days before cancel
NPS score drops below 6	Medium	1-3 months before cancel

Health Score Model

Build an illustrative health score (0-100) from normalized 0-100 signals. Calibrate weights/thresholds against later churn on held-out cohorts, handle missing data explicitly and avoid sensitive/proxy profiling:

Health Score = (
  Login frequency score × 0.30 +
  Feature usage score   × 0.25 +
  Support sentiment     × 0.15 +
  Billing health        × 0.15 +
  Engagement score      × 0.15
)

Score	Status	Action
80-100	Healthy	Upsell opportunities
60-79	Needs attention	Proactive check-in
40-59	At risk	Intervention campaign
0-39	Critical	Personal outreach

Proactive Interventions

Before they think about cancelling:

Trigger	Intervention
Usage drop >50% for 2 weeks	"We noticed you haven't used [feature]. Need help?" email
Approaching plan limit	Upgrade nudge (not a wall — paywall-upgrade-cro handles this)
No login for 14 days	Re-engagement email with recent product updates
NPS detractor (0-6)	Personal follow-up within 24 hours
Support ticket unresolved >48h	Escalation + proactive status update
Annual renewal in 30 days	Value recap email + renewal confirmation

Involuntary Churn: Payment Recovery

Measure the failed-payment share and recovery by failure reason using your own data.

The Dunning Stack

Pre-dunning → Smart retry → Dunning emails → Grace period → Hard cancel

Pre-Dunning (Prevent Failures)

Card expiry alerts: Email 30, 15, and 7 days before card expires
Backup payment method: Prompt for a second payment method at signup
Card updater services: Visa/Mastercard auto-update programs (availability and issuer participation vary)
Pre-billing notification: Email 3-5 days before charge for annual plans

Smart Retry Logic

Not all failures are the same. Retry strategy by decline type:

Decline Type	Examples	Retry Strategy
Soft decline (temporary)	Insufficient funds, processor timeout	Retry 3-5 times over 7-10 days
Hard decline (permanent)	Card stolen, account closed	Don't retry — ask for new card
Authentication required	3D Secure, SCA	Send customer to update payment

Retry timing best practices:

Retry 1: 24 hours after failure
Retry 2: 3 days after failure
Retry 3: 5 days after failure
Retry 4: 7 days after failure (with dunning email escalation)
After 4 retries: Hard cancel with reactivation path

Retry implementation: Follow the provider's current decline and network rules. Stripe Smart Retries chooses timing; it does not guarantee same-day-of-month scheduling. Avoid duplicate custom retries alongside provider retries; use idempotency and event deduplication.

Dunning Email Sequence

Email	Timing	Tone	Content
1	Day 0 (failure)	Friendly alert	"Your payment didn't go through. Update your card."
2	Day 3	Helpful reminder	"Quick reminder — update your payment to keep access."
3	Day 7	Urgency	"Your account will be paused in 3 days. Update now."
4	Day 10	Final warning	"Last chance to keep your account active."

Dunning email best practices:

Use the provider's hosted payment-update session or a short-lived, scoped secure link; authorize the correct billing account and never expose card details in URLs
Show what they'll lose (their data, their team's access)
Don't blame ("your payment failed" not "you failed to pay")
Include support contact for help
Plain text performs better than designed emails for dunning

Illustrative Recovery Targets

The table below is an unsourced planning example, not an industry benchmark. Replace it with comparable product cohorts, a fixed recovery window and a unique-invoice denominator.

Metric	Poor	Average	Good
Soft decline recovery	<40%	50-60%	70%+
Hard decline recovery	<10%	20-30%	40%+
Overall payment recovery	<30%	40-50%	60%+
Pre-dunning prevention	None	10-15%	20-30%

For the complete dunning playbook with provider-specific setup, see references/dunning-playbook.md.

Metrics & Measurement

Key Churn Metrics

Targets below are illustrative hypotheses. Exclude newly acquired customers from beginning-of-period logo churn; net revenue churn must include contraction and expansion from that same starting cohort. Measure retained saves at a fixed later paid horizon; an offer click or abandoned cancel session is not a retained customer.

Metric	Formula	Target
Monthly churn rate	Churned customers / Start-of-month customers	<5% B2C, <2% B2B
Revenue churn (net)	(Churned MRR + Contraction MRR - Expansion MRR) / Starting-cohort MRR	Negative (net expansion)
Cancel flow save rate	Saved / Total cancel sessions	25-35%
Offer acceptance rate	Accepted offers / Shown offers	15-25%
Pause reactivation rate	Reactivated / Total paused	60-80%
Dunning recovery rate	Recovered / Total failed payments	50-60%
Signal-to-cancel lag	Days from first churn signal to cancel	Track trend

Cohort Analysis

Segment churn by:

Acquisition channel — Which channels bring stickier customers?
Plan type — Which plans churn most?
Tenure — When do most cancellations happen? (30, 60, 90 days?)
Cancel reason — Which reasons are growing?
Save offer type — Which offers work best for which segments?

Cancel Flow A/B Tests

Test one variable at a time:

Test	Hypothesis	Metric
Discount % (20% vs 30%)	Higher discount saves more	Save rate, LTV impact
Pause duration (1 vs 3 months)	Longer pause increases return rate	Reactivation rate
Survey placement (before vs after offer)	Survey-first personalizes offers	Save rate
Offer presentation (modal vs full page)	Full page gets more attention	Save rate
Copy tone (empathetic vs direct)	Empathetic reduces friction	Save rate

How to run cancel flow experiments: Use the ab-test-setup skill to design statistically rigorous tests. PostHog is a good fit for cancel flow experiments — its feature flags can split users into different flows server-side, and its funnel analytics track each step of the cancel flow (survey → offer → accept/decline → confirm).

Common Mistakes

Unmeasured retention offers — Direct cancellation is a valid design. Test optional offers against later paid retention, margin, complaints and time needed to cancel.
Making cancellation hard to find — Hidden cancel buttons breed resentment and bad reviews. Check applicable current consumer and auto-renewal requirements; the FTC's 2024 amended rule was vacated in July 2025, as documented in its March 2026 notice
Same offer for every reason — A blanket discount doesn't address "missing feature" or "not using it"
Discounts too deep — 50%+ discounts train customers to cancel-and-return for deals
Ignoring involuntary churn — Measure its share and address recoverable failures
No dunning emails — Letting payment failures silently cancel accounts
Guilt-trip copy — "Are you sure you want to abandon us?" damages brand trust
Not tracking save offer LTV — A "saved" customer who churns 30 days later wasn't really saved
Pausing too long — Choose pause limits from your own customer needs and return data.
No post-cancel path — Make reactivation easy and trigger win-back emails, because some churned users will want to come back

Before any live billing changes or customer messages, confirm the exact approved account, audience, offer terms and scope. Drafts and analysis do not authorize sending campaigns, charging cards, changing subscriptions or granting discounts. Keep payment/behavior data minimal, respect opt-outs and disclose data retention accurately. Provider tables below are discovery aids, not live-verified feature guarantees.

Tool Integrations

For implementation, use the billing, analytics, and experimentation tools available in the current environment.

Retention Platforms

Tool	Best For	Key Feature
Churnkey	Full cancel flow + dunning	Adaptive offer workflows; verify current plan/features
ProsperStack	Cancel flows with analytics	Advanced rules engine, Stripe/Chargebee integration
Raaft	Simple cancel flow builder	Easy setup, good for early-stage
Chargebee Retention	Chargebee customers	Native integration, was Brightback

Billing Providers (Dunning)

Provider	Smart Retries	Dunning Emails	Card Updater
Stripe	Built-in (Smart Retries)	Built-in	Automatic
Chargebee	Built-in	Built-in	Via gateway
Paddle	Built-in	Built-in	Managed
Recurly	Built-in	Built-in	Built-in
Braintree	Manual config	Manual	Via gateway

Related CLI Tools

Tool	Use For
`stripe`	Subscription management, dunning config, payment retries
`customer-io`	Dunning email sequences, retention campaigns
`posthog`	Cancel flow A/B tests via feature flags, funnel analytics
`mixpanel` / `ga4`	Usage tracking, churn signal analysis
`segment`	Event routing for health scoring

Related Skills

email-sequence: For win-back email sequences after cancellation
paywall-upgrade-cro: For in-app upgrade moments and trial expiration
pricing-strategy: For plan structure and annual discount strategy
onboarding-cro: For activation to prevent early churn
analytics-tracking: For setting up churn signal events
ab-test-setup: For testing cancel flow variations with statistical rigor

Limitations

Use this skill only when the task clearly matches the scope described above.
Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

When it activates

Automatically, when a task matches. Use when users are cancelling, failed payments are rising, or subscription retention needs improvement.

About this skill

Automatic

Customer Success pack

SkillSafety

✓ 3 of 3 passed

Code scan15 of 15 checks clean

0 critical · 0 warning · 0 info — scanner v8 — 11/8/2026

View 15 scanner checks

live_secretremote_code_executionreverse_shelldata_exfiltrationssrf_metadataagent_snoopinganti_refusaldestructive_commandsobfuscated_unicodeunicode_homoglyphopaque_blobsuspicious_urltool_overreachtrigger_abuseprompt_injection_phrasing

IntentSafe

LLM judge · does the skill do what it claims

ContentClean

LLM judge · policy & harmful-content review

Source

Imported

sickn33 / antigravity-awesome-skills

skills/churn-prevention/SKILL.md

View on GitHub ↗

License MITImported 11/8/2026Version v2Bundled 2 files

Illustrative Want to see what sickn33/churn-prevention would put in front of your model? Preview the rendered body and check its trigger phrases — no LLM call, no signup.

Other skills for the same job

Published skills whose descriptions closely match this one, with their headline benchmark lift.

Related skills

Skills that do similar work, with their headline benchmark lift.

From the same source and nearby in the catalogue.

Ready to supercharge your AI agents?

SkillScore

Safety

What it changes

Track record

Use this skill

Churn Prevention

When to Use

Before Starting

1. Current Churn Situation

2. Billing & Platform

3. Product & Usage Data

4. Constraints

How This Skill Works

Cancel Flow Design

The Cancel Flow Structure

Exit Survey Design

Dynamic Save Offers

Save Offer Types

Cancel Flow UI Patterns

Churn Prediction & Proactive Retention

Risk Signals

Health Score Model

Proactive Interventions

Involuntary Churn: Payment Recovery

The Dunning Stack

Pre-Dunning (Prevent Failures)

Smart Retry Logic

Dunning Email Sequence

Illustrative Recovery Targets

Metrics & Measurement

Key Churn Metrics

Cohort Analysis

Cancel Flow A/B Tests

Common Mistakes

Tool Integrations

Retention Platforms

Billing Providers (Dunning)

Related CLI Tools

Related Skills

Limitations

When it activates

SkillSafety

Source

Other skills for the same job

Related skills

More in the registry