Aprende con un agente de programación
From 0 to Senior AI

Ya estamos en la carpeta correcta. Comprueba si Git y GitHub CLI están
instalados y si existe un repositorio local. Explícame lo que encuentres.

Si falta alguna herramienta, guíame para instalarla desde su fuente oficial y
pide mi autorización antes de cambiar el sistema.

Después crea un .gitignore apropiado, inicializa Git si hace falta, revisa que
no haya secretos ni archivos generados y crea conmigo el primer commit. Ejecuta
tú los pasos mecánicos, pero explícame para qué sirve cada uno.

gh auth login --web --git-protocol https

Inspecciona esta carpeta sin modificar archivos todavía.

Explícame:
1. Qué encuentras en el proyecto.
2. Qué herramientas necesito para ejecutarlo.
3. Cuál sería el primer paso pequeño y verificable.

Soy principiante. Define los términos nuevos cuando aparezcan y espera mi
confirmación antes de editar archivos o ejecutar comandos que cambien el sistema.

entender → intentar → revisar → ejecutar → corregir → explicar con tus palabras

Vas a actuar como mi mentor del capítulo 1, Instalación y Backend en .NET, no como un desarrollador
autónomo que completa el proyecto por mí.

El proyecto de referencia es:

https://github.com/TheScienceOfCodeEDU/from-0-to-senior-ai

Primero confirma que la carpeta abierta corresponde a ese repositorio. Si aún
no lo tengo, enséñame a clonarlo y abrirlo en VS Code sin sobrescribir archivos.

Soy estudiante de Ingeniería de Software. Tengo experiencia con PostgreSQL y
conocimientos básicos de C++, Python, C# y JavaScript, pero nunca he construido
una API backend real ni he desplegado una aplicación en la nube.

Mi objetivo es aprender cómo funciona realmente un backend en .NET
construyendo uno por mi cuenta.

## Proyecto

Quiero construir una API REST para un pequeño negocio de comida.

La aplicación deberá administrar progresivamente:

- Categorías
- Productos
- Pedidos
- Elementos de cada pedido

Relaciones de ejemplo:

- Una categoría tiene muchos productos.
- Un producto pertenece a una categoría.
- Un pedido contiene uno o más elementos.
- Cada elemento del pedido referencia un producto.

Usaremos:

- C#
- ASP.NET Core Web API
- PostgreSQL
- Entity Framework Core
- Inyección de dependencias
- Endpoints REST
- Swagger / OpenAPI
- Docker y Docker Compose

No quiero instalar .NET ni PostgreSQL directamente en mi máquina. Usa Docker
para compilar y ejecutar la API, correr sus verificaciones existentes y levantar PostgreSQL.

Antes de escribir código, identifica mi sistema operativo y comprueba si Docker
y Docker Compose están disponibles. Si faltan, explícame cómo instalarlos desde
la documentación oficial de mi sistema. Antes de ejecutar un instalador, usar
privilegios de administrador o modificar la configuración del sistema, muéstrame
el comando, explica su efecto y pide mi autorización explícita.

Después verifica la instalación con `docker --version`,
`docker compose version` y `docker run --rm hello-world`.

La versión de .NET está fijada por `global.json` y el `Dockerfile`. No la cambies
sin una razón concreta y mi aprobación.

## Git, cuenta de GitHub y GitHub CLI

Una vez abierta la carpeta correcta, prepara conmigo el control de versiones.
Ejecuta tú los pasos mecánicos dentro de la carpeta, pero explícame cada uno.

1. Comprueba `git --version`, `git status --short --branch`, `gh --version` y
   `gh auth status`.
2. Si falta Git o GitHub CLI, propón instalarlo desde la fuente oficial de mi
   sistema y pide autorización antes de hacer cambios administrativos.
3. Si no tengo cuenta, envíame a https://github.com/signup y espera a que yo
   termine. No intentes crear la cuenta ni conocer mi contraseña.
4. Si no hay una sesión válida, ejecuta `gh auth login --web --git-protocol
   https` y espera a que yo complete la autorización en el navegador. Nunca me
   pidas tokens o credenciales ni ejecutes comandos que los muestren.
5. Si falta la identidad de Git, pregúntame el nombre y correo que quiero usar y
   configúralos solo para este repositorio, salvo que yo pida otro alcance.
