marketing-selling-point-generator

name	marketing-selling-point-generator
description	AI-powered tool to discover, prioritize, and write compelling product selling points for marketing campaigns
triggers	["generate product selling points","analyze product value proposition","create marketing copy from features","find product differentiators","write compelling product descriptions","refine product messaging strategy","extract selling points from product info","optimize product positioning copy"]

Marketing Selling Point Generator

Skill by ara.so — Marketing Skills collection.

Overview

Marketing Selling Point Generator is a comprehensive tool designed to help product managers and marketers transform product features into compelling selling points. It uses a three-phase approach: Find (discover selling points), Define (prioritize them), and Write (create persuasive copy).

The tool analyzes product attributes, competitive positioning, user feedback, and pain points to generate targeted marketing copy optimized for different platforms and audiences.

Installation

# Clone the repository
git clone https://github.com/danidai098-arch/marketing-selling-point-generator.git
cd marketing-selling-point-generator

# Install dependencies (assuming Node.js/Python based on typical structure)
npm install
# or
pip install -r requirements.txt

Core Workflow

1. Find Selling Points (找卖点)

Extract potential selling points from various data sources:

const { SellingPointFinder } = require('./src/finder');

const finder = new SellingPointFinder();

// Analyze product attributes
const productData = {
  name: "Smart Wireless Earbuds Pro",
  features: [
    "Active Noise Cancellation",
    "40-hour battery life",
    "IPX7 waterproof",
    "Bluetooth 5.3"
  ],
  price: 99.99,
  category: "Audio"
};

const attributePoints = await finder.analyzeAttributes(productData);
// Returns structured selling points based on features

# Python equivalent
from src.finder import SellingPointFinder

finder = SellingPointFinder()

product_data = {
    "name": "Smart Wireless Earbuds Pro",
    "features": [
        "Active Noise Cancellation",
        "40-hour battery life",
        "IPX7 waterproof",
        "Bluetooth 5.3"
    ],
    "price": 99.99,
    "category": "Audio"
}

attribute_points = finder.analyze_attributes(product_data)

Competitive Analysis

// Compare with competitors
const competitorData = [
  { name: "Brand X Earbuds", price: 129.99, battery: "30 hours" },
  { name: "Brand Y Pods", price: 89.99, battery: "24 hours" }
];

const competitivePoints = await finder.compareCompetitors(
  productData,
  competitorData
);
// Returns: differentiation advantages like "33% longer battery vs competitors"

User Feedback Analysis

const reviews = [
  "Amazing battery life, lasts all week!",
  "Sound quality is incredible for the price",
  "Finally earbuds that survive my workouts"
];

const userInsights = await finder.analyzeReviews(reviews);
// Extracts: key value points users actually care about

Pain Point Mapping

const targetAudience = {
  segment: "fitness enthusiasts",
  painPoints: [
    "Earbuds fall out during exercise",
    "Battery dies mid-workout",
    "Not sweat-resistant"
  ]
};

const painPointMap = await finder.mapPainPoints(productData, targetAudience);
// Maps product features to solved pain points

2. Define Selling Points (定卖点)

Prioritize and score discovered selling points:

const { SellingPointRanker } = require('./src/ranker');

const ranker = new SellingPointRanker();

const allPoints = [
  ...attributePoints,
  ...competitivePoints,
  ...userInsights,
  ...painPointMap
];

// Score by differentiation
const scoredPoints = await ranker.scoreDifferentiation(allPoints);
// Returns points sorted by competitive advantage strength

// Match to target audience
const audienceConfig = {
  demographic: "25-35, fitness-focused professionals",
  values: ["performance", "durability", "convenience"],
  channels: ["Instagram", "fitness forums"]
};

const audienceMatched = await ranker.matchAudience(scoredPoints, audienceConfig);

// Evaluate by scenario
const scenarios = ["gym workout", "daily commute", "work calls"];
const scenarioScores = await ranker.evaluateScenarios(audienceMatched, scenarios);

