Prepara tu laptop: la terminal, las carpetas y tus archivos de práctica

En esta lección dejas lista la laptop para el taller: una terminal abierta, una carpeta de práctica con tres archivos y, si quieres, OpenCode instalado desde antes. Son unos 10 a 15 minutos.

Hay dos caminos y los dos llevan al mismo resultado:

• Opción A: solo con la terminal. Copias un bloque, lo pegas y listo. Es la más rápida.
• Opción B: con Visual Studio Code. Creas los archivos con un editor donde los ves. Es la más cómoda si nunca has usado una terminal.

Antes de elegir, cinco ideas que vas a usar toda la sesión.

Cinco ideas antes de empezar

1. Qué es una terminal (y qué es un shell)

Normalmente usas tu computadora con el ratón: haces clic en carpetas, arrastras archivos, abres programas. La terminal es otra forma de hacer lo mismo: una ventana donde escribes órdenes en lugar de hacer clic.

Dentro de la terminal hay un programa que lee lo que escribes y lo ejecuta. Ese programa se llama shell. En Mac el shell suele ser zsh, en Linux bash, y en Windows usamos PowerShell. Son como dialectos: la idea es la misma, pero algunas palabras cambian. Por eso más abajo hay un bloque para Mac/Linux y otro para Windows.

Analogía: la interfaz con ventanas es como pedir en un restaurante señalando fotos del menú. La terminal es decirle al mesero exactamente lo que quieres. Es más precisa y más rápida, pero tienes que saber las palabras.

Por qué importa aquí: OpenCode vive en la terminal. Y cuando el agente "ejecuta un comando", está escribiendo en la terminal igual que tú.

2. Qué es un comando

Un comando es una orden de una línea. Casi siempre tiene esta forma:

  mkdir    -p     ~/agent-workshop
  -----    --     ----------------
  que      como   sobre que
  hacer    (opcion) (argumento)

Escribes la línea, presionas Enter, el shell la ejecuta y te muestra el resultado (o nada, si todo salió bien y no había nada que mostrar).

3. Carpetas, archivos y rutas

• Un archivo es un documento: expenses.csv, notes.md.
• Una carpeta (o directorio) es un contenedor de archivos y de otras carpetas.
• Una ruta es la dirección de un archivo, como una dirección postal: dice en qué carpeta está, dentro de cuál otra. Por ejemplo /Users/ana/agent-workshop/notes.md se lee "el archivo notes.md, dentro de agent-workshop, dentro de ana, dentro de Users".

4. Qué significa ~ (tu carpeta personal)

Cada usuario de la computadora tiene su carpeta personal (en inglés, home). Ahí suelen estar Documentos, Descargas y Escritorio. Como su ruta completa es larga y cambia de persona a persona, los shells tienen un atajo: ~ (se llama "tilde" o "virgulilla").

5. La carpeta "donde estás parado"

La terminal siempre está dentro de una carpeta, igual que una ventana del explorador de archivos. Los comandos actúan sobre esa carpeta, salvo que digas otra. Esto es clave para el taller: OpenCode trabaja sobre la carpeta donde lo abres, y solo sobre esa. Por eso creamos una carpeta de práctica aparte: el agente no puede ver ni tocar el resto de tu computadora desde ahí.

Qué vas a tener al final

Una carpeta en tu carpeta personal con exactamente tres archivos:

~  (tu carpeta personal)
|
+-- Documents/
+-- Downloads/
+-- ...
|
+-- agent-workshop/          <-- la carpeta de practica
    |
    +-- expenses.csv         gastos de septiembre (datos de ejemplo)
    +-- notes.md             tus notas, con una meta de presupuesto
    +-- opencode.json        reglas para el agente: pedir permiso

Paso 0. Descarga tu terminal: Warp o Visual Studio Code

Tu computadora ya trae una terminal, y funciona. Pero para el taller te recomendamos instalar una de estas dos, antes de la sesión. Las dos son gratuitas y funcionan en Mac, Windows y Linux.

Cómo instalar Warp:

