Crear un entorno de desarrollo end-to-end para desplegar soluciones de IA

Hace poco me escribió un conocido preguntándome cómo empezar a mejorar sus capacidades en el mundo de la IA: no leyendo sobre ella, sino construyendo con ella. Mi consejo fue muy personal, porque era sencillamente lo que hice yo. Me abrí tres cuentas: una en Amazon Web Services, otra en GitHub y otra para Claude Code. Instalé Claude Code en mi ordenador y lo conecté con las otras dos. A partir de ahí, una página que dice Hola Mundo, un dashboard o un agente de IA están a una conversación de estar publicados en internet, en un dominio propio.

Esta nota es esa respuesta escrita al detalle: cómo abrir cada cuenta, cómo interconectarlas y cómo pasar de una carpeta vacía a una página pública, con control de versiones y que se vuelve a desplegar sola con cada cambio. El ejemplo es deliberadamente mínimo. El entorno que lo rodea es el mismo que hace funcionar todos los proyectos de este sitio.

Un notebook te convence a ti. Una aplicación desplegada convence a los demás.

Llevo mucho tiempo escribiendo código: MATLAB desde 2007, R desde 2015, Python desde 2017, después Spark y, desde 2022, notebooks en la nube con Databricks. Cada paso resolvió un problema real y cada uno me enseñó algo sobre estructura y escala. Pero un resultado en un notebook tiene un solo público: quien pueda abrir ese notebook.

El punto al que debes llegar es otro. Quieres poder decirle a una empresa o a un cliente: eeeey, mira lo que he hecho yo mismo. Una aplicación real que funciona y está desplegada. No una captura de pantalla, una URL. Para eso hacen falta tres cosas que los notebooks nunca me dieron juntas: un sitio para el código con todo su historial, un sitio donde se ejecute para todo el mundo y una forma de pasar de uno a otro sin hacerlo a mano. Con un asistente que trabaja en tu terminal, esas tres cosas dejan de ser tres carreras distintas. Se convierten en un entorno que configuras una vez.

El mapa: tres cuentas, una terminal

