Marketing Psychology

Name: Marketing Psychology
Author: borghei

borghei/claude-skills

115 installs
451 repo stars
Updated July 21, 2026
borghei/claude-skills

marketing-psychology is a skill that applies behavioral psychology and 70+ mental models to diagnose marketing barriers and prescribe testable changes to copy, pricing, and campaigns.

About

This skill applies behavioral psychology, cognitive biases, and a catalog of 70+ mental models to marketing. It diagnoses behavioral barriers, prescribes relevant principles, and turns them into concrete, testable changes to landing pages, pricing, email, copy, and ads. It ships Python tools that audit copy and pricing pages for persuasion principles and cognitive biases. Marketers use it to diagnose why an asset is underperforming and apply persuasion techniques ethically.

Diagnoses behavioral barriers and prescribes 2-3 matching principles from a catalog of 70+ mental models
Turns psychology into testable changes to landing pages, pricing, email, copy, and ads
Ships Python auditors for persuasion principles, cognitive biases, and pricing psychology

Marketing Psychology by the numbers

115 all-time installs (skills.sh)
Ranked #426 of 853 Sales & Marketing skills by installs in the Skillselion catalog
Data as of Aug 5, 2026 (Skillselion catalog sync)

At a glance

marketing-psychology capabilities & compatibility

Capabilities: conversion optimization · persuasion audit · pricing psychology · copywriting
Use cases: marketing · copywriting
Pricing: Free

From the docs

What marketing-psychology says it does

The skill diagnoses behavioral barriers, prescribes 2-3 relevant principles from a catalog of 70+ mental models, and turns them into concrete, testable changes to landing pages, pricing, email, copy,

SKILL.md