1. Entra a warp.dev/download. La página detecta tu sistema; si no, elige Mac, Windows o Linux.
2. Instálalo como cualquier aplicación. En Mac, arrástralo a Aplicaciones. En Windows, abre el instalador y sigue los pasos.
3. Ábrelo. Te ofrece crear una cuenta: es opcional, puedes saltarte ese paso.
4. En Windows, revisa que Warp abra PowerShell: los bloques de este taller para Windows están escritos para PowerShell. Si te pregunta qué shell usar, elige PowerShell.

Warp trae su propia IA. En este taller no la usamos. Escribe los comandos tal cual, como en cualquier terminal. El agente del taller es OpenCode, que corre dentro de la terminal. Si usas la IA de Warp y la de OpenCode a la vez, no sabrás cuál hizo qué.

  La terminal (Warp, la de tu sistema o la de VS Code)
  +---------------------------------------------------+
  |  $ cd ~/agent-workshop                            |
  |  $ opencode          <-- OpenCode corre aquí      |
  |  +---------------------------------------------+  |
  |  |  OpenCode: el agente con el que trabajamos  |  |
  |  +---------------------------------------------+  |
  +---------------------------------------------------+

Si eliges VS Code, la instalación completa está más abajo, en la Opción B.

Paso 1. Abre una terminal

• Si instalaste Warp: ábrelo, en Mac, Windows o Linux.
• Mac: abre Terminal (búscala con Cmd + Espacio y escribe "Terminal").
• Windows: abre Terminal o PowerShell desde el menú Inicio.
• Linux: la terminal de tu escritorio (suele abrirse con Ctrl + Alt + T).

Escribe esto y presiona Enter:

echo hola

echo es el comando más simple que existe: repite lo que le escribes. Si la terminal te contesta hola, está lista y entendió tu orden.

Si prefieres la Opción B, este paso lo puedes hacer más adelante desde la terminal integrada de VS Code.

Paso 2, Opción A: crea la carpeta con un solo bloque

Vamos a crear los tres archivos copiando un solo bloque y pegándolo en la terminal. Así no tienes que pelear con ningún editor de texto, y todos quedamos con archivos idénticos.

En Mac o Linux

Copia todo este bloque, pégalo en la terminal y presiona Enter:

mkdir -p ~/agent-workshop && cd ~/agent-workshop

cat > expenses.csv <<'EOF'
date,description,category,amount
2026-09-01,Groceries at the market,food,54.20
2026-09-02,Bus card top-up,transport,20.00
2026-09-03,Coffee with a friend,Food,6.50
2026-09-05,Internet bill,home,35.00
2026-09-07,Movie tickets,fun,18.00
2026-09-09,Groceries at the market,food,61.75
2026-09-12,Taxi home,Transport,12.40
2026-09-14,Electricity bill,home,42.10
2026-09-18,Lunch near the office,food,11.90
2026-09-21,Concert,fun,45.00
2026-09-25,Bus card top-up,transport,20.00
2026-09-28,Groceries at the market,food,58.30
EOF

cat > notes.md <<'EOF'
# Notas del presupuesto

- Quiero saber en qué se me va el dinero cada mes.
- Mi meta para octubre: gastar menos de 350 en total.
- Sospecho que la comida es lo más caro, pero no lo he sumado.
EOF

cat > opencode.json <<'EOF'
{
  "$schema": "https://opencode.ai/config.json",
  "permission": {
    "edit": "ask",
    "bash": "ask"
  }
}
EOF

ls

Qué hace este bloque, línea por línea

Parece mucho, pero son solo cuatro comandos distintos, repetidos.

Sobre cat > archivo <<'EOF': el símbolo > significa "manda el resultado a este archivo" (si ya existía, lo reemplaza). Y <<'EOF' significa "el texto que te voy a dar empieza en la siguiente línea y termina cuando veas EOF solo en una línea". Las comillas en 'EOF' le dicen al shell que copie el texto al pie de la letra, sin interpretar símbolos como $. Eso importa en opencode.json, que tiene un "$schema".

  cat > notes.md <<'EOF'        <-- "guarda en notes.md..."
  # Notas del presupuesto        \
                                  |
  - Quiero saber en que...        |  ...todo esto, tal cual...
  - Mi meta para octubre...       |
  - Sospecho que la comida...    /
  EOF                           <-- "...hasta aqui"

