Desenvolvedores já passam o dia cercados de linguagem útil.

Ela aparece em comentários de pull request, notas de debugging, threads de issues, discussões de release, trade-offs de arquitetura e conversas com agentes que ajudam no trabalho de programação. O problema não é falta de material de aprendizado. O problema é que esse material fica espalhado pelo dia de trabalho e raramente vira algo que você consiga revisar depois.

A linguagem mais útil já está dentro do seu fluxo de trabalho

Se você é engenheiro, a linguagem de que mais precisa geralmente não vem de um livro didático.

É a linguagem que você usa para explicar um bug, pedir review, descrever um risco de migração, contestar o escopo ou resumir resultados de testes. Essas são as frases que importam no trabalho de verdade, e também são as mais difíceis de colecionar com consistência, porque desaparecem dentro de ferramentas e conversas.

O que uma skill faz nesse fluxo

Nesse cenário, uma skill é um arquivo de instruções reutilizável para um agente que suporta skills.

Em vez de reescrever o mesmo prompt toda vez, você salva o fluxo uma única vez e deixa o agente reutilizá-lo. Para o LangCapture, isso significa que o agente pode revisar a conversa ou o contexto de trabalho atual, extrair de 1 a 5 expressões úteis no idioma que você está aprendendo, pedir confirmação e enviar as linhas aprovadas para o LangCapture.

É exatamente por isso que esse fluxo é especialmente amigável para desenvolvedores: o material de aprendizado vem diretamente do trabalho real de engenharia.

A skill language-learning completa

Abaixo está o conteúdo completo da skill. Salve como language-learning/SKILL.md no diretório de skills de qualquer sistema de agentes que suporte skills, e depois substitua o placeholder do token pelo seu próprio token de API do LangCapture. A etapa de upload inclui padrões de comando para Windows e 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 "extrair expressões", "extrair frases em inglês", "aprender inglês", "enviar para o LangCapture", "organizar frases", "coletar material de idioma", 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."

-> Usada para relatar o progresso de uma correção, indicando que ainda há partes a 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 que isso é especialmente útil para desenvolvedores

A comunicação de desenvolvedores é altamente contextual.

Uma frase é útil não porque soa impressionante, mas porque ajuda você a fazer bem um trabalho específico. Você pode precisar de linguagem para:

  • dar uma atualização de progresso clara
  • explicar a causa raiz de um bug
  • pedir que alguém revise uma mudança
  • discutir trade-offs antes de um release
  • alinhar escopo, rollout ou cobertura de testes

Quando essas expressões vêm diretamente do seu trabalho real de engenharia, elas são mais fáceis de entender, mais fáceis de lembrar e muito mais prováveis de serem reutilizadas.

Como o fluxo funciona

O fluxo continua simples:

  • Trabalhe nas suas ferramentas habituais ou dentro de uma conversa com um agente.
  • Instale esta skill no agente que você já usa.
  • Peça ao agente para extrair expressões úteis do contexto atual.
  • Confirme quais linhas valem a pena salvar.
  • Deixe a skill enviá-las para o LangCapture.

Isso significa que o LangCapture não é só um lugar para guardar frases aleatórias. Ele se torna uma biblioteca estruturada de expressões que vieram do seu trabalho real de desenvolvimento.

Se você quer a visão geral do produto, comece por Transforme a linguagem real do trabalho na sua biblioteca pessoal de aprendizado.

Se você quer mais ideias de fluxos de captura, leia Como capturar frases úteis do GitHub, Slack, Jira e e-mail.

Para experimentar esse fluxo, gere um token nas configurações de token de API, cole na skill e conecte o LangCapture ao fluxo baseado em skills que você já usa.