> For the complete documentation index, see [llms.txt](https://elguerre.gitbook.io/de0an/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://elguerre.gitbook.io/de0an/conclusiones/epilogo.md).

# Epílogo: el 10% que puse yo

Al final de las conclusiones te pedía que pusieras tú el 10% restante. Sería injusto pedírtelo sin contarte qué hice yo con el mío.

Este libro nació con otro título: *"De 0 a 90 con Task\[in]"*. La idea era sencilla: yo te llevaba hasta el 90 y tú hacías el resto. Pero la vida hizo lo que suele hacer con los planes, y el libro se quedó a medias durante años, con capítulos empezados y una aplicación que la plataforma sobre la que se construyó ya no iba a sostener. Por eso hoy se llama *"De 0 a N"*: porque la N nunca fue un número fijo. Primero fue 90, después 100, y siempre habrá uno más.

## Lo que vino después de Task\[in]

En enero de 2023 lo volví a intentar con un proyecto al que llamé **CocktailDev**: una coctelera en la que mezclar todo mi trabajo técnico disperso y servirlo como una sola historia. Trabajar en abierto, entregar algo útil desde el primer día y no esperar a tenerlo todo terminado. Las intenciones sobrevivieron. Las tecnologías que elegí entonces, casi ninguna.

Después llegó **Task\[in] 2.0**, el mismo que te propuse en el capítulo 11: volver a construir la aplicación con Angular, .NET, Aspire y la IA como copiloto. Te seré sincero: no lo he terminado, y Task\[in] y Task\[in] 2.0 siguen ahí como lo que siempre fueron, intenciones. Pero dieron sus frutos, como siempre, aprendiendo por el camino. Volví a ponerme al día con un stack moderno de principio a fin, desde el frontend hasta la observabilidad. Aprendí a trabajar con un agente de IA como compañero y no como un autocompletado con esteroides. Y, sobre todo, descubrí lo que les faltaba: proyectos reales, con usuarios reales, en los que merezca la pena invertir cada una de esas horas.

Así que me lancé a comprobar si todo aquello servía para algo más que para un ejercicio. En 2026 nacieron dos aplicaciones móviles con Angular, Ionic y Capacitor, construidas mano a mano con un agente de IA. La primera, [**Salitre**](https://salitre.elguerre.com/), es un monitor de la costa española: cruza viento, oleaje y mareas con las características de miles de playas para recomendarte la mejor según lo que te apetezca hacer ese día. La segunda, [**Litro**](https://litro.elguerre.com/), encuentra la gasolinera más barata cerca de ti o en tu ruta, y calcula dónde repostar para llegar a destino gastando lo mínimo. Las dos siguieron el mismo camino que Task\[in] en el capítulo 10: pruebas, versiones beta y el largo proceso de llegar a una tienda de aplicaciones, esta vez Google Play. Y las dos me enseñaron lo mismo: con un agente al lado, una sola persona puede llevar una idea de principio a fin mucho más rápido de lo que imaginaba. Quedaba ver qué pasaba con algo mucho más grande.

Ese algo más grande lo encontré en mi propio terreno, el comercio electrónico, y a partir de ahí todo lo aprendido tiene otro nombre: **Tendero**. Litro y Salitre siguen adelante, pero es en Tendero donde tengo puesto hoy el foco.

Y Tendero tiene algo que lo une a este libro más que ningún otro proyecto: intenta hacer lo mismo que hicimos aquí. No enseña solo el resultado, sino todo el proceso: lo que aprendo, las decisiones de todo tipo que voy tomando (técnicas, de diseño y también aquellas en las que me equivoco), lo que funciona y lo que hay que tirar para volver a empezar. La diferencia es que ahora lo cuento mientras ocurre, y no años después, en un mundo que cambia muy deprisa pero que por fin puedo contar al día.

Este libro envejeció antes de terminarlo; UWP, HockeyApp o VSTS son buena prueba de ello. Ahora, con la IA, corro más, y espero no quedarme obsoleto de nuevo. O quizás no tanto ;)

Un tendero es el de la tienda de la esquina: el que conoce a cada cliente, le recomienda lo que de verdad le encaja y recuerda lo que compró la última vez. Tendero es eso mismo convertido en software: una plataforma de comercio electrónico construida con **.NET, Aspire y Angular**, con la inteligencia artificial en el centro y pensada para dos tipos de clientes. Las personas, como siempre. Y los **agentes de IA** que compran en su nombre.

## Del Pomodoro a los agentes

Si has llegado hasta aquí, conoces a Tendero mejor de lo que crees. Casi todo lo que hicimos con Task\[in] tiene su equivalente:

| En Task\[in] aprendimos…                     | En Tendero se convierte en…                                                                     |
| -------------------------------------------- | ----------------------------------------------------------------------------------------------- |
| Prototipar en Blend antes de escribir código | Un sistema de diseño que existió antes que la primera pantalla                                  |
| MVVM para separar la vista de la lógica      | Vertical slices y bounded contexts que no comparten entidades                                   |
| Pruebas unitarias y de UI en la build        | Tests de arquitectura y una métrica de calidad de búsqueda (NDCG) que rompe la build si empeora |
| El servicio de datos y el backend            | Postgres, Elasticsearch, un outbox y una saga que reserva stock                                 |
| Pensar en el usuario                         | Pensar también en usuarios que no son personas: agentes que hablan MCP y UCP                    |
| Publicar en la Windows Store                 | Un repositorio público que cualquiera arranca con un solo comando                               |
| HockeyApp para saber qué pasa en producción  | OpenTelemetry para ver cada petición, cada evento y cada token                                  |

Cambian las herramientas, como ya vimos en el capítulo 11. Los principios son los mismos: diseñar antes de construir, testear desde el principio, pensar en quien va a usar lo que haces y no tener miedo a lo nuevo.

## Aprender con un agente al lado

Hay una diferencia que no cabe en la tabla. Tendero lo estoy construyendo **junto a un agente de IA**, y esa colaboración es en sí misma lo que más estoy aprendiendo: qué hace bien, dónde se equivoca con total seguridad y qué necesita un repositorio para que trabajar así funcione de verdad. Reglas escritas que el agente lee antes que el código, tests que tienen que fallar antes de contar como tests y la costumbre de desconfiar de una explicación solo porque suena bien. Unas veces el error es suyo, y bastantes otras, mío.

Es lo que empecé con Task\[in] 2.0 y seguí con Salitre y Litro, solo que ahora llevado mucho más lejos y contado en voz alta, con lo que sale bien y con lo que no.

## Tu turno, otra vez

El código de este libro sigue ahí: [Task\[in\]](https://github.com/juanluelguerre/Taskin/tree/develop) tal y como lo construimos y [Task\[in\] 2.0](https://github.com/juanluelguerre/Taskin2.0/tree/main) tal y como lo dejé, por si quieres terminarlo tú a tu manera. Pero si quieres seguirme a mí, mi foco ya no está ahí: está en [Salitre](https://salitre.elguerre.com/), en [Litro](https://litro.elguerre.com/) y, sobre todo, en Tendero.

**Empieza por** [**tendero.elguerre.com**](https://tendero.elguerre.com)**.** En unos minutos verás qué es Tendero, para qué sirve, un vídeo corto y su arquitectura explicada a dos niveles de detalle. Desde ahí tienes todo lo demás:

* **El código**: [github.com/juanluelguerre/tendero](https://github.com/juanluelguerre/tendero) — público, con licencia MIT, y se arranca con `dotnet run --project src/AppHost`.
* **El blog**: [elguerre.com](https://elguerre.com) — cada artículo cuenta una parte del camino y enlaza el código exacto que describe.

Está abierto por si quieres acompañarme, mirar cómo está hecho o, mejor aún, llevarme la contraria.

Este libro empezó enseñándote a gestionar tu tiempo con Pomodoros. Termina con algo parecido: aprender no es un proyecto con fecha de fin, es un hábito. Veinticinco minutos cada vez, un paso detrás de otro, de 0 a N.

Nos vemos en la siguiente N.

@juanluelguerre