Hola a todos, sean todos muy bienvenidos
a este curso de Cloud Code que hemos
estado preparando junto a Danielila
junto a Jorge Salgado que ven acá. Eh,
es impresionante la cantidad de gente
interesada en aprender sobre esta
tecnología. Eh, quiero darle las gracias
a los chiquillos por la disposición, por
estar acá. Y bueno, Daniel va a dictar
el curso. Eh, Daniel se maneja mucho con
Claus Code a él. Ahí él les va a contar
algunas experiencias que tiene con
algunos proyectos que han se han hecho
muy populares y de hecho han tenido
muchas miles miles miles de descargas en
Jitha. Así que dan cuenta al cancé a
presentar creo, pero bueno chicos, me
presento. Yo soy Cami, soy ingeniera en
informática, convención en
ciberseguridad. Yo me dedico a a revisar
herramientas de inteligencia artificial
todo el tiempo y mostrarlas en mis redes
sociales. Y bueno, ahora sí le damos el
pase a Dani para que nos dé toda la
explicación, porque tengo entendido que
hoy día vamos a ver eh Cloud Code en más
profundidad, vamos a ver cada línea de
código, así que Dani, te doy el pase.
Muchas gracias.
Muchas gracias. Por fin vamos a partir
con el módulo. Este es un módulo de
introducción, así que voy a estar
hablando de los fundamentos que tienes
que manejar para poder trabajar con este
tipo de tecnología.
No es un módulo que sea para cualquier
persona, así que eso lo voy a advertir
desde ya, desde un inicio. Esto no es
para personas que no sean técnicas,
¿okay? Esta este video y este módulo y
esta introducción es para programadores.
Por lo menos no tienen que ser expertos
en programación, pero sí tienen que
tener por lo menos las bases y los
fundamentos de programación orientada a
objeto. podrían tener ya algunos
conocimientos de JavaScript, de Python,
pero si ya conocen más o menos algunos
conceptos de la programación, ya han
trabajado en una terminal, por ejemplo,
deberían poder manejar este primer
módulo. Si es que no los conoces y estás
aquí y estás viendo este primer inicio
con Cloud Code, te recomiendo que partas
por aprender programación.
Eh, lamentablemente va a ser muy
complicado para ti eh tomar algunos
conceptos y entender cómo funcionan. Así
que te pido que vayas a algún curso de
programación, que veas algunos videos de
programación de JavaScript, de Python,
eh PHP, bases de datos y después te
puedas mover a este curso para que
entiendas completamente cómo funciona y
finalmente sea algo muy productivo para
ti. Así que dicho esto, ya partimos, eh,
así que pongan muchísima atención.
Para comenzar les quiero contar algo muy
breve de mí, de lo que he estado
haciendo. Yo llevo ya más de 15 años
programando. Voy a sacarme aquí un
poquitito de la pantalla para que puedan
ver toda la presentación. Llevo más de
15 años programando. Eh, ya he creado
dos empresas, dos startups, las partidas
en Chile, otra la partida acá en Estados
Unidos. Eh, tengo bastante experiencia
programando, tengo bastante experiencia
levantando servicios en la nube, en
Microsoft, en Google, en Amazon. Eh, y
he hecho estas diferentes charlas e en
Chile, en México, en Estados Unidos, en
España y e, incluso en en Corea del Sur.
fui a dar una charla a Corea del Sur,
así que ya tengo bastante experiencia.
Soy eh bien antiguo en este mundo de la
programación. Tengo algunas buenas
prácticas, malas prácticas, pero la idea
es que me conozcan un poco y que
entiendan que no van a estar con una
persona que simplemente apareció y dijo,
"Oh, voy a utilizar estos modelos." sino
que vengo del mundo antiguo de donde
teníamos que escribir el código. Ahora
ya no escribimos mucho código, pero eh
todos estos 15 años que llevo eh en mi
carrera fue mucha escritura de código,
mucha eh eh entendimiento de patrones de
diseño, de cómo armar plataformas que
soportan muchísimo tráfico y muchísimos
usuarios. Así que desde ahí viene mi
conocimiento y desde ahí que lo he
traspasado a este mundo de agentes, de
modelos de lenguaje y de cloud code. Así
que por eso creo que puede entender muy
muy bien cómo aplicar este tipo de
tecnología en el mundo de la
programación y cómo veníamos
construyendo las cosas. E, así que les
quiero transmitir ese conocimiento
también para que puedan entender por qué
estoy explicando estas cosas, cómo las
explico.
Y a lo que vinimos, Cloud Code. ¿Qué es
Cloud Code? Básicamente es un software,
¿okay? No es un modelo, no es un modelo
de lenguaje, no es una no es una
inteligencia artificial, es un software
que corre eh como una interfaz que
nosotros la vemos, la podemos manejar y
por debajo hay varias varios componentes
que finalmente llegan a un modelo de
lenguaje. Y en este módulo vamos a estar
viendo cómo pasamos de utilizar esta
herramienta nosotros, usuarios normales,
cómo le enviamos contexto a esta
herramienta y cómo esta herramienta eh
toma este contexto, cómo lo arma, cómo
lo ejecuta y cómo se lo envía a un
modelo de lenguaje, que básicamente es
la inteligencia artificial que está por
detrás, que nos va a responder o que va
a ejecutar algunas acciones. En este
caso va a escribir código. Ya nos vamos
a enfocar muchísimo en que le pasemos
buen contexto a Cloud Code de una forma
correcta con todos los componentes que
tiene este ambiente de Cloud Code y e
Cloud Code puede ejecutar correctamente
el código que nosotros le estamos
solicitando o armar una arquitectura o
que pueda levantar servicios, que pueda
crear una página web que pueda correr
migración en una base de datos, que
pueda hacer absolutamente todo lo que
nosotros queremos, que no alucine, que
no se pierda, que no e que no haga otras
cosas, básicamente.
Entonces, partamos. Lo primero que te
voy a pedir es que cierres Cloud Code.
No lo vamos a utilizar en este módulo.
Así que si querías partir instalando
algunos componentes, skills, corriendo
agentes, no lo vamos a hacer en este
video. Así que quiero que entiendas lo
que pasa por debajo cuando utilizamos
Cloud Code. Y si entiendes, el próximo
módulo va a ser pero espectacular para
ti, porque el que maneje esto, el que
maneje lo que les voy a comentar hoy día
en este video completo, va a ser capaz
de entender qué pasa cada vez que tú le
envías algún contexto, cada vez que tú
le mandas alguna solicitud, cada vez que
tú instalas un agente o instalas un
skills, cada vez que tú creas un skill
también manejando esto vas a poder crear
buenos skills, vas a poder ejecutar
buenos skills y vas a poder básicamente
manejar muy muy bien Cloud Code. Si es
que quieres saltarte esto, puedes
hacerlo. Puedes ir directamente a videos
en YouTube, videos en Instagram donde te
dicen eh utiliza este skill, este skill
te va a armar una plataforma completa,
este skill te va a hacer unos videos,
este skill te va a crear tu página web o
te va a correr toda tu empresa sin que
tú hagas absolutamente nada y vas a
tener que volver a este video porque
eso, ese tipo de contenido no es e muy
educativo, básicamente es un contenido
que llama a saltarse pasos y básicamente
no entiendes lo que está pasando por
debajo y llegas a un punto donde no
puedes seguir avanzando y cloud code no
funciona. Okay, lo digo muy
abiertamente, no funciona si es que te
saltan los pasos de los fundamentos y de
el entendimiento de cómo manejar el
contexto y pasárselo al modelo de
lenguaje. Si te vas directamente a
instalar un skill que viste en
Instagram, no te va a funcionar. Vas a
llegar a la primera interacción y
después vas a decir, "¿Cómo sigo
trabajando con esto?" Y hasta ahí
llegaste.
¿Qué es lo que primero debemos entender?
Es que lo que les decía en un principio,
Cloud Code es una interfaz entre el
usuario y entre la inteligencia
artificial. Me voy a sacar aquí para que
podamos ver todo el la presentación.
Y todo esto se maneja con la ventana de
contexto.
Em,
sigan muy bien este concepto, porque
este concepto es clave, la ventana de
contexto que maneja un modelo de
lenguaje. Estos modelos pueden consumir
muchísima información. al principio
consumía muy poca y teníamos que hacer
un poco de magia con el tema del de la
ventana de contexto o cuánta información
le enviábamos a los modelos, pero hoy en
día consumen muchísima información y eso
quiere decir que podemos enviarle mucha
información y eso quiere decir que
pueden consumir muchísimo ruido externo
que probablemente no necesiten para
poder ejecutar las tareas que nosotros
les estamos pidiendo. Entonces, cuando
nosotros le enviamos información a este
modelo de lenguaje, tenemos que ser
supercisos, super específicos en lo que
le tenemos que enviar. Si empezamos a
agregar skills, agregar MCPs, agregar el
PROM mágico que vimos por internet,
probablemente vamos a enviarle muchísima
información que el modelo no necesita
para poder ejecutar la tarea que
nosotros queremos que ejecute. Entonces,
por eso es clave que entendamos que el
flujo es usuario que está enviando la
información, Cloud Code, que es el
software que va a compactar todo este
contexto que le estamos enviando y el
modelo de lenguaje que simplemente
recibe texto y devuelve texto. Y luego
Cloud Code toma el texto de vuelta y
dice, "Ah, tengo que o responder o
ejecutar acciones." Y eh esto lo
recibimos nosotros como usuario con una
un output o una salida que nos envió
cloud Code. Okay, pasemos al siguiente.
Este interacción que acabamos de ver
ocurre en turnos. Ya. La primera
interacción es el primer mensaje que
envía el usuario y lo estamos viendo en
esta parte de acá. Cada vez que nosotros
enviamos un mensaje y recibimos una
salida, que es el texto de salida que
está acá, se empieza a llenar esta
ventana de contexto. Entonces, el modelo
empieza a recibir información y empieza
a devolver información, pero al segundo
turno, el modelo necesita recibir el
historial de mensajes que ocurrieron
anteriormente y es por eso que se amplía
la ventana de contexto del modelo y
empezamos a enviarle más y más
información. Entonces, cada vez que
nosotros hablamos con Chat GPT, por
ejemplo, nosotros partimos saludándolo.
Hola, Chat GPT, ¿cómo estás? Ese es el
primer mensaje, el primer turno. Chat
GPT no responde. Estoy super bien. ¿En
qué vamos a trabajar hoy día? Pasa al
segundo turno. Nosotros le decimos e,
"No sé, cuéntame un chiste." Y nosotros
tenemos que enviarle el primer mensaje,
el primer hola, ¿cómo estás? Y después
el cuéntame un chiste. Eso está pasando
entre medio de la interfaz que tú estás
viendo con Chat GPT. Exactamente lo
mismo pasa con Cloud Code. Cada vez que
tú abres Cloud Code es un chat donde tú
tienes que enviar el historial y esto va
a ir trabajando por turnos. El primer
turno, primer saludo, primer mensaje,
segundo turno, el historial del turno
anterior más el segundo mensaje y más la
respuesta. Y si te vas fijando ya
empieza a ser un poco más grande el
output. ¿Por qué? porque viene con
mensajes de saludo, después viene con
alguna pregunta y después ya en el
tercer turno ya vienen todos los
mensajes anteriores más la respuesta y
más el mensaje del usuario y así con
todos los turnos. Imagínate cuántos
turnos, cuántas sesiones tienes tú todos
los días con Cloud Code. En cada mensaje
que tú le envías, tú le estás enviando
información al modelo y el modelo recibe
y recibe información y recibe
información. Todo esto hace que la
ventana de contexto del modelo se
amplíe, sea muy grande, pero el modelo
no necesita toda esa información, no
necesita tanta información para cumplir
con alguna tarea específica. E incluso
se pone peor
porque lo que vimos recién eran
solamente mensajes y ahora lo que les
voy a mostrar son razonamientos, ¿ya?
Porque los modelos tienen este
razonamiento. Cada vez que tú ves que
Cloud Code empieza a poner thinking es
que está pensando y eso significa que
internamente ejecuta turnos con otros
modelos para poder entender lo que tú le
estás diciendo. O sea, el modelo ya son
tan inteligentes que tienen que e
deducir cómo hablan los humanos, porque
nosotros no hablamos perfectamente,
nosotros no nos comunicamos muy bien.
Entonces, cuando tú le envías una
solicitud a Cloud Code, Cloud Code tiene
que decir, "Uf, esta solicitud no está
muy buena. Déjame razonar internamente,
preguntarme a qué se refiere lo que me
está diciendo este ser humano y de esta
forma voy a poder entender lo que está
pasando." Entonces, a los turnos
anteriores, súmale que el modelo va a
ser un razonamiento cuando no te
entienda y va a decir, "Voy a intentar
entenderle a este ser humano y voy a
ponerle más output y más salida. porque
necesito este razonamiento interno para
poder entender la solicitud que me está
pidiendo el ser humano. Entonces, ahora
viene con un system prompt, después
viene con un eh el mensaje del usuario,
después viene con un eh una extensión
del razonamiento y después viene el
texto de salida. Todo esto lo podemos
ver en Cloud Code. Nosotros cuando
estamos trabajando podemos ver que dice
pensando y tú puedes e ampliar esa
ventana y puedes ver que el modelo dice
el usuario me dijo esto, pero creo que
está diciendo esto otro, mejor le
pregunto o mejor creo que voy a tomar
este camino y no voy a tomar este otro.
Todo ese razonamiento lo podemos ver y
en la plataforma de Cloud Code podemos
entender lo que está pasando.
Eh, así que ventana de contexto, cada
vez que pasa este razonamiento, más
ventana de contexto, más ruido, porque
absolutamente todo se lo estamos
enviando al modelo. En cada uno de los
turnos que el modelo razonó, eso también
se envía y se envía y se envía y se
envía información. mucho texto que le
estamos enviando al modelo y el modelo
tiene que procesarlo. Cada vez que le
llega una solicitud tiene que tomar
todos los turnos anteriores, tiene que
procesarlo y tiene que responderte una
pregunta que tú le hiciste al final
después de que ya conversaste muchísimas
veces con él, tienes que tiene que
responderte esa última pregunta. Y e
esto se pone peor aún porque aparte de
los mensajes, aparte del historial,
aparte del razonamiento, el modelo tiene
que procesar tools. Tools significa
herramientas. Así que el modelo por
debajo tiene que ejecutar algunas
herramientas y estas herramientas les
dan el poder a los modelos de decir,
"Necesito que ejecutes esto." Y esto no
lo hace el modelo en sí, lo hace el
software que está entre medio, lo hace
Cloud Code. Y este software dice, "Ah,
el modelo me está pidiendo que ejecute
una herramienta específica. la voy a
ejecutar y cuando la ejecute le voy a
pasar el resultado de esa herramienta al
modelo para que aparte del mensaje del
usuario, aparte del razonamiento tenga
un resultado de alguna herramienta que
yo ejecuté. Pongámosle que herramientas
son leer un archivo, que son editar un
archivo, escribir un nuevo archivo.
Entonces, el modelo cuando te pide que
tú eh leas un archivo específico, porque
el modelo necesita entender qué está
dentro de ese archivo, el modelo de le
dice al software, lee este archivo. Y el
software le dice al modelo, aquí está el
archivo, lo leí. Y acá está el output,
acá está el contenido completo del
archivo. Y el modelo toma este contenido
y vuelve a responderle al usuario. Ahora
ya leí el archivo y este archivo tiene,
no sé, 200 líneas y en la línea cinco
hay algo raro que necesitamos editar
para poder cumplir con la solicitud que
me estás pidiendo. De esta forma
funciona y esto es todo lo que pasa por
debajo con Cloud Code. Así que por eso
es tan complicado pasarle tanto
contexto, por eso es tan complicado que
Cloud Code entienda perfectamente lo que
nosotros necesitamos que haga, ¿okay?
Así que tengan muy en cuenta cada vez
que ustedes le piden algo a Cloud Code,
que Cloud Code tiene que procesar todo
esto, todos estos turnos, todo este
razonamiento, tools y todo esto pasa
miles de veces en una sesión. O sea,
este flujo que les estoy mostrando acá
se ejecuta unas 500 veces cada vez que
ustedes conversan con CloudCo.
Ahora vamos a ir directamente al
software. Yo les decía que hay un
software intermedio dentro de los
modelos y este software puede ser un
editor de código como es Cursor, como es
Visual Studio o como es Antigravity o
puede ser Cloud Code que tiene varias
plataformas. Les voy a mostrar todas las
plataformas que tiene. Eh, Cloud Code
puede vivir en una extensión. Acá le
estoy mostrando las plataformas que
tiene Cloud Code. Esta es una extensión
la que se ve acá. Tú la descargas de
Visual Studio Code, del Marketplace
extensiones y puedes abrirlo acá como
una ventana al lado de Visual Studio
Code. Por debajo es el mismo software,
corre Cloud Code y por debajo es el
mismo modelo, corre los modelos de
Antropic por debajo de este software.
¿Okay? También tú puedes correrlo en la
terminal, que es la que está
aquí, aquí. Esa esa terminal es e una
consola, una terminal que se comunica
directamente con el hardware. Ya aquí no
estamos pasando por la por Visual Studio
Code, sino que estamos literalmente
trabajando en la terminal. Y también
tenemos e acá les voy a mostrar el cloud
Code Desktop, que lo que es básicamente
es Cloud Code dentro de una interfaz que
está creando el equipo de Antropic para
poder utilizarlo de una forma eh que
ellos están están creando. Es muy buena.
Yo les sugiero que la prueben al final.
Ahora vamos a entender cuál es la mejor
interfaz para trabajar, pero esta denle
denle una oportunidad porque es bastante
buena. Yo la estado utilizando en
algunas tareas específicas. [resoplido]
¿Qué son estos software? Básicamente
todo partió con Visual Studio Code,
¿okay? Eh, cursor y Antigravity. Las que
están acá son Visual Studio Code. Visual
Studio Code más bonito. Le cambiaron los
colores y le hicieron un fork. Ya los
programadores sabemos lo que es un fork,
así que no voy a pasar por esa parte,
pero básicamente es copiar el código
libre que está en GitHub de este
software y básicamente copiarlo. Okay,
eso es lo que hizo Cursor y eso es lo
que hizo Antigravity. tomaron Visual
Studio Code, que estaba libre, y
dijeron, "Voy a sacar mi propio
producto, le voy a cambiar el nombre y
voy a cambiarle los colores y voy a
ponerle la inteligencia artificial que
yo quiera y voy a sacar un producto
millonario." Tiene eh 38,000 Fork Visual
Studio Co, así que mucha gente ha
intentado hacer lo mismo y a estos tipos
les funcionó. ¿Cuál es el problema de
Visual Studio Code? Y es que eh tú para
poder traspasar este conocimiento que
les comentaba anteriormente, tienes que
utilizar la API de Visual Studio Code. Y
esta API es no es una API web, sino que
es una API interna del software que te
permite acceder a las funciones de el
editor de código. Entonces es muy
complicado poder trabajar con eh este
intermediario que es la API de Visual
Studio Code para que el modelo entienda
absolutamente todo lo que tú puedes
hacer. todas las tools que puede manejar
y absolutamente todo. Entonces, todo lo
que hicieron el equipo de Cloud Code,
que es el equipo de Antropic, fue
saltarse esta API de Visual Studio Code,
no hacer un fork y se fueron
directamente a la terminal, directamente
a la interfaz de comandos de un
computador donde tú puedes hacer
absolutamente todo. En una terminal tú
puedes eliminar tu computador completo,
puedes limpiarlo, puedes entrar a todas
las carpetas, tienen los permisos de
absolutamente todo, si es que esa
terminal tiene los permisos de
administrador. Entonces, lo que hicieron
los de Visual Studio Code o, perdón, los
de Cloud Code fue directamente a crear
un software que viva en la terminal y de
esa forma tenemos acceso a todo y ya no
tenemos que estar pidiendo permiso y no
tenemos que estar e trabajando con una
app intermedia y esto va a ser muy
poderoso y por eso Cloud Code es tan tan
poderoso porque vive en la terminal y
ejecuta absolutamente todo lo que tú
quieras con un control adecuado.
Entonces, e aquí son las plataformas que
les acabo de mostrar. Podemos trabajar
en la CLI, que es la que está acá.
Podemos trabajar en la extensión, que es
la que está acá, o podemos trabajar en
Cloud Code Desktop, que es esta que está
acá. Yo les recomiendo que se vayan a la
CLI inmediatamente, que partan por acá.
¿Por qué? Porque es la más poderosa y es
la que está más avanzada. Todas los eh
nuevas características van a salir
primero acá y después se van a mudar acá
y después se van a mudar a la que está
acá. La CLI puede hacer absolutamente
todo y todo lo que les voy a mostrar en
este curso va a ser bajo la CLI. ¿Okay?
E pero vamos a primero a entender qué es
lo que pasa con la CLI. Ya, como ya
sabemos que Cloud Code ejecuta comandos
y ejecuta razonamiento y ejecuta tools,
ejecuta herramientas, porque el modelo
le manda a ejecutar esas herramientas y
le dice, "Necesito leer, necesito
entender. Eh, busca estos archivos,
después navega por aquí, navega por allá
para que yo pueda básicamente
responderle a este usuario que me está
pidiendo cosas y yo no sé dónde estoy,
no sé cómo funciona todo lo que me está
pidiendo. Así que necesito investigar
primero la CLI, la línea de comandos, es
perfecta para esto. Puedes hacer
absolutamente todo y por eso Cloud Code
es tan poderoso. Entonces vamos a ver en
esta simple interacción. Esta
interacción tomó medio segundo. Cloud
Code pasó por acá, ejecutó esto, después
ejecutó este razonamiento y después
siguió ejecutando tareas. Em lo primero,
¿qué fue lo primero que hizo? Fíjense
acá. hizo una eh un fine. Un fine es un
comando Unix, que es una línea de
comando. No me voy a meter muy mucho en
el tema de los comandos de Unix, pero
son cómo se utilizaban los computadores
antes que existiera Windows, antes que
existieran las interfaces de usuario,
los programadores teníamos que escribir
estos comandos y mucha gente que lo
sigue utilizando porque de hecho cuando
tú te metes a un servidor tienes que
utilizar esta línea de comandos, no hay
una interfaz e el Linux sobre todo. Y
para poder ejecutar esto, simplemente el
modelo fue y le dijo a Cloud Code,
ejecuta la esta tools específica que va
a ejecutar este comando específico
porque necesito entender algún archivo.
El usuario me está pidiendo alguna
tarea, pero yo necesito encontrar este
archivo. Entonces, podemos darnos cuenta
de que eh usa fine y head para leer el
primer archivo Jason que encuentra en el
directorio de hooks. Okay, eso es lo que
está haciendo en este milisegundo donde
Cloud Code pasó y ejecutó muchas cosas
sin saber exactamente el nombre del
archivo, o sea, está buscando, está
intentando encontrar contexto eh esa
exploración dinámica del del file
system, o sea, simplemente está
explorando algún e algún sistema de
archivos que el usuario le pudo haber
pedido que explorara. Estos son comandos
Unix, como les acabo de comentar, y lo
que está haciendo básicamente es que
está tomando los primeros 10 archivos.
Eh, Jason. Okay. Entonces, no tenemos
que saber esto. Esa es la magia de todo
eso. No tenemos que saber absolutamente
nada de lo que está haciendo Cloud Code,
porque Cloud Code conoce muy bien los
comandos Unix, pero sí tenemos que
entender que está pasando eh alguna
ejecución de comandos en tu computador
porque es peligroso. O sea, básicamente
Cloud Co se está metiendo a tu sistema
de archivo, lo está leyendo y está
ejecutando cosas. ¿Cómo podemos mitigar
un poco eso? es nosotros mismos guiando
a Cloud Code para que Cloud Code no haga
esta exploración e cuando nosotros
sabemos lo que tiene que ir a buscar.
Entonces, por ejemplo, en vez de haberle
yo dicho, "Ey, busca todos los archivos
y los archivos Jason por aquí o por allá
y haberle dado una instrucción super
vaga y super general, podría yo haber
implementado esto que está acá, que es
primero el archivo. Voy a sacar para que
podamos ver todo." Primero le digo en el
archivo @vversel.jason.
Entonces, ya le estoy indicando un
archivo, ya le estoy diciendo, "Anda
allá, no tienes que buscar todos los
Jason que hay en mi proyecto. Vectamente
a versel.jonjon
y verifica la configuración con @ otro
archivo que le estoy pasando que viene
con una instrucción. Entonces, de esta
forma,
de esta forma podemos ejecutar una tarea
muy directa a Cloud Code. No vamos a
estar desperdiciando tokens en búsquedas
que no necesitamos. Cloud Code
directamente recibió una tarea donde le
está diciendo lo que tiene que hacer y
podemos ver que no va a ejecutar una
búsqueda. Podemos ver que se va a ir
directamente ese archivo, lo va a abrir,
lo va a leer y después va a ir al otro
archivo que es un subagent, que lo vamos
a ver en los siguientes módulos, pero lo
va a exactamente va a ser lo mismo, lo
va a leer y lo va a ejecutar. Y de esta
forma nosotros conociendo el contexto
que le estamos pasando a la herramienta,
no ahorramos tiempo, nos no ahorramos
tokens y la ventana de contexto queda
chiquitita, queda pequeña. No es mucho
ruido el que le estamos pasando al
modelo. Le estamos entregando
exactamente lo que el modelo necesita y
el modelo ejecuta perfectamente lo que
nosotros le estamos pidiendo.
Tareas específicas, tareas directas y
así el modelo no se va a perder.
Vamos al paso número dos. Imagínense el
modelo ya encontró el archivo Jason.
Imagínense, nosotros lo hicimos mal y no
no le estoy pidiendo que lo hagan
siempre, que siempre busquen los
archivos porque eso es imposible con la
velocidad que ejecutan los agentes.
Cuando sepan ustedes cuál es el archivo,
pásenselo. Pásenselo en el texto con un
a y le pasan el archivo específico que
necesitan trabajar. Pero en el segundo
paso está superinesante. El segundo paso
lo vamos a revisar acá. Ahora tengo una
imagen clara de los campos del front.
Déjame ver que hay disponible en compost
en compon components.jonjason
para verificar si la descripción ya está
ahí. O sea, otro problema, otro problema
más. ¿Qué pasó? que no le dimos más
contexto. Aquí lo que está haciendo eh
Cloud Code está razonando internamente,
ya encontró un poco de información, pero
ahora Cloud Code, no se estaba viendo
todo el texto. Ahí lo voy a ya encontró
un poco de información, pero tampoco
nosotros le dijimos qué es lo que tenía
que hacer con ese archivo o qué es lo
que tenía dentro de ese archivo. Okay.
Entonces, lo más sano hubiese sido que
aparte de pasarle el archivo, nosotros
le hubiéramos dicho la tarea que tiene
que ejecutar específicamente y los
campos que tiene que modificar en ese
archivo. Ya no es directamente
programar, sino que es guiar al al
modelo, guiar a la gente de Cloud Code
para que entienda la tarea y para que
pueda ejecutarla correctamente.
Estamos muy cerca de hacerlo nosotros
porque si estamos viendo esa tarea es
por por qué nosotros no vamos a la
descripción y al modelo. Es porque
nosotros tenemos que crear algunos
promps que guíen al modelo y les voy a
explicar después porque estos son los
pasos iniciales. Después el modelo o el
software más que nada empieza a aprender
de la interacción del usuario y después
no necesita que el usuario le diga este
tipo de cosas. Pero si nosotros somos
bien específicos al principio, si
creamos componentes bien específicos al
principio, si creamos skill, si creamos
subagent, si creamos un buen cloud MD,
que lo vamos a ver en los siguientes
módulos, el modelo después ya no va a
necesitar que seamos tan específicos
como lo estamos haciendo ahora. ¿Okay?
Pero esto es para que nosotros podamos
entender. Si nosotros le hubiéramos
dicho que eh habían unos campos que es
el nombre, la descripción y el modelo en
un formato Yamel, el modelo no debería
haber abierto ese archivo y haber
investigado que tenía el archivo.
Nosotros ya se lo estamos pasando y el
modelo eh se ahorra tokens, se ahorra
ventana de contexto y todo queda super
específico.
¿Por qué pasa esto? ¿Por qué el modelo
necesita esta información? Y básicamente
es porque em me voy a mover un poquitito
ahí, creo que estaba un poco colapsado
la luz. Básicamente es porque el modelo
es stateless y no es stateful. Okay,
tengo un video en YouTube completo, así
que pued lo voy a dejar en los
comentarios para que puedan ir a ver de
qué se trata esto de stateless y
stateful. Y véanlo, porque van a
entender muy bien cómo funcionan los
modelos de lenguaje, van a entender muy
bien cómo funcionan las APIs de Open AI,
de Antropic. Y entendiendo eso, ya
pueden entender cómo se comunica, ya
pueden ver cómo pasa una información a
la API y después al modelo y después al
software y lo y saben por qué les llega
esa información de vuelta. Entonces,
¿qué significa? Vamos a hacer un resumen
muy muy corto de de lo que significa
esto. ¿Qué significa que sea stateless?
Es que tú le envías una información al
servidor y el servidor te devuelve una
información sin ningún contexto extra,
¿okay? Tú le estás pasando algo y el
servidor te devuelve algo. Exactamente
igual como les comenté en los turnos al
principio. En el primer turno tú le
envías un mensaje al modelo y el modelo
te devuelve el mensaje y después al
segundo turno, tú tienes que volver a
enviarle todo el historial porque si no
le envías todo el historial el modelo es
como si estuviese recibiendo ese primer
mensaje sin el contexto anterior.
Entonces es como si estuviese saludando
de nuevo, pero tú ya lo saludaste, ahora
le estás pasando la pregunta y después
le vas a pasar el una tools, después le
vas a pasar un razonamiento. Para el
modelo eso no existe. Para la API que
está recibiendo esta información siempre
es una interacción y tú tienes que estar
agregándole el contexto. Por eso de
repente vemos que que Cloud Code se
olvida de algo. Por eso de repente vemos
que te vuelve a modificar un archivo o
te borra alguna tabla de la base de
datos. Y eso es básicamente porque el
modelo está volviendo a ejecutar esa
misma solicitud porque el modelo es
state stateless, perdón. Cuando el
modelo es stateful significa que tiene
ese contexto o el servidor tiene ese
contexto guardado y el modelo no
necesita que tú le envíes y le envíes
información. Eso lo tiene ya
directamente el servidor y en este caso
no funcionan así. Las appis de los
modelos de lenguaje son stateless.
Siempre tienes que pasarle todo el
contexto y tienes que entregarle toda la
información posible porque siempre es la
primera interacción que está llegando.
¿Okay?
Em, nosotros tenemos que ayudar un poco
a Cloud Code para que envíe el contexto
correcto, porque todo este trabajo de
enviar el contexto lo hace Cloud Code,
lo hace con diferentes componentes, pero
eso lo tiene que armar el usuario.
¿Okay? Cloud Code te ayuda. Cloud Code
intenta mandar el historial. Cloud Code
intenta entrar por los archivos, intenta
encontrar contexto, intenta hacer ese
razonamiento, intenta entender al ser
humano, pero no es eh no es todo lo que
necesita Cloud Code. Cloud necesita
también ayuda y por eso les decía que
hay que guiarlo con los archivos, hay
que guiarlo con la instrucción completa,
hay que decirle estos son los los
parámetros que tiene este archivo, esta
es la función que quiero que edites,
este es el archivo con este formato.
Mientras más específico eres, mejor para
Cloud Code porque dice, "No tengo que ir
a buscar todos los archivos Jason, no
tengo que leer este archivo gigante
porque ya me lo está diciendo este ser
humano, me está guiando, me está
ayudando."
Y acá eh aparecen estos componentes que
ayudan a Cloud Code y Cloud Code cada
vez que envía esta solicitud a este
modelo stateless, envía también esta
información, por ejemplo, el cloud ehm
que en Cloud Code siempre es este
archivo y en otros en otras plataformas
es agents.m. Así que nosotros
concentremos concentremos todo en
cloud.md
es lo que manejamos.
También tenemos un settings.m que
también se envía, que básicamente nos
ayuda a configurar cómo Cloud Code va a
a comportarse. Eh, de repente ayuda a
manejar el output de salida, de repente
ayuda a ver qué permisos tiene Cloud
Code para poder ejecutar cosas.
Entonces, también lo toma el modelo y
también dice, "Ah, mira, tengo permisos
para leer, tengo permisos para entrar a
este directorio." Entonces, también
tenemos que enviarle un
settings.jonjason.
Ahí está mal. Es settings.jonjason.
Pero este archivo inicial, el cloud.md,
es el el más importante porque es una
instrucción general de tu proyecto. Son
normas, son reglas, son ayudas, son
guías que tú tienes que pasarle al
modelo. Y también tenemos al punto
mcp.jason, Jason, que son los
conectores, que son los MCPs, que son eh
las aplicaciones a las que va a tener
acceso, que son aplicaciones externas,
no son aplicaciones que están en tu
proyecto, sino que son aplicaciones que
tú puedes ir a consultar. Por ejemplo,
yo ocupo muchísimo el MCP de Linear, que
es un es como traelo que te ayuda a
mantener eh una guía de las tareas que
está haciendo el modelo. Y este MCP
funciona bastante bien y tú lo puedes
configurar en este mcp.jon.
Y después tenemos los agentes y tenemos
los skills, que lo vamos a ver en las
siguientes en los siguientes módulos,
cómo configurarlos, cómo ejecutarlos y
cómo trabajar con ellos. Por ahora,
quédense con el contexto de que son
texto. Es más información, es más
contexto y todo esto va en la ventana de
contexto del pobre modelo que está
recibiendo y recibiendo información y
nosotros lo estamos cargando y cargando
con información, que por un lado es
bueno porque lo estamos guiando, pero
por otro lado no es tan bueno si es que
empezamos a meterle todos los skills,
todos los sub agents, todos los MCP que
encontramos en Instagram o en cualquier
lado. el modelo va a decir, "¿Por qué me
estáis pasando tanta información si yo
necesito solamente cumplir con la tarea
que me estás pidiendo?" [resoplido]
Y por último, vamos al último paso. Ya
vimos el primero donde e se ejecutó un
comando batch, donde se cargaron 36
líneas donde el modelo buscó un archivo
Jason en unos directorios. Entonces, lo
hicimos navegar por un directorio.
Gastamos muchos tokens acá porque no
fuimos específicos y no le dijimos este
este es el archivo que tienes que
encontrar o en el que tienes que
trabajar. Después el paso dos, donde el
modelo razonó y dijo, "Bueno, ya
encontré un archivo, ahora tengo que
entrar a ver qué es lo que tiene este
archivo. Este usuario me está pidiendo
que haga algo, pero no sé qué hay dentro
de ese archivo."
Y en el paso número tres, algo muy muy
efectivo que hace Cloud Code, que es que
ejecuta eh Python, generalmente ejecuta
Python e en una sola línea de comando y
eso le da todo el poder e aún mayor
porque tiene el poder de la programación
mientras va pensando. O sea, imagínense
nosotros eh pensáramos y programáramos
en Python y ejecutáramos en Python
mientras estamos pensando. Eso es
maravilloso. Cloud Code lo puede hacer y
lo ejecuta efectivamente muy bien. De
repente vemos que se equivoca en algunos
parámetros, pero después se corrige y
vuelve a ejecutar algún archivo en
Python mientras está buscando, mientras
está e haciendo algunas tareas. Cloud
Code dice, "Déjame ejecutar Python.
¿Para qué voy a eh darme vueltas? ¿Para
qué voy a seguir revisando archivos? Si
con Python yo puedo ir directamente a lo
que necesito hacer. Entonces, en este
caso, si leemos un poquitito aquí el
archivo en Python, está importando eh la
librería Jason, está abriendo el
archivo. Nosotros no le dijimos los
campos, entonces por eso estaba como
medio confundido, cuáles son los campos
de este archivo. Entonces está eh
pintando, está devolviendo, necesita el
output. ¿Okay? Entonces, siempre van a
ver que Cloud Code eh ocupa el print.
¿Por qué? porque necesita mandarle el
output al modelo. El modelo necesita más
contexto. Entonces, aquí lo que está
haciendo es que está pintando todos los
los campos del archivo. Descubrió que
hay un nombre, descubrió que hay una
descripción y aquí se está saltando una
línea y está pintando y pintando
información. Entonces, quiere ver lo que
hay dentro de ese archivo y la forma más
efectiva en vez de leer el archivo y
entrar fue ejecutar Python y el modelo e
literalmente encontró la información
directa de lo que necesitaba. Esto es
mágico porque lo hace directamente en
una línea, no crea, no te va creando
archivos en tu proyecto, eso sería
terrible. Entonces, cuando vemos que
hizo Python-C es que está ejecutando en
la misma línea el el código en Python y
lo está recibiendo como una respuesta. Y
eso lo va a hacer mucho, muchas veces
Cloud Code, porque muchas veces va a
necesitar el poder de Python, el poder
de código para poder extraer contexto y
eso lo hace muy muy efectivo.
Y e esa es la magia de Cloud Code.
Significa que cuando puede ejecutar
comandos en batch, cuando puede hacer
razonamiento, cuando puede ejecutar
Python en una línea de comando, eso
significa que se puede ejecutar en
cualquier lado. Y por eso les decía en
un principio que partan utilizando Cloud
Code en la CLI, en la terminal, porque
van a poder ejecutarlo en su local.
Todos los computadores tienen CLI,
absolutamente todos. Van a poder
ejecutarlo en un servidor con SSH, o
sea, van a poder conectarse al servidor
y van a poder decir, "Cloud Code, entra
a este servidor y empecemos a hacer
magia porque va a ejecutar comandos
Unix, comandos en la terminal. van a
poder ejecutarlo en Visual Studio Code,
que es lo que les mostré al principio,
porque existen las extensiones y aparte
Visual Studio Code tiene su propia
terminal interna, así que pueden
ejecutarlo en la extensión o en la
terminal y se conecta al a Visual Studio
Co. Pueden eh ejecutar slash idar
contexto de Visual Studio Code. Y
también existe CWK, que también lo vamos
a ver, yo creo, en el último módulo,
porque ya es una plataforma un poco más
avanzada que no es tanto para
programadores, pero sí tiene todo el
poder de Cloud Code y tener una interfaz
un poco más eh fácil de ejecutar, ya
sabiendo cómo funciona Cloud Code,
después ya puedes empezar a hacer magia
con otras interfaces, porque Cloud Code
corre por debajo de todas las
plataformas de Antropic, ya por debajo
siempre corre el Cloud Agent SDK, que es
el SDK,
ejecuta absolutamente todas las las
aplicaciones de CloudCode. Por último,
esto es lo último que me gustaría
explicarles. Cada vez que ustedes hacen
una solicitud
al modelo, a Cloud Code, a este servidor
stateless que cada vez va a recibir este
contexto, pasan estas etapas. Primero es
tu promp, tu solicitud, tu eh tu texto
que escribiste, tu solicitud, tu cambio,
eh tu pregunta. Eso es lo primero que
vas a enviarle al modelo. Después vienen
todos los componentes que les comenté
que estaba el cloud.md, MD, que vamos a
verlo en el siguiente módulo. Cómo
escribir un buen archivo. MD, que es
markdown, es texto, texto de
configuraciones que tú le vas pasando
Cloud Code para que entienda, para que
sepa cuáles son los archivos, para que
sepa cuáles son los campos de cada uno
de los archivos, para que entienda
cuáles son las buenas normas y las
mejores prácticas de tu proyecto.
Después vienen los skills, los sub
agents, los comandos, los hooks,
absolutamente todo lo que tú puedas
configurar dentro de Cloud Code también
se va a sumar al contexto. O sea, ya
tenemos el promp, ya tenemos todos los
componentes. Después vienen los
archivos, viene el contexto, viene todo
lo que les acabo de explicar que hizo
Cloud Code en el ejemplo que vimos. se
metió a ver archivos, se metió a revisar
eh archivos Jason, se metió a abrir un
archivo Jason, ejecutó Python y también
lo pintó dentro del de la de la
respuesta. Entonces, ya tenemos el
promp, ya tenemos las configuraciones y
ahora tenemos además los archivos donde
estuvo eh Cloud explorando, se suman
también a la solicitud. Y después algo
muy importante es el promp, el system
prompt de Antropic, ¿ya? Por debajo no
es que tú le envíes todo a este modelo
stateless, sino que tú le envías toda tu
información, toda la información del
proyecto, tu solicitud y los archivos
del proyecto. Y además Antropic tiene un
system prompt que filtra mucha
información, que le dice cómo
comportarse a Cloud Code, que le dice
que está en un ambiente de programación.
Entonces, por eso si utilizas Cloud Code
para hacer cualquier otra cosa, siempre
va a pensar en código, en programación,
en archivos, porque hay un system prom,
¿ya? Y eso lo escribe Antropic y lo
tiene bien diseñado con muchos filtros
porque tú no puedes escribir virus, por
ejemplo, no puedes pedirle que te haga
la próxima arma nuclear. Aquí están
todos los filtros que agrega Antropic a
este modelo para que tú no puedas
pedirle este tipo de cosas. Y por último
viene eh la API. Ahí recién estás
llegando a la API de Cloud, recién estás
eh llegando al modelo y además ellos
tienen unas tools internas, así que es
bastante complejo todo este flujo. Es
difícil es difícil manejar que Cloud
Code pueda entender un contexto completo
porque tiene que pasar por todas estas
etapas y hay algunas etapas que tú no
manejas. Por ejemplo, el prompt de
Antropic, ese no lo manejas, ese lo
maneja Antropic y de repente cambia
cosas y de repente cambia el
comportamiento del modelo. Por eso un
día cuando Antropic te estaba
respondiendo super bien y Cloud Cout
estaba escribiendo todos los archivos,
de repente Antropic dijo, "Vamos a
cambiar un par de líneas." Y el modelo
se vuelve un poco raro, empieza a
responder diferente y es porque ellos
están modificando este tipo de cosas. De
repente ellos agregan algunas tools
diferentes, ¿no? No siempre tienen las
mismas tools, no siempre es voy a
ejecutar comandos, no siempre es voy a
leer, voy a escribir. De repente le
agregan una tools nueva que hay eh
exploración, hay validación,
verificaciones, de repente hay unos
skills nuevos que también se los agregan
y eso significa que tiene que aumentar
la ventana de contexto con este nuevo
skill que está dentro de Cloud Code.
Entonces ellos manejan mucho cómo se
comporta la herramienta y de repente
tocan cosas. Eso significa que tú tienes
que cambiar también esta parte de acá
que es tu configuración. Por eso es tan
difícil, por eso hay que estar siempre
al día de cómo funciona. Y esto acá
cambia constantemente tu proyecto. Cada
vez que tú ejecutas CloudCoud, cada vez
que tú ejecutas o cambias el código, ya
el proyecto cambió. Por eso de repente
Cloud dice, eh, no me voy a meter en
este archivo, lo voy a leer primero
porque probablemente algo se modificó en
este archivo y necesito primero leerlo y
después ver si lo edito. Y por último,
tus promp. O sea, si tus promps
malísimos y no sabes cómo pedirle cosas
al modelo, eh, todas estas capas ya se
pierden completamente. O sea, por eso mi
anuncio al principio era, sepan
programar, porque si no saben programar,
básicamente no saben cómo pedirle. al
modelo que busque eh los Jason, que lea
los archivos Yamel, que la estructura de
la de los archivos están dentro de una
carpeta específica porque está ocupando
React, por ejemplo, dónde están los
componentes de React, eh creaste un API,
cuáles son los módulos del API, está
ocupando un ORM, necesitas entregarle
esa información a Cloud. Cloud necesita
saber que eh los los módulos del ORM
están en esta carpeta específica y esa
es la que se comunica con la base de
datos. Si es que no lo sabes, Cloud va a
intentar buscarlo, va a intentar
ayudarte, pero básicamente vas a romper
todo con todos los nuevos prom que le
está va a estar diciendo, porque va a
llegar un punto donde le va a estar
diciendo, "Por favor, soluciona esto,
que no sé cómo solucionarlo, pero hazlo
tú." Cloud va a decir, "Voy a hacer lo
que yo quiera." Entonces va a romper
todo, va a escribir y sobresescribir el
proyecto y va a llegar a un punto donde
el skill que eh instalaste, porque lo
viste en Instagram te va a funcionar muy
mal, te va a funcionar eh completamente
eh va a ser inservible básicamente
porque no tienes el conocimiento para
poder ejecutarlo y entender bien lo que
está pasando con el modelo.
Skills, justamente les hablaba de
skills, eh, son una maravilla. lo vamos
a ver en el siguiente módulo, como
también vamos a ver el setup de
cloud.md, vamos a ver los settings,
vamos a ver los modelos, los subents,
los hooks, absolutamente todo. Y por
último, los invito a que se metan a este
repositorio que es Cloud Code Templates,
que está acá. Ya lleva más de 23,000
estrellas y es el repositorio que vamos
a estar trabajando, donde vamos a estar
sacando componentes y vamos a estar
utilizándolos.
Eh, está mi repo en GitHub. Acá les voy
a dejar mi GitHub. Bueno, este es el
repositorio el antiguo que tenía. Ahora
ya está un poco más avanzado este que
está acá, donde vamos a poder ver
skills, agentes. Va a ser mucho más
fácil entender todos los conceptos que
vamos a ver en el e curso completo si es
que utilizamos este este proyecto, este
repositorio y empezamos a utilizar lo
que ya está construido acá y después
ustedes lo pueden modificar.
Y por último, me voy a mover aquí un
poquitito para que podamos ver esto.
Dejo las redes sociales de Camila, de el
equipo que está armando todos estos
módulos. Somos tres personas, somos
Camila, Jorge, que ahora se van a
despedir y vamos a cerrar este módulo.
Eh, y les pido que nos sigan, nos sigan
en redes sociales. Todo esto es
completamente gratis. Simplemente les
pedimos que nos sigan y que puedan eh
seguir viendo estos módulos porque van a
ser unos tres o cuatro módulos más
dependiendo de cómo siga todo. Si es que
tenemos muchos likes y si es que tenemos
muchas reproducciones, quizás esto lo
alargamos muchísimo más. Así que muchas
gracias y los invito al cierre con
Camila y Jorge.
Wow, Dani, qué espectacular. todo lo que
nos acabas de mostrar sobre Cloud Code.
Yo estoy segura que la gente quedó
impresionada porque no he visto a nadie,
a nadie que que enseñe Cloud Code de
esta manera. Así que chiquillos, los
invito a seguir en la comunidad, estar
hablando, generando networking, hablando
con la gente, eh mostrando quiénes son
en la comunidad. Y los invito al próximo
curso, o sea, al próximo capítulo que
vamos a tener junto a Jorge y Daniel
Ávila, donde vamos a continuar
enseñándoles un poquito más sobre Claus
Coven.
Oye, espectacular, espectacular. Todo lo
que vimos en este capítulo aprendimos
mucho. Descubrimos que Claud Co era un
poquito más que simplemente agente de
inteligencia artificial, código,
comando, ¿cierto? Eh, esta clase eh
Daniel nos ayudó a entender un poquito
más el trasfondo de lo que hay por
detrás e en el modelo lo mismo, cómo
trabaja, cómo funciona y realmente ha
sido super enriquecedor tener esta
información que nos ayuda a entender muy
bien cómo funciona el modelo por detrás,
algo que quizá no todos eh sabemos con
tanta seguridad. Así que qué genial, qué
clase más magistral. Esperamos que las
próximas sean todavía mejores. Muchas
gracias, Dani.
Vale, gracias a todos. Nos vemos en la
siguiente clase. Sí.