En Windows (PowerShell)

Abre PowerShell, copia todo este bloque, pégalo y presiona Enter:

New-Item -ItemType Directory -Force -Path "$HOME\agent-workshop" | Out-Null
Set-Location "$HOME\agent-workshop"

@'
date,description,category,amount
2026-09-01,Groceries at the market,food,54.20
2026-09-02,Bus card top-up,transport,20.00
2026-09-03,Coffee with a friend,Food,6.50
2026-09-05,Internet bill,home,35.00
2026-09-07,Movie tickets,fun,18.00
2026-09-09,Groceries at the market,food,61.75
2026-09-12,Taxi home,Transport,12.40
2026-09-14,Electricity bill,home,42.10
2026-09-18,Lunch near the office,food,11.90
2026-09-21,Concert,fun,45.00
2026-09-25,Bus card top-up,transport,20.00
2026-09-28,Groceries at the market,food,58.30
'@ | Set-Content -Encoding ascii expenses.csv

@'
# Notas del presupuesto

- Quiero saber en qué se me va el dinero cada mes.
- Mi meta para octubre: gastar menos de 350 en total.
- Sospecho que la comida es lo más caro, pero no lo he sumado.
'@ | Set-Content -Encoding utf8 notes.md

@'
{
  "$schema": "https://opencode.ai/config.json",
  "permission": {
    "edit": "ask",
    "bash": "ask"
  }
}
'@ | Set-Content -Encoding ascii opencode.json

ls

Qué hace el bloque de PowerShell

Es la misma receta, en el dialecto de Windows:

El símbolo | se llama pipe (tubería): toma lo que sale del comando de la izquierda y se lo pasa al de la derecha. Aquí toma el bloque de texto y se lo pasa a Set-Content, que lo escribe en el archivo. -Encoding indica cómo se guardan las letras; notes.md usa utf8 porque tiene acentos.

  +-------------------+           +---------------------+
  | @'                |           |  Set-Content        |
  | texto del archivo |   pipe    |  -Encoding ascii    |
  | ...               | --- | --> |  expenses.csv       |
  | '@                |           |  (lo escribe)       |
  +-------------------+           +---------------------+

Comprueba el resultado

Al final, ls te muestra lo que hay en la carpeta. Deberías ver los tres archivos: expenses.csv, notes.md y opencode.json. La carpeta queda en tu carpeta personal, con el nombre agent-workshop.

Es seguro pegar el bloque dos veces: vuelve a escribir los mismos archivos encima.

Paso 2, Opción B: con Visual Studio Code

Visual Studio Code (VS Code) es un editor de código gratuito. Para una primera vez tiene una gran ventaja: ves tus archivos en una barra lateral, y tienes una terminal dentro de la misma ventana. En la sesión, cuando el agente cree o cambie un archivo, lo vas a ver aparecer ahí mismo.

+----------------------------------------------------------------+
|  VS Code                                                       |
+------------------+---------------------------------------------+
| EXPLORADOR       |  expenses.csv                               |
|                  |                                             |
| AGENT-WORKSHOP   |  date,description,category,amount           |
|   expenses.csv   |  2026-09-01,Groceries at the market,...     |
|   notes.md       |  ...                                        |
|   opencode.json  |                                             |
|                  +---------------------------------------------+
|  (aqui ves los   |  TERMINAL                                   |
|   archivos que   |  $ opencode        <-- aqui corre el agente |
|   crea el agente)|                                             |
+------------------+---------------------------------------------+

1. Instala VS Code

Descárgalo de code.visualstudio.com, instálalo con las opciones por defecto y ábrelo.

2. Crea y abre la carpeta