npx skills add https://github.com/borghei/claude-skills --skill marketing-psychology

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/borghei/claude-skills/marketing-psychology.svg)](https://skillselion.com/skills/borghei/claude-skills/marketing-psychology)

Installs	115
repo stars	★ 451
Last updated	July 21, 2026
Repository	borghei/claude-skills ↗

What it does

Diagnose why a marketing asset underperforms and apply behavioral-psychology principles as testable changes.

Who is it for?

Marketers optimizing conversion who need a behavioral root-cause diagnosis and matching persuasion principles.

Skip if: Academic psychology research, clinical applications, or A/B test statistical analysis tools.

When should I use this skill?

A page, pricing tier, email, or ad underperforms and you need a behavioral diagnosis, or you are designing a pricing page.

What you get

Produces a behavioral diagnosis with 2-3 matched principles turned into specific, testable asset changes.

Behavioral diagnosis
Prescribed persuasion principles
Testable asset changes

By the numbers

Catalog of 70+ mental models
Prescribes 2-3 relevant principles per diagnosis
Three Python tools: persuasion auditor, cognitive bias checker, pricing psychology analyzer

Files

SKILL.mdMarkdownGitHub ↗

Marketing Psychology

Applied behavioral science for marketing — identifying which psychological principles apply to specific challenges and showing exactly how to implement them. The skill diagnoses behavioral barriers, prescribes 2-3 relevant principles from a catalog of 70+ mental models, and turns them into concrete, testable changes to landing pages, pricing, email, copy, and ads.

Core Capabilities

Behavioral diagnosis — map the decision journey, identify barriers (cognitive load, choice paralysis, trust deficit, friction), and prescribe matching principles
Mental model catalog — 70+ principles across buyer psychology, persuasion/influence, pricing, design/UX, and growth
Application by challenge — principle-by-principle playbooks for landing pages, pricing pages, email, churn reduction, and ad creative
Pricing & conversion frameworks — three-tier/decoy pricing design, the trust cascade, the micro-commitment ladder
Copy techniques — loss vs. gain framing, specificity bias, future pacing
Ethical application — the persuasion/manipulation line, anti-dark-pattern boundaries, A/B testing discipline

When to Use

A page, pricing tier, email, or ad is underperforming and you need a behavioral root-cause diagnosis
You are designing or optimizing a pricing page (anchoring, decoy, charm pricing, tier structure)
You want to apply psychology to copy or campaign creative with specific, testable changes
You need to audit existing assets for missing persuasion principles or dark patterns

Quick Start

Diagnose Why Something Is Not Converting

1. Identify the desired behavior (click, buy, share, return) 2. Identify the current friction (too many choices, unclear value, no urgency) 3. Map the visitor's emotional state (excited, skeptical, confused, impatient) 4. Match to applicable principles from references/mental-models.md 5. Implement 2-3 principle-based changes with specific execution

Apply Psychology to a Marketing Asset

1. Select the asset (landing page, pricing page, email, ad) 2. Review the applicable psychology in references/application-playbooks.md 3. Choose 3-5 principles to apply 4. Implement each with the specific technique described 5. Measure the impact through A/B testing

References

Load the reference that matches the task — keep this file lean and pull detail on demand:

[references/mental-models.md](references/mental-models.md) — full catalog of 70+ principles (buyer psychology, persuasion, pricing, design/UX, growth) with definitions and marketing applications. Read when matching a barrier to the principle that addresses it.
[references/application-playbooks.md](references/application-playbooks.md) — behavioral diagnosis workflows, principle-by-challenge tables (landing pages, pricing, email, churn, ads), pricing framework, trust cascade, micro-commitment ladder, and copy techniques. Read when diagnosing a problem or applying psychology to an asset.
[references/ethics-and-quality.md](references/ethics-and-quality.md) — ethical guidelines (persuasion vs. manipulation), best practices, troubleshooting table, and success criteria. Read when judging whether a technique is ethical or hardening an implementation.

Python Automation Tools

`scripts/persuasion_auditor.py` — audits copy for Cialdini's 7 principles plus behavioral economics techniques; flags what's applied and what's missing.
`scripts/cognitive_bias_checker.py` — identifies cognitive biases leveraged (or missed) in copy, pricing pages, and landing pages.
`scripts/pricing_psychology_analyzer.py` — analyzes pricing page structure for anchoring, decoy effect, charm pricing, framing, and tier design.

python scripts/persuasion_auditor.py page.html
python scripts/cognitive_bias_checker.py pricing_page.html --json
python scripts/pricing_psychology_analyzer.py pricing.json

Scope & Limitations

In Scope: Behavioral psychology principles applied to marketing, conversion optimization, pricing strategy, copy improvement, campaign design. 70+ mental models with implementation guides.

Out of Scope: Academic psychology research, clinical applications, UX research methodology (use product-team), A/B test statistical analysis tools, consumer psychology outside marketing context.

Limitations: Psychology provides hypotheses, not certainties. All changes must be A/B tested. What works for consumer SaaS may not work for enterprise. Cultural context matters significantly. Principles should be applied ethically — persuasion that helps customers make good decisions, not manipulation.

Integration Points

Copywriting — Apply psychological principles when writing page copy (headlines, CTAs, objection handling).
Landing Page Generator — Use psychology to guide page structure and section ordering.
Paid Ads — Apply ad-specific psychology (mere exposure, contrast effect, curiosity gap) to creative.
Pricing — Apply pricing psychology (anchoring, decoy, charm pricing) to pricing page design.
Copy Editing — Use the Heightened Emotion sweep to apply psychology during editorial review.
Marketing Context — Understanding customer psychology informs positioning and messaging strategy.

Application Playbooks

Read this when diagnosing a specific conversion problem or applying psychology to an asset — covers the behavioral diagnosis workflows, principle-by-challenge tables (landing pages, pricing, email, churn, ads), the pricing framework, the conversion playbook, and copy techniques.

Core Workflows

Workflow 1: Behavioral Diagnosis

When something is not converting, diagnose through a behavioral lens:

Step 1: Map the Decision Journey

Stage	What Visitor Does	What Visitor Feels	Potential Barriers
Arrival	Lands on page	Curious or skeptical	No immediate value recognition
Evaluation	Reads content	Interested or confused	Too much information, unclear benefits
Comparison	Considers alternatives	Analytical	No differentiation visible
Decision	Approaches CTA	Hesitant	Risk perception, friction, objections
Action	Clicks/purchases	Committed or uncertain	Form complexity, hidden costs, trust deficit

Step 2: Identify Behavioral Barriers

For each stage, check for these barrier types:

Barrier Type	Description	Example
Cognitive load	Too much to process	15 pricing options, walls of text
Choice paralysis	Too many options	6 plans with unclear differences
Loss aversion	Fear of making wrong choice	No guarantee, no trial, no refund
Trust deficit	Not enough credibility	No social proof, no named testimonials
Status quo bias	Effort of switching feels too high	No migration support, complex setup
Friction	Too many steps to complete action	Long forms, mandatory account creation

Step 3: Prescribe Principles

Match each barrier to the psychological principle that addresses it. See the Mental Model Catalog (references/mental-models.md).

Workflow 2: Principle Application

Step 1: Select 3-5 Relevant Principles

Do not apply every principle at once. Select the 3-5 most relevant to the specific challenge.

Step 2: Implement Concretely

For each principle, define:

Where on the page/flow it applies
What specific change to make
What the expected behavioral impact is

Step 3: Test and Measure

Every psychology-based change should be A/B tested:

Hypothesis: "Applying [principle] to [element] will increase [metric] because [behavioral reason]"
Test duration: minimum 14 days or 1,000 visitors per variant
Success metric: conversion rate, click rate, or engagement rate

Application by Marketing Challenge

Landing Page Not Converting

Principle	Where to Apply	Specific Change
Loss Aversion	Headline	Frame as what they lose without you, not what they gain
Social Proof	Below hero	Customer count, logos, or star rating visible above fold
Anchoring	Near CTA	Show the value they get vs. the price they pay
Hick's Law	Navigation	Remove all navigation links — one page, one CTA
Cognitive Fluency	Throughout	Simplify language, increase white space, reduce choices

Pricing Page Optimization

Principle	Where to Apply	Specific Change
Decoy Effect	Plan structure	Add a tier that makes your target tier the obvious value choice
Charm Pricing	Price display	Use $49 not $50 (consumer) or round $100 (enterprise)
Good-Better-Best	Tier design	Three tiers, middle is "Most Popular," clearly highlighted
Anchoring	Top of page	Show highest price or enterprise price first
Default Effect	Toggle	Pre-select annual billing (saves them money, you get commitment)
Zero-Price Effect	Free tier	If free tier exists, make it clearly useful but limited

Email Engagement

Principle	Where to Apply	Specific Change
Zeigarnik Effect	Subject line	Open loops: "The one thing we got wrong about..."
Reciprocity	Email content	Give genuine value before asking for anything
Goal-Gradient	Onboarding	"You're 2 steps from your first dashboard"
Commitment	Micro-asks	Start with easy asks (reply to this email) before hard asks (book a demo)
Curiosity Gap	Preview text	Create knowledge gap that the email body closes

Reducing Churn

Principle	Where to Apply	Specific Change
Endowment Effect	Cancel flow	Show what they will lose (data, history, integrations)
Sunk Cost	Cancel flow	"You've created 47 dashboards and saved 120 hours"
Loss Aversion	Retention email	"Without [Product], you'll go back to [painful manual process]"
Switching Costs	Product	Deep integrations, team workflows, embedded in daily routine
Status Quo Bias	Throughout	Make staying easy, make leaving feel effortful

Ad Creative Improvement

Principle	Where to Apply	Specific Change
Mere Exposure	Retargeting	Show consistent branding across multiple touchpoints
Contrast Effect	Ad copy	Before/after comparison, competitor comparison
Framing	Headline	Frame the same benefit from a loss vs. gain perspective
Social Proof	Ad body	"Join 10,000+ teams" or customer testimonial snippet
Pratfall Effect	Brand messaging	"We're not the cheapest — but teams stay 3x longer"

Pricing Psychology Framework

Three-Tier Pricing Design

Tier 1 (Starter): Anchors the low end. Useful but limited. Makes Tier 2 look like great value.

Tier 2 (Growth — Target Tier): The one you want most people to buy. Best value ratio. Label as "Most Popular" or "Recommended."

Tier 3 (Enterprise): Anchors the high end. Makes Tier 2 feel affordable by comparison. Custom pricing creates exclusivity.

Decoy Pricing Example

Without decoy (equal attractiveness):

Basic: $19/mo (5 users)
Pro: $49/mo (25 users)

With decoy (Pro becomes obvious choice):

Basic: $19/mo (5 users)
Plus: $39/mo (10 users) ← Decoy: close to Pro price, much less value
Pro: $49/mo (25 users) ← Now clearly the best value

Price Display Best Practices

Show monthly price even when billing annually (it is a smaller number)
Pre-select annual billing as the default
Show the savings: "Save 20% with annual billing"
Enterprise tier: "Contact us" or "Custom" (no fixed price — enables value-based selling)
Include "per user" only if the per-user price is low ($5-15/user)
For usage-based: show an example calculation ("For a team of 10, that is $X/month")

Conversion Psychology Playbook

The Trust Cascade

Trust must be built in sequence. Visitors will not convert until sufficient trust is established:

1. Visual Trust (0-3 seconds)
   → Professional design, brand consistency, no visual errors
   → If this fails, visitor bounces immediately

2. Relevance Trust (3-10 seconds)
   → Headline matches their need, content speaks their language
   → If this fails, visitor leaves without scrolling

3. Credibility Trust (10-60 seconds)
   → Social proof, authority signals, specific claims
   → If this fails, visitor evaluates competitors instead

4. Risk Trust (60+ seconds)
   → Guarantee, free trial, easy cancellation, clear pricing
   → If this fails, visitor abandons at the CTA

Micro-Commitment Ladder

Build toward the big ask through small steps:

Read a blog post (zero commitment)
↓
Download a guide (email exchange)
↓
Start a free trial (product experience)
↓
Activate a key feature (value realization)
↓
Upgrade to paid (financial commitment)
↓
Expand to team (organizational commitment)

Each step increases commitment incrementally. Do not ask for the big commitment first.

Copy Psychology Techniques

Loss-Framed vs. Gain-Framed Headlines

Gain-Framed	Loss-Framed (usually stronger)
"Save 4 hours every week"	"Stop losing 4 hours every week"
"Get more leads"	"Stop letting leads slip through"
"Improve your conversion rate"	"Your conversion rate is costing you $X"

Specificity Bias

Specific claims are more believable than round numbers:

"Save 37% on infrastructure costs" beats "Save over 30%"
"2,847 teams" beats "thousands of teams"
"Setup in 8 minutes" beats "Setup in minutes"

Future Pacing

Help readers visualize the outcome:

"Imagine opening your dashboard Monday morning and seeing every metric you need, already organized."
"Picture your next board meeting where you present data you trust, not data you spent all weekend assembling."

Ethics, Best Practices & Quality

Read this when deciding whether a technique crosses the line into manipulation, hardening an implementation against pitfalls, or defining what "good" looks like — covers ethical guidelines, best practices, the troubleshooting table, and success criteria.

Ethical Guidelines

The Line Between Persuasion and Manipulation

Persuasion (ethical): Helping people make decisions that are genuinely good for them, using psychological insights to remove barriers and communicate value clearly.

Manipulation (unethical): Exploiting cognitive biases to trick people into decisions that are not in their interest.

Principles for Ethical Application

1. Transparency — If you would be embarrassed to explain the technique to the customer, do not use it. 2. Alignment — Every psychological technique should help the customer reach a decision that is genuinely good for them. 3. Reversibility — If the customer changes their mind, make it easy to reverse the decision (easy cancellation, refunds). 4. Honesty — Scarcity must be real. Social proof must be real. Claims must be verifiable. 5. Proportionality — Do not use high-pressure techniques for low-stakes decisions.

Specific Ethical Boundaries

Scarcity: Only use when the constraint is real (limited seats, deadline pricing, inventory).
Social proof: Only show real testimonials, real numbers, real logos with permission.
Urgency: Only create urgency when a genuine deadline exists.
Dark patterns: Never hide unsubscribe options, pre-check unwanted options, or make cancellation deliberately difficult.

Best Practices

1. Diagnose before prescribing — Understand what behavioral barrier exists before applying a principle. Random psychology application is noise.

2. Apply 2-3 principles, not 20 — Overloading a page with every psychological technique creates cognitive overwhelm.

3. Test everything — Psychology provides hypotheses. Data provides answers. A/B test every change.

4. Context matters — Social proof that works for consumer SaaS may not work for enterprise. Adapt to your audience.

5. Ethics first — If a technique feels manipulative, it probably is. Long-term trust outperforms short-term conversion.

6. Combine principles — The most effective implementations combine 2-3 complementary principles (e.g., social proof + scarcity + loss aversion near CTA).

7. Specificity wins — "2,847 teams" is more psychologically compelling than "thousands of teams" because specific numbers trigger credibility bias.

8. Study the science — Read Kahneman, Cialdini, Ariely, and Thaler for deep understanding. Surface-level application produces surface-level results.

9. Monitor for diminishing returns — Psychological techniques lose effectiveness over time as audiences become desensitized. Refresh regularly.

10. Document learnings — Every A/B test teaches something about your audience's psychology. Build a knowledge base of what works for your specific audience.

Troubleshooting

Symptom	Likely Cause	Fix
Page feels persuasive but doesn't convert	Missing trust cascade (visual > relevance > credibility > risk)	Build trust in sequence. Run `persuasion_auditor.py` to find gaps.
Pricing page has high drop-off	No anchoring, no decoy, no recommended plan	Run `pricing_psychology_analyzer.py`. Add 3-tier structure with highlighted middle tier.
Social proof present but not working	Generic testimonials without specificity	Replace "Great product!" with named testimonials + specific metrics + outcomes.
Scarcity messaging feels manipulative	Fake constraints (countdown timers, fake "limited")	Only use scarcity when genuine. Fake scarcity erodes trust permanently.
Too many principles applied at once	Cognitive overload from stacking 10+ techniques	Apply 2-3 complementary principles, not everything. Less is more.
Loss-framed headlines not performing	Audience is solution-aware, not problem-aware	Match framing to awareness level. Solution-aware audiences respond to gain framing.
Users abandon during long forms	Friction too high, no progress indicators	Apply Zeigarnik effect: add progress bars. Reduce fields to minimum.

Success Criteria

Cialdini principle coverage: 4+ of 7 principles applied on key conversion pages
Every pricing page uses anchoring, recommended plan highlight, and risk reversal
A/B test running on every psychology-based change (hypothesis + measurement)
Loss-framed and gain-framed headline variants tested (loss framing typically wins 60-70%)
Social proof includes specific numbers (not "thousands" but "2,847 teams")
Ethical guidelines followed: all scarcity real, all claims verifiable, easy cancellation
Document learnings: build audience-specific psychology knowledge base from test results

Mental Model Catalog

Read this when you need the full catalog of 70+ psychological principles — their definitions and concrete marketing applications — to match a behavioral barrier to the principle that addresses it.

Buyer Psychology (Decision-Making)

Principle	Definition	Marketing Application
Loss Aversion	People feel losses 2x more than equivalent gains	Frame benefits as what they will miss without your product
Anchoring	First number seen sets expectations for all subsequent numbers	Show higher price first (original price, competitor price) before showing yours
Social Proof	People follow the actions of others	Show customer count, testimonials, logos, review scores
Scarcity	Limited availability increases perceived value	Show real constraints (limited seats, deadline-based pricing)
Paradox of Choice	Too many options leads to decision paralysis	Limit to 3 pricing tiers, highlight the recommended one
Endowment Effect	People value things more once they feel ownership	Free trials, saved progress, personalized dashboards
Zero-Price Effect	"Free" is disproportionately attractive	Offer a free tier or free trial (not just "cheap")
Status Quo Bias	People prefer the current state unless motivated to change	Show the cost of doing nothing, make switching easy
Framing Effect	Same information presented differently changes decisions	"95% uptime" vs "down 18 days/year" — choose the frame wisely
Sunk Cost Fallacy	Invested time/money makes people continue even when irrational	Show progress toward goals, remind of time invested
Bandwagon Effect	People adopt behaviors that appear popular	"Most popular plan," "Trending," "Join 10,000+ teams"
Peak-End Rule	Experiences judged by peak moment and ending	Make the best feature prominent, make offboarding pleasant

Persuasion and Influence

Principle	Definition	Marketing Application
Reciprocity	People feel compelled to return favors	Give value first (free tool, audit, guide) before asking
Commitment & Consistency	Small yes leads to bigger yes	Start with micro-commitments (email signup before demo request)
Authority	People defer to credible experts	Expert endorsements, credentials, certifications, media mentions
Liking	People buy from those they like	Brand personality, relatable stories, shared values
Unity Principle	Shared identity strengthens influence	"Built by marketers, for marketers" community framing
Contrast Effect	Items seem different when placed next to contrasting items	Show competitor comparison, before/after, or price anchoring
Mere Exposure	Repeated exposure increases preference	Retargeting, consistent branding, regular content publishing
Pratfall Effect	Admitting a small flaw increases credibility	"We're not for everyone" messaging, honest limitations

Pricing Psychology

Principle	Definition	Marketing Application
Charm Pricing	$49 feels significantly cheaper than $50 (left-digit effect)	Price at .99 or .95 endings for consumer, round numbers for premium
Decoy Effect	A dominated option makes the target option look better	Add a third tier that makes your target tier the obvious choice
Rule of 100	Under $100: show % discount. Over $100: show $ discount.	$80 product: "25% off." $500 product: "$125 off."
Good-Better-Best	Three tiers with increasing value make the middle most popular	Design middle tier as your target with best value positioning
Price Anchoring	Show higher number first to make actual price feel reasonable	"Usually $199/mo — now $99/mo" or "Enterprise plans start at $499"
Pennies-a-Day	Daily cost framing feels cheaper than monthly	"$3.29/day" feels cheaper than "$99/month"
Pain of Paying	Every payment creates psychological friction	Annual billing (one payment vs. twelve), free trial (delay payment)

Design and UX Psychology

Principle	Definition	Marketing Application
Hick's Law	More choices = more time to decide (and less likely to decide)	Fewer form fields, fewer navigation options, clear primary CTA
Fitts's Law	Larger, closer targets are easier to click	Large CTA buttons, prominent placement
Von Restorff Effect	Distinctive items are remembered better	Highlight recommended plan, use contrasting color for CTA
Zeigarnik Effect	Incomplete tasks create mental tension	Progress bars, "3 steps left," incomplete profile prompts
Cognitive Fluency	Easy-to-process information is more persuasive	Simple language, clean design, familiar patterns
Default Effect	People tend to accept the default option	Pre-select the recommended plan, pre-check annual billing
Fogg Behavior Model	Behavior = Motivation + Ability + Prompt at same moment	High-motivation moment + easy action + visible CTA

Growth Psychology

Principle	Definition	Marketing Application
Network Effects	Product becomes more valuable as more people use it	Collaborative features, shared workspaces, team invites
IKEA Effect	People value things they helped create more	User customization, personalized setup, co-created content
Goal-Gradient Effect	People accelerate effort as they approach a goal	Progress bars near completion, "You're 80% there" messaging
Switching Costs	Higher switching costs increase retention	Data lock-in, workflow integration, team adoption depth
Variable Rewards	Unpredictable rewards are more engaging than predictable ones	Feature announcements, surprise upgrades, varied content
Compounding	Small improvements that accumulate over time	Show cumulative value: "You've saved 47 hours this quarter"

#!/usr/bin/env python3
"""
Cognitive Bias Checker

Identifies cognitive biases being leveraged (or missed) in
marketing copy, pricing pages, and landing pages.

Usage:
    python cognitive_bias_checker.py page.txt
    python cognitive_bias_checker.py page.html --json
"""

import argparse
import json
import re
import sys
from pathlib import Path

HTML_TAG = re.compile(r"<[^>]+>")

BIASES = {
    "anchoring": {
        "patterns": [
            re.compile(r"(was|originally|compare|usually|valued at|worth)\s*\$?\d+", re.IGNORECASE),
            re.compile(r"\$\d+.*\$\d+"),
            re.compile(r"(starting at|from|as low as)\s*\$?\d+", re.IGNORECASE),
        ],
        "description": "First number sets frame for all subsequent numbers",
        "application": "Show higher price first, then your price",
        "risk": "low",
    },
    "loss_aversion": {
        "patterns": [
            re.compile(r"(don't miss|lose|losing|miss out|without|left behind|cost of inaction|fall behind)", re.IGNORECASE),
            re.compile(r"(stop (losing|wasting|missing)|what you'll lose)", re.IGNORECASE),
        ],
        "description": "People feel losses 2x more than equivalent gains",
        "application": "Frame as 'stop losing X' instead of 'gain X'",
        "risk": "medium",
    },
    "social_proof": {
        "patterns": [
            re.compile(r"\d+\s*(teams|companies|customers|users|people|businesses)", re.IGNORECASE),
            re.compile(r"(most popular|best.?seller|trending|top rated|#1)", re.IGNORECASE),
            re.compile(r"(trusted|used|loved|chosen)\s*by", re.IGNORECASE),
        ],
        "description": "People follow the actions of others",
        "application": "Show customer counts, 'Most Popular' labels",
        "risk": "low",
    },
    "paradox_of_choice": {
        "patterns": [
            re.compile(r"(recommended|popular|best value|suggested)", re.IGNORECASE),
            re.compile(r"(simple|easy choice|just pick|one plan)", re.IGNORECASE),
        ],
        "description": "Too many options leads to decision paralysis",
        "application": "Limit to 3 tiers, highlight recommended plan",
        "risk": "low",
    },
    "decoy_effect": {
        "patterns": [
            re.compile(r"(\$\d+.*\$\d+.*\$\d+)", re.IGNORECASE),
            re.compile(r"(basic|starter|plus|pro|enterprise|premium)", re.IGNORECASE),
        ],
        "description": "A dominated option makes target option look better",
        "application": "Add a 3rd tier that makes middle tier obvious best value",
        "risk": "low",
    },
    "endowment_effect": {
        "patterns": [
            re.compile(r"(your (dashboard|account|data|workspace|plan|trial))", re.IGNORECASE),
            re.compile(r"(personalized|customized|tailored) for you", re.IGNORECASE),
            re.compile(r"(keep|save) your", re.IGNORECASE),
        ],
        "description": "People value things more once they feel ownership",
        "application": "Free trials, 'your dashboard', saved progress",
        "risk": "low",
    },
    "framing_effect": {
        "patterns": [
            re.compile(r"(save|saving|savings)\s*\$?\d+", re.IGNORECASE),
            re.compile(r"\d+%\s*(off|discount|savings|cheaper)", re.IGNORECASE),
            re.compile(r"(\$\d+/day|\$\d+\.?\d*/day|per day|daily)", re.IGNORECASE),
        ],
        "description": "Same info presented differently changes decisions",
        "application": "'$3.29/day' feels cheaper than '$99/month'",
        "risk": "low",
    },
    "zeigarnik_effect": {
        "patterns": [
            re.compile(r"(step \d of|progress|(\d+%|almost) (complete|done|there))", re.IGNORECASE),
            re.compile(r"(you're \d|one step|almost done|nearly there|halfway)", re.IGNORECASE),
        ],
        "description": "Incomplete tasks create mental tension to finish",
        "application": "Progress bars, 'Step 2 of 3', '80% complete'",
        "risk": "low",
    },
    "scarcity_bias": {
        "patterns": [
            re.compile(r"(limited|only \d|last chance|ending|expires|deadline|few (remaining|left|available))", re.IGNORECASE),
            re.compile(r"(\d+ (spots|seats|slots) (left|remaining))", re.IGNORECASE),
        ],
        "description": "Limited availability increases perceived value",
        "application": "Real constraints: limited spots, deadline pricing",
        "risk": "high -- only ethical if scarcity is real",
    },
    "default_effect": {
        "patterns": [
            re.compile(r"(pre.?selected|default|recommended|suggested|auto)", re.IGNORECASE),
            re.compile(r"(annual|yearly) (billing|plan|subscription)", re.IGNORECASE),
        ],
        "description": "People tend to accept the default option",
        "application": "Pre-select annual billing, recommended plan",
        "risk": "medium -- must not be deceptive",
    },
    "charm_pricing": {
        "patterns": [
            re.compile(r"\$\d+\.(99|95|97)"),
            re.compile(r"\$\d*9\b"),
        ],
        "description": "Prices ending in 9 feel significantly cheaper (left-digit effect)",
        "application": "$49 instead of $50 for consumer; round numbers for premium",
        "risk": "low",
    },
}


def check_biases(text: str) -> dict:
    plain = HTML_TAG.sub(" ", text)
    plain = re.sub(r"\s+", " ", plain).strip()

    detected = {}
    not_detected = {}

    for name, config in BIASES.items():
        matches = []
        for pattern in config["patterns"]:
            for m in pattern.finditer(plain):
                matches.append(m.group().strip())

        if matches:
            detected[name] = {
                "evidence": list(set(matches))[:4],
                "description": config["description"],
                "risk": config["risk"],
            }
        else:
            not_detected[name] = {
                "description": config["description"],
                "application": config["application"],
            }

    # Ethical assessment
    high_risk = [name for name, info in detected.items() if "high" in info["risk"]]
    ethical_notes = []
    if high_risk:
        ethical_notes.append(f"High-risk biases detected: {', '.join(high_risk)}. Ensure these are applied ethically (real scarcity, real constraints).")
    if "scarcity_bias" in detected:
        ethical_notes.append("Scarcity MUST be genuine. Fake scarcity erodes trust and can violate advertising standards.")

    score = len(detected) * 10
    score = min(100, score)

    return {
        "biases_detected": len(detected),
        "biases_total": len(BIASES),
        "score": score,
        "grade": "A" if score >= 80 else "B" if score >= 60 else "C" if score >= 40 else "D" if score >= 20 else "F",
        "detected": detected,
        "opportunities": not_detected,
        "ethical_notes": ethical_notes,
        "top_opportunities": list(not_detected.keys())[:5],
    }


def format_human(result: dict) -> str:
    lines = ["\n" + "=" * 60, "  COGNITIVE BIAS CHECKER", "=" * 60]
    lines.append(f"\n  Score: {result['score']}/100 ({result['grade']})")
    lines.append(f"  Biases Detected: {result['biases_detected']}/{result['biases_total']}")

    if result["detected"]:
        lines.append(f"\n  Active Biases:")
        for name, info in result["detected"].items():
            evidence = ", ".join(info["evidence"][:3])
            risk = f" [RISK: {info['risk']}]" if "high" in info["risk"] else ""
            lines.append(f"    [+] {name.replace('_', ' ').title()}{risk}")
            lines.append(f"        {info['description']}")
            lines.append(f"        Evidence: {evidence}")

    if result["top_opportunities"]:
        lines.append(f"\n  Opportunities (not yet applied):")
        for name in result["top_opportunities"]:
            info = result["opportunities"][name]
            lines.append(f"    [-] {name.replace('_', ' ').title()}")
            lines.append(f"        How: {info['application']}")

    if result["ethical_notes"]:
        lines.append(f"\n  Ethical Notes:")
        for note in result["ethical_notes"]:
            lines.append(f"    !! {note}")

    lines.append("")
    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Check marketing copy for cognitive bias application.")
    parser.add_argument("file", help="Text or HTML file")
    parser.add_argument("--json", action="store_true", dest="json_output")
    args = parser.parse_args()

    try:
        text = Path(args.file).read_text()
    except FileNotFoundError:
        print(f"Error: {args.file} not found", file=sys.stderr)
        sys.exit(1)

    result = check_biases(text)
    if args.json_output:
        print(json.dumps(result, indent=2))
    else:
        print(format_human(result))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Persuasion Auditor

Audits marketing copy for the application of Cialdini's 7
principles of persuasion plus key behavioral economics principles.

Usage:
    python persuasion_auditor.py page.txt
    python persuasion_auditor.py page.html --json
"""

import argparse
import json
import re
import sys
from pathlib import Path

HTML_TAG = re.compile(r"<[^>]+>")

PRINCIPLES = {
    "reciprocity": {
        "patterns": [
            re.compile(r"(free guide|free tool|free audit|free template|free trial|free ebook|free download|complimentary|bonus)", re.IGNORECASE),
            re.compile(r"(here's|we've created|download|get your free|take this)", re.IGNORECASE),
        ],
        "description": "Give value before asking for anything in return",
        "example": "Free tool, guide, or audit offered before the ask",
    },
    "commitment_consistency": {
        "patterns": [
            re.compile(r"(step 1|get started|start with|begin by|first step|quiz|assessment)", re.IGNORECASE),
            re.compile(r"(you've already|you started|continue|pick up where|your progress)", re.IGNORECASE),
        ],
        "description": "Small commitments leading to larger ones",
        "example": "Quiz > Email > Trial > Paid progression",
    },
    "social_proof": {
        "patterns": [
            re.compile(r"(trusted by|used by|loved by|join)\s+\d+", re.IGNORECASE),
            re.compile(r"\d+\s*(teams|companies|customers|users|businesses|people)", re.IGNORECASE),
            re.compile(r"(testimonial|review|rating|\d\.\d\s*/\s*5|stars)", re.IGNORECASE),
            re.compile(r'".+"\s*[-—]\s*\w+', re.IGNORECASE),
            re.compile(r"(most popular|best.?seller|trending|top rated)", re.IGNORECASE),
        ],
        "description": "Show others like them are choosing this",
        "example": "'Trusted by 2,847 teams' or named testimonials",
    },
    "authority": {
        "patterns": [
            re.compile(r"(expert|certified|award|featured in|as seen|published|recognized|accredited)", re.IGNORECASE),
            re.compile(r"(phd|md|professor|researcher|author of|years of experience|\d+ years)", re.IGNORECASE),
            re.compile(r"(forbes|techcrunch|wall street|nyt|bloomberg|y combinator)", re.IGNORECASE),
        ],
        "description": "Credible expertise signals",
        "example": "Featured in Forbes, 15 years experience, certified expert",
    },
    "liking": {
        "patterns": [
            re.compile(r"(our team|our story|meet the|about us|behind the scenes|we believe|our mission)", re.IGNORECASE),
            re.compile(r"(built by|created by|founded by|designed for|made for)", re.IGNORECASE),
        ],
        "description": "Build rapport and shared identity",
        "example": "'Built by marketers, for marketers' or team stories",
    },
    "scarcity": {
        "patterns": [
            re.compile(r"(limited|only \d|last chance|ending soon|expires|deadline|sold out|waitlist|few remaining)", re.IGNORECASE),
            re.compile(r"(\d+ (spots|seats|slots) (left|remaining|available))", re.IGNORECASE),
        ],
        "description": "Limited availability increases perceived value",
        "example": "'Only 5 spots remaining' or deadline-based pricing",
    },
    "unity": {
        "patterns": [
            re.compile(r"(community|together|us|tribe|family|insider|member|exclusive group)", re.IGNORECASE),
            re.compile(r"(fellow|like you|people like you|others in your|your peers)", re.IGNORECASE),
        ],
        "description": "Shared identity and belonging",
        "example": "'Join the community' or 'fellow founders'",
    },
}

BEHAVIORAL_ECONOMICS = {
    "loss_aversion": {
        "patterns": [
            re.compile(r"(don't miss|losing|miss out|without|stop losing|left behind|fall behind|cost of)", re.IGNORECASE),
        ],
        "description": "Frame as what they lose, not just what they gain",
    },
    "anchoring": {
        "patterns": [
            re.compile(r"(was \$|originally \$|compare|usually \$|valued at|worth \$|\$\d+.*\$\d+)", re.IGNORECASE),
        ],
        "description": "First number sets expectations for subsequent prices",
    },
    "endowment_effect": {
        "patterns": [
            re.compile(r"(your (dashboard|account|data|workspace|profile)|personalized|customized for you)", re.IGNORECASE),
        ],
        "description": "Ownership feeling increases perceived value",
    },
    "zero_price_effect": {
        "patterns": [
            re.compile(r"(free tier|free plan|free forever|no cost|\$0|completely free)", re.IGNORECASE),
        ],
        "description": "'Free' is disproportionately attractive vs. cheap",
    },
}


def audit_persuasion(text: str) -> dict:
    plain = HTML_TAG.sub(" ", text)
    plain = re.sub(r"\s+", " ", plain).strip()

    found_principles = {}
    missing_principles = {}

    for name, config in PRINCIPLES.items():
        matches = []
        for pattern in config["patterns"]:
            for m in pattern.finditer(plain):
                matches.append(m.group().strip())

        if matches:
            found_principles[name] = {
                "found": True,
                "matches": list(set(matches))[:5],
                "description": config["description"],
            }
        else:
            missing_principles[name] = {
                "found": False,
                "description": config["description"],
                "example": config["example"],
            }

    found_behavioral = {}
    for name, config in BEHAVIORAL_ECONOMICS.items():
        matches = []
        for pattern in config["patterns"]:
            for m in pattern.finditer(plain):
                matches.append(m.group().strip())
        if matches:
            found_behavioral[name] = {
                "found": True,
                "matches": list(set(matches))[:3],
                "description": config["description"],
            }

    total_principles = len(PRINCIPLES)
    found_count = len(found_principles)
    coverage = round(found_count / total_principles * 100)

    # Score
    score = found_count * 12 + len(found_behavioral) * 5
    score = min(100, score)

    recs = []
    if "social_proof" not in found_principles:
        recs.append("Add social proof: customer counts, testimonials with names and metrics, or review scores.")
    if "reciprocity" not in found_principles:
        recs.append("Add reciprocity: offer something valuable (free tool, guide, audit) before the ask.")
    if "scarcity" not in found_principles:
        recs.append("Consider genuine scarcity: limited spots, deadline pricing, or waitlist. Only if real.")
    if "authority" not in found_principles:
        recs.append("Add authority signals: media mentions, certifications, expert endorsements.")
    if "loss_aversion" not in found_behavioral:
        recs.append("Frame benefits as loss avoidance: 'Stop losing X' is stronger than 'Gain X'.")

    if found_count >= 5:
        recs.insert(0, "Strong persuasion coverage. A/B test to see which principles drive the most conversions.")

    return {
        "cialdini_coverage": f"{found_count}/{total_principles}",
        "coverage_pct": coverage,
        "score": score,
        "grade": "A" if score >= 85 else "B" if score >= 70 else "C" if score >= 55 else "D" if score >= 40 else "F",
        "principles_found": found_principles,
        "principles_missing": missing_principles,
        "behavioral_economics_found": found_behavioral,
        "recommendations": recs,
    }


def format_human(result: dict) -> str:
    lines = ["\n" + "=" * 60, "  PERSUASION AUDITOR (Cialdini + Behavioral Economics)", "=" * 60]
    lines.append(f"\n  Score: {result['score']}/100 ({result['grade']})")
    lines.append(f"  Cialdini Coverage: {result['cialdini_coverage']} principles ({result['coverage_pct']}%)")

    lines.append(f"\n  Principles Found:")
    for name, info in result["principles_found"].items():
        matches = ", ".join(info["matches"][:3])
        lines.append(f"    [+] {name.replace('_', ' ').title()}: {info['description']}")
        lines.append(f"        Evidence: {matches}")

    if result["principles_missing"]:
        lines.append(f"\n  Principles Missing:")
        for name, info in result["principles_missing"].items():
            lines.append(f"    [-] {name.replace('_', ' ').title()}: {info['description']}")
            lines.append(f"        Add: {info['example']}")

    if result["behavioral_economics_found"]:
        lines.append(f"\n  Behavioral Economics Applied:")
        for name, info in result["behavioral_economics_found"].items():
            lines.append(f"    [+] {name.replace('_', ' ').title()}: {info['description']}")

    lines.append(f"\n  Recommendations:")
    for r in result["recommendations"]:
        lines.append(f"    > {r}")

    lines.append("")
    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Audit marketing copy for persuasion principles.")
    parser.add_argument("file", help="Text or HTML file to audit")
    parser.add_argument("--json", action="store_true", dest="json_output")
    args = parser.parse_args()

    try:
        text = Path(args.file).read_text()
    except FileNotFoundError:
        print(f"Error: {args.file} not found", file=sys.stderr)
        sys.exit(1)

    result = audit_persuasion(text)
    if args.json_output:
        print(json.dumps(result, indent=2))
    else:
        print(format_human(result))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Pricing Psychology Analyzer

Analyzes pricing page structure for psychological optimization:
anchoring, decoy effect, charm pricing, framing, and tier design.

Usage:
    python pricing_psychology_analyzer.py pricing.json
    python pricing_psychology_analyzer.py pricing.json --json
    python pricing_psychology_analyzer.py --sample

Input JSON:
{
    "tiers": [
        {"name": "Starter", "price": 19, "billing": "monthly", "features": 5, "highlighted": false},
        {"name": "Pro", "price": 49, "billing": "monthly", "features": 15, "highlighted": true},
        {"name": "Enterprise", "price": 99, "billing": "monthly", "features": 30, "highlighted": false}
    ],
    "annual_discount_pct": 20,
    "has_free_tier": false,
    "currency": "USD"
}
"""

import argparse
import json
import sys
from pathlib import Path

SAMPLE = {
    "tiers": [
        {"name": "Starter", "price": 19, "billing": "monthly", "features": 5, "highlighted": False},
        {"name": "Pro", "price": 49, "billing": "monthly", "features": 15, "highlighted": True},
        {"name": "Enterprise", "price": 149, "billing": "monthly", "features": 50, "highlighted": False},
    ],
    "annual_discount_pct": 20,
    "has_free_tier": False,
    "currency": "USD",
}


def analyze_pricing(data: dict) -> dict:
    tiers = data.get("tiers", [])
    annual_discount = data.get("annual_discount_pct", 0)
    has_free = data.get("has_free_tier", False)
    currency = data.get("currency", "USD")

    checks = []
    score = 50
    recommendations = []

    # Tier count
    if len(tiers) == 3:
        checks.append({"name": "Good-Better-Best", "status": "PASS", "detail": "3 tiers (optimal)"})
        score += 10
    elif len(tiers) == 2:
        checks.append({"name": "Tier Count", "status": "WARN", "detail": "2 tiers -- add a 3rd for decoy effect"})
        recommendations.append("Add a 3rd tier to enable decoy pricing. The middle tier should be the target.")
    elif len(tiers) > 4:
        checks.append({"name": "Tier Count", "status": "WARN", "detail": f"{len(tiers)} tiers -- too many options causes choice paralysis"})
        recommendations.append("Reduce to 3-4 tiers. Paradox of choice: more options = fewer decisions.")
    elif len(tiers) == 4:
        checks.append({"name": "Tier Count", "status": "PASS", "detail": "4 tiers (acceptable)"})
        score += 5

    # Highlighted tier
    highlighted = [t for t in tiers if t.get("highlighted")]
    if highlighted:
        checks.append({"name": "Recommended Plan", "status": "PASS", "detail": f"'{highlighted[0]['name']}' highlighted"})
        score += 10
    else:
        checks.append({"name": "Recommended Plan", "status": "FAIL", "detail": "No plan highlighted"})
        recommendations.append("Highlight the target tier as 'Most Popular' or 'Recommended'. Default effect drives selection.")
        score -= 10

    # Charm pricing
    prices = [t.get("price", 0) for t in tiers if t.get("price", 0) > 0]
    charm_priced = [p for p in prices if p % 10 == 9 or str(p).endswith(("9", "99", "95", "97"))]

    if charm_priced:
        checks.append({"name": "Charm Pricing", "status": "PASS", "detail": f"Prices ending in 9: {charm_priced}"})
        score += 8
    elif prices:
        round_prices = [p for p in prices if p % 10 == 0]
        if round_prices:
            checks.append({"name": "Round Pricing", "status": "INFO", "detail": f"Round numbers: {round_prices} (premium positioning)"})
            score += 3
        else:
            recommendations.append("Use charm pricing ($49 not $50) for consumer, or round numbers ($100) for premium/enterprise.")

    # Anchoring
    if len(prices) >= 2:
        price_range = max(prices) - min(prices)
        ratio = max(prices) / min(prices) if min(prices) > 0 else 0

        if ratio >= 3:
            checks.append({"name": "Price Anchoring", "status": "PASS", "detail": f"High-to-low ratio: {ratio:.1f}x (strong anchor)"})
            score += 10
        elif ratio >= 2:
            checks.append({"name": "Price Anchoring", "status": "OK", "detail": f"Ratio: {ratio:.1f}x (moderate anchor)"})
            score += 5
        else:
            checks.append({"name": "Price Anchoring", "status": "WARN", "detail": f"Ratio: {ratio:.1f}x (weak anchor)"})
            recommendations.append("Increase price spread between tiers for stronger anchoring effect.")

    # Decoy analysis
    if len(tiers) >= 3:
        sorted_tiers = sorted(tiers, key=lambda t: t.get("price", 0))
        mid = sorted_tiers[1]
        low = sorted_tiers[0]
        high = sorted_tiers[2]

        mid_price = mid.get("price", 0)
        low_price = low.get("price", 0)
        high_price = high.get("price", 0)
        mid_features = mid.get("features", 0)
        low_features = low.get("features", 0)
        high_features = high.get("features", 0)

        if mid_price > 0 and low_price > 0:
            value_low = low_features / low_price if low_price > 0 else 0
            value_mid = mid_features / mid_price if mid_price > 0 else 0

            if value_mid > value_low * 1.3:
                checks.append({"name": "Decoy Effect", "status": "PASS", "detail": f"Middle tier ({mid['name']}) has better value ratio"})
                score += 10
            else:
                recommendations.append("Adjust features/pricing so middle tier is clearly the best value per dollar.")

    # Annual discount
    if annual_discount > 0:
        checks.append({"name": "Annual Billing", "status": "PASS", "detail": f"{annual_discount}% discount"})
        score += 5
        if annual_discount < 15:
            recommendations.append("Increase annual discount to 15-25% to drive commitment.")
        elif annual_discount > 30:
            recommendations.append("Annual discount above 30% may signal pricing is too high monthly.")
    else:
        recommendations.append("Offer annual billing with 15-25% discount. Reduces churn and pain of paying.")

    # Free tier
    if has_free:
        checks.append({"name": "Zero-Price Effect", "status": "PASS", "detail": "Free tier available"})
        score += 5
    else:
        recommendations.append("Consider a free tier or free trial. 'Free' is disproportionately attractive (zero-price effect).")

    # Pennies-a-day
    if prices:
        min_price = min(prices)
        daily = round(min_price / 30, 2)
        recommendations.append(f"Consider daily framing: '${daily}/day' feels cheaper than '${min_price}/month' (pennies-a-day effect).")

    score = max(0, min(100, score))

    return {
        "tier_count": len(tiers),
        "score": score,
        "grade": "A" if score >= 85 else "B" if score >= 70 else "C" if score >= 55 else "D" if score >= 40 else "F",
        "checks": checks,
        "tier_summary": [{"name": t["name"], "price": t.get("price", 0), "features": t.get("features", 0), "highlighted": t.get("highlighted", False)} for t in tiers],
        "recommendations": recommendations,
        "psychology_principles_applied": [c["name"] for c in checks if c["status"] == "PASS"],
    }


def format_human(result: dict) -> str:
    lines = ["\n" + "=" * 55, "  PRICING PSYCHOLOGY ANALYZER", "=" * 55]
    lines.append(f"\n  Score: {result['score']}/100 ({result['grade']}) | Tiers: {result['tier_count']}")

    lines.append(f"\n  Tiers:")
    for t in result["tier_summary"]:
        hl = " [HIGHLIGHTED]" if t["highlighted"] else ""
        lines.append(f"    {t['name']}: ${t['price']}/mo ({t['features']} features){hl}")

    lines.append(f"\n  Psychology Checks:")
    for c in result["checks"]:
        icon = {"PASS": "+", "WARN": "!", "FAIL": "X", "OK": "~", "INFO": "i"}
        lines.append(f"    [{icon.get(c['status'], '?')}] {c['name']}: {c['detail']}")

    lines.append(f"\n  Principles Applied: {', '.join(result['psychology_principles_applied'])}")

    if result["recommendations"]:
        lines.append(f"\n  Recommendations:")
        for i, r in enumerate(result["recommendations"], 1):
            lines.append(f"    {i}. {r}")

    lines.append("")
    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Analyze pricing page psychology.")
    parser.add_argument("file", nargs="?")
    parser.add_argument("--json", action="store_true", dest="json_output")
    parser.add_argument("--sample", action="store_true")
    args = parser.parse_args()

    if args.sample:
        data = SAMPLE
    elif args.file:
        try:
            data = json.loads(Path(args.file).read_text())
        except (FileNotFoundError, json.JSONDecodeError) as e:
            print(f"Error: {e}", file=sys.stderr)
            sys.exit(1)
    else:
        parser.print_help()
        sys.exit(1)

    result = analyze_pricing(data)
    if args.json_output:
        print(json.dumps(result, indent=2))
    else:
        print(format_human(result))


if __name__ == "__main__":
    main()

Related skills

Sales EnablementGenerate high-quality sales collateral, pitch decks, one-pagers, objection handlers, demo scripts and playbooks that help close deals.82.7k42.4k

Churn PreventionDesign cancel flows, dunning, and health-score tactics to cut voluntary and failed-payment churn on a subscription product.82.4k42.4k

RevopsDesign and optimize revenue operations, lead lifecycle management, and marketing-to-sales handoff processes.79.4k42.4k

Cross Border EcommerceEvaluate and prioritize international markets before committing engineering and marketing resources to global expansion.61.9k540

Community MarketingGet structured, battle-tested guidance when choosing community platforms, diagnosing engagement problems, or scaling an early-stage user community.51.1k42.4k

Co MarketingSystematically identify and brainstorm campaigns with complementary products that share the same audience but solve different problems.42.4k42.4k

FAQ

How many principles does it catalog?

A catalog of 70+ mental models across buyer psychology, persuasion, pricing, design/UX, and growth.

Does it enforce ethics?

Yes, it draws a persuasion vs manipulation line, sets anti-dark-pattern boundaries, and requires A/B testing.

Sales & Marketingcontentlifecycle

About

Marketing Psychology by the numbers

marketing-psychology capabilities & compatibility

What marketing-psychology says it does

Add your badge

What it does

Who is it for?

When should I use this skill?

What you get

By the numbers

Files

Marketing Psychology

Core Capabilities

When to Use

Quick Start

Diagnose Why Something Is Not Converting

Apply Psychology to a Marketing Asset

References

Python Automation Tools

Scope & Limitations

Integration Points

Application Playbooks

Core Workflows

Workflow 1: Behavioral Diagnosis

Workflow 2: Principle Application

Application by Marketing Challenge

Landing Page Not Converting

Pricing Page Optimization

Email Engagement

Reducing Churn

Ad Creative Improvement

Pricing Psychology Framework

Three-Tier Pricing Design

Decoy Pricing Example

Price Display Best Practices

Conversion Psychology Playbook

The Trust Cascade

Micro-Commitment Ladder

Copy Psychology Techniques

Loss-Framed vs. Gain-Framed Headlines

Specificity Bias

Future Pacing

Ethics, Best Practices & Quality

Ethical Guidelines

The Line Between Persuasion and Manipulation

Principles for Ethical Application

Specific Ethical Boundaries

Best Practices

Troubleshooting

Success Criteria

Mental Model Catalog

Buyer Psychology (Decision-Making)

Persuasion and Influence

Pricing Psychology

Design and UX Psychology

Growth Psychology

Related skills

FAQ

How many principles does it catalog?

Does it enforce ethics?

This week in AI coding