Cómo dejé de sentirme perdido ante una tarea grande

Antes, cuando tenía que hacer una pantalla grande de una aplicación o una integración que no conocía, me quedaba atascado. Abría el editor, miraba el archivo vacío y no sabía con qué empezar. Después había dos escenarios: o código caótico que luego da vergüenza releer, o dos horas en YouTube con la excusa de que «tenía que entenderlo». Hoy trabajo de otra manera. El cambio resultó simple, pero me tomó mucho tiempo llegar a él.
Síntomas
Si te reconoces, el caso te resulta familiar:
- Abres el archivo, escribes la primera línea, la borras
- Cambiar a Google cinco o seis veces en cinco minutos
- Después de una hora de código, la sensación de que «todo está mal, empiezo de nuevo»
- Por dentro quieres que alguien te diga exactamente qué hacer
- Cada pequeña decisión te frena. Dónde poner el archivo, cómo nombrar la variable, si usar una librería o no
No es pereza. Es sobrecarga cognitiva. La cabeza intenta mantener en foco a la vez el objetivo, la arquitectura, la sintaxis, los nombres, los casos límite. Cada uno de esos elementos consume recursos, y cuando todo llega junto, el cerebro simplemente dice basta.
Una cita que me marcó
Ilya Krasinsky dijo una vez: «No podemos permitirnos lanzamientos largos, resultan infinitamente costosos». En ese momento trabajaba en mi primer producto, y la frase me dio justo donde duele.
Los lanzamientos largos no son solo lentos. Cuando trabajo en una sola tarea durante dos semanas, pierdo el impulso que tenía los primeros dos días. Las decisiones que al principio parecían obvias, al final generan dudas. El contexto se diluye y terminas gastando un cuarto de la jornada en volver a donde te quedaste ayer.
De ahí nació mi regla personal. Si el fundador sabe trabajar con las manos, validar una hipótesis le sale varias veces más barato. No porque no gaste en un desarrollador. Sino porque entre «se me ocurrió» y «vi la reacción del usuario» pasan días, no meses.
Para trabajar con las manos rápido hay que dejar de atascarse. Ahí es donde aparece la descomposición.
El método
Suena trillado, por eso lo ignoré durante mucho tiempo.
Antes de abrir el editor, abro una nota y escribo los pasos.
No un plan en Notion con etiquetas y estimaciones. No un ticket de Jira. Solo una lista con viñetas en el primer lugar que encuentro. El objetivo es sacar de la cabeza eso que el cerebro intenta retener en paralelo mientras escribes código.
Escribo los pasos hasta el momento en que se vuelven demasiado obvios. Ese es el criterio para parar. Si el siguiente paso suena a «llamar a la función X con tales parámetros», ya no hace falta detallarlo más. A partir de ahí empieza el trabajo en el código.
Mientras escribo los pasos ocurre lo importante: aparecen las incógnitas. Me sorprendo preguntándome «¿y cómo devuelve los datos exactamente este servidor?», «¿y aquí hace falta animación?», «¿y si el usuario no tiene internet?». Cada pregunta de esas se convierte en un punto aparte o en una tarea de «confirmar con el cliente, revisar la documentación».
Después de 15-30 minutos de descomposición entiendo la tarea mucho mejor. Y llego al código con un primer paso concreto, no con la pregunta «¿por dónde empiezo?».
Un ejemplo de un proyecto real
Lo muestro con una tarea de un proyecto de cliente, No Sugar Challenge. Había que hacer un sistema de onboarding personalizado con scoring. O sea, el usuario recorre cuatro grupos de preguntas, las respuestas definen sus parámetros personales y luego la aplicación le arma las tareas diarias.
Al principio habría abierto un archivo nuevo, OnboardingViewModel.swift, y me habría puesto a escribir la clase. Y me habría atascado en la segunda línea.
En lugar de eso, abrí una nota y escribí:
- Describir la estructura: un grupo de preguntas, un conjunto
Question, cada pregunta con tipo de respuesta y peso - Decidir cómo guardar la respuesta parcial. En la memoria del ViewModel o en Core Data
- Los parámetros del usuario que calculamos a partir de las respuestas: requerimiento calórico, rutina habitual, nivel de motivación. ¿Dónde están definidas esas fórmulas?
- Scoring. Cada respuesta tiene un peso; al final del grupo sumamos y lo asociamos a un parámetro
- Bloqueadores dinámicos. Algunas respuestas deben bloquear las preguntas siguientes (por ejemplo: «sin alergias», nos saltamos el bloque de alérgenos)
- Salida del onboarding. A dónde nos vamos, qué guardamos
- Persistencia. Qué vive en Firestore (event-driven, ver la arquitectura del proyecto) y qué se guarda en local
- Pruebas. Qué edge cases importan: omitir una respuesta, una respuesta de excepción, volver al paso anterior
Cuando lo escribí, se hicieron evidentes tres cosas:
- La estructura de
Questionconviene hacerla como enum con associated values según el tipo de respuesta - Las fórmulas del scoring no las sé: eso es algo que hay que preguntarle al cliente, no me toca inventarlas
- Los bloqueadores dinámicos son una tarea aparte con lógica independiente; conviene llevarlos a un servicio separado
Después de eso hice dos cosas. Le envié al cliente la pregunta sobre las fórmulas y me senté a escribir código. Las primeras dos horas se fueron en la estructura de Question y Answer, más una navegación simple entre las preguntas. Al final del primer día tenía un onboarding que funcionaba con datos de prueba estáticos. Sin bloqueadores, sin scoring, pero un esqueleto funcional.
Si hubiera empezado «como siempre», habría pasado las primeras dos horas dándole vueltas, luego habría hecho una clase con las respuestas como diccionario de strings y después me habría puesto a refactorizar. Y al final del día tendría la mitad de lo que tengo ahora.
Cuándo no hace falta descomponer
A veces descomponer estorba. Si la tarea es un ajuste sencillo de estilos, un cambio de copy, reemplazar una imagen, siéntate y hazlo. Detallar pasos como «buscar el archivo, abrirlo, cambiarlo, guardarlo» es pura burocracia.
Mi límite es más o menos así. Si tengo una imagen mental precisa del resultado y sé cuál es el primer paso, lo hago de inmediato. Si falta alguno de esos dos puntos, abro una nota.
Además, la descomposición funciona mal en las tareas de investigación. Cuando estoy explorando una tecnología nueva, por ejemplo PassKit para Apple Wallet por primera vez, no puedo armar ningún plan: no sé lo suficiente para escribirlo. En esos casos trabajo al revés. Voy probando en el código, entiendo un detalle, entiendo otro, y solo entonces me siento a escribir el plan: «ahora ya sé lo suficiente para hacerlo de verdad».
Sobre estimar el tiempo
Uso el mismo método para estimar plazos ante el cliente. Sin descomponer, digo «tres días» y casi siempre es mentira. Con descomposición, reviso mi lista de 8-15 puntos, estimo cada uno en horas, los sumo, multiplico por 1.5 (porque me olvidé de algo) y obtengo una estimación honesta.
Llevo dos años registrando mi tiempo de trabajo en una tabla, y con ella puedo decirlo. Las tareas que descompuse de antemano suelen terminarse dentro de la estimación o antes. Las tareas sin descomposición se alargan, en promedio, dos o tres veces.
Qué te llevas de esto
Si te quedas bloqueado frente a una tarea, prueba algo simple:
- Cierra el editor de código. Abre una nota de texto.
- Escribe el objetivo en una sola línea: qué debe quedar como resultado.
- Divide el trabajo en 8-15 pasos hasta el momento en que el siguiente paso sea «abre el archivo y escribe X».
- Mientras escribes, marca las preguntas y lo que no sabes como puntos aparte.
- Cuando la lista esté lista, envía las preguntas a quien pueda responderlas (el cliente, el líder técnico, la documentación). No te bloquees con ellas: empieza por los puntos independientes.
- Abre el editor y trabaja siguiendo la lista.
Después de cinco tareas hechas con este proceso, dejarás de quedarte atascado. Después de veinte, aprenderás a estimar plazos con más honestidad que el 80% de los desarrolladores que «estiman a ojo».
Y lo más importante. No se trata de productividad. Se trata de poder trabajar con calma, sin la sensación de que te estás hundiendo en lo desconocido.
Qué sigue
¿Necesitas construir un producto sin lanzamientos largos y sin caos en el código? Calcula los plazos o escríbenos, y analizamos tu tarea antes de que se convierta en un sprint de tres meses.