1. Ve a File > Open Folder (en español, Archivo > Abrir carpeta). En Mac el menú puede decir solo Open....
2. En la ventana que se abre, ve a tu carpeta personal (la que lleva tu nombre de usuario).
3. Crea una carpeta nueva llamada exactamente agent-workshop (botón Nueva carpeta) y ábrela.
4. Si VS Code te pregunta si confías en los autores de la carpeta, di que sí: la carpeta es tuya.

3. Crea los tres archivos

En la barra lateral izquierda (el Explorador), pasa el ratón sobre el nombre de la carpeta y haz clic en el ícono de New File (Nuevo archivo). Escribe el nombre exacto y presiona Enter. Repite para los tres:

• expenses.csv
• notes.md
• opencode.json

Luego abre cada uno, pega su contenido y guarda (Cmd + S en Mac, Ctrl + S en Windows y Linux). El contenido de cada archivo es el que aparece en el bloque de la Opción A entre la línea que dice <<'EOF' (o @') y la que dice EOF (o '@). No copies esas dos líneas, solo lo de en medio.

4. Abre la terminal integrada

Ve a Terminal > New Terminal (o presiona Ctrl + `, la tecla del acento grave, que suele estar junto al 1 o junto a la Ñ). Se abre una terminal abajo, ya parada dentro de agent-workshop. Escribe ls y deberías ver los tres archivos. Aquí mismo vas a abrir OpenCode en la sesión.

5. Solo en Mac: el comando code

Abre la paleta de comandos con Cmd + Shift + P, escribe Shell Command: Install 'code' command in PATH y selecciónalo. Esto te deja abrir VS Code desde la terminal escribiendo code ., y lo necesita la extensión de OpenCode para VS Code más adelante. En Windows el instalador ya lo hace por ti.

¿Y con otro editor de texto?

Qué es cada archivo, y por qué está ahí

• expenses.csv: los gastos de septiembre. CSV significa valores separados por comas: cada línea es una fila y las comas separan las columnas, como una hoja de cálculo en texto plano. Tiene algo raro a propósito. No lo corrijas: es parte del ejercicio.
• notes.md: tus notas, con una meta de presupuesto. .md es Markdown: texto normal donde # marca un título y - una lista.
• opencode.json: le dice al agente que te pida permiso antes de escribir un archivo ("edit": "ask") o ejecutar un comando ("bash": "ask"). Por defecto OpenCode edita sin preguntar. Para una primera vez queremos que pregunte, así ves cada cambio antes de que ocurra. OpenCode lee este archivo automáticamente cuando lo abres en esta carpeta.

  Sin opencode.json                     Con nuestro opencode.json
  -----------------                     -------------------------
  Agente decide cambiar un archivo      Agente decide cambiar un archivo
          |                                       |
          v                                       v
  Lo cambia de inmediato                Te muestra el cambio y pregunta
                                                  |
                                        +---------+---------+
                                        |                   |
                                     Aceptas             Rechazas
                                        |                   |
                                  se escribe        no pasa nada

Paso 3. (Opcional) Instala OpenCode desde antes

Si quieres ganar tiempo, instálalo ya con los pasos de la Parte 2: Instalar OpenCode y conectarlo a un modelo, en la lección del módulo En vivo. Si algo falla, no te preocupes: lo resolvemos en los primeros minutos de la sesión.

Verifica que estás listo

• Una terminal (Warp, la de mi sistema o la de VS Code) respondió hola.
• ls dentro de agent-workshop muestra expenses.csv, notes.md y opencode.json.

Para comprobar que entendiste

Resumen

• La terminal es una ventana para dar órdenes escritas; el shell (zsh, bash, PowerShell) es quien las ejecuta. ~ es tu carpeta personal.
• Creaste la carpeta agent-workshop con los tres archivos de práctica, con un bloque de terminal (Opción A) o con VS Code (Opción B), y sabes qué hace cada línea.
• opencode.json hace que el agente te pida permiso antes de cambiar algo. Siguiente paso: conseguir la llave de un proveedor de modelos.