2026-03-14
New: Use Skills to Turn Developer Work into English Learning Material
LangCapture now works with agents that support skills, and this post includes the full english-learning skill you can use to turn engineering discussions into reusable English expressions.
Developers already spend their day surrounded by useful English.
It appears in pull request comments, debugging notes, issue threads, release discussions, architecture tradeoffs, and conversations with agents that help with coding work. The problem is not a lack of learning material. The problem is that this material is scattered across the workday and rarely gets turned into something you can actually review later.
The Most Useful English Is Already Inside Your Workflow
If you are an engineer, the English you need most is usually not from a textbook.
It is the language you use to explain a bug, ask for review, describe a migration risk, push back on scope, or summarize test results. These are the phrases that matter in real work, and they are also the hardest ones to collect consistently because they disappear inside tools and conversations.
What a Skill Does in This Workflow
In this setup, a skill is a reusable instruction file for an agent that supports skills.
Instead of rewriting the same prompt every time, you save the workflow once and let the agent reuse it. For LangCapture, that means the agent can review the current conversation or work context, extract 1 to 5 useful English expressions, ask for confirmation, and upload the approved lines to LangCapture.
This is exactly why the workflow is especially friendly for developers: the learning material comes directly from real engineering work.
The Full english-learning Skill
Below is the full skill content. Save it as english-learning/SKILL.md inside the skill directory of any agent system that supports skills, then replace the token placeholder with your own LangCapture API token. The upload step includes both Windows and macOS/Linux command patterns.
md
---
name: english-learning
description: |
Extract 1-5 reusable workplace English expressions from the current conversation, ask the user which ones to keep, and upload the approved sentences to LangCapture. Use when the user asks to "提炼英语", "提取英语表达", "学习英语", "上传到 LangCapture", "整理英语句子", "收集英语素材", or similar requests about reviewing the current session and turning it into English learning material.
---
# English Learning
Extract concise, reusable workplace English 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 an English-speaking coworker. Prefer expressions that are likely to be reused in engineering conversations.
### 2. Extract 1-5 useful English expressions
Select only sentences that are:
- Natural workplace English
- 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 English sentence
- A short Chinese 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."
-> 用于汇报修复进展，同时说明还有待验证的部分
~~~
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://www.langcapture.com/api/sentences?mode=async' `
-Headers @{
Authorization = 'Bearer <YOUR_LANGCAPTURE_API_TOKEN>'
'X-LangCapture-Async' = '1'
} `
-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://www.langcapture.com/api/sentences?mode=async',
'-H', 'Content-Type: application/json',
'-H', 'Authorization: Bearer <YOUR_LANGCAPTURE_API_TOKEN>',
'-H', 'X-LangCapture-Async: 1',
'--data', payload
], capture_output=True, text=True)
print(result.stdout.strip())
" "<SENTENCE>"
~~~
Treat 200 and 202 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 English over polished textbook English.
- 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.
Why This Is Especially Useful for Developers
Developer communication is highly contextual.
A sentence is useful not because it sounds impressive, but because it helps you do a specific job well. You may need language for:
- giving a clear progress update
- explaining the root cause of a bug
- asking someone to review a change
- discussing tradeoffs before a release
- aligning on scope, rollout, or test coverage
When those expressions come directly from your real engineering work, they are easier to understand, easier to remember, and much more likely to be reused.
How the Workflow Works
The flow stays simple:
- Work inside your usual tools or inside an agent conversation.
- Install this skill in the agent you already use.
- Ask the agent to extract useful English from the current context.
- Confirm which lines are worth saving.
- Let the skill upload them to LangCapture.
That means LangCapture is not just a place to store random sentences. It becomes a structured library of English expressions that came from your actual development work.
If you want the broader product story, start with Turn Real Workplace English into Your Personal Language Library.
If you want more ideas for capture workflows, read How to Capture Useful Chinese-English Sentences from GitHub, Slack, Jira, and Email.
To try this workflow yourself, generate a token in API token settings, paste it into the skill, and connect LangCapture to the skill-based workflow you already use.