// Predict viral potential
const viralityScores = await ranker.predictVirality(scenarioScores);

# Python equivalent
from src.ranker import SellingPointRanker

ranker = SellingPointRanker()

scored_points = ranker.score_differentiation(all_points)
audience_matched = ranker.match_audience(scored_points, audience_config)
scenario_scores = ranker.evaluate_scenarios(audience_matched, scenarios)
virality_scores = ranker.predict_virality(scenario_scores)

3. Write Selling Points (写卖点)

Generate platform-optimized copy:

const { CopyWriter } = require('./src/writer');

const writer = new CopyWriter();

const topPoints = viralityScores.slice(0, 5);

// FAB (Features-Advantages-Benefits) transformation
const fabCopy = await writer.transformFAB(topPoints[0]);
// Input: "40-hour battery life"
// Output: {
//   feature: "40-hour battery life",
//   advantage: "5x longer than typical earbuds",
//   benefit: "Charge once a week, not every day"
// }

// Emotion hook design
const emotionHooks = await writer.createEmotionHooks(topPoints, {
  emotions: ["relief", "excitement", "confidence"]
});
// Returns: "Never ask 'Are my earbuds charged?' again"

// Platform-specific copy
const platformCopy = await writer.adaptToPlatform(topPoints, {
  platform: "ecommerce",
  maxLength: 150,
  includeCTA: true
});

// E-commerce example
console.log(platformCopy.ecommerce);
// "40-hour battery. IPX7 waterproof. Premium sound at half the price. 



 socialCopy =  writer.(topPoints, {
  : ,
  : ,
  : 
});

.(socialCopy.);

A/B Testing Variants

const abVariants = await writer.generateABVariants(topPoints[0], {
  count: 3,
  variables: ["headline", "cta", "emotional_angle"]
});

console.log(abVariants);
// [
//   { headline: "Battery that lasts as long as you do", cta: "Shop Now" },
//   { headline: "40 hours of pure freedom", cta: "Get Yours" },
//   { headline: "Never cut your workout short again", cta: "Try It" }
// ]

Configuration

Create a config.json file:

{
  "platform": "ecommerce",
  "style": "professional",
  "max_points": 5,
  "include_emotion_hook": true,
  "include_cta": true,
  "target_audience": {
    "age_range": "25-45",
    "interests": ["fitness", "technology"],
    "pain_points": ["battery anxiety", "durability concerns"]
  },
  "brand_voice": {
    "tone": "confident but approachable",
    "avoid": ["technical jargon" 
      
  
     

Load configuration:

const { loadConfig } = require('./src/config');

const config = loadConfig('./config.json');
const writer = new CopyWriter(config);

Complete Example Workflow

const { 
  SellingPointFinder, 
  SellingPointRanker, 
  CopyWriter 
} = require('./src');

async function generateMarketingCopy(productData, competitorData, reviews) {
  // Phase 1: Find
  const finder = new SellingPointFinder();
  const attributePoints = await finder.analyzeAttributes(productData);
  const competitivePoints = await finder.compareCompetitors(
    productData, 
    competitorData
  );
  const userPoints = await finder.analyzeReviews(reviews);
  
  // Phase 2: Define
  const ranker = new SellingPointRanker();
  const allPoints = [...attributePoints, ...competitivePoints, ...userPoints];
  const scoredPoints = await ranker.scoreDifferentiation(allPoints);
  const topPoints = scoredPoints.slice(0, 5);
  
  // Phase 3: Write
  const writer = new CopyWriter({
    platform: 'ecommerce',
    style: 'professional',
    include_cta: true
  });
  
  const marketingCopy = {
    :  writer.([topPoints[]]),
    :  .(
      topPoints.( writer.(p))
    ),
    :  writer.(topPoints, {
      : ,
      : 
    }),
    :  writer.(topPoints[], { :  })
  };
  
   marketingCopy;
}


 result =  (
  productData,
  competitorData,
  reviews
);

.(result);

Common Patterns

Pattern 1: Quick Product Description

const { quickGenerate } = require('./src/quick');

const description = await quickGenerate({
  productName: "Smart Wireless Earbuds Pro",
  keyFeatures: ["40h battery", "ANC", "IPX7"],
  targetPlatform: "amazon"
});

// Returns optimized Amazon listing copy

Pattern 2: Multi-Platform Campaign

const platforms = ['ecommerce', 'instagram', 'facebook_ad', 'google_ad'];

const campaign = await Promise.all(
  platforms.map(platform => 
    writer.adaptToPlatform(topPoints, { 
      platform, 
      style: 'casual' 
    })
  )
);

const campaignPack = Object.fromEntries(
  platforms.map((p, i) => [p, campaign[i]])
);

Pattern 3: Competitive Positioning

const positioning = await finder.generatePositioningStatement({
  product: productData,
  competitors: competitorData,
  targetAudience: "fitness enthusiasts",
  keyDifferentiator: "battery life"
});

// Returns: "For fitness enthusiasts who need reliable audio, 
//  Smart Earbuds Pro offers 40-hour battery life—33% longer 
//  than leading competitors—so you never miss a beat."

Environment Variables

# .env file
OPENAI_API_KEY=your_openai_key_here
ANALYSIS_MODEL=gpt-4
COPY_MODEL=gpt-3.5-turbo
MAX_TOKENS=500
TEMPERATURE=0.7

Load in code:

require('dotenv').config();

const writer = new CopyWriter({
  apiKey: process.env.OPENAI_API_KEY,
  model: process.env.COPY_MODEL,
  temperature: parseFloat(process.env.TEMPERATURE)
});

Troubleshooting

Issue: Generated copy too generic

Solution: Provide more specific product data and competitive context

// ❌ Too generic
const productData = { name: "Earbuds", features: ["wireless"] };

// ✅ Specific
const productData = {
  name: "Smart Wireless Earbuds Pro",
  features: [
    { name: "ANC", spec: "35dB reduction", userBenefit: "blocks gym noise" },
    { name: "Battery", spec: "40 hours", userBenefit: "weekly charging" }
  ],
  targetScenarios: ["gym", "commute", "work calls"]
};

Issue: Points don't match target audience

Solution: Define detailed audience configuration

const audienceConfig = {
  demographic: "25-35, urban professionals",
  psychographic: "values efficiency and quality",
  painPoints: ["battery anxiety", "poor call quality"],
  desiredOutcomes: ["all-day reliability", "professional sound"],
  influencers: ["tech reviewers", "fitness influencers"]
};

const matched = await ranker.matchAudience(points, audienceConfig);

Issue: Copy doesn't fit platform character limits

Solution: Use strict length constraints

const twitterCopy = await writer.adaptToPlatform(points, {
  platform: 'twitter',
  maxLength: 280,
  enforceStrict: true, // Cuts off at limit
  priorityPoints: [points[0], points[1]] // Focus on top 2
});

Issue: Need multilingual support

Solution: Specify target language in config

const chineseCopy = await writer.adaptToPlatform(points, {
  platform: 'ecommerce',
  language: 'zh-CN',
  culturalContext: 'China market preferences'
});

Advanced Usage

Custom Scoring Weights

const ranker = new SellingPointRanker({
  weights: {
    differentiation: 0.4,
    audienceMatch: 0.3,
    virality: 0.2,
    feasibility: 0.1
  }
});

Batch Processing

const products = [product1, product2, product3];

const batchResults = await Promise.all(
  products.map(p => generateMarketingCopy(p, competitors, reviews))
);

Export to Marketing Tools

const { exportToCSV, exportToJSON } = require('./src/export');

await exportToCSV(marketingCopy, './output/copy.csv');
await exportToJSON(campaignPack, './output/campaign.json');