Cómo hacer que Claude analice a la competencia

Antes de analizar nada necesitas el SDK de Anthropic y tu clave. Crea la API key en console.anthropic.com y guárdala como variable de entorno para no exponerla en el código (crítico si versionas con git). Instala el SDK oficial de Python. Este será el esqueleto de todo el pipeline. Trabajaremos con claude-opus-4-8, el modelo por defecto, ideal para razonamiento analítico complejo como comparativas estratégicas. Si estás en España o LATAM, la facturación es en USD y funciona con cualquier tarjeta internacional. Verifica que la instalación es correcta ejecutando un import rápido. En este paso no gastas tokens todavía, solo dejas todo listo para las llamadas.

pip install anthropic

# En terminal (Linux/Mac):
export ANTHROPIC_API_KEY='tu-api-key-aqui'

# En Windows PowerShell:
# $env:ANTHROPIC_API_KEY='tu-api-key-aqui'

Claude analiza lo que le des: la calidad del output depende de la calidad del input. No pidas a Claude que 'investigue' competidores de su memoria, porque puede alucinar datos desactualizados o inventar precios. En su lugar, recopila tú información pública real (textos de webs, pricing, propuestas de valor, reseñas) y pásasela como contexto. Organiza cada competidor como un diccionario con campos consistentes. Esto permite que el análisis sea comparable y reproducible. Cuantos más datos objetivos incluyas, más útil será el resultado. Para este tutorial usamos datos de ejemplo del sector SaaS, pero sustitúyelos por los tuyos: copia y pega texto de landing pages, pricing y mensajes de marketing de tus competidores reales.

competidores = [
    {
        "nombre": "CompetidorA",
        "web": "competidora.com",
        "propuesta_valor": "CRM todo en uno para pymes, setup en 5 minutos",
        "pricing": "29€/mes por usuario, plan gratuito hasta 3 usuarios",
        "publico": "Pymes de 5-50 empleados en Espana y LATAM",
        "mensajes_clave": "Facil, rapido, sin formacion tecnica"
    },
    {
        "nombre": "CompetidorB",
        "web": "competidorb.com",
        "propuesta_valor": "CRM enterprise con automatizaciones avanzadas",
        "pricing": "desde 79€/usuario/mes, sin plan gratuito",
        "publico": "Empresas medianas y grandes",
        "mensajes_clave": "Potente, personalizable, integraciones ilimitadas"
    }
]

El prompt es donde se juega el 80% del resultado. Usa un system prompt que defina el rol (analista de estrategia competitiva) y estructure el framework que debe seguir: propuesta de valor, fortalezas, debilidades, diferenciadores y amenazas para tu producto. La clave para un análisis fiable es instruir a Claude a separar hechos (basados en los datos aportados) de inferencias (su razonamiento estratégico). Además, le pedimos salida en JSON para poder integrar el resultado en dashboards o hojas de cálculo. Incluye tu propio producto como contexto para que el análisis sea relativo a ti, no genérico. Un buen prompt es específico sobre el formato de salida y sobre qué debe evitar.

SYSTEM_PROMPT = """Eres un analista senior de estrategia competitiva.
Analizas competidores SOLO con los datos que te proporciono.

Reglas:
- Distingue entre HECHOS (extraidos de los datos) e INFERENCIAS (tu razonamiento).
- Si un dato no esta disponible, indica 'no disponible' en vez de inventarlo.
- Se concreto y accionable, evita generalidades.

Devuelve SIEMPRE un JSON valido con esta estructura:
{
  "competidores": [
    {
      "nombre": str,
      "fortalezas": [str],
      "debilidades": [str],
      "diferenciador_principal": str,
      "amenaza_para_nosotros": "alta|media|baja",
      "como_ganarles": str
    }
  ],
  "oportunidades_de_mercado": [str],
  "recomendacion_estrategica": str
}"""

