Pine Script TradingView: cómo crear una estrategia sin programar, en vivo con IA
¿Necesitás saber programar para armar una estrategia de Pine Script TradingView? La respuesta corta es: no - y lo probamos en vivo, en una sesión de menos de 15 minutos, sin escribir una sola línea de código a mano.
La herramienta que usamos fue Claude Code, un asistente de IA de Anthropic que corre directo en la terminal.
Acá vas a ver el proceso completo: desde la idea de la estrategia hasta el Pine Script funcional en TradingView, incluyendo el backtest en el Strategy Tester (la misma disciplina que aplicamos en nuestro backtesting con Python) y la configuración de alertas.
El código generado en esta sesión está disponible para estudiar y adaptar - está claramente marcado como ejemplo educativo. Leé el aviso de abajo antes de seguir.
⚠️ Aviso de riesgo: El trading de criptomonedas implica riesgo real de pérdida de capital. Los resultados pasados no garantizan resultados futuros. Este contenido es educativo y no constituye asesoramiento financiero ni de inversión.
Lo que vas a necesitar
Para replicar esta sesión necesitás tres cosas: Claude Code instalado en la terminal, una cuenta en TradingView y la descripción de tu estrategia en texto simple.
Claude Code instalado en tu computadora
Claude Code es el asistente de IA que va a transformar la descripción de tu estrategia en Pine Script. Si todavía no lo tenés instalado, revisá la guía oficial de instalación de Claude Code antes de seguir.
Para este tutorial usamos Claude Code directo en la terminal de Windows. El proceso es idéntico en Mac o Linux. Una sesión como esta lleva menos de 15 minutos.
TradingView - elegí tu plan
Para crear, testear y configurar alertas básicas con Pine Script, la cuenta gratuita alcanza. Para conectar la estrategia a un bot vía webhook - el próximo paso de esta serie - vas a necesitar el plan Essential.
Si operás desde Argentina, no hace falta ninguna cuenta bancaria especial para pagar TradingView - se puede pagar con tarjeta internacional habilitada para consumos en dólares.
La idea de tu estrategia
No necesitás una especificación formal. Alcanza con saber responder tres preguntas: ¿Cuándo entro? ¿Cuándo salgo? ¿Cuál es el riesgo por operación?
Claude Code no inventa la estrategia por vos - codifica exactamente lo que describís. La calidad del Pine Script generado depende directamente de la claridad de tu descripción.
Cómo estructurar tu estrategia antes de abrir Claude Code
Claude Code codifica exactamente lo que describís - la calidad del Pine Script generado depende directamente de la claridad de la especificación. En esta sección te mostramos cómo documentar tu estrategia en lenguaje natural antes de abrir la terminal.
¿Qué es Pine Script en TradingView?
Pine Script es el lenguaje de programación nativo de TradingView. Se usa para crear indicadores, estrategias y alertas personalizadas directamente en la plataforma. Con IA, podés generar Pine Script sin escribir una línea de código - alcanza con describir la lógica.
Describí tu estrategia en lenguaje natural
Antes de abrir Claude Code, escribí tu estrategia en un archivo de texto simple. No hace falta que sea técnico - puede ser "entro cuando el RSI sale de sobrecompra con el precio haciendo un nuevo máximo".
Cuanto más preciso seas en los casos límite, mejor va a salir el Pine Script generado.
Nuestra estrategia de ejemplo: Divergencia de RSI
La estrategia que elegimos para esta sesión en vivo fue la Divergencia de RSI con confirmación de momentum en 4H. El concepto: cuando el precio hace un nuevo máximo pero el RSI no lo confirma, puede haber un debilitamiento del momentum.
¿Qué es la divergencia de RSI en trading?
La divergencia de RSI ocurre cuando el precio hace un nuevo máximo (o mínimo) pero el RSI no confirma ese movimiento. Ya documentamos esta misma lógica con backtest en Python, en 3 configuraciones, en un artículo aparte.
Es una señal de debilitamiento del momentum - el precio puede estar por revertir. El setup tiene 4 pasos secuenciales con confirmación de momentum vía SMA del RSI.
El setup SHORT exige: (1) RSI arriba de 65, (2) el precio renueva el máximo con el RSI saliendo de sobrecompra, (3) el RSI cruza por debajo de su SMA(5), (4) señal disparada al cierre de la vela. El setup LONG es el espejo exacto con RSI abajo de 30. SL fijo en 1% de la vela de disparo, TP en 2R (el doble del riesgo).
💡 Consejo Sano: Antes de usar Claude Code, dejá bien claros los casos límite de tu estrategia. Ejemplo: si el precio hace un nuevo máximo y el RSI sigue arriba de 65, eso es continuación del setup y no divergencia. Sin esa definición, el código puede interpretar mal la lógica.
Configurando la sesión en Claude Code
Con la estrategia documentada, el próximo paso es preparar el entorno en Claude Code. Dos archivos de texto alcanzan para definir todo lo que el asistente necesita saber antes de generar el Pine Script.
¿Qué es Claude Code y cómo funciona con Pine Script?
Claude Code es un asistente de IA de Anthropic que corre en la terminal de tu computadora. Describís tu estrategia en archivos de texto (.md), y él genera el código Pine Script listo para pegar en TradingView.
Creando la carpeta de la estrategia
El primer paso es crear una carpeta dedicada para la sesión. Creamos la carpeta C:\EstrategiaTV-ES y abrimos Claude Code ahí. Dentro de esta carpeta, dos archivos de texto definen toda la sesión: CLAUDE.md y estrategia.md.
El archivo CLAUDE.md - definiendo el rol del asistente
El CLAUDE.md define el rol de Claude Code para esta sesión: va a comportarse como un especialista en Pine Script v6 (la versión por defecto del Pine Editor desde noviembre de 2024).
Este archivo no cambia entre estrategias - podés reutilizar la misma plantilla. Copiá el contenido de abajo y guardalo como CLAUDE.md en la carpeta de tu estrategia:
# Contexto de la Sesión — Estrategia Pine Script
Sos un especialista en Pine Script v6 y análisis técnico. En esta sesión vamos a implementar una estrategia completa en TradingView a partir de la especificación en `estrategia.md`, que ya define la lógica de forma exhaustiva y sin ambigüedades.
## Objetivo
Generar un script Pine Script v6 funcional que implemente la estrategia de divergencia de RSI descrita en `estrategia.md`, incluyendo:
- Máquina de estados (4 pasos secuenciales) para el setup SHORT y LONG
- Señales visuales en el gráfico (flechas o triángulos al cierre de la vela)
- Alertas compatibles con `alertcondition()`
- Gestión de riesgo integrada: SL y TP calculados automáticamente
- Todos los parámetros configurables vía `input.*()` en la parte superior del script
## Estándar de código
- Pine Script v6 (`//@version=6`)
- Estrategia: usar `strategy()` con `calc_on_every_tick=false` (solo velas cerradas)
- No agregar ningún otro parámetro a `strategy()` más allá de los que ya están en `estrategia.md`
- Comentarios en español
- Parámetros agrupados arriba con `group=` en los inputsEl archivo estrategia.md - tu estrategia por escrito
El estrategia.md es donde describís la lógica de tu estrategia. Cuanto más detallado, mejor sale el Pine Script generado - incluyendo el orden exacto de precedencia entre reglas, que fue justamente el punto donde más ida y vuelta tuvimos con Claude Code en esta sesión (lo vas a ver más abajo).
La sesión en vivo: del texto al código Pine Script
Con los dos archivos listos, abrimos Claude Code en la carpeta de la estrategia e iniciamos la sesión.
Un prompt inicial más detallado da mejores resultados
Le pedimos a Claude Code que leyera estrategia.md completo y describiera la máquina de estados en bullets antes de generar código - con una aclaración extra en el prompt: la especificación ya incluye el orden de precedencia entre reglas y una lista de casos de prueba, así que no debería quedar ninguna ambigüedad real.
Si de todos modos surgía alguna duda, le pedimos que la preguntara directo en vez de asumir. Este es el prompt exacto que usamos:
Leé el archivo estrategia.md. Antes de generar cualquier código, describí en bullet points la máquina de estados que vas a implementar — SHORT y LONG — para que yo valide si entendiste la lógica correctamente. La especificación ya incluye el orden de precedencia y los casos de prueba, así que no debería quedar ninguna ambigüedad — si igual tenés alguna duda, preguntala directamente en vez de asumir.La clave está en estrategia.md: cuanto más resuelvas ahí de antemano - el orden exacto de precedencia entre reglas, qué pasa con el contador de tiempo al renovar una referencia de precio, cómo tratar una señal contraria en simultáneo con un reset por tiempo - menos ida y vuelta necesitás después con Claude Code para llegar al código final.
La lectura de Claude Code: una sola duda real
Con la especificación ya sin ambigüedades, Claude Code devolvió una lectura completa y ordenada de la máquina de estados - los 5 estados posibles, la cadena de precedencia completa (reset por tiempo, señal contraria, y recién después la rama de máximos/mínimos) y la gestión de riesgo.
Luego quedó una sola pregunta real sin resolver en la especificación: si después de disparar una señal y volver al estado neutro, un setup nuevo puede nacer en esa misma vela o recién en la siguiente.
💡 Consejo Sano: Esa pregunta no tenía una respuesta escrita en estrategia.md - era un caso límite que se nos había pasado por alto al documentar la lógica. Confirmamos que el disparo deja el estado en neutro para la vela siguiente, sin re-evaluar el nacimiento de un setup nuevo en la misma vela. Por más detallada que sea tu especificación, siempre va a aparecer algún caso límite que no habías pensado - la idea es que sean cada vez menos, no cero.
Confirmando y generando el código
Confirmamos esa última duda y le pedimos a Claude Code que generara el código. El resultado: un Pine Script funcional en v6, con panel de estado visual incluido para validar en vivo qué está pasando en cada vela.
El código Pine Script generado
Nota: el código de abajo se generó en esta sesión en vivo como ejemplo educativo. Lo compartimos para que puedas estudiar la lógica, testearlo en tu TradingView y adaptarlo a tu propia estrategia.
Esto no es un sistema validado para operar con capital real y no debe interpretarse como recomendación de inversión.
Antes de darlo por confirmado, Claude Code repasó el código contra los casos límite de la especificación uno por uno - la renovación de una referencia de precio, una señal contraria, dos pasos disparando en la misma vela, y qué pasa cuando dos condiciones se cumplen a la vez en la cadena de precedencia. Los cinco casos coincidieron con lo que estaba escrito en estrategia.md.
//@version=6
strategy("Divergencia de RSI con Confirmación de Momentum (4H)", overlay=true, calc_on_every_tick=false)
// ============================================================================
// PARÁMETROS
// ============================================================================
rsi_length = input.int(14, "Período del RSI", group="RSI")
rsi_ma_length = input.int(5, "Período de la SMA del RSI", group="RSI")
rsi_ob = input.int(70, "Nivel de sobrecompra", group="RSI")
rsi_os = input.int(30, "Nivel de sobreventa", group="RSI")
lookback_limit = input.int(200, "Máximo de velas entre step 1 y step 4", group="Setup / Lookback")
sl_pct = input.float(1.0, "Stop Loss (%)", group="Gestión de Riesgo")
tp_mult = input.float(2.0, "Multiplicador de Take Profit (R)", group="Gestión de Riesgo")
mostrar_debug = input.bool(false, "Mostrar referencias de debug (ref_high/ref_low)", group="Visualización")
// ============================================================================
// INDICADORES
// ============================================================================
rsi = ta.rsi(close, rsi_length)
rsi_sma = ta.sma(rsi, rsi_ma_length)
// ============================================================================
// MÁQUINA DE ESTADOS
// ============================================================================
int ESTADO_NEUTRO = 0
int ESTADO_S1_SHORT = 1
int ESTADO_S2_MOM_SHORT = 2
int ESTADO_S1_LONG = 3
int ESTADO_S2_MOM_LONG = 4
var int estado = ESTADO_NEUTRO
var float ref_high = na
var float ref_low = na
var int bar_inicio = na
bool disparo_short = false
bool disparo_long = false
if estado == ESTADO_NEUTRO
if rsi > rsi_ob
estado := ESTADO_S1_SHORT
ref_high := high
bar_inicio := bar_index
else if rsi < rsi_os
estado := ESTADO_S1_LONG
ref_low := low
bar_inicio := bar_index
else
bool lado_short = estado == ESTADO_S1_SHORT or estado == ESTADO_S2_MOM_SHORT
bool lado_long = estado == ESTADO_S1_LONG or estado == ESTADO_S2_MOM_LONG
if bar_index - bar_inicio > lookback_limit
estado := ESTADO_NEUTRO
ref_high := na
ref_low := na
bar_inicio := na
else if lado_short and rsi < rsi_os
estado := ESTADO_S1_LONG
ref_low := low
ref_high := na
bar_inicio := bar_index
else if lado_long and rsi > rsi_ob
estado := ESTADO_S1_SHORT
ref_high := high
ref_low := na
bar_inicio := bar_index
else
if estado == ESTADO_S1_SHORT
if high > ref_high and rsi > rsi_ob
ref_high := high
else if high > ref_high and rsi <= rsi_ob and rsi < rsi_sma
disparo_short := true
estado := ESTADO_NEUTRO
ref_high := na
bar_inicio := na
else if high > ref_high and rsi <= rsi_ob
estado := ESTADO_S2_MOM_SHORT
else if estado == ESTADO_S2_MOM_SHORT
if rsi < rsi_sma
disparo_short := true
estado := ESTADO_NEUTRO
ref_high := na
bar_inicio := na
else if estado == ESTADO_S1_LONG
if low < ref_low and rsi < rsi_os
ref_low := low
else if low < ref_low and rsi >= rsi_os and rsi > rsi_sma
disparo_long := true
estado := ESTADO_NEUTRO
ref_low := na
bar_inicio := na
else if low < ref_low and rsi >= rsi_os
estado := ESTADO_S2_MOM_LONG
else if estado == ESTADO_S2_MOM_LONG
if rsi > rsi_sma
disparo_long := true
estado := ESTADO_NEUTRO
ref_low := na
bar_inicio := na
// ============================================================================
// GESTIÓN DE RIESGO
// ============================================================================
entrada = close
sl_short = high * (1 + sl_pct / 100)
tp_short = entrada - (sl_short - entrada) * tp_mult
sl_long = low * (1 - sl_pct / 100)
tp_long = entrada + (entrada - sl_long) * tp_mult
if disparo_short
strategy.entry("SHORT", strategy.short)
strategy.exit("SL/TP SHORT", from_entry="SHORT", stop=sl_short, limit=tp_short)
if disparo_long
strategy.entry("LONG", strategy.long)
strategy.exit("SL/TP LONG", from_entry="LONG", stop=sl_long, limit=tp_long)
// ============================================================================
// SEÑALES VISUALES
// ============================================================================
plotshape(disparo_short, title="Señal SHORT", style=shape.triangledown, location=location.abovebar, color=color.red, size=size.small, text="SHORT")
plotshape(disparo_long, title="Señal LONG", style=shape.triangleup, location=location.belowbar, color=color.green, size=size.small, text="LONG")
// ============================================================================
// ALERTAS — usar "Any alert() function call" en TradingView
// ============================================================================
alertcondition(disparo_short, title="Señal SHORT - Divergencia de techo", message="Señal SHORT: divergencia de RSI confirmada")
alertcondition(disparo_long, title="Señal LONG - Divergencia de piso", message="Señal LONG: divergencia de RSI confirmada")| Parámetro | Valor por defecto | Qué controla |
|---|---|---|
| rsi_length | 14 | Período del RSI |
| rsi_ma_length | 5 | Período de la SMA aplicada al RSI |
| rsi_ob | 65 | Nivel de sobrecompra |
| rsi_os | 30 | Nivel de sobreventa |
| lookback_limit | 200 | Máximo de velas antes de resetear el setup |
| sl_pct | 1.0% | Stop Loss en % arriba/abajo de la vela de disparo |
| tp_mult | 2.0 | Multiplicador de riesgo para el Take Profit (por defecto: 2R) |
Pegando el Pine Script en TradingView y configurando
Con el archivo pine_script.pine generado, el próximo paso es poner el código a funcionar en TradingView - sin instalar nada, directo en el Pine Editor de la plataforma.
Abriendo el Pine Editor y agregando al gráfico
Con el Pine Script generado, abrí TradingView y entrá al Pine Editor en el menú de abajo. Pegá el código, hacé clic en "Add to chart" y esperá que compile.
Si no hay errores de sintaxis, los triángulos SHORT (rojo) y LONG (verde) aparecen directo en el gráfico. Lo testeamos en ETH/USDT 4H y funcionó sin ajustes adicionales.
Configurando los parámetros de la estrategia
Hacé clic en el ícono de engranaje al lado del nombre de la estrategia en el gráfico para acceder a los inputs. Los parámetros configurables aparecen agrupados exactamente como se definieron en el Pine Script.
💡 Consejo Sano: Como el script no fija el tamaño de la orden en el código, tenés que configurarlo manualmente: pestaña Properties del panel de la estrategia → sección Order size → elegí Percent of equity y poné 100. Si te olvidás de esto, TradingView usa 1 unidad fija por operación en vez de invertir todo el capital disponible, y el resultado del backtest no tiene sentido.
Resultados del backtest: ETH/USDT 4H (dic/2021 a sep/2026)
⚠️ Aviso de riesgo: El trading de criptomonedas implica riesgo real de pérdida de capital. Los resultados pasados no garantizan resultados futuros. Este contenido es educativo y no constituye asesoramiento financiero ni de inversión.
Después de agregar la estrategia al gráfico y configurar el tamaño de la orden, el Strategy Tester calcula los resultados históricos automáticamente. Lo testeamos en ETH/USDT 4H con el período de diciembre de 2021 a septiembre de 2026, arrancando con 10.000 USDT de capital.
Los números de abajo son datos históricos - los resultados pasados no garantizan resultados futuros.
| Métrica | Resultado |
|---|---|
| P&L total | +261.43% |
| Total de operaciones | 136 |
| Operaciones ganadoras | 30.15% (41/136) |
| Profit factor | 1,588 |
| Drawdown máximo | 21.97% |
| Período | Dic/2021 - Sep/2026 |
El 30.15% de operaciones ganadoras puede parecer bajo, pero es coherente con un sistema 2R cada operación ganadora rinde el doble de lo que pierde una perdedora.
En otras palabras, ni siquiera necesitás acertar 1 de cada 3 operaciones para tener un resultado positivo en el histórico. El profit factor de 1,588 confirma que las ganancias superaron a las pérdidas en un 58,8% en el período testeado.
El drawdown de 21.97% es un número real y no lo suavizamos: en algún momento del período, la estrategia redujo el capital en casi un cuarto antes de recuperarse. Rodá el backtest en distintos activos y timeframes antes de tomar cualquier decisión con capital real.
💡 Consejo Sano: Corré siempre el mismo backtest en dos o tres ventanas de tiempo distintas antes de confiar en un solo número. La ventana que elegimos acá (dic/2021 a sep/2026) le pega a un ciclo bajista fuerte de ETH al principio del período - un recorte distinto de fechas te puede dar un resultado bastante diferente con la misma lógica exacta.
Configurando alertas en TradingView para esta estrategia Pine Script
Con la estrategia funcionando en el gráfico, el próximo paso es configurar alertas para recibir un aviso cada vez que dispare una señal SHORT o LONG - sin necesidad de estar mirando el gráfico todo el día.
¿Cómo configurar alertas para una estrategia Pine Script en TradingView?
En scripts strategy(), usá la función alertcondition() dentro del código Pine Script. Al crear la alerta en TradingView, elegí la condición correspondiente a "Señal SHORT" o "Señal LONG" en el desplegable.
Cada alerta identifica cuál señal disparó, incluyendo el ticker y el precio de cierre.
¿Cómo testear una estrategia en TradingView antes de operar?
Usá el Strategy Tester, disponible en la barra de abajo de TradingView. Muestra métricas como el porcentaje de operaciones ganadoras, el profit factor, el drawdown máximo y la equity curve con datos históricos.
Para testear tu estrategia, alcanza con agregar el Pine Script al gráfico - el tester se actualiza automáticamente. Los resultados de un backtest no garantizan una performance futura.
Conclusión - de cero a Pine Script en una sesión
El proceso completo para crear una estrategia Pine Script sin programar, de cero al código funcionando en TradingView:
- Crear la carpeta de la estrategia y abrir Claude Code
- Escribir el CLAUDE.md definiendo el rol del asistente
- Describir la estrategia en estrategia.md en lenguaje natural, incluyendo el orden de precedencia entre reglas
- Validar la lógica con Claude Code antes de generar el código
- Pegar el Pine Script en TradingView, configurar el tamaño de la orden y las alertas
Este es el Art. 2 de la Serie Bot CriptoMatiko - si estás arrancando, leé primero el Art. 1: ¿vale la pena tener un bot de trading propio? El código de arriba está disponible como punto de partida para estudiar la lógica y adaptarlo a tu propio enfoque.
No interpretes los resultados del backtest como validación para uso real. El Pine Script generado es un ejemplo educativo - adaptalo, testealo y evaluá con responsabilidad.
En los próximos artículos de la serie seguimos documentando el proceso: del Pine Script al bot automatizado, con Python y la API de una exchange. Mientras tanto, podés seguir bots corriendo con capital real en el CriptoMatiko Lab - datos verificados vía API, no estimados.
⚠️ Aviso de riesgo: El trading de criptomonedas implica riesgo real de pérdida de capital. Los resultados pasados no garantizan resultados futuros. Este contenido es educativo y no constituye asesoramiento financiero ni de inversión.
Preguntas frecuentes sobre crear una estrategia Pine Script
Respondemos abajo las dudas más comunes de quienes están arrancando a crear estrategias Pine Script en TradingView con IA.
¿Necesito saber programar para crear una estrategia Pine Script en TradingView?
No. Con Claude Code describís la lógica de tu estrategia en lenguaje natural y él genera el Pine Script. Lo que necesitás es saber describir con claridad: cuándo entrar, cuándo salir y cuál es el riesgo por operación.
¿Cuánto tiempo lleva crear una estrategia Pine Script con IA?
En esta sesión, desde el primer prompt hasta el Pine Script funcional llevó menos de 15 minutos - incluyendo la validación de la lógica antes de generar el código. El tiempo varía según la complejidad de la estrategia y qué tan clara sea tu descripción inicial.
¿El Pine Script generado por IA funciona sin editarlo a mano?
En esta sesión funcionó sin ajustes de código - el script compiló y graficó las señales directo. Esto depende de la claridad de la especificación: cuanto más preciso seas en los casos límite, menor la chance de tener que corregir algo después.
¿Tengo que pagar una suscripción de TradingView para crear estrategias Pine Script?
No. La cuenta gratuita de TradingView alcanza para crear, testear y configurar alertas básicas con Pine Script. Solo necesitás un plan pago (Essential) cuando quieras conectar la estrategia a un bot vía webhook.
¿Cuál es la diferencia entre un indicador y una estrategia en Pine Script?
Un indicador (declarado con indicator()) solo dibuja señales en el gráfico, sin simular operaciones. Una estrategia (declarada con strategy(), como la de este artículo) simula entradas y salidas reales, calculando P&L, porcentaje de operaciones ganadoras y drawdown automáticamente en el Strategy Tester.
Algunos links en este artículo son de afiliados, con bonos exclusivos para vos. ¿Cómo funciona?