flowchart LR
    you["Tú
(un chat en la terminal)"] --> cc["Claude Code
en tu ordenador"]
    cc -- "git + gh CLI
(tu sesión de GitHub)" --> gh["GitHub
repositorio + historial"]
    cc -- "AWS CLI
(tu sesión de AWS)" --> aws["AWS
hosting, dominio, modelos de IA"]
    gh -- "GitHub Actions
OIDC, sin claves guardadas" --> aws
    aws --> web["www.tu-dominio.com
publicado para todos"]
    classDef you fill:#E1C340,stroke:#E1C340,color:#0c0c12,font-weight:bold
    classDef cc fill:#3a3418,stroke:#E1C340,stroke-width:2px,color:#f2f2f8
    classDef gh fill:#2c2547,stroke:#a78bfa,stroke-width:2px,color:#f2f2f8
    classDef aws fill:#3b2a16,stroke:#ff9f43,stroke-width:2px,color:#f2f2f8
    classDef web fill:#2dd4bf,stroke:#2dd4bf,color:#0c0c12,font-weight:bold
    class you you
    class cc cc
    class gh gh
    class aws aws
    class web web
    linkStyle default stroke:#E1C340,stroke-width:2px
      

Claude Code es la pieza que cambia la experiencia. Se ejecuta en tu terminal, lee y escribe los archivos de tu proyecto y ejecuta comandos (git, gh, aws) con las credenciales que ya tienes configuradas, pidiéndote permiso antes de hacerlo. GitHub guarda cada versión de tu trabajo y ejecuta el despliegue. AWS aloja el resultado, te vende el dominio, te da modelos de IA a través de Amazon Bedrock y te envía una sola factura por todo.

Paso 1 · Abre tu cuenta de AWS (y protégela el primer día)

1. Regístrate en aws.amazon.com con un correo que vayas a conservar durante años. Necesitarás una tarjeta de crédito y un teléfono para la verificación. Elige el plan de soporte Basic, que es gratuito. Las cuentas nuevas empiezan con ofertas de la capa gratuita (Free Tier); lee las condiciones vigentes al registrarte.
2. Bloquea el usuario raíz. El correo con el que te registraste es el usuario raíz (root): puede hacer cualquier cosa, incluso cerrar la cuenta. Actívale enseguida la autenticación multifactor (MFA) y deja de usarlo para el trabajo diario.
3. Crea tu usuario de todos los días en IAM Identity Center con acceso de administrador, y entra con ese usuario a partir de ahora. Es el que usará la línea de comandos.
4. Elige una región y quédate en ella. Mantén tus recursos cerca de tus usuarios y en un solo lugar, para que nada quede olvidado en otra esquina del mundo. Yo uso Europa (Irlanda), eu-west-1. La única excepción que te encontrarás es el certificado de un dominio en CloudFront, que AWS exige en us-east-1.
5. Crea un presupuesto antes de construir nada. En Billing and Cost Management, crea un presupuesto mensual con alerta por correo (5 dólares sobran para una página estática) y abre Cost Explorer una vez para que empiece a recopilar datos. Es el paso más importante para mantener el control.

Paso 2 · Abre tu cuenta de GitHub

1. Regístrate en github.com y activa la autenticación en dos pasos.
2. Instala git y la CLI de GitHub (gh) en tu ordenador e inicia sesión una vez. La CLI guarda el token por ti, así que ni tú ni Claude tendréis que pegarlo nunca.

# configuración inicial, una sola vez
$ git config --global user.name  "Tu Nombre"
$ git config --global user.email "tu@ejemplo.com"
$ gh auth login        # elige GitHub.com, HTTPS, inicia sesión con el navegador
$ gh auth status       # comprueba: "Logged in to github.com"

Paso 3 · Instala Claude Code

Claude Code necesita un plan de pago de Claude (Pro o Max) o una cuenta de pago por uso. Instálalo con el instalador nativo o con npm, abre una terminal en cualquier carpeta y escribe claude. La primera vez abre el navegador para iniciar sesión.

# macOS, Linux o WSL
$ curl -fsSL https://claude.ai/install.sh | bash
# o, si tienes Node.js instalado
$ npm install -g @anthropic-ai/claude-code

$ mkdir hola-mundo && cd hola-mundo
$ claude

¿Qué interfaz usar? El mismo Claude Code, cuatro puertas

Yo soy un usuario techy, así que trabajo en la terminal Linux básica: una ventana, el chat y git en el mismo sitio, nada en medio. Es rápida y muestra exactamente qué comando se ejecuta. Pero no es la única forma de entrar, y si prefieres ver el código que genera Claude y editarlo con el ratón, hay opciones más amigables visualmente o más avanzadas. Todas usan la misma cuenta, las mismas reglas de CLAUDE.md y la misma carpeta del proyecto, así que puedes combinarlas.

Una buena combinación para empezar: usa Claude Code dentro de VS Code, para ver cada cambio de archivo en el momento y aprender a leer el código, y pasa a la terminal sola más adelante si descubres, como yo, que ya no necesitas las ventanas extra.

Paso 4 · Interconecta las tres

No hay ninguna integración especial que instalar. Claude Code trabaja con las mismas herramientas de línea de comandos que usarías tú, así que conectarlo consiste en configurar esas herramientas una vez.

# AWS CLI v2, con tu usuario de Identity Center
$ aws configure sso    # región eu-west-1, nombre de perfil p. ej. "dev"
$ aws sso login --profile dev
$ aws sts get-caller-identity --profile dev   # comprueba: el id de tu cuenta

La regla detrás de la tabla: nunca se escribe en un archivo una contraseña o clave de larga duración. Añade un CLAUDE.md en la raíz de tu carpeta de proyectos con tus propias reglas (región, presupuesto, nombres, "nunca subas archivos .env") y Claude Code lo leerá al empezar cada sesión. Yo guardo en el mío lo que no quiero repetir nunca: la región, los nombres y qué carpetas se pueden limpiar sin preguntar.

Al principio pregunta mucho. Luego "os vais conociendo".

Prepárate para esto: los primeros días, Claude Code te pide permiso en casi cada paso. ¿Puedo ejecutar este comando? ¿Puedo editar este archivo? ¿Puedo hacer push a GitHub? El proceso se interrumpe muchas veces esperando a que pulses una tecla, y puede parecer lento. Es intencionado. Está actuando en tus cuentas, con tu dinero y tu código, y mientras no le hayas dicho qué está bien, preguntar es lo seguro.

Las interrupciones se reducen conforme os vais conociendo. Cada vez que pregunta, puedes permitir ese tipo de acción para siempre (leer archivos, ejecutar git status, desplegar una página estática) y reservar la confirmación para lo que la merece (borrar recursos, todo lo que cueste dinero, publicar fuera de tus propias cuentas). Las reglas que escribes en CLAUDE.md hacen el resto: una decisión que tomas una vez, como "puedes limpiar estas carpetas de caché sin preguntar", no se vuelve a preguntar. Al cabo de unas semanas, la mayoría de mis sesiones van de la petición al resultado desplegado con solo las preguntas que de verdad importan.

Paso 5 · Compra un dominio

Piensa en una marca, www.tu-dominio.com, lo que se te ocurra, y regístrala en Route 53 dentro de la misma cuenta de AWS. Un .com cuesta del orden de quince dólares al año, la zona alojada que responde por él cincuenta céntimos al mes, y ambos aparecen en la misma factura que todo lo demás. También puedes pedirle a Claude Code que compruebe la disponibilidad y lo registre por ti; te mostrará el comando y esperará tu aprobación antes de cobrar nada.

Organiza tu espacio de trabajo: una carpeta, un repositorio, un nombre

Después de unos cuantos proyectos, el orden importa más que cualquier herramienta. Mi regla es sencilla: una carpeta por repositorio, todas dentro de una carpeta general, y el mismo nombre en todas partes. La carpeta, el repositorio de GitHub y el subdominio llevan el mismo nombre, así que nunca te preguntas dónde vive cada cosa.

~/Developments/                  # la carpeta general: arranca claude aquí
├── CLAUDE.md                    # reglas para todos los proyectos (región, nombres, limpieza)
├── windward/                    # github.com/tu-usuario/windward -> windward.tu-dominio.com
│   ├── CLAUDE.md                # reglas solo para este proyecto
│   └── ...
├── noise-monitor/               # github.com/tu-usuario/noise-monitor -> noise-monitor.tu-dominio.com
├── kanban/                      # github.com/tu-usuario/kanban -> kanban.tu-dominio.com
└── hola-mundo/                  # github.com/tu-usuario/hola-mundo -> tu-dominio.com/hola-mundo

Usa nombres cortos, en minúsculas y con guiones, los mismos que valen en una URL. Cuando arrancas claude en la carpeta general, ve todos tus repositorios a la vez: puedes decirle "trabaja en noise-monitor" o "aplica este arreglo a todos los proyectos que usan el mismo login", y se mueve entre carpetas sin que tengas que cambiar de directorio. El CLAUDE.md de arriba guarda las reglas para todo, y cada repositorio puede añadir las suyas. Pídele a Claude que mantenga esta estructura desde el primer día: "crea cada proyecto nuevo como una carpeta aquí, con un repositorio de GitHub y un subdominio del mismo nombre".

¿Reanudar la conversación o empezar una nueva?

Claude Code guarda tus conversaciones anteriores por carpeta, otro motivo para arrancarlo siempre desde la misma carpeta general. Dos comandos las recuperan: claude --continue reabre la más reciente, y claude --resume te muestra la lista para que elijas.

• Reanuda cuando la tarea no está terminada y el contexto todavía sirve: cerraste la terminal, reiniciaste el portátil o lo dejaste a mitad de un despliegue. Claude recuerda las decisiones, los errores ya vistos y lo que falta.
• Empieza una sesión nueva cuando arrancas otra tarea o pasas a otro repositorio, cuando el trabajo anterior está terminado y con su commit, o cuando la conversación se ha hecho muy larga. Un historial largo hace cada mensaje nuevo más lento y más caro, y los detalles más antiguos acaban resumidos. Dentro de una sesión, /clear te da el mismo comienzo limpio.

El hábito que hace que empezar de cero no duela: todo lo que merezca recordarse va al repositorio (el README, CLAUDE.md, un mensaje de commit), no solo al chat. Así una sesión nueva empieza sabiéndolo ya.

Paso 6 · Hola Mundo, con un solo chat

Aquí empieza la magia. En la carpeta vacía hola-mundo, con claude en marcha, escribe lo que quieres con palabras normales:

> Crea una página web sencilla que diga nada más "Hola Mundo".
  Crea un repositorio público en GitHub llamado hola-mundo para respaldarla y controlar las versiones.
  Despliégala en AWS, en eu-west-1, en www.tu-dominio.com con HTTPS,
  y añade un workflow de GitHub Actions para que cada push a main la vuelva a desplegar.
  Usa OIDC para el despliegue, sin claves de acceso. Explícame cada paso antes de ejecutarlo.

Lo que sigue es una conversación, no un script. Claude propone cada paso, te enseña el comando y lo ejecuta cuando lo apruebas. Para esta petición construye lo siguiente:

%%{init: {'theme':'dark','themeVariables':{'actorBkg':'#2c2547','actorBorder':'#a78bfa','actorTextColor':'#f2f2f8','actorLineColor':'#4a4a66','signalColor':'#E1C340','signalTextColor':'#e8e8f0','labelBoxBkgColor':'#3b2a16','sequenceNumberColor':'#0c0c12','noteBkgColor':'#E1C340','noteTextColor':'#0c0c12','noteBorderColor':'#E1C340'}}}%%
sequenceDiagram
    participant Y as Tú
    participant C as Claude Code
    participant G as GitHub
    participant A as AWS
    rect rgba(225,195,64,0.12)
    Note over Y,A: Primer despliegue: una conversación
    Y->>C: "Una página que diga Hola Mundo, versionada y desplegada"
    C->>C: escribe index.html, git init, primer commit
    C->>G: gh repo create hola-mundo --public --push
    C->>A: bucket S3 (privado) + CloudFront + certificado HTTPS
    C->>A: registro en Route 53 www.tu-dominio.com
    C->>A: rol IAM que solo confía en este repo de GitHub
    C->>G: .github/workflows/deploy.yml
    end
    rect rgba(45,212,191,0.14)
    Note over Y,A: Cada cambio después: un git push
    Y->>C: "Cambia el color a dorado"
    C->>G: commit + push
    G->>A: Actions: sincroniza archivos, refresca la caché
    A-->>Y: nueva versión publicada en tu dominio
    end
      

La página

<!DOCTYPE html>
<html lang="es">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Hola Mundo</title>
  <style>
    body { margin: 0; min-height: 100vh; display: grid; place-items: center;
           background: #0c0c12; color: #E1C340; font-family: system-ui, sans-serif; }
    h1 { font-size: clamp(2.5rem, 10vw, 6rem); margin: 0; }
  </style>
</head>
<body>
  <h1>Hola Mundo</h1>
</body>
</html>

El despliegue automático

El workflow es corto porque la parte difícil, la confianza, vive en AWS: el rol IAM solo acepta tokens de tu repositorio, así que GitHub nunca guarda una clave de AWS.

name: Deploy
on:
  push:
    branches: [main]
permissions:
  id-token: write      # permite a GitHub pedir a AWS un token de corta duración
  contents: read
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: arn:aws:iam::<id-de-cuenta>:role/github-deploy-hola-mundo
          aws-region: eu-west-1
      - run: aws s3 sync . s3://<tu-bucket> --exclude ".git*" --delete
      - run: aws cloudfront create-invalidation --distribution-id <id> --paths "/*"

Puedes ver la misma página en vivo en forwardforecasting.eu/hola-mundo. Es el archivo de arriba, publicado con el pipeline de este mismo sitio: la misma idea (push a GitHub, Actions despliega en AWS con OIDC), con mi servidor ya existente como destino en lugar de un bucket.

Paso 7 · De Hola Mundo a la IA

Con el entorno montado, los siguientes proyectos son solo conversaciones más largas. Pide un formulario que envíe texto a un modelo Amazon Nova en Bedrock a través de una pequeña función Lambda. Después, un agente que use herramientas. Después, un dashboard con tus propios datos detrás de un login. Cada uno es un repositorio nuevo, desplegado de la misma forma, y en cada uno entiendes un poco más del proceso, hasta ser capaz de desarrollar aplicaciones funcionales que hagan desde procesos sencillos hasta otros más complejos con modelos de IA, agentes, etc.

Una decisión práctica que recomiendo por experiencia: llama a los modelos de IA a través de Bedrock en tu propia cuenta de AWS, en lugar de con una clave distinta para cada proveedor. El acceso se controla con los mismos roles IAM que todo lo demás y el coste aparece en la misma factura.

¿Qué modelo usar? No el más avanzado, el adecuado

Una pregunta que se hace todo el que empieza: ¿debo usar siempre el modelo más potente? No. Claude viene en niveles, y el precio por token crece mucho más rápido que la diferencia que vas a notar en el trabajo diario. Estos son los precios oficiales de Anthropic por millón de tokens en octubre de 2026:

Yo uso Sonnet para casi todo, y este es el porqué. Construir una página, escribir un workflow, crear una función Lambda o un dashboard no son problemas donde la inteligencia bruta sea el cuello de botella; lo son las instrucciones claras. Sonnet resuelve muy bien ese tipo de programación y de trabajo con agentes, a la mitad de precio que Opus y a una quinta parte que Fable, y responde más rápido, lo que mantiene la conversación fluida. Como ejemplo, una sesión de trabajo larga que lee 2 millones de tokens y escribe 200.000 cuesta unos 6 dólares con Sonnet, 12 con Opus y 30 con Fable, antes de cualquier descuento por caché. Con una suscripción mensual la lógica es la misma: un modelo más ligero hace que tu cuota de uso dure más.

Mi regla práctica: empieza con Sonnet. Sube a Opus solo cuando Sonnet falle dos veces en el mismo problema, por ejemplo una decisión de arquitectura complicada o un error que no consigues aislar, y vuelve a bajar cuando esté resuelto. Baja a Haiku, o a un modelo pequeño de Amazon Nova en Bedrock, para las llamadas repetitivas que tu propia aplicación hace miles de veces. En Claude Code cambias de modelo con el comando /model en cualquier momento de la conversación.

Sé el amo de tus recursos

Tres resultados que vale la pena guardar

1. Diecisiete segundos de git push a página publicada

Cuando publiqué la página Hola Mundo para esta nota, lo cronometré: 17 segundos desde el git push hasta que la página respondió en la URL pública. No fue un golpe de suerte. En los últimos 53 despliegues correctos de este sitio, la mediana fue de 20 segundos, con el más rápido en 16 y el más lento en 29.

La lección: cuando publicar cuesta veinte segundos y ninguna decisión, dejas de acumular cambios y dejas de tenerles miedo. Publicas en pequeño, a menudo, y el historial de GitHub te dice exactamente qué cambió.

2. Empieza humilde: unos dos dólares al mes por una página estática

No necesitas un gran presupuesto para empezar. Cuando empecé, pagaba una sola máquina virtual EC2 pequeña por unos 15 dólares al mes, y era más que suficiente para mis primeros despliegues. Una página estática como Hola Mundo es aún más barata, porque no hay ningún servidor encendido:

La VM pequeña merece la pena cuando quieres tener un backend, una API o una base de datos junto a tus páginas; una página estática sola no la necesita. La factura solo crece cuando tú decides construir más: hoy, con más de veinte proyectos en la misma cuenta, todas las llamadas a modelos de IA de todos ellos costaron 2,94 dólares en septiembre. Pon tu alerta de presupuesto justo por encima de tu plan, 5 o 20 dólares, y te enterarás por un correo la misma semana si algo se dispara, no por una sorpresa a final de trimestre.

3. Una clave compartida, cuatro proyectos caídos

Al principio, varios de mis proyectos llamaban a un modelo de IA con una única clave de API compartida de un proveedor. Cuando esa clave tuvo un problema, cuatro proyectos se cayeron a la vez. La solución fue llevar el trabajo de IA nuevo a Amazon Bedrock: el acceso se concede con roles IAM como todo lo demás, el uso se ve por servicio en el mismo Cost Explorer y no hay ninguna clave secreta que compartir o filtrar.

La lección para quien empieza: centralizar no es solo tener una factura. Es tener un único lugar donde se ven el acceso, el coste y los fallos. Hoy esa cuenta y ese perfil de GitHub reúnen 29 repositorios activos, y todos siguen el mismo camino que acabas de leer.

Por qué lo he escrito

Esto empezó como una respuesta a una persona, y creo que le sirve a muchas más. Si sabes algo de programación pero todo lo que has construido vive en tu ordenador, el hueco que te falta no es otro curso. Es este entorno. Si nunca has programado, un chat en una terminal es hoy una vía de entrada real, siempre que leas lo que te propone y preguntes por qué. Una vez que tienes las tres cuentas conectadas, ya tienes la varita de Harry Potter en tu mano: desarrolla proyectos demostrativos de las tecnologías que más te interesen, despliégalos y sigue hasta poder enseñarle a alguien una aplicación real que funciona.

Cuánto cuesta este entorno

Abrir las cuentas de AWS y GitHub es gratis. Claude Code necesita un plan de pago de Claude, o uso de pago por consumo a través de la API o de Bedrock; suele ser el mayor coste fijo. Una página estática como Hola Mundo en S3 y CloudFront cuesta céntimos al mes con poco tráfico, más el dominio (unos quince dólares al año por un .com) y cincuenta céntimos al mes por su zona DNS: unos dos dólares al mes en total. Cuando quieras también un backend, una sola VM pequeña basta para empezar, unos 15 dólares al mes. Todo lo demás crece solo tan rápido como lo que decidas construir, y tu alerta de presupuesto te avisa cuando lo hace.

Sobre la portada: una ilustración dibujada con Matplotlib del entorno descrito aquí. Los tiempos salen del historial de despliegues de este sitio; el presupuesto inicial, de los precios de AWS y de lo que pagaba yo al empezar; la cifra de IA, del AWS Cost Explorer de septiembre de 2026.