Ahora unimos datos y prompt en una llamada real. Serializamos los competidores a JSON y los pasamos como mensaje de usuario junto con el contexto de tu propio producto. Usamos claude-opus-4-8 por su capacidad de razonamiento para comparativas estratégicas. Fijamos max_tokens con margen suficiente para un análisis completo y temperature baja (0.2) para respuestas consistentes y menos creativas: en análisis quieres rigor, no imaginación. La respuesta llega en message.content[0].text. Envolvemos la llamada para reutilizarla con distintos conjuntos de competidores. Este es el corazón del pipeline: una función que recibe competidores y devuelve el análisis crudo de Claude.

import anthropic
import json

client = anthropic.Anthropic()

def analizar_competencia(competidores, mi_producto):
    mensaje = f"""MI PRODUCTO:
{mi_producto}

COMPETIDORES A ANALIZAR:
{json.dumps(competidores, ensure_ascii=False, indent=2)}

Analiza a cada competidor frente a mi producto."""

    respuesta = client.messages.create(
        model="claude-opus-4-8",
        max_tokens=2000,
        temperature=0.2,
        system=SYSTEM_PROMPT,
        messages=[{"role": "user", "content": mensaje}]
    )
    return respuesta.content[0].text

mi_producto = "CRM para autonomos y micropymes, 15€/mes, foco en facturacion espanola y LATAM"
resultado = analizar_competencia(competidores, mi_producto)
print(resultado)

Claude devuelve texto que debería ser JSON válido, pero conviene parsearlo de forma defensiva. A veces el modelo envuelve el JSON en bloques de código markdown; limpiamos esos delimitadores antes de parsear. Convertimos el string a un diccionario Python para poder trabajar con los datos programáticamente: filtrar por nivel de amenaza, exportar a CSV o alimentar un dashboard. Si el parseo falla, lo capturamos y mostramos la salida cruda para depurar. Esta capa de validación es lo que convierte una demo bonita en un pipeline productivo y fiable que puedes ejecutar cada semana con datos frescos.

def parsear_analisis(texto):
    # Limpia posibles delimitadores markdown
    limpio = texto.strip()
    if limpio.startswith("```"):
        limpio = limpio.split("```")[1]
        if limpio.startswith("json"):
            limpio = limpio[4:]
    try:
        return json.loads(limpio)
    except json.JSONDecodeError as e:
        print(f"Error parseando JSON: {e}")
        print("Salida cruda:", texto)
        return None

analisis = parsear_analisis(resultado)

if analisis:
    for c in analisis["competidores"]:
        print(f"\n{c['nombre']} - Amenaza: {c['amenaza_para_nosotros']}")
        print(f"  Como ganarles: {c['como_ganarles']}")
    print(f"\nRecomendacion: {analisis['recomendacion_estrategica']}")

El último paso convierte el análisis en algo consumible por tu equipo. Exportamos los resultados a un CSV que cualquiera puede abrir en Excel o Google Sheets, muy práctico para reuniones de estrategia. Puedes programar este script con un cron job semanal para tener un radar competitivo siempre actualizado. Si quieres ir más allá, encadena este análisis con una segunda llamada a Claude que genere un resumen ejecutivo en lenguaje natural para dirección. La ventaja de tener el pipeline en código es la reproducibilidad: mismo prompt, mismos criterios, resultados comparables a lo largo del tiempo. Sustituye los datos de ejemplo por los de tu sector real y tendrás un sistema de inteligencia competitiva funcional.

import csv

def exportar_csv(analisis, ruta="analisis_competencia.csv"):
    with open(ruta, "w", newline="", encoding="utf-8") as f:
        writer = csv.writer(f)
        writer.writerow(["Competidor", "Amenaza", "Diferenciador", "Como ganarles"])
        for c in analisis["competidores"]:
            writer.writerow([
                c["nombre"],
                c["amenaza_para_nosotros"],
                c["diferenciador_principal"],
                c["como_ganarles"]
            ])
    print(f"Informe exportado a {ruta}")

if analisis:
    exportar_csv(analisis)