<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/">
    <channel>
        <title>Valdovinos Code</title>
        <link>https://albertovaldovinos.com</link>
        <description>Ingeniería de software, IA generativa y productividad, explicadas con claridad.</description>
        <lastBuildDate>Thu, 19 Nov 2026 04:58:59 GMT</lastBuildDate>
        <docs>https://validator.w3.org/feed/docs/rss2.html</docs>
        <generator>https://github.com/jpmonette/feed</generator>
        <language>es</language>
        <image>
            <title>Valdovinos Code</title>
            <url>https://albertovaldovinos.com/photo.png</url>
            <link>https://albertovaldovinos.com</link>
        </image>
        <copyright>© 2026 Valdovinos</copyright>
        <item>
            <title><![CDATA[Cuánto cuesta realmente un asistente con IA, y cómo bajarlo sin perder calidad]]></title>
            <link>https://albertovaldovinos.com/blog/optimizar-costos-de-ia</link>
            <guid>https://albertovaldovinos.com/blog/optimizar-costos-de-ia</guid>
            <pubDate>Wed, 18 Nov 2026 23:30:00 GMT</pubDate>
            <description><![CDATA[El costo de un LLM es una multiplicación: tokens por precio por token. Caché, ruteo de modelos, agentes y memoria, y por qué ningún ahorro vale si no mides la calidad al mismo tiempo. Con calculadora.]]></description>
            <content:encoded><![CDATA[<p>Hacer que un asistente con IA funcione es la primera mitad del trabajo. La segunda es que la factura al final del mes tenga sentido. Y casi nadie la planea desde el principio.</p>
<p>Estoy cursando <strong>AI Cost Optimization</strong> de ByteByteGo, con Jeremy Hintz, y el curso arranca con una idea que ordena todo lo demás: el costo de un modelo de lenguaje es una multiplicación.</p>
<blockquote>
<p><strong>costo = número de tokens × precio por token</strong></p>
</blockquote>
<p>Toda técnica de optimización ataca uno de esos dos factores. Esto es lo que me llevo.</p>
<h2>Factor 1: mandar menos tokens</h2>
<p>Cada llamada a un modelo cobra por lo que entra (instrucciones, contexto, historial) y por lo que sale (la respuesta). En un asistente con RAG, la entrada suele ser la parte más grande: el documento recuperado viaja en cada pregunta.</p>
<ul>
<li><strong>Caché del prompt:</strong> las instrucciones del sistema y el contexto fijo se repiten idénticos en cada llamada. Los proveedores cobran mucho menos por la parte que ya tienen en caché.</li>
<li><strong>Caché semántico:</strong> si alguien pregunta "¿cuántos días tengo para pedir un reembolso?" y otro "¿hasta cuándo puedo devolver algo?", es la misma pregunta. Con <em>embeddings</em> se detecta y se responde desde la caché, sin llamar al modelo.</li>
<li><strong>Compactar el contexto:</strong> resumir el historial de la conversación en lugar de reenviarlo completo.</li>
<li><strong>Memoria estructurada:</strong> guardar aparte los datos que importan para recuperarlos solo cuando se necesitan.</li>
</ul>
<p>Estas técnicas tienen una ventaja enorme: <strong>devuelven la misma respuesta por menos dinero</strong>.</p>
<h2>Factor 2: pagar menos por cada token</h2>
<p>Aquí está la diferencia más grande. Una escalera de precios típica con tres modelos (dólares por millón de tokens, entrada / salida, a noviembre de 2026):</p>
<table>
<thead>
<tr>
<th>Nivel</th>
<th>Modelo</th>
<th>Precio</th>
</tr>
</thead>
<tbody>
<tr>
<td>Económico</td>
<td>gpt-4o-mini</td>
<td>$0.15 / $0.60</td>
</tr>
<tr>
<td>Intermedio</td>
<td>claude-haiku-4-5</td>
<td>$1.00 / $5.00</td>
</tr>
<tr>
<td>Frontera</td>
<td>claude-sonnet-4-6</td>
<td>$3.00 / $15.00</td>
</tr>
</tbody>
</table>
<p>El modelo de frontera cuesta unas <strong>20 veces más</strong>. Para una pregunta sencilla ("¿cuántos días tengo para pedir un reembolso?") los dos responden bien, y pagar el fuerte es tirar el dinero. Para una pregunta con trampa ("me equivoqué de contraseña 3 veces a las 10:00 y 2 veces a las 10:20, ¿está bloqueada mi cuenta?"), el económico se equivocó en las pruebas y el fuerte no.</p>
<p>Ese es el problema del <strong>ruteo de modelos</strong>: decidir, pregunta por pregunta, qué modelo responde.</p>
<h3>Cuatro formas de rutear, de la más simple a la más sofisticada</h3>
<ol>
<li><strong>Reglas en el gateway.</strong> Se califica la pregunta por su forma: longitud, palabras como "paso a paso", código, montos. Es gratis y auditable, pero mide qué tan complicada <em>se ve</em> una pregunta, no qué tan difícil <em>es</em>. Y cada regla nueva trae falsos positivos que alguien tiene que mantener.</li>
<li><strong>Rutas por embeddings.</strong> Cada pregunta se compara con ejemplos de cada departamento (pedidos, facturación, cuenta) y se manda al modelo asignado a ese departamento. Funciona, pero "facturación es dinero, mándalo al fuerte" sigue siendo una suposición humana.</li>
<li><strong>Cascada.</strong> Responde primero el modelo económico, un verificador barato califica la respuesta y, si hay duda, escala al fuerte. La idea viene del paper <em>FrugalGPT</em>. Su trampa: cuando escala, pagas los dos intentos.</li>
<li><strong>Ruteo por preferencias.</strong> Un modelo de <em>machine learning</em> clásico, entrenado con miles de comparaciones entre respuestas de modelos, predice desde la pregunta si el modelo fuerte daría una respuesta mejor. Es el enfoque de <em>RouteLLM</em>.</li>
</ol>
<p>La calculadora de abajo compara la cascada contra mandar todo a un solo modelo. Mueve el porcentaje de preguntas difíciles y la tasa de falsas alarmas del verificador, y observa en qué momento deja de ahorrar.</p>
<!-- interactive -->
<h2>Lo que más me sorprendió</h2>
<h3>Rutear cambia la respuesta</h3>
<p>La caché y la compresión devuelven la misma respuesta por menos dinero. El ruteo no: un modelo distinto puede responder distinto. Por eso cada experimento debe registrar <strong>costo y precisión en la misma tabla</strong>. Un ahorro sin la columna de calidad no sirve para tomar una decisión de producción.</p>
<p>Es exactamente la idea de <a href="/blog/ciclo-de-vida-aplicacion-genai">las evals en el ciclo de vida de una aplicación GenAI</a>: sin una forma de medir, no sabes si ahorraste o si empeoraste el producto.</p>
<h3>Los umbrales no se pueden copiar</h3>
<p>RouteLLM publica umbrales calibrados con tráfico público de chatbots. En la práctica, el umbral que en teoría manda "más o menos la mitad" al modelo fuerte mandó alrededor del 60% del tráfico de ejemplo. Un umbral solo vale para el tráfico con el que se calibró. La forma correcta es calibrarlo con una muestra de tu propio tráfico y una decisión de negocio: "puedo pagar el modelo fuerte en el 30% de las preguntas".</p>
<h3>El valor de un router está en tus datos</h3>
<p>Entrené un router propio con unas 250 comparaciones de preguntas de un negocio de ejemplo. El router publicado, entrenado con decenas de miles de comparaciones, distinguía las preguntas difíciles apenas mejor que una moneda al aire en ese dominio. El propio, con 250 ejemplos, lo superó.</p>
<p>Y aun así, con solo 32 preguntas de prueba, no se podía demostrar que uno fuera mejor que el otro: el modelo económico se equivocaba en tan pocas que casi no había dónde ver la diferencia. Medir bien también requiere suficientes datos.</p>
<h2>Agentes: el costo crece con cada paso</h2>
<p>Un agente es un modelo en un ciclo con herramientas. El problema de costo es que <strong>en cada paso vuelve a leer todo lo anterior</strong>: las instrucciones, la definición de cada herramienta y cada resultado previo. En una prueba, la última llamada de un agente fue más del doble de grande que la primera, y todo se cobró al precio del modelo fuerte.</p>
<p>Dos ideas para controlarlo:</p>
<ul>
<li><strong>Planear y ejecutar.</strong> El modelo fuerte lee el caso una sola vez y escribe un plan de pasos independientes. Cada paso lo ejecuta un modelo económico con un contexto limpio. El costo se concentra en el plan; si el caso es sencillo, el plan es puro gasto extra.</li>
<li><strong>Equipos de especialistas.</strong> Cada agente tiene su modelo, sus herramientas y su parte de la documentación: facturación con el modelo fuerte, pedidos con el económico. Pero un sistema multiagente <strong>no es más barato por diseño</strong>: solo lo es si el trabajo realmente cae en los agentes baratos. En un ejemplo, bajar al especialista de facturación de nivel recortó el costo del equipo alrededor de 40% y perdió uno de nueve datos correctos.</li>
</ul>
<h2>Memoria: compactar sin olvidar</h2>
<p>Resumir la conversación ahorra tokens, pero el resumen puede tirar justo el dato importante. Un ejemplo clarísimo: el cliente da su número de pedido en el primer mensaje y lo vuelve a necesitar en el décimo; con la conversación compactada, el asistente ya no lo tiene.</p>
<p>La solución es una memoria de hechos: después de cada turno, un modelo económico extrae los datos duraderos (identificadores, montos, decisiones) y antes de cada respuesta se recuperan los que tienen que ver con la pregunta.</p>
<h2>Mi checklist de costos</h2>
<ul>
<li>¿Sé cuánto cuesta <strong>cada solicitud</strong> y cada etapa de un agente, no solo la factura total?</li>
<li>¿Las instrucciones y el contexto fijo aprovechan la <strong>caché del prompt</strong>?</li>
<li>¿Las preguntas repetidas se resuelven con <strong>caché semántico</strong>?</li>
<li>¿Uso el modelo fuerte solo donde <strong>mis datos</strong> demuestran que hace falta?</li>
<li>¿Cada cambio de ruteo se valida con <strong>evals</strong> de calidad, en la misma tabla que el costo?</li>
<li>¿La memoria <strong>conserva los datos clave</strong> cuando compacto la conversación?</li>
</ul>
<hr>
<blockquote>
<p>Optimizar costos de IA no es usar el modelo más barato. Es pagar el modelo caro solo cuando la diferencia se nota, y tener los datos para demostrarlo.</p>
</blockquote>
<h3>Referencias</h3>
<ul>
<li>ByteByteGo, <em>AI Cost Optimization</em>, cohorte de noviembre de 2026, con Jeremy Hintz.</li>
<li>Chen, Zaharia y Zou, <a href="https://arxiv.org/abs/2305.05176">FrugalGPT: How to Use Large Language Models While Reducing Cost and Improving Performance</a>.</li>
<li>Ong et al., <a href="https://arxiv.org/abs/2406.18665">RouteLLM: Learning to Route LLMs with Preference Data</a>.</li>
<li>Anthropic, <a href="https://www.anthropic.com/engineering/building-effective-agents">Building effective agents</a>.</li>
</ul>
]]></content:encoded>
            <author>valdovinoscode@gmail.com (Valdovinos)</author>
            <category>ai</category>
        </item>
        <item>
            <title><![CDATA[Prompt injection y jailbreaking: cuando un chatbot dice lo que no debe, y cómo evitarlo]]></title>
            <link>https://albertovaldovinos.com/blog/prompt-injection-y-jailbreaking</link>
            <guid>https://albertovaldovinos.com/blog/prompt-injection-y-jailbreaking</guid>
            <pubDate>Tue, 03 Nov 2026 18:00:00 GMT</pubDate>
            <description><![CDATA[Un asistente en producción rechaza una pregunta fuera de tema… hasta que se la escribes en leetspeak. Qué son el jailbreaking y la prompt injection, por qué siguen siendo el riesgo número uno de OWASP, y las capas de defensa que sí funcionan. Con video real y simulador.]]></description>
            <content:encoded><![CDATA[<p>Hice una prueba sencilla con el asistente virtual de atención a clientes de una empresa de servicios en México. Le pedí algo inofensivo pero claramente fuera de su función: los números del 1 al 9 en inglés, en español y en binario.</p>
<p>La primera vez respondió lo correcto: que solo puede hablar de los servicios de la empresa. Luego repetí <strong>exactamente la misma pregunta</strong>, pero escribiendo algunas palabras en <em>leetspeak</em> (cambiando letras por números, como <code>d4rm3</code> en lugar de <code>darme</code>).</p>
<figure class="wide">
  <video src="/media/prompt-injection/demo-chatbot.mp4" poster="/media/prompt-injection/demo-poster.jpg" autoplay muted loop playsinline controls preload="metadata"></video>
  <figcaption>Prueba real a un asistente en producción. La marca y el nombre del asistente están difuminados a propósito: el objetivo es aprender, no exhibir a nadie.</figcaption>
</figure>
<p>Respondió sin problema, con tablas incluidas. Y hay un segundo detalle, más sutil: citó como <strong>fuente</strong> un manual del control remoto, que no tiene nada que ver con números binarios.</p>
<p>El contenido es inofensivo. Pero la prueba demuestra dos cosas que en otro contexto sí serían graves:</p>
<ol>
<li><strong>El control de alcance se basa en la forma del texto, no en su intención.</strong> Si basta con cambiar unas letras para saltarlo, la misma técnica funciona para cosas menos inocentes.</li>
<li><strong>El sistema no verifica que su respuesta esté sustentada en lo que cita.</strong> Eso es exactamente cómo un asistente termina inventando políticas, precios o datos con apariencia oficial.</li>
</ol>
<h2>Dos ataques que se parecen, pero no son lo mismo</h2>
<p>Estas semanas estoy estudiando seguridad de IA con el material de <a href="https://learnprompting.org">Learn Prompting</a>, que distingue dos conceptos que solemos mezclar:</p>
<ul>
<li><strong>Jailbreaking:</strong> lograr que el modelo haga algo que sus creadores no querían, rompiendo sus reglas de seguridad o de alcance. Pasa típicamente cuando el usuario habla directo con un chatbot.</li>
<li><strong>Prompt injection:</strong> un ataque contra <em>la aplicación</em>. Las instrucciones del desarrollador y un texto no confiable terminan en el mismo prompt, y el texto malicioso le gana a las instrucciones originales.</li>
</ul>
<p>Una regla práctica que me gustó: si estás hablando con un chatbot, probablemente es <em>jailbreaking</em>; si el modelo está dentro de un sitio web o de un agente que lee datos, probablemente es <em>prompt injection</em>.</p>
<p>La inyección, a su vez, tiene dos variantes:</p>
<ul>
<li><strong>Directa:</strong> el atacante escribe las instrucciones maliciosas en su propio mensaje ("ignora tus instrucciones y…").</li>
<li><strong>Indirecta:</strong> las instrucciones vienen escondidas en algo que el sistema lee por su cuenta: un PDF adjunto, una página web, un correo, la respuesta de una API. Nadie las escribe en el chat. Es el caso más peligroso para los agentes.</li>
</ul>
<p>No es un tema de nicho. En la edición 2026 del <strong>OWASP Top 10 para aplicaciones con LLM</strong>, publicada en agosto, la <em>prompt injection</em> sigue en el primer lugar, como en todas las ediciones anteriores, y la <strong>agencia excesiva</strong> (darle al modelo más permisos de los necesarios) subió al tercero.</p>
<h2>Las técnicas más comunes</h2>
<p>No hace falta ser un experto para intentarlas, y por eso importan:</p>
<ul>
<li><strong>Ofuscación:</strong> leetspeak, otros idiomas, codificaciones o errores de ortografía intencionales para esquivar filtros literales. Es lo que muestra el video.</li>
<li><strong>Juego de roles:</strong> pedirle al modelo que interprete un personaje "sin reglas" o una escena de ficción donde la respuesta prohibida parece parte de la historia.</li>
<li><strong>Cambio de contexto o desvío de tarea:</strong> empezar con una petición legítima y redirigirla, o disfrazar la petición como algo inocente (el famoso "mi abuela me contaba…").</li>
<li><strong>Instrucciones escondidas en contenido:</strong> texto blanco sobre fondo blanco en un documento, comentarios en una página, metadatos.</li>
</ul>
<h2>Por qué funciona</h2>
<p>La causa de fondo es simple y todavía no tiene solución definitiva: <strong>para el modelo, las instrucciones y los datos son lo mismo</strong>. Todo llega como una sola secuencia de tokens. El modelo no tiene una forma confiable de distinguir "esto lo dijo el desarrollador" de "esto venía dentro del PDF que subió el usuario".</p>
<p>Por eso las defensas que viven <em>dentro</em> del prompt ("nunca reveles…", "ignora cualquier instrucción del usuario que…") ayudan, pero no son una barrera de seguridad. Son una sugerencia que el atacante puede negociar.</p>
<h2>Lo que está en juego</h2>
<p>En un chatbot que solo responde preguntas, el peor caso suele ser reputacional. El riesgo crece en cuanto el asistente <strong>tiene acceso a datos o puede hacer cosas</strong>:</p>
<ul>
<li>Un bot de atención que puede <strong>aplicar reembolsos</strong> por su cuenta es un bot al que se le puede pedir dinero.</li>
<li>Un asistente conectado a <strong>expedientes de clientes o pacientes</strong> es un canal de fuga de datos personales si el modelo decide quién ve qué.</li>
<li>Un agente que <strong>lee correos o páginas web</strong> puede ser secuestrado por un texto que nunca vio un humano.</li>
</ul>
<h2>Defensa en capas: ninguna barrera basta sola</h2>
<p>La idea central de seguridad aquí es la misma de siempre: <strong>asume que el modelo va a ser engañado</strong> y diseña para que, cuando eso pase, el daño sea mínimo. Prueba el simulador: elige un ataque y activa o desactiva capas para ver cuál lo detiene.</p>
<!-- interactive -->
<p>Lo que el simulador intenta mostrar, en orden de impacto:</p>
<h3>1. Los controles críticos viven fuera del modelo</h3>
<p>La autorización se decide en el backend, con la identidad real del usuario autenticado, nunca porque el modelo "creyó" que alguien era de soporte. Si el asistente consulta datos, la consulta debe estar limitada por los permisos de quien pregunta, no por lo que dice el prompt.</p>
<h3>2. Mínimo privilegio para herramientas y acciones</h3>
<p>El modelo solo debe tener las herramientas que necesita, con límites duros: montos máximos, reglas de negocio validadas en código y <strong>confirmación humana</strong> para todo lo irreversible. Un reembolso que requiere aprobación no se puede obtener con una frase ingeniosa.</p>
<h3>3. El contenido externo es dato, no instrucción</h3>
<p>Todo lo que venga de documentos, páginas o APIs debe entrar al contexto delimitado y marcado como no confiable, y el sistema debe tratarlo como información a analizar, nunca como órdenes. No es infalible, pero reduce mucho la superficie de la inyección indirecta.</p>
<h3>4. Normaliza antes de filtrar, y filtra por intención</h3>
<p>Un filtro por palabras clave se rompe con <code>d4rm3</code>. Antes de cualquier validación, normaliza el texto: leetspeak, caracteres Unicode equivalentes, codificaciones. Y para decidir si algo está dentro del alcance, usa un clasificador de intención, no una lista de palabras.</p>
<h3>5. Revisa también la salida</h3>
<p>Un guardrail de salida verifica que la respuesta esté dentro del alcance, que no contenga datos personales que no debería, y que <strong>lo que afirma esté sustentado en las fuentes que cita</strong>. Esa última revisión habría detectado la referencia al manual del control remoto del video.</p>
<h3>6. El system prompt no es un secreto</h3>
<p>OWASP renombró en 2026 su categoría de fuga del system prompt como <em>exposición de contexto oculto</em>, que abarca todo lo que se arma en el contexto del modelo. La lección es la misma: no pongas ahí credenciales, reglas de negocio sensibles ni nada que no soportarías ver publicado.</p>
<h3>7. Ataca tu propio sistema, continuamente</h3>
<p>Incluye pruebas adversariales en tus evals: un conjunto de intentos de jailbreak e inyección que se ejecuta con cada cambio de prompt o de modelo, igual que las pruebas de regresión. Y en producción, registra y monitorea los intentos bloqueados; son la mejor señal de qué están probando los atacantes. Lo conecté con el resto del proceso en <a href="/blog/ciclo-de-vida-aplicacion-genai">el ciclo de vida de una aplicación GenAI</a>.</p>
<h2>Checklist antes de poner un asistente con IA frente a clientes</h2>
<ul>
<li>¿Qué <strong>datos</strong> puede leer el asistente, y la autorización se valida <strong>fuera</strong> del modelo?</li>
<li>¿Qué <strong>acciones</strong> puede ejecutar, con qué límites, y cuáles requieren confirmación humana?</li>
<li>¿El contenido de archivos, páginas y APIs entra <strong>marcado como no confiable</strong>?</li>
<li>¿Los filtros de entrada <strong>normalizan</strong> el texto y evalúan <strong>intención</strong>, no solo palabras?</li>
<li>¿Hay un <strong>guardrail de salida</strong> que revise alcance, datos personales y sustento en fuentes?</li>
<li>¿El system prompt está libre de <strong>secretos</strong>?</li>
<li>¿Tengo un set de <strong>pruebas adversariales</strong> que corre con cada cambio, y <strong>monitoreo</strong> de intentos en producción?</li>
</ul>
<hr>
<h2>Una nota sobre divulgación responsable</h2>
<p>Si encuentras un comportamiento así en un sistema que no es tuyo, lo correcto es reportarlo a la empresa antes de publicarlo con su nombre, y nunca intentar obtener datos o acciones reales. En este caso el contenido era inofensivo y la marca está anonimizada; el propósito es mostrar un patrón que se repite en muchos asistentes, no señalar a uno.</p>
<blockquote>
<p>Un modelo de lenguaje no es una frontera de seguridad. Es un componente que puede ser persuadido. La seguridad está en todo lo que lo rodea.</p>
</blockquote>
<h3>Referencias</h3>
<ul>
<li>OWASP GenAI Security Project, <a href="https://genai.owasp.org/">Top 10 para aplicaciones con LLM</a>.</li>
<li>Learn Prompting, <a href="https://learnprompting.org">material sobre prompt hacking, jailbreaking y prompt injection</a>.</li>
</ul>
]]></content:encoded>
            <author>valdovinoscode@gmail.com (Valdovinos)</author>
            <category>seguridad</category>
        </item>
        <item>
            <title><![CDATA[Biometría que se puede auditar: cómo leer NIST FRTE, ISO/IEC 30107-3, APCER y BPCER]]></title>
            <link>https://albertovaldovinos.com/blog/biometria-que-se-puede-auditar</link>
            <guid>https://albertovaldovinos.com/blog/biometria-que-se-puede-auditar</guid>
            <pubDate>Fri, 16 Oct 2026 18:00:00 GMT</pubDate>
            <description><![CDATA[Las soluciones de identidad presumen siglas como NIST, ISO 30107-3 o “liveness”. Qué mide realmente cada una, qué no mide, y qué debe exigir un ingeniero antes de confiar en un sistema biométrico. Incluye un simulador del umbral de decisión.]]></description>
            <content:encoded><![CDATA[<p>Cualquier plataforma de verificación de identidad muestra en su página una fila de siglas: <em>NIST</em>, <em>ISO/IEC 30107-3</em>, <em>liveness</em>, <em>KYC</em>. Suenan a garantía, pero cada una responde una pregunta distinta, y ninguna por sí sola dice si el sistema es seguro.</p>
<p>En esta entrada explico, desde el punto de vista de un ingeniero, qué significa cada una, cómo leer sus números y qué preguntas hacer antes de poner un sistema biométrico en producción.</p>
<h2>Dos preguntas que no son la misma</h2>
<p>Un sistema de reconocimiento facial en un proceso de confianza tiene que responder dos cosas:</p>
<ol>
<li><strong>¿Eres tú?</strong> Comparar el rostro capturado contra una referencia. Puede ser una <strong>verificación 1:1</strong> (¿esta persona es quien dice ser, según su identificación?) o una <strong>identificación 1:N</strong> (¿quién de toda la base de datos es esta persona?).</li>
<li><strong>¿Eres real?</strong> Confirmar que frente a la cámara hay una persona viva y presente, y no una foto, un video en una pantalla o una máscara. Esto es la <strong>detección de ataques de presentación</strong> (PAD), lo que en el mercado se llama <em>liveness</em>.</li>
</ol>
<p>Un algoritmo puede ser excelente en la primera pregunta y vulnerable en la segunda. Por eso se evalúan por separado.</p>
<h2>NIST FRTE y FATE: un banco de pruebas, no un sello</h2>
<p>Durante años, la referencia mundial fue el <em>Face Recognition Vendor Test</em> (FRVT) del NIST de Estados Unidos. En 2023 el programa se dividió en dos:</p>
<ul>
<li><strong>FRTE</strong> (<em>Face Recognition Technology Evaluation</em>): mide la precisión del reconocimiento, en pistas como verificación 1:1 e identificación 1:N.</li>
<li><strong>FATE</strong> (<em>Face Analysis Technology Evaluation</em>): mide capacidades de análisis, como detección de ataques de presentación, detección de <em>morphing</em> y calidad de imagen.</li>
</ul>
<p>Lo importante: <strong>aparecer en NIST no es una certificación</strong>. Significa que un fabricante envió su algoritmo y el NIST lo midió con sus conjuntos de datos. Al leer un resultado conviene preguntar:</p>
<ul>
<li><strong>¿Qué pista?</strong> No es lo mismo 1:1 que 1:N, ni fotos de visa que imágenes tomadas en la calle.</li>
<li><strong>¿Qué fecha?</strong> Los algoritmos mejoran rápido; un resultado de hace dos años dice poco.</li>
<li><strong>¿En qué punto de operación?</strong> La tasa de rechazo (FNMR) siempre se reporta a una tasa de falsa aceptación (FMR) fija. Bajar una sube la otra.</li>
</ul>
<h2>ISO/IEC 30107-3: cómo se mide el <em>liveness</em></h2>
<p>La norma ISO/IEC 30107-3 (segunda edición, 2023) define <strong>cómo probar y reportar</strong> la detección de ataques de presentación. Sus dos métricas centrales son:</p>
<ul>
<li><strong>APCER</strong> (<em>Attack Presentation Classification Error Rate</em>): la proporción de ataques que el sistema clasificó como personas reales. Es decir, <strong>cuántos fraudes pasaron</strong>.</li>
<li><strong>BPCER</strong> (<em>Bona fide Presentation Classification Error Rate</em>): la proporción de personas reales que el sistema clasificó como ataque. Es decir, <strong>cuántos usuarios legítimos fueron rechazados</strong>.</li>
</ul>
<p>Las dos dependen del mismo umbral de decisión, y se mueven en sentidos opuestos. No hay forma de bajar ambas moviendo el umbral; solo un mejor detector las baja a la vez. Muévelo tú:</p>
<!-- interactive -->
<p>Tres detalles que suelen perderse en los materiales comerciales:</p>
<ol>
<li><strong>El APCER se reporta por tipo de ataque.</strong> Un sistema puede detectar el 100% de las fotos impresas y fallar con máscaras de silicón. Un solo APCER "promedio" esconde el peor caso, que es justo el que buscará un atacante.</li>
<li><strong>La norma no define niveles.</strong> Expresiones como "nivel 1" o "nivel 2" vienen de los programas de prueba de laboratorios acreditados, que eligen qué ataques probar y con qué presupuesto. Decir "cumple con 30107-3" sin nombrar el laboratorio, el nivel y los resultados dice qué manual se usó, no qué resultado se obtuvo.</li>
<li><strong>No cubre los ataques de inyección.</strong> La norma trata ataques <em>frente a la cámara</em>. Un atacante que inyecta un video, o un <em>deepfake</em>, directamente en el flujo de datos, con una cámara virtual o un dispositivo manipulado, nunca "presenta" nada ante el sensor. Eso requiere controles adicionales: integridad del dispositivo, del canal y de la sesión.</li>
</ol>
<h2>El dato biométrico es un dato sensible</h2>
<p>En México, la nueva <strong>Ley Federal de Protección de Datos Personales en Posesión de los Particulares</strong> se publicó en el DOF el 20 de marzo de 2025 y entró en vigor al día siguiente, sustituyendo a la ley de 2010. La autoridad en la materia para particulares dejó de ser el INAI y pasó a la Secretaría Anticorrupción y Buen Gobierno.</p>
<p>Para quien construye el sistema, la conclusión práctica es clara: un rostro es un <strong>dato personal sensible</strong>, y su tratamiento exige consentimiento informado y medidas de seguridad proporcionales al riesgo. En el diseño eso se traduce en decisiones concretas:</p>
<ul>
<li><strong>Guardar plantillas, no fotos</strong>, siempre que el proceso lo permita, y cifrarlas en reposo y en tránsito.</li>
<li><strong>Definir la retención</strong> desde el diseño: cuánto tiempo vive cada dato y quién puede borrarlo.</li>
<li><strong>Registrar cada decisión</strong> con su puntaje, su umbral y la versión del modelo, para poder auditarla después.</li>
<li><strong>Revisión humana</strong> de los resultados adversos: si una persona es rechazada en un proceso de contratación, alguien debe poder explicar por qué.</li>
</ul>
<p><em>No soy abogado; esto es la lectura de un ingeniero. Cualquier implementación debe validarse con el área legal.</em></p>
<h2>Checklist antes de confiar en un sistema biométrico</h2>
<ul>
<li>¿Qué resultado de <strong>NIST FRTE</strong> tiene el algoritmo, en qué pista y de qué fecha?</li>
<li>¿Su <strong>PAD</strong> fue evaluado por un laboratorio independiente bajo ISO/IEC 30107-3? ¿Con qué nivel y qué <strong>APCER por tipo de ataque</strong>?</li>
<li>¿Qué <strong>BPCER</strong> espero con mi población real, mis cámaras y mi iluminación? ¿Lo medí con una prueba piloto?</li>
<li>¿Qué controles tengo contra <strong>ataques de inyección</strong>?</li>
<li>¿Mi umbral está elegido según el <strong>costo real</strong> de cada error en mi proceso: fraude contra fricción?</li>
<li>¿Cada decisión queda <strong>registrada y es auditable</strong>?</li>
<li>¿El tratamiento de datos cumple con la <strong>LFPDPPP</strong> y está documentado en el aviso de privacidad?</li>
</ul>
<hr>
<h2>La misma lección que con los LLM</h2>
<p>Esta semana escribí que <a href="/blog/como-funciona-un-llm-en-7-frases">ningún número cuenta la historia completa de un modelo de lenguaje</a>. Con la biometría pasa exactamente lo mismo: un porcentaje de "confianza" no significa nada sin saber qué se midió, contra qué ataques, en qué punto de operación y con qué población. La confianza no se declara; se mide, se registra y se puede auditar.</p>
<h3>Referencias</h3>
<ul>
<li>NIST, <a href="https://www.nist.gov/programs-projects/face-technology-evaluations-frtefate">Face Technology Evaluations – FRTE/FATE</a>.</li>
<li>Cámara de Diputados, <a href="https://www.diputados.gob.mx/LeyesBiblio/pdf/LFPDPPP.pdf">Ley Federal de Protección de Datos Personales en Posesión de los Particulares</a> (nueva ley, DOF 20-03-2025).</li>
<li>ISO, <a href="https://www.iso.org/standard/79520.html">ISO/IEC 30107-3:2023 – Presentation attack detection, Part 3: Testing and reporting</a>.</li>
</ul>
]]></content:encoded>
            <author>valdovinoscode@gmail.com (Valdovinos)</author>
            <category>seguridad</category>
        </item>
        <item>
            <title><![CDATA[Cómo funciona un LLM, en 7 frases]]></title>
            <link>https://albertovaldovinos.com/blog/como-funciona-un-llm-en-7-frases</link>
            <guid>https://albertovaldovinos.com/blog/como-funciona-un-llm-en-7-frases</guid>
            <pubDate>Tue, 13 Oct 2026 17:00:00 GMT</pubDate>
            <description><![CDATA[De la predicción del siguiente token a un producto con guardrails: los fundamentos de los modelos de lenguaje, condensados en siete ideas y con un playground para ver en vivo qué hacen la temperatura y el top-p.]]></description>
            <content:encoded><![CDATA[<p>Cuando empecé a estudiar a fondo los modelos de lenguaje, me propuse un ejercicio: al final de cada semana, resumir todo lo aprendido en siete frases. Si no cabe en siete frases, todavía no lo entiendo.</p>
<p>Este es el resumen de la <strong>semana 1</strong>: los fundamentos. Para cada frase agrego lo que realmente significa cuando construyes un producto con un LLM.</p>
<h2>1. La mayoría de los LLM son Transformers <em>decoder-only</em> entrenados para predecir el siguiente token</h2>
<p>Un LLM no "entiende" una pregunta y luego "piensa" una respuesta. Recibe una secuencia de tokens (fragmentos de palabras) y calcula una distribución de probabilidad sobre cuál debería ser el siguiente. Eso es todo. La arquitectura <em>decoder-only</em>, la de la familia GPT y la mayoría de los modelos abiertos como Llama, solo mira hacia atrás: cada token se predice a partir de los anteriores.</p>
<p><strong>En producción:</strong> todo lo que el modelo "sabe" de tu caso tiene que estar en el contexto. Si no está en el prompt, en los documentos recuperados o en la conversación, para el modelo no existe.</p>
<h2>2. El preentrenamiento con billones de tokens produce un modelo base con conocimiento amplio, pero que solo continúa texto</h2>
<p>El preentrenamiento consume cantidades enormes de texto, limpio y tokenizado. El resultado es un <strong>modelo base</strong>: sabe muchísimo, pero si le escribes "¿Cuál es la capital de Francia?", puede responder con otra pregunta, porque en internet las preguntas suelen venir en listas de preguntas.</p>
<p><strong>En producción:</strong> casi nunca usas un modelo base directamente. Usas uno que ya pasó por las etapas 4 y 5.</p>
<h2>3. El texto se genera token por token; la estrategia de decodificación equilibra enfoque y variedad</h2>
<p>En cada paso, el modelo produce probabilidades y alguien tiene que <strong>elegir</strong> un token. Ahí entran dos perillas:</p>
<ul>
<li><strong>Temperatura:</strong> escala las probabilidades. Baja la concentra en lo más probable; alta la aplana y da oportunidad a opciones raras.</li>
<li><strong>Top-p (nucleus sampling):</strong> solo sortea entre los tokens más probables que, juntos, suman <em>p</em>. Todo lo demás queda fuera, aunque la temperatura sea alta.</li>
</ul>
<p>Pruébalo tú mismo. Mueve las perillas y genera respuestas para ver cuánta variedad sale:</p>
<!-- interactive -->
<p><strong>En producción:</strong> la configuración depende de la tarea. Para extraer campos de un documento o generar código conviene temperatura baja; para lluvia de ideas, más alta. Y la misma configuración que funciona en un caso puede ser un riesgo en otro.</p>
<h2>4. El SFT enseña al modelo base a seguir instrucciones a partir de ejemplos (prompt, respuesta)</h2>
<p>El <em>Supervised Fine-Tuning</em> toma el modelo base y lo entrena con pares de instrucción y respuesta escritos o curados por personas. Ahí aprende el formato de un asistente: responder la pregunta, seguir el tono pedido, respetar una estructura.</p>
<p><strong>En producción:</strong> cuando haces <em>fine-tuning</em> de un modelo con tus propios ejemplos, estás haciendo una versión pequeña de este paso. Es poderoso, pero caro de iterar; muchas veces un buen prompt o mejores datos de contexto resuelven lo mismo.</p>
<h2>5. El aprendizaje por refuerzo hace las respuestas más correctas, útiles y seguras</h2>
<p>Después del SFT viene el aprendizaje por refuerzo (RL). El modelo genera respuestas y recibe una recompensa, que puede venir de <strong>verificadores</strong> automáticos (¿el código compila?, ¿la respuesta matemática es correcta?) o de un <strong>modelo de recompensa</strong> entrenado con las preferencias de personas que compararon respuestas.</p>
<p><strong>En producción:</strong> este paso explica por qué los modelos modernos rechazan ciertas solicitudes, piden aclaraciones o admiten incertidumbre. No es un accidente; es comportamiento entrenado.</p>
<h2>6. Se evalúa con benchmarks, jueces LLM, calificaciones humanas y arenas; ningún número cuenta la historia completa</h2>
<p>Un modelo puede ser excelente en un benchmark de matemáticas y mediocre en tu caso de uso. Por eso se combinan varias señales: benchmarks públicos, un LLM que califica respuestas con una rúbrica, evaluación humana y arenas donde las personas comparan modelos a ciegas.</p>
<p><strong>En producción:</strong> los benchmarks públicos te ayudan a elegir un modelo; <strong>tus propias evals</strong> te dicen si funciona para tu problema. Lo desarrollé a fondo en <a href="/blog/ciclo-de-vida-aplicacion-genai">el ciclo de vida de una aplicación GenAI</a>.</p>
<h2>7. Un producto real envuelve al LLM con guardrails, manejo de prompts y gestión de sesiones</h2>
<p>El modelo es solo una pieza. Alrededor necesita:</p>
<ul>
<li><strong>Guardrails:</strong> filtros de entrada y salida para datos sensibles, contenido inseguro o respuestas fuera de política.</li>
<li><strong>Manejo de prompts:</strong> plantillas versionadas, contexto recuperado, instrucciones del sistema.</li>
<li><strong>Gestión de sesiones:</strong> memoria de la conversación, límites de contexto, identidad del usuario y permisos.</li>
</ul>
<p><strong>En producción:</strong> aquí es donde se juega la seguridad. Un LLM conectado a datos reales hereda todos los riesgos de cualquier sistema que maneja información sensible, más algunos nuevos, como la inyección de prompts.</p>
<hr>
<h2>La idea que me llevo de la semana 1</h2>
<blockquote>
<p>Un LLM es un predictor de tokens muy bien educado. El producto es todo lo que construyes alrededor para que esa predicción sea útil, medible y segura.</p>
</blockquote>
<p>La próxima semana: cómo se representa el significado (embeddings), cómo funciona la recuperación de documentos (RAG) y por qué la calidad de los datos importa más que el tamaño del modelo.</p>
]]></content:encoded>
            <author>valdovinoscode@gmail.com (Valdovinos)</author>
            <category>ai</category>
        </item>
        <item>
            <title><![CDATA[Del demo a producción: el ciclo de vida de una aplicación GenAI]]></title>
            <link>https://albertovaldovinos.com/blog/ciclo-de-vida-aplicacion-genai</link>
            <guid>https://albertovaldovinos.com/blog/ciclo-de-vida-aplicacion-genai</guid>
            <pubDate>Tue, 29 Sep 2026 17:00:00 GMT</pubDate>
            <description><![CDATA[Hacer que un modelo responda bien en una demo toma una tarde. Hacer que responda bien todos los días, frente a usuarios reales, es otra disciplina. Este es el mapa completo, paso a paso y en versión interactiva.]]></description>
            <content:encoded><![CDATA[<p>Hay un momento que casi todos los que trabajamos con IA generativa hemos vivido: escribes un buen prompt, el modelo responde algo sorprendente, y alguien en la sala dice <em>"esto ya está, hay que lanzarlo"</em>.</p>
<p>No está. Lo que tienes es un <strong>prototipo</strong>. Entre ese momento y una aplicación en la que la gente confía todos los días hay un proceso entero: definir qué significa "funcionar bien", medirlo, observar lo que pasa en producción y convertir cada falla en una mejora. Ese proceso no es una línea recta. Es un ciclo.</p>
<p>En este artículo te comparto el mapa que uso para pensar en ese ciclo. Abajo lo encuentras en versión <strong>interactiva</strong>: puedes recorrerlo paso a paso o hacer clic en cualquier bloque para ver qué es, por qué importa y qué preguntas debe responder tu equipo antes de avanzar.</p>
<h2>Por qué el software con IA necesita otro proceso</h2>
<p>En el software tradicional, si una función recibe la misma entrada, devuelve la misma salida. Escribes pruebas unitarias, pasan, y puedes dormir tranquilo.</p>
<p>Con un modelo de lenguaje eso deja de ser cierto. Tres cosas cambian las reglas:</p>
<ul>
<li><strong>No es determinístico.</strong> La misma pregunta puede producir respuestas distintas, y un cambio en el prompt que arregla un caso puede romper otros diez.</li>
<li><strong>Falla en silencio.</strong> Una API rota lanza un error. Un modelo que alucina devuelve un <code>200 OK</code> con una respuesta perfectamente redactada… y equivocada.</li>
<li><strong>Se mueve debajo de ti.</strong> El proveedor actualiza el modelo, tus usuarios empiezan a preguntar cosas nuevas, tus documentos cambian. La calidad puede degradarse sin que nadie toque el código.</li>
</ul>
<p>Por eso no basta con "construir y lanzar". Hay que construir, <strong>medir, observar y mejorar</strong> de forma continua.</p>
<h2>Las cuatro fases del ciclo</h2>
<p>El mapa tiene 17 pasos agrupados en cuatro fases:</p>
<ol>
<li><strong>Definir.</strong> Antes de escribir código: cuál es el problema, cómo se ve el éxito en números (métricas) y cómo vamos a medirlo automáticamente (evals).</li>
<li><strong>Construir y lanzar.</strong> La prueba de concepto, el sistema agéntico que orquesta al modelo, la aplicación que usan las personas y la exposición gradual a usuarios reales.</li>
<li><strong>Observar y monitorear.</strong> Trazas de cada ejecución, feedback humano, una plataforma central de observabilidad, tableros de métricas y alertas cuando algo se sale de rango.</li>
<li><strong>Evaluar y mejorar.</strong> Correr las evals sobre tráfico real, encontrar las que fallan y elegir la palanca correcta para corregirlas: prompt, datos, modelo o arquitectura. El resultado es una nueva versión que vuelve a los usuarios.</li>
</ol>
<!-- interactive -->
<h2>Tres ideas que vale la pena llevarte</h2>
<h3>1. Las evals se definen antes que el PoC</h3>
<p>Es tentador construir primero y medir después. Pero si no defines las evals al principio, nunca sabrás si la versión 2 es mejor que la 1; solo sabrás que <em>se siente</em> mejor. Un conjunto pequeño de casos reales con su respuesta esperada (un <em>golden dataset</em>) vale más que cualquier demo impresionante.</p>
<h3>2. Si no está en una traza, no pasó</h3>
<p>Cada ejecución del sistema debería dejar un registro completo: qué entró, qué contexto se recuperó, qué herramientas se llamaron, qué respondió el modelo, cuánto tardó y cuántos tokens consumió. Sin eso, depurar un agente es adivinar. Con eso, una queja de un usuario se convierte en un caso de prueba en minutos.</p>
<h3>3. Elige la palanca más barata primero</h3>
<p>Cuando una eval falla, la reacción instintiva es pensar en <em>fine-tuning</em> o en cambiar de modelo. Casi siempre conviene empezar por lo más barato:</p>
<table>
<thead>
<tr>
<th>Palanca</th>
<th>Costo</th>
<th>Cuándo usarla</th>
</tr>
</thead>
<tbody>
<tr>
<td>Prompt engineering</td>
<td>Bajo</td>
<td>Instrucciones ambiguas, formato inconsistente</td>
</tr>
<tr>
<td>Preparación de datos / RAG</td>
<td>Medio</td>
<td>Respuestas sin fundamento o con información desactualizada</td>
</tr>
<tr>
<td>Herramientas y agentes</td>
<td>Medio</td>
<td>El modelo necesita calcular, consultar o actuar</td>
</tr>
<tr>
<td>Ruteo de modelos</td>
<td>Medio</td>
<td>Costo o latencia altos en casos simples</td>
</tr>
<tr>
<td>Fine-tuning</td>
<td>Alto</td>
<td>Estilo o tarea muy específica que no se logra de otra forma</td>
</tr>
</tbody>
</table>
<p>Y con las evals en su lugar, cada cambio se puede <strong>demostrar</strong> antes de lanzarlo.</p>
<h2>Cómo usar este mapa en tu equipo</h2>
<p>Te propongo un ejercicio sencillo: toma un proyecto de IA que tengas en curso y recórrelo paso a paso con tu equipo. En cada etapa, respondan las tres preguntas que aparecen en el panel. Lo más probable es que descubran dos o tres huecos; típicamente, evals que nunca se definieron o trazas que no se están guardando.</p>
<p>Esos huecos son exactamente donde los proyectos de IA se atoran entre la demo y producción.</p>
<blockquote>
<p>La diferencia entre una demo y un producto no es el modelo. Es el ciclo que lo rodea.</p>
</blockquote>
<p>En próximas entradas voy a profundizar en cada fase con ejemplos concretos: cómo armar un primer <em>golden dataset</em>, qué registrar en una traza y cómo decidir entre RAG y fine-tuning. Si quieres que cubra algún paso en particular, escríbeme.</p>
]]></content:encoded>
            <author>valdovinoscode@gmail.com (Valdovinos)</author>
            <category>ai</category>
        </item>
        <item>
            <title><![CDATA[Tu propio JavaScript y CSS en cualquier sitio, con respaldo en un repositorio]]></title>
            <link>https://albertovaldovinos.com/blog/js-y-css-propios-en-cualquier-sitio</link>
            <guid>https://albertovaldovinos.com/blog/js-y-css-propios-en-cualquier-sitio</guid>
            <pubDate>Sat, 18 Apr 2020 22:22:02 GMT</pubDate>
            <description><![CDATA[Cuando uso mucho un sitio, termino queriendo cambiarle algo. Así personalizo sitios con mis propias reglas sin perderlas al cambiar de computadora o de perfil.]]></description>
            <content:encoded><![CDATA[<p>Cuando uso mucho un sitio, termino queriendo arreglarle algo: ocultar un elemento que estorba, cambiar un color que cansa la vista o automatizar un clic que hago cien veces al día. Ya escribí dos ejemplos: <a href="/blog/ocultar-sugerencias-youtube">ocultar las sugerencias de YouTube</a> y <a href="/blog/videos-con-sonido-al-pasar-el-cursor">activar el sonido de los videos al pasar el cursor</a>.</p>
<h2>Las herramientas</h2>
<ul>
<li><strong>Para CSS:</strong> una extensión de estilos de usuario como <strong>Stylus</strong>.</li>
<li><strong>Para JavaScript:</strong> un administrador de scripts como <strong>Tampermonkey</strong> o <strong>Violentmonkey</strong>. En versiones recientes de Chrome hay que activar <em>Permitir scripts de usuario</em> en los detalles de la extensión.</li>
</ul>
<p>Las dos funcionan bien, pero tienen tres problemas cuando las usas en serio:</p>
<ol>
<li><strong>No se sincronizan entre perfiles.</strong> Si trabajas con varios perfiles de Chrome, tienes que copiar tus reglas en cada uno.</li>
<li><strong>No hay respaldo automático.</strong> Si reinstalas el navegador o cambias de computadora, las pierdes.</li>
<li><strong>No hay historial.</strong> Si cambias una regla y algo se rompe, no hay forma de regresar a la versión anterior.</li>
</ol>
<h2>La solución: tratar las reglas como código</h2>
<p>Guardo todas mis reglas en un <strong>repositorio</strong>, con un archivo por sitio:</p>
<pre><code>mis-reglas/
├── youtube.com.css
├── x.com.user.js
└── documentacion-interna.css
</code></pre>
<p>Y las cargo desde ahí:</p>
<ul>
<li><strong>Stylus</strong> y <strong>Tampermonkey</strong> pueden instalar estilos y scripts desde una URL y buscar actualizaciones ahí (<code>@updateURL</code>). Si las reglas no tienen nada sensible, apuntarlas al archivo del repositorio hace que todos mis perfiles se actualicen solos.</li>
<li>Si el repositorio es privado, las copio a mano, pero sigo teniendo el respaldo y el historial.</li>
<li>Cada cambio queda registrado con su mensaje de commit, y si algo se rompe, regreso a la versión anterior.</li>
</ul>
<p>Un ejemplo de regla sencilla que uso para leer documentación larga, con un fondo más cálido que cansa menos la vista:</p>
<pre><code class="language-css">body {
  background: #f4ecd8 !important;
  color: #3b3024 !important;
  line-height: 1.7 !important;
}
</code></pre>
<hr>
<p>Un detalle de seguridad: nunca instales scripts de usuario de fuentes que no conoces. Un script corre con acceso completo a la página: puede leer lo que escribes, incluidas contraseñas. Por eso prefiero escribir los míos y tenerlos en mi propio repositorio.</p>
]]></content:encoded>
            <author>valdovinoscode@gmail.com (Valdovinos)</author>
            <category>productivity</category>
        </item>
        <item>
            <title><![CDATA[Chrome parpadea o da saltos al hacer scroll: qué revisar]]></title>
            <link>https://albertovaldovinos.com/blog/chrome-scroll-con-saltos</link>
            <guid>https://albertovaldovinos.com/blog/chrome-scroll-con-saltos</guid>
            <pubDate>Sat, 08 Feb 2020 22:22:02 GMT</pubDate>
            <description><![CDATA[Si las páginas parpadean o se ven entrecortadas al bajar, casi siempre el problema está entre Chrome y la tarjeta de video. Estos son los pasos que sigo, en orden.]]></description>
            <content:encoded><![CDATA[<p>Cuando el scroll en Chrome parpadea, deja rastros o se siente entrecortado, casi siempre el problema está en cómo Chrome usa la tarjeta de video. Estos son los pasos que sigo, del más sencillo al más profundo.</p>
<h2>1. Probar sin aceleración por hardware</h2>
<p>Ve a <code>chrome://settings/system</code>, desactiva <strong>Usar aceleración de gráficos cuando esté disponible</strong> y reinicia Chrome.</p>
<p>Si el problema desaparece, ya sabes que la causa es el controlador de video. No lo dejes así para siempre: sin aceleración, Chrome usa más CPU y los videos se ven peor. Sigue al paso 2.</p>
<h2>2. Actualizar el controlador de la tarjeta de video</h2>
<p>Descarga el controlador directamente del fabricante (NVIDIA, AMD o Intel) en lugar de esperar a Windows Update. Después vuelve a activar la aceleración por hardware y prueba de nuevo.</p>
<h2>3. Revisar qué está usando Chrome</h2>
<p>Abre <code>chrome://gpu</code>. Ahí aparece qué funciones gráficas están activas y si Chrome detectó problemas con tu controlador. Es lo primero que conviene compartir si vas a reportar el error.</p>
<h2>4. Descartar extensiones</h2>
<p>Abre una ventana de incógnito (las extensiones suelen estar desactivadas ahí) y prueba la misma página. Si en incógnito funciona bien, desactiva tus extensiones una por una hasta encontrar la culpable.</p>
<h2>5. Revisar las flags experimentales</h2>
<p>Si alguna vez cambiaste algo en <code>chrome://flags</code>, usa el botón <strong>Restablecer todo</strong>. Las flags cambian o desaparecen entre versiones, y una que ayudaba hace años puede causar problemas hoy.</p>
<hr>
<p>La mayoría de las veces se resuelve en el paso 2.</p>
]]></content:encoded>
            <author>valdovinoscode@gmail.com (Valdovinos)</author>
            <category>productivity</category>
        </item>
        <item>
            <title><![CDATA[Videos con sonido al pasar el cursor, en X (antes Twitter)]]></title>
            <link>https://albertovaldovinos.com/blog/videos-con-sonido-al-pasar-el-cursor</link>
            <guid>https://albertovaldovinos.com/blog/videos-con-sonido-al-pasar-el-cursor</guid>
            <pubDate>Fri, 31 Jan 2020 00:40:32 GMT</pubDate>
            <description><![CDATA[En X los videos se reproducen en silencio y hay que darle clic a cada uno para escucharlo. Con un script de 10 líneas, el sonido se activa al pasar el cursor y se apaga al salir.]]></description>
            <content:encoded><![CDATA[<p><em>Publicado originalmente en 2020 y actualizado en noviembre de 2026.</em></p>
<p>En X (antes Twitter) los videos se reproducen automáticamente, pero en silencio. Si quieres escuchar uno, tienes que darle clic, y al seguir bajando tienes que acordarte de silenciarlo otra vez.</p>
<p>Lo resolví con un pequeño script: el video suena mientras el cursor está encima y se silencia en cuanto lo quitas.</p>
<h2>Cómo instalarlo</h2>
<ol>
<li>Instala un administrador de scripts de usuario, como <strong>Tampermonkey</strong>.</li>
<li>En versiones recientes de Chrome, entra a los detalles de la extensión y activa <strong>Permitir scripts de usuario</strong>; sin eso, los scripts no se ejecutan.</li>
<li>Crea un script nuevo y pega esto:</li>
</ol>
<pre><code class="language-javascript">// ==UserScript==
// @name         Sonido al pasar el cursor
// @match        https://x.com/*
// @match        https://twitter.com/*
// @grant        none
// ==/UserScript==

window.addEventListener('mouseover', ({ target }) => {
  if (target instanceof HTMLVideoElement) target.muted = false
})

window.addEventListener('mouseout', ({ target }) => {
  if (target instanceof HTMLVideoElement) target.muted = true
})
</code></pre>
<ol start="4">
<li>Guarda y recarga la página.</li>
</ol>
<h2>Por qué funciona</h2>
<p>En lugar de buscar cada video (X carga contenido nuevo todo el tiempo mientras bajas), el script escucha los eventos del cursor en toda la ventana y solo actúa cuando el elemento bajo el cursor es un <code>&#x3C;video></code>. Así funciona también con los videos que se cargan después.</p>
<p>La misma idea sirve para cualquier sitio que reproduzca videos en silencio: solo cambia las líneas <code>@match</code>.</p>
]]></content:encoded>
            <author>valdovinoscode@gmail.com (Valdovinos)</author>
            <category>productivity</category>
        </item>
        <item>
            <title><![CDATA[Cómo ocultar las tarjetas y sugerencias que tapan los videos de YouTube]]></title>
            <link>https://albertovaldovinos.com/blog/ocultar-sugerencias-youtube</link>
            <guid>https://albertovaldovinos.com/blog/ocultar-sugerencias-youtube</guid>
            <pubDate>Wed, 11 Dec 2019 16:38:53 GMT</pubDate>
            <description><![CDATA[Al final de muchos videos, las tarjetas de sugerencias tapan justo lo que quieres ver. Con una regla de CSS las desaparezco.]]></description>
            <content:encoded><![CDATA[<p><em>Publicado originalmente en 2019 y actualizado en noviembre de 2026.</em></p>
<p>Ves un tutorial, llegas a la parte importante y justo ahí aparecen las tarjetas de "ver otro video" encima del código o de la pantalla que estabas leyendo. A mí me pasaba seguido con videos de programación.</p>
<p><img src="/media/ublock-youtube-overlay/01.webp" alt="Sugerencias de YouTube encima del video" title="Las sugerencias tapando el video"></p>
<p>La solución es ocultar esos elementos con CSS propio.</p>
<h2>Con una extensión de estilos (Chrome, Edge, Firefox)</h2>
<ol>
<li>Instala una extensión para estilos de usuario, como <strong>Stylus</strong>.</li>
<li>Crea un estilo nuevo que aplique a <code>youtube.com</code>.</li>
<li>Pega este CSS y guarda:</li>
</ol>
<pre><code class="language-css">/* Tarjetas y pantallas finales encima del video */
.ytp-ce-element,
.ytp-ce-covering-overlay,
.ytp-ce-element-shadow,
.ytp-ce-covering-image,
.ytp-ce-expanding-image,
.ytp-cards-teaser,
/* Sugerencias que aparecen al pausar */
.ytp-pause-overlay {
  display: none !important;
}
</code></pre>
<h2>Con uBlock Origin (Firefox o Brave)</h2>
<p>Si usas uBlock Origin, puedes poner las mismas reglas en <em>Mis filtros</em>:</p>
<pre><code>youtube.com##.ytp-ce-element
youtube.com##.ytp-cards-teaser
youtube.com##.ytp-pause-overlay
</code></pre>
<p>Ojo: desde 2025 Chrome ya no permite el uBlock Origin completo por el cambio a Manifest V3; en Chrome existe uBlock Origin Lite, que tiene menos control sobre filtros personalizados. Por eso en Chrome prefiero la opción de CSS.</p>
<hr>
<p>YouTube cambia sus clases de vez en cuando. Si un día deja de funcionar, haz clic derecho sobre la tarjeta, elige <em>Inspeccionar</em> y actualiza el nombre de la clase en la regla.</p>
]]></content:encoded>
            <author>valdovinoscode@gmail.com (Valdovinos)</author>
            <category>productivity</category>
        </item>
        <item>
            <title><![CDATA[Cómo trabajar con varios perfiles de Chrome sin volverte loco]]></title>
            <link>https://albertovaldovinos.com/blog/varios-perfiles-de-chrome</link>
            <guid>https://albertovaldovinos.com/blog/varios-perfiles-de-chrome</guid>
            <pubDate>Tue, 16 Jul 2019 21:19:27 GMT</pubDate>
            <description><![CDATA[Separar trabajo, clientes y vida personal en perfiles de Chrome es de lo más útil que hay, hasta que abres un enlace desde otra aplicación y se abre en el perfil equivocado.]]></description>
            <content:encoded><![CDATA[<p>Cuando trabajas con varios clientes al mismo tiempo, los perfiles de Chrome son de lo más útil que hay. Cada perfil tiene sus propias sesiones, marcadores, extensiones y contraseñas. No tienes que cerrar sesión en ningún lado y nada se mezcla.</p>
<h2>Cómo los organizo</h2>
<ul>
<li><strong>Un perfil por contexto</strong>, no por cuenta: personal, cada cliente, y uno limpio para pruebas.</li>
<li><strong>Color y foto distintos</strong> en cada perfil. Parece un detalle, pero evita escribir en el chat del cliente equivocado.</li>
<li><strong>Solo las extensiones necesarias</strong> en cada uno. Menos extensiones, menos riesgo y un navegador más rápido.</li>
<li><strong>Un acceso directo por perfil</strong> en la barra de tareas, para abrir el que necesitas directamente.</li>
</ul>
<h2>El problema</h2>
<p>Cuando abres un enlace <strong>desde fuera de Chrome</strong> (un correo en Outlook, un mensaje en Teams, un documento de Word), Windows lo abre en el último perfil que usaste. Si el último era el personal y el enlace era del sistema de un cliente, terminas iniciando sesión donde no debías.</p>
<h2>Cómo resolverlo</h2>
<p><strong>Dentro de Chrome</strong>, haz clic derecho sobre cualquier enlace y elige <strong>Abrir vínculo como</strong> para mandarlo al perfil correcto.</p>
<p><strong>Desde fuera de Chrome</strong>, hay aplicaciones para Windows que funcionan como selector de navegador: se registran como navegador predeterminado y, cada vez que abres un enlace, te preguntan en qué navegador o perfil abrirlo. Las más útiles permiten guardar reglas por dominio, por ejemplo, que todo lo de <code>cliente-a.com</code> se abra siempre en el perfil de ese cliente. Busca "browser selector" o "browser picker" en la Microsoft Store.</p>
<p><strong>Sin instalar nada</strong>, puedes crear accesos directos que abran un perfil específico agregando el parámetro <code>--profile-directory</code>:</p>
<pre><code>"C:\Program Files\Google\Chrome\Application\chrome.exe" --profile-directory="Profile 2"
</code></pre>
<p>El nombre de la carpeta de cada perfil aparece en <code>chrome://version</code>, en la línea <em>Ruta de acceso del perfil</em>.</p>
<hr>
<p>Separar contextos no solo es comodidad: también es seguridad. Un perfil por cliente reduce el riesgo de mezclar sesiones, credenciales o datos entre organizaciones.</p>
]]></content:encoded>
            <author>valdovinoscode@gmail.com (Valdovinos)</author>
            <category>productivity</category>
        </item>
        <item>
            <title><![CDATA[GTD con Trello: un sistema para sacar todo de la cabeza]]></title>
            <link>https://albertovaldovinos.com/blog/gtd-con-trello</link>
            <guid>https://albertovaldovinos.com/blog/gtd-con-trello</guid>
            <pubDate>Wed, 27 Mar 2019 00:46:37 GMT</pubDate>
            <description><![CDATA[No me gusta la rutina, y como programador tengo una ventaja: puedo automatizarla. Así armo el método GTD de David Allen en Trello, incluidos los enlaces que guardo y nunca vuelvo a ver.]]></description>
            <content:encoded><![CDATA[<p>No me gusta la rutina. Una de las mejores cosas de ser programador es que puedo automatizar buena parte de ella, y lo que no se puede automatizar, por lo menos se puede organizar.</p>
<p>La idea central de <em>Getting Things Done</em> (GTD), de David Allen, es sencilla: tu cabeza sirve para pensar, no para guardar pendientes. Todo lo que te ocupa espacio mental tiene que vivir en un sistema confiable fuera de ella.</p>
<h2>Qué va al sistema</h2>
<ul>
<li><strong>Ideas:</strong> algo que quizá haga algún día.</li>
<li><strong>Tareas:</strong> acciones concretas, de una sola sentada.</li>
<li><strong>Proyectos:</strong> cualquier resultado que necesita más de una acción.</li>
<li><strong>Notas y referencias:</strong> información que quiero conservar.</li>
<li><strong>Enlaces:</strong> artículos, documentación, videos. Esta es la categoría que casi todos olvidan: se acumulan en los marcadores del navegador y nunca se vuelven a abrir.</li>
</ul>
<h2>Mi tablero</h2>
<p>Uso un tablero con estas listas, que son casi literalmente las de GTD:</p>
<table>
<thead>
<tr>
<th>Lista</th>
<th>Qué contiene</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>Bandeja de entrada</strong></td>
<td>Todo lo que capturo, sin ordenar.</td>
</tr>
<tr>
<td><strong>Siguientes acciones</strong></td>
<td>Tareas claras que puedo hacer en cuanto tenga tiempo.</td>
</tr>
<tr>
<td><strong>En espera</strong></td>
<td>Lo que depende de alguien más, con la fecha en que lo pedí.</td>
</tr>
<tr>
<td><strong>Proyectos</strong></td>
<td>Una tarjeta por proyecto, con su lista de pasos como checklist.</td>
</tr>
<tr>
<td><strong>Algún día</strong></td>
<td>Ideas sin compromiso.</td>
</tr>
<tr>
<td><strong>Para leer</strong></td>
<td>Los enlaces que guardo.</td>
</tr>
</tbody>
</table>
<h2>Capturar rápido</h2>
<p>Si capturar cuesta trabajo, no lo vas a hacer. Algunas formas rápidas de mandar cosas a la bandeja de entrada:</p>
<ul>
<li><strong>Correo al tablero:</strong> cada tablero de Trello tiene una dirección de correo propia. Reenviar un correo a esa dirección lo convierte en tarjeta.</li>
<li><strong>Desde el celular:</strong> la app de Trello permite compartir un enlace directo a una lista.</li>
<li><strong>Desde el navegador:</strong> hay extensiones que crean una tarjeta con la página que estás viendo.</li>
</ul>
<h2>Lo que hace que funcione: la revisión semanal</h2>
<p>El sistema no sirve si no lo revisas. Una vez por semana vacío la bandeja de entrada: cada tarjeta se convierte en una siguiente acción, entra a un proyecto, pasa a <em>Algún día</em> o se elimina. Y cada mañana elijo dos o tres tareas importantes del día, marcadas con una etiqueta, para no perderme entre todo lo demás.</p>
<hr>
<p>Trello no hace el trabajo por ti, pero si tu cabeza confía en que nada se va a perder, deja de recordarte las cosas a las 3 de la mañana.</p>
]]></content:encoded>
            <author>valdovinoscode@gmail.com (Valdovinos)</author>
            <category>productivity</category>
        </item>
        <item>
            <title><![CDATA[CRLF vs. LF en Windows: cómo dejar de pelear con los saltos de línea en Git]]></title>
            <link>https://albertovaldovinos.com/blog/crlf-a-lf-en-windows</link>
            <guid>https://albertovaldovinos.com/blog/crlf-a-lf-en-windows</guid>
            <pubDate>Thu, 21 Jun 2018 12:22:42 GMT</pubDate>
            <description><![CDATA[Si trabajas en Windows con gente en Mac o Linux, tarde o temprano un pull request aparece con todo el archivo modificado sin que nadie haya tocado nada. Así lo dejo resuelto de una vez.]]></description>
            <content:encoded><![CDATA[<p>Me ha pasado más de una vez: abro un pull request, cambié una línea y Git dice que modifiqué el archivo completo. No es magia, son los saltos de línea.</p>
<p>Windows usa <strong>CRLF</strong> (<code>\r\n</code>) y Linux y macOS usan <strong>LF</strong> (<code>\n</code>). Si cada quien guarda con el suyo, cada commit es una pequeña guerra. En equipos distribuidos, donde unos están en Windows y otros en Mac, esto pasa más seguido de lo que parece.</p>
<p>Esta es la configuración que uso para que todos mis proyectos queden en LF, aunque trabaje en Windows.</p>
<h2>1. Que Git no convierta nada por su cuenta</h2>
<pre><code class="language-bash">git config --global core.autocrlf false
</code></pre>
<p>Si estás instalando Git, también puedes elegirlo en el instalador con la opción <em>Checkout as-is, commit as-is</em>:</p>
<p><img src="/media/crlf-to-lf/01.png" alt="Opción de saltos de línea en el instalador de Git" title="Instalador de Git para Windows"></p>
<h2>2. Que el repositorio decida, no la máquina de cada quien</h2>
<p>Crea un archivo <code>.gitattributes</code> en la raíz del proyecto. Esta es la parte más importante, porque viaja con el repositorio y aplica igual para todo el equipo:</p>
<pre><code># Por defecto, todo el texto se guarda con LF
* text=auto eol=lf

# Archivos que Visual Studio espera con CRLF
*.sln text eol=crlf
*.bat text eol=crlf
*.cmd text eol=crlf

# Binarios: nunca tocarlos
*.png binary
*.jpg binary
*.pdf binary
*.zip binary
</code></pre>
<h2>3. Normalizar lo que ya existe</h2>
<p>Con el <code>.gitattributes</code> en su lugar, aplica la regla a todos los archivos que ya estaban en el repositorio:</p>
<pre><code class="language-bash">git add --renormalize .
git commit -m "Normaliza saltos de línea a LF"
</code></pre>
<p>Hazlo en un commit aparte, sin otros cambios. Así, cuando alguien revise el historial, va a entender por qué ese commit tocó todo.</p>
<h2>4. Que el editor también escriba LF</h2>
<p>En VS Code, en la configuración de usuario o del proyecto:</p>
<pre><code class="language-json">{
  "files.eol": "\n"
}
</code></pre>
<p><img src="/media/crlf-to-lf/02.png" alt="Configuración de fin de línea en VS Code" title="Configuración de VS Code"></p>
<p>Si el equipo usa distintos editores, un <code>.editorconfig</code> en la raíz ayuda a que todos respeten la misma regla:</p>
<pre><code>root = true

[*]
end_of_line = lf
insert_final_newline = true
</code></pre>
<hr>
<p>Son cinco minutos de configuración y te ahorras muchos pull requests ilegibles. Lo hago al inicio de cualquier proyecto nuevo, antes del primer commit.</p>
]]></content:encoded>
            <author>valdovinoscode@gmail.com (Valdovinos)</author>
            <category>programming</category>
        </item>
    </channel>
</rss>