La idea más extendida sobre el handoff es que Dev Mode de Figma acabó con las redlines. Muchos equipos dejaron de anotar medidas en 2023, activaron la vista de desarrollo y dieron el tema por cerrado. Seis meses después, los tickets de «esto no se parece al diseño» seguían llegando, y a veces llegaban más.
Lo que se pierde en esa transición no son las medidas, que Dev Mode muestra mejor que cualquier anotación manual. Es la intención. Dev Mode enseña con precisión lo que está dibujado en el archivo, incluidos sus errores, y no tiene forma de saber qué parte de ese dibujo es una regla y qué parte es un accidente. Las redlines, bien hechas, nunca fueron solo números: eran decisiones escritas. Decidir entre una cosa y otra empieza por separar esas dos funciones.
Lo que Dev Mode enseña y lo que no puede saber
Figma presentó Dev Mode en su conferencia Config de junio de 2023 como un espacio de trabajo propio para desarrolladores. Fue gratuito durante la beta y pasó a requerir un asiento de pago a principios de 2024. Su propuesta es sencilla: el desarrollador selecciona cualquier capa y obtiene dimensiones, distancias, tipografía, colores, variables y fragmentos de código en CSS, Swift o Kotlin, sin que nadie del equipo de diseño haya tenido que anotarlos.
Con el tiempo ha sumado piezas que atacan los puntos débiles del handoff clásico. El estado «listo para desarrollo» marca qué pantallas están cerradas. La comparación de cambios enseña qué se modificó desde que una pantalla se marcó como lista, algo que con redlines en PDF era casi imposible.
Las anotaciones y las medidas fijadas permiten dejar notas sobre el propio lienzo. Y Code Connect vincula los componentes de Figma con los componentes reales del repositorio, de modo que el desarrollador ve el código del sistema de diseño en lugar de un CSS genérico.
Lo que Dev Mode no puede saber es por qué un valor es el que es. Si una tarjeta mide 343 puntos de ancho, el panel dirá 343. No dirá si ese ancho es fijo, si debe ocupar el ancho del contenedor menos 16 puntos por lado, o si el diseñador lo estiró a ojo. Tampoco sabe qué pasa cuando el texto del botón se traduce al alemán y duplica su longitud, qué estado tiene el componente al cargar, ni en qué orden debe recorrerse con el tabulador.
Ahí está la trampa. Cuanto más preciso es el panel, más se fía de él el desarrollador. Un archivo con auto layout bien construido y variables aplicadas transmite casi toda la intención por sí mismo. Un archivo con capas sueltas y valores a mano transmite números exactos que no significan nada.
Lo que las redlines siguen haciendo mejor
Las redlines nacieron como especificaciones anotadas sobre la maqueta: cotas de distancia, tamaños de fuente, códigos de color. Herramientas como Zeplin o el antiguo panel Inspect de Figma automatizaron la parte de las medidas mucho antes de Dev Mode. Lo que nunca automatizaron fue la otra mitad.
Esa otra mitad es el comportamiento. Una buena especificación dice qué se estira y qué no, qué pasa con el contenido largo, cómo se ve el estado vacío, cuánto tarda una transición y qué ocurre si falla la red. También recoge decisiones de accesibilidad: el orden de foco, las etiquetas para lectores de pantalla, el tamaño mínimo de las áreas táctiles. Nada de eso aparece al seleccionar una capa.
Las redlines también fuerzan una revisión. Anotar una pantalla obliga al diseñador a recorrerla con la mirada del desarrollador, y en ese recorrido aparecen las incoherencias: dos espaciados de 14 y 16 puntos que deberían ser el mismo, un gris que no está en la paleta. Cuando Dev Mode elimina el paso de anotar, elimina también esa revisión, salvo que alguien la mantenga a propósito.
El coste es conocido. Anotar a mano es lento, se desactualiza en cuanto cambia el diseño y produce documentos que nadie sabe si son la versión vigente. Por eso la pregunta útil no es «redlines o Dev Mode», sino qué parte de las redlines conviene seguir escribiendo.
Las tres opciones, cara a cara
La mayoría de equipos acaba en una de tres configuraciones. La tabla resume en qué se diferencian.
| Criterio | Redlines manuales | Dev Mode sin anotaciones | Dev Mode con notas de comportamiento |
|---|---|---|---|
| Medidas y colores | Escritos a mano, propensos a error | Exactos y siempre actualizados | Exactos y siempre actualizados |
| Intención y reglas de layout | Explícitas si el diseñador las escribe | Solo si el archivo usa auto layout y variables | Explícitas en notas sobre el lienzo |
| Estados, errores y casos límite | Documentados aparte | Ausentes salvo que estén dibujados | Dibujados o anotados donde aplican |
| Coste de mantener actualizado | Alto | Casi nulo | Bajo, solo cuando cambia una regla |
| Detección de cambios | Manual, por versión de documento | Comparación de cambios integrada | Comparación de cambios integrada |
| Dependencia de la calidad del archivo | Baja | Muy alta | Alta |
| Coste de licencias | Ninguno adicional | Asientos con acceso a Dev Mode | Asientos con acceso a Dev Mode |
La fila de dependencia de la calidad del archivo es la que decide. Dev Mode amplifica lo que hay en el archivo, para bien y para mal. Un equipo con un sistema de diseño maduro gana casi todo y pierde poco. Un equipo con archivos desordenados gana precisión en datos que no deberían copiarse.
Cuánto cuesta cada opción: un ejemplo con números
Un ejemplo ilustrativo, con cifras inventadas pero plausibles para un equipo de producto mediano. El equipo entrega 40 pantallas nuevas o modificadas por trimestre, con 2 diseñadores y 6 desarrolladores frontend y móvil.
Con redlines manuales, anotar una pantalla completa lleva unos 45 minutos: 40 pantallas suponen 30 horas de diseño al trimestre. A eso se suman las dudas posteriores. Supongamos 3 preguntas por pantalla en el canal del equipo, de 10 minutos cada una entre quien pregunta y quien responde: 20 horas más. Total aproximado, 50 horas.
Con Dev Mode y notas solo de comportamiento, la anotación baja a unos 15 minutos por pantalla, 10 horas en total, porque las medidas ya no se escriben. Si las preguntas bajan a 1,5 por pantalla, son otras 10 horas. Total, 20 horas: un ahorro de 30 horas por trimestre.
Falta el coste de las licencias. Con un precio ilustrativo de 25 euros al mes por asiento de desarrollo (la tarifa real depende del plan y conviene consultarla), 6 asientos cuestan 450 euros por trimestre. Si la hora combinada del equipo se valora en 50 euros, las 30 horas ahorradas equivalen a 1.500 euros. La cuenta sale a favor de Dev Mode con holgura.
Ahora el escenario malo. Si el archivo no usa auto layout y los desarrolladores copian valores absolutos, aparecen errores que antes no había. Basta con que 4 de las 40 pantallas necesiten un ciclo de corrección de 5 horas entre desarrollo, revisión y nuevo despliegue para perder 20 de las 30 horas ganadas. El ahorro depende menos de la herramienta que del archivo que se le entrega.
Árbol de decisión y checklist para tu equipo
Estas preguntas, en orden, llevan a una configuración razonable. Responde sí o no.
- ¿Los componentes de tu sistema de diseño usan auto layout y variables en la mayoría de pantallas? Si no, mantén notas de layout explícitas en cada pantalla, uses Dev Mode o no. Si sí, sigue.
- ¿Tus desarrolladores tienen o pueden tener asiento con acceso a Dev Mode? Si no, el panel de inspección básico y una especificación de comportamiento bastan; las redlines de medidas siguen siendo útiles. Si sí, sigue.
- ¿Los componentes de Figma tienen un equivalente directo en el repositorio? Si sí, configura Code Connect antes de nada: es la pieza que más preguntas elimina. Si no, sigue igualmente.
- ¿El producto tiene estados complejos, como formularios largos, pagos o flujos con errores de red? Si sí, dibuja los estados en el archivo y anota el comportamiento en el lienzo. Si no, las notas pueden limitarse a las reglas de layout.
- ¿Trabajáis con equipos externos o en otra zona horaria? Si sí, añade una nota de alcance por pantalla, porque las preguntas tardan un día en resolverse. Si no, una revisión conjunta de 15 minutos por entrega suele ser más barata que documentar.
Antes de marcar una pantalla como lista para desarrollo, este checklist cubre lo que Dev Mode no dice por sí solo:
- Cada contenedor indica si su ancho es fijo, fluido o depende del contenido.
- El texto más largo previsto, en el idioma más largo del producto, está probado en el diseño.
- Estados de carga, vacío, error y deshabilitado están dibujados o descritos.
- Orden de foco y etiquetas accesibles anotados en los componentes nuevos.
- Valores fuera del sistema de diseño marcados como excepción intencionada o corregidos.
- La pantalla se revisó en la vista de comparación de cambios si ya estuvo lista antes.
Mini-caso ilustrativo: el ancho fijo que nadie pidió
Caso ilustrativo, compuesto a partir de situaciones habituales. Una app de finanzas personales migra su handoff a Dev Mode y deja de escribir redlines. La pantalla de resumen de cuenta tiene una tarjeta de saldo dibujada sobre un frame de iPhone de 393 puntos, sin auto layout, con un ancho de 361 puntos.
El desarrollador de iOS selecciona la tarjeta, lee 361 en el panel y lo implementa como ancho fijo. En el iPhone para el que se diseñó se ve perfecta. En un iPhone SE, con 375 puntos de ancho, la tarjeta deja solo 7 puntos de margen por lado en lugar de los 16 del resto de la app. En un iPad en vista dividida, queda flotando en el centro de una columna mucho más ancha.
Nadie hizo nada mal según su propio criterio. El panel mostró un número correcto y el desarrollador lo copió. Lo que faltaba era la regla: «ancho del contenedor menos 16 por lado». Con redlines, el diseñador la habría escrito casi sin pensarlo. Con Dev Mode, tenía que estar en el archivo como auto layout o en una nota, y no estaba en ninguno de los dos sitios.
La corrección fue doble. La tarjeta se reconstruyó con auto layout y relleno horizontal de 16 puntos, de modo que el panel pasó a mostrar «fill container» en lugar de un número. Y el equipo añadió a su checklist la primera línea de la lista anterior.
Hacia dónde va esto se ve ya en Code Connect y en el servidor MCP de Dev Mode, que permite a los asistentes de programación leer el diseño directamente. Cuando un agente de código convierte una pantalla en componentes del repositorio, las medidas dejan de ser el problema por completo. Lo que no puede inferir es la intención no escrita, y ahí las redlines vuelven con otra forma: menos cotas, más reglas.