MeerMost

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í:

  1. Describir la estructura: un grupo de preguntas, un conjunto Question, cada pregunta con tipo de respuesta y peso
  2. Decidir cómo guardar la respuesta parcial. En la memoria del ViewModel o en Core Data
  3. 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?
  4. Scoring. Cada respuesta tiene un peso; al final del grupo sumamos y lo asociamos a un parámetro
  5. Bloqueadores dinámicos. Algunas respuestas deben bloquear las preguntas siguientes (por ejemplo: «sin alergias», nos saltamos el bloque de alérgenos)
  6. Salida del onboarding. A dónde nos vamos, qué guardamos
  7. Persistencia. Qué vive en Firestore (event-driven, ver la arquitectura del proyecto) y qué se guarda en local
  8. 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 Question conviene 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:

  1. Cierra el editor de código. Abre una nota de texto.
  2. Escribe el objetivo en una sola línea: qué debe quedar como resultado.
  3. Divide el trabajo en 8-15 pasos hasta el momento en que el siguiente paso sea «abre el archivo y escribe X».
  4. Mientras escribes, marca las preguntas y lo que no sabes como puntos aparte.
  5. 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.
  6. 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.

Todos los artículos

Artículos relacionados

Tu propio servicio VPN: cómo crearlo y qué necesitas para lanzarlo
Negocios

Tu propio servicio VPN: cómo crearlo y qué necesitas para lanzarlo

Cómo crear tu propio servicio VPN para vender: cliente, configuraciones, backend con pagos y soporte. Por qué las configuraciones básicas no funcionan en Rusia y qué exige App Store.

11 min de lectura
Llevo 2 años registrando mis horas de trabajo en una hoja de cálculo. Esto es lo que reveló
Negocios

Llevo 2 años registrando mis horas de trabajo en una hoja de cálculo. Esto es lo que reveló

Dos años registrando las horas de trabajo de un desarrollador independiente. La conclusión principal: después de 6 horas al día, el nivel de felicidad baja. Por qué 4 horas de concentración son mejores que 8 horas de rutina.

8 min de lectura
Cómo hacer un MVP y no ahogarte en el desarrollo
DesarrolloVideo

Cómo hacer un MVP y no ahogarte en el desarrollo

Enfoque para desarrollar el MVP de una aplicación móvil: el conjunto mínimo de funciones y el camino hasta el lanzamiento sin mejoras interminables.

1 min de lectura