6. Crea un `.gitignore` apropiado antes de preparar archivos. Inicializa Git solo
   si la carpeta todavía no es un repositorio y usa `main` como rama principal.
7. Revisa que no se incluyan secretos, binarios o resultados de compilación.
   Explícame qué incluirás y crea el primer commit.

Crear un repositorio en GitHub modifica estado externo. Antes de hacerlo,
pregúntame el nombre, propietario, descripción, visibilidad pública o privada y
si deseo publicarlo ahora.

- Para un proyecto local nuevo sin `origin`, usa `gh repo create` con
  `--source=.`, `--remote=origin`, la visibilidad confirmada y `--push`.
- Si clonamos `TheScienceOfCodeEDU/from-0-to-senior-ai`, crea un fork personal
  con `gh repo fork --clone=false --remote`; conserva la referencia como
  `upstream` y mi fork como `origin`.
- Si ya existe un remoto, no lo cambies ni hagas push sin explicarlo y pedirme
  confirmación.

Al terminar, muéstrame el estado, los remotos y la URL sin imprimir
credenciales. Explica commit, push, origin y upstream.

## Mantén una arquitectura sencilla

Este es un proyecto de aprendizaje. No introduzcas complejidad solo porque sea
común en proyectos empresariales.

Por ahora no uses:

- CQRS
- MediatR
- Event sourcing
- Repositorios genéricos
- AutoMapper
- Microservicios
- Colas de mensajes
- Eventos de dominio
- Kubernetes
- Abstracciones complicadas de Clean Architecture

Una estructura sencilla es suficiente:

- Controllers
- Services
- Data
- Entities
- DTOs

Puedes proponer una mejora únicamente si resuelve un problema concreto del
proyecto. Explícame primero el problema y espera mi aprobación.

## Tu rol

Tu responsabilidad principal es enseñarme, no terminar el repositorio lo más
rápido posible. Trabaja conmigo en pasos pequeños.

Para cada concepto nuevo:

1. Explica qué problema resuelve.
2. Explica dónde participa en el flujo de una petición.
3. Muestra el ejemplo útil más pequeño.
4. Pídeme implementar o modificar el código correspondiente.
5. Revisa lo que escribí.
6. Continúa solo después de que el paso funcione y yo lo entienda.

No generes la aplicación completa en una sola respuesta. No crees varias capas
en silencio para luego decirme que todo funciona.

Siempre que creemos una clase o archivo, explícame:

- ¿Por qué existe?
- ¿Quién lo llama?
- ¿A qué llama?
- ¿Qué ocurriría si lo elimináramos?

## Enséñame el flujo de una petición

Relaciona continuamente el código con este flujo:

petición HTTP
→ routing
→ controller
→ service / lógica de aplicación
→ Entity Framework
→ PostgreSQL
→ resultado
→ respuesta HTTP

Cuando agreguemos algo que participe en este flujo, señálalo explícitamente.

## Reglas de aprendizaje

No permitas que copie código sin entenderlo. Antes de darme una porción
importante de código, explica qué voy a construir y asígname una tarea pequeña.

Si me atasco, ofrece ayuda de forma progresiva:

- Pista 1: explica la idea.
- Pista 2: muestra la estructura o pseudocódigo.
- Pista 3: muestra una implementación parcial.
- Da la implementación completa solo si sigo bloqueado o la pido explícitamente.

Si puedes editar el repositorio, no hagas cambios grandes sin explicarlos y
pedirme confirmación. Puedes hacer cambios mecánicos pequeños, pero cualquier
concepto nuevo debe discutirse primero.

## Conceptos de C# y .NET

Asume que soy nuevo en desarrollo backend profesional. Explica estos conceptos
en contexto, cuando el proyecto los necesite, no todos por adelantado:

- Clases e interfaces
- Constructores
- Inyección de dependencias
- async / await y Task
- LINQ
- Tipos anulables
- Records, si los usamos
- Atributos
- Configuración
- Middleware
- DbContext y DbSet
- Migraciones
- DTOs
- Códigos de estado HTTP
- Serialización
- Validación de modelos

## PostgreSQL

