Los desarrolladores ya pasan el día rodeados de lenguaje útil.

Aparece en comentarios de pull requests, notas de depuración, hilos de issues, discusiones de releases, compromisos de arquitectura y conversaciones con agentes que ayudan con el trabajo de código. El problema no es la falta de material de aprendizaje. El problema es que ese material está disperso a lo largo de la jornada y rara vez se convierte en algo que puedas repasar después.

El lenguaje más útil ya está dentro de tu flujo de trabajo

Si eres ingeniero, el lenguaje que más necesitas normalmente no viene de un libro de texto.

Es el lenguaje que usas para explicar un bug, pedir una revisión, describir el riesgo de una migración, cuestionar el alcance o resumir resultados de pruebas. Esas son las frases que importan en el trabajo real, y también son las más difíciles de coleccionar de forma consistente porque desaparecen dentro de las herramientas y conversaciones.

Qué hace un skill en este flujo de trabajo

En este contexto, un skill es un archivo de instrucciones reutilizable para un agente que soporta skills.

En lugar de reescribir el mismo prompt cada vez, guardas el flujo una sola vez y dejas que el agente lo reutilice. Para LangCapture, eso significa que el agente puede revisar la conversación o el contexto de trabajo actual, extraer de 1 a 5 expresiones útiles en tu idioma objetivo, pedir confirmación y subir las líneas aprobadas a LangCapture.

Precisamente por esto el flujo es especialmente amigable para desarrolladores: el material de aprendizaje sale directamente del trabajo real de ingeniería.

El skill language-learning completo

Abajo está el contenido completo del skill. Guárdalo como language-learning/SKILL.md dentro del directorio de skills de cualquier sistema de agentes que los soporte, y luego reemplaza el placeholder del token con tu propio token de API de LangCapture. El paso de subida incluye patrones de comando tanto para Windows como para macOS/Linux.

md

---

name: language-learning

description: |

Extract 1-5 reusable workplace expressions in the target language from the current conversation, ask the user which ones to keep, and upload the approved sentences to LangCapture. Use when the user asks to "extraer expresiones", "aprender inglés", "subir a LangCapture", "organizar frases", "recopilar material de idiomas", or similar requests about reviewing the current session and turning it into language learning material.

---

# Language Learning

Extract concise, reusable workplace language from the current chat. Confirm with the user before uploading anything to LangCapture.

Workflow

### 1. Review the current session

Read the conversation history in the current session. Identify the main work topics being discussed, such as debugging, implementation, status updates, review feedback, deployment, testing, or coordination.

Think from the perspective of explaining the same work to a coworker who speaks your target language. Prefer expressions that are likely to be reused in engineering conversations.

### 2. Extract 1-5 useful expressions

Select only sentences that are:

  • Natural workplace language
  • Reusable without depending on hidden context
  • Useful for engineers discussing progress, issues, requests, review, testing, or results
  • Concise enough to remember and practice

Avoid sentences that are:

  • Overly academic or textbook-like
  • Too specific to internal file names, secrets, or one-off details
  • Unclear without extra explanation

For each item, output:

  • The sentence in the target language
  • A short native-language note describing meaning or usage

Use this format:

~~~text

  • "The latest change fixes the retry path, but I still need to verify the error handling."

-> Sirve para reportar el avance de una corrección y señalar lo que falta por verificar

~~~

If the session does not contain enough good material, say so directly instead of inventing weak examples.

### 3. Ask for confirmation before upload

After listing the extracted expressions, ask the user which ones to upload.

If an interactive question tool is available, use it with these options:

  • All upload
  • Choose specific items
  • Skip

If no such tool is available, ask a short plain-text question that offers the same three choices.

Do not upload anything until the user confirms.

If the user skips, stop immediately.

### 4. Upload the approved expressions to LangCapture

Upload each approved sentence individually.

Prefer using the local shell tool. Use the command pattern that matches the current platform.

Windows (PowerShell):

~~~powershell

$body = @{ original_text = "<SENTENCE>" } | ConvertTo-Json -Compress

try {

(Invoke-WebRequest `

-Method POST `

-Uri 'https://langcapture.com/api/sentences' `

-Headers @{

Authorization = 'Bearer <YOUR_LANGCAPTURE_API_TOKEN>'

} `

-ContentType 'application/json' `

-Body $body

).StatusCode

} catch {

$_.Exception.Response.StatusCode.value__

}

~~~

macOS/Linux (bash/zsh/sh):

~~~sh

python3 -c "

import json, subprocess, sys

sentence = sys.argv[1]

payload = json.dumps({'original_text': sentence})

result = subprocess.run([

'curl', '-s', '-o', '/dev/null', '-w', '%{http_code}',

'-X', 'POST', 'https://langcapture.com/api/sentences',

'-H', 'Content-Type: application/json',

'-H', 'Authorization: Bearer <YOUR_LANGCAPTURE_API_TOKEN>',

'--data', payload

], capture_output=True, text=True)

print(result.stdout.strip())

" "<SENTENCE>"

~~~

Treat 200 as success.

If one sentence fails, report it and continue with the remaining approved sentences.

### 5. Summarize the result

List each approved sentence with its upload result:

  • Uploaded successfully
  • Failed with HTTP status code

State clearly how many items were uploaded and how many failed.

Quality rules

  • Prefer realistic workplace language over polished textbook language.
  • Keep the list short and high-signal.
  • Require user confirmation before upload.
  • Use the current session only; do not fabricate conversation context.
  • Treat the API token as sensitive. Use it only for the LangCapture upload request and do not expose it unnecessarily in the final user-facing summary.

Por qué esto es especialmente útil para desarrolladores

La comunicación entre desarrolladores es altamente contextual.

Una frase es útil no porque suene impresionante, sino porque te ayuda a hacer bien un trabajo específico. Puedes necesitar lenguaje para:

  • dar una actualización de avance clara
  • explicar la causa raíz de un bug
  • pedirle a alguien que revise un cambio
  • discutir compromisos antes de un release
  • alinearse sobre alcance, despliegue o cobertura de pruebas

Cuando esas expresiones salen directamente de tu trabajo real de ingeniería, son más fáciles de entender, más fáciles de recordar y mucho más probables de reutilizar.

Cómo funciona el flujo de trabajo

El flujo se mantiene simple:

  • Trabaja dentro de tus herramientas habituales o dentro de una conversación con un agente.
  • Instala este skill en el agente que ya usas.
  • Pídele al agente que extraiga expresiones útiles del contexto actual.
  • Confirma qué líneas vale la pena guardar.
  • Deja que el skill las suba a LangCapture.

Eso significa que LangCapture no es solo un lugar para almacenar frases al azar. Se convierte en una biblioteca estructurada de expresiones que salieron de tu trabajo real de desarrollo.

Si quieres la historia general del producto, empieza con Convierte el lenguaje real de tu trabajo en tu biblioteca personal de aprendizaje.

Si quieres más ideas de flujos de captura, lee Cómo capturar frases útiles de GitHub, Slack, Jira y el correo.

Para probar este flujo tú mismo, genera un token en la configuración de tokens de API, pégalo en el skill y conecta LangCapture al flujo basado en skills que ya usas.