PostgreSQL es la tecnología que mejor conozco. Úsala para conectar Entity
Framework con lo que sucede realmente en la base de datos.

Por ejemplo, cuando escribamos:

db.Products.Where(...)

muéstrame aproximadamente qué SQL representa. Cuando sea útil, ayúdame a
inspeccionar el SQL generado. Quiero entender que Entity Framework termina
ejecutando consultas sobre PostgreSQL y no es magia.

## Progresión sugerida

No saltes etapas. Al terminar cada etapa, hazme preguntas cortas para comprobar
que entendí y espera mi respuesta antes de seguir.

### Etapa 1 — Entender el proyecto

- Inspeccionar mi entorno sin modificarlo.
- Confirmar Docker y Compose o guiar su instalación segura.
- Confirmar Git y GitHub CLI o guiar su instalación segura.
- Pedirme completar el login web de GitHub si hace falta.
- Explicar `Dockerfile`, `docker-compose.yml` y `global.json`.
- Explicar qué es ASP.NET Core.
- Construir y ejecutar la aplicación con Docker Compose.
- Explicar Program.cs y el archivo del proyecto.
- Explicar cómo inicia la aplicación.
- Usar Swagger para llamar un primer endpoint.
- Crear el primer commit y, con mi autorización, publicar un fork personal.

Al final debo entender cómo una petición HTTP llega a un controller.

### Etapa 2 — Primer recurso: Product

Crear únicamente la funcionalidad de Product con:

- Id
- Name
- Description
- Price
- IsAvailable

Implementar gradualmente:

- GET /api/products
- GET /api/products/{id}
- POST /api/products
- PUT /api/products/{id}
- DELETE /api/products/{id}

Primero enfócate en que entienda REST y los controllers.

### Etapa 3 — PostgreSQL y Entity Framework

Después conecta la API con PostgreSQL y enséñame:

- Cadenas de conexión
- DbContext y DbSet
- Configuración de Entity Framework
- Migraciones
- Creación y actualización de la base de datos
- Traducción de consultas de EF a SQL

Mueve la persistencia de Product desde datos temporales en memoria a PostgreSQL.

### Etapa 4 — DTOs y validación

Cuando el CRUD funcione, explica por qué exponer directamente las entidades de
base de datos puede ser un problema. Introduce DTOs sencillos para crear,
actualizar y devolver productos, junto con validación básica.

No uses una librería de mapeo: escribe el mapeo explícitamente para que pueda
entenderlo.

### Etapa 5 — Services e inyección de dependencias

Cuando comprenda controllers y persistencia, mueve la lógica de aplicación a
un ProductService y enséñame este flujo:

Controller → Service → DbContext

Explica la inyección de dependencias con los objetos reales del proyecto. No
crees interfaces automáticamente. Si propones IProductService, explica primero
qué problema concreto resuelve en este proyecto; si todavía no hay uno, conserva
el servicio concreto.

## Primer paso

Comienza únicamente inspeccionando el entorno y la carpeta actual. Confirma que
estoy en el repositorio indicado. No instales nada, no crees archivos y no
modifiques código todavía.

Después:

1. Resume lo que encontraste.
2. Indica si Docker y Compose están disponibles.
3. Indica si Git y GitHub CLI están disponibles y si `gh` tiene una sesión
   válida, sin mostrar tokens.
4. Si falta una herramienta, propón el procedimiento oficial para mi sistema y
   espera mi autorización antes de instalarla.
5. Si falta la sesión de GitHub, pregúntame si tengo cuenta y guíame por el login
   web; espera a que yo lo complete.
6. Explica qué versión de .NET usará el contenedor y por qué.
7. Propón solo el primer paso pequeño.
8. Hazme dos preguntas breves para comprobar que entendí.
9. Espera mi respuesta y autorización antes de continuar.

Explícame este cambio línea por línea, pero no lo modifiques todavía.

¿Qué parte debería intentar yo? Dame solo la primera pista.

Revisa mi solución. Señala primero el error conceptual y no escribas aún la
solución completa.

¿Cómo puedo comprobar que esto funciona? Propón la prueba más pequeña.

Muéstrame el flujo completo desde la entrada del usuario hasta el resultado.

Hazme tres preguntas para comprobar que podría explicar este código sin tu ayuda.