DEV Community: srini047

Skills-i8n: When your Skills become i8n friendly ☸️

srini047 — Sat, 14 Mar 2026 08:55:31 +0000

Introduction 🫥

The recent addition to the current generation of Agentic AI is Skills. Instead of a formal definition, the analogy is closely related to skills that humans possess, which provide them with an edge over others, but not for agents. This is a nascent space since most of the teams and organizations are creating the required skills for their product. This looks like the right time to introduce the ideology of i8n to Skills. Let's understand in depth the need and solution for the same.

Why i8n for skills❓

Let's understand the primary reasons that you will be missing if skills aren't internationalized:

Agent skills are instructions: if your team or users don't read the default, the skill is useless regardless of how well it's written.
Language Unification — an agent skill in Japanese, Hindi, or Arabic unlocks entire engineering communities that would otherwise skip it entirely.
Technical details survive translation — with a proper glossary, terms like MCP, SKILL.md, and API stay intact while the surrounding instructions become locally natural.
Skills out of sync without i18n infrastructure — When the source skill updates, translated copies fall out of sync. A standardised tool makes re-translation a one-command operation, not a manual effort.
Agent ecosystems are Global 🌍 — Claude, Cursor, and other agents are deployed worldwide. Skills that can't localise are a ceiling on how far an agent platform can actually reach.

This is where the skills-i8n project or tool comes to the rescue. It easily fits into the current skills framework without needing any fancy plugins and heavy dependencies. Get your free API key at lingo.dev.

Features of the tool ✨

Async concurrency with semaphore limit — all skills translate in parallel using asyncio, bounded by --concurrency (default 3, max 10). A 10-skill repo doesn't make 10 simultaneous API calls — it makes 3 at a time, preventing rate-limit errors while still being significantly faster than sequential translation.
One request, full context — name, description, and the entire body travel as a single flat payload. The Lingo.dev engine applies Glossary, Brand Voice, and Instructions holistically across the whole skill, not on separate strings.
Zero SDK dependency — talks directly to api.lingo.dev via pure httpx. No third-party wrapper that can silently break or lag behind the real API.
Repo-aware, incremental by default — discovers skills across all known agent layouts (.claude/skills/, skills/*/, flat), skips already-translated files, copies companion scripts and assets untouched. Re-run safely after any source skill update.
Engine ID unlocks production-grade localization — pass --engine-id eng_xxx and every translation inherits your org's configured glossary, brand voice, and per-locale LLM selection — all without touching the code.

Setup 🔌

Follow these steps to get your first translation:

# Install uv
curl -LsSf https://astral.sh/uv/install.sh | sh

# Clone repository
git clone https://github.com/srini047/skills-i18n
cd skills-i18n

# Install dependencies
uv sync

# Set environment variables
cp .env.example .env
# OR
export LINGODOTDEV_API_KEY=your_key_here

🎉 You have successfully installed the tool and are ready to proceed with your first translation.

Workflow 🏗️

Tool usage 🛠️

Now that we have all set up, let's understand what this tool has to offer you:

➜  skills-i18n git:(master) uv run skills-i8n --help

 Usage: skills-i8n [OPTIONS] COMMAND [ARGS]...                                                                                    

 🌐 i8n for AI Agent Skills — powered by Lingo.dev                                                                                

╭─ Options ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                                                                    │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ translate     Translate all SKILL.md files in a skills repository.                                                             │
│ scan          Scan a skills repository and list discovered SKILL.md files.                                                     │
│ list-locales  List all locales supported by Lingo.dev.                                                                         │
│ detect        Detect the source language of a SKILL.md file.                                                                   │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Translate 💬

Core implementation of the tool, where the SKILL.md is translated from the detected language to the target language. It preserves the directory structure.

➜  skills-i18n git:(master) uv run skills-i8n translate ./example_skills de 
  ____  _    _ _ _           _  ___        
 / ___|| | _(_) | |___      (_)( _ ) _ __  
 \___ \| |/ / | | / __|_____| |/ _ \| '_ \ 
  ___) |   <| | | \__ \_____| | (_) | | | |
 |____/|_|\_\_|_|_|___/     |_|\___/|_| |_|

Skill i18n · powered by Lingo.dev

╭──────────────────────────────────────────────── 🌐 skills-i8n Translation Job ─────────────────────────────────────────────────╮
│ Repository: /Users/apple/Documents/skills-i18n/example_skills                                                                  │
│ Target:     de · German                                                                                                        │
│ Source:     en                                                                                                                 │
│ Output:     /Users/apple/Documents/skills-i18n/example_skills/i8n                                                              │
│ Engine:     eng_L7DVg4T8pYoYu8BJ                                                                                               │
│ Threads:    3                                                                                                                  │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Found 3 skill(s) to translate:

  • code-review (code-review/SKILL.md)
  • pdf-processing (pdf-processing/SKILL.md)
  • readme-writer (readme-writer/SKILL.md)

  ⏭ readme-writer ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 100% 0:00:00

            📊 Translation Results — de (German)            
┏━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Skill          ┃ Status     ┃ Output Path                ┃
┡━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ code-review    │ ⏭  skipped │ de/code-review/SKILL.md    │
│ pdf-processing │ ⏭  skipped │ de/pdf-processing/SKILL.md │
│ readme-writer  │ ⏭  skipped │ de/readme-writer/SKILL.md  │
└────────────────┴────────────┴────────────────────────────┘

✓ 3 succeeded
Output: /Users/apple/Documents/skills-i18n/example_skills/i8n

Scan 🔍

Before translating, it's advised that you execute the scan command, which lists the relative path of the SKILL.md file that would be translated. It provides a tabular output for quick reference that helps you decide beforehand if any modification(s) is/are required.

uv run skills-i8n scan ./example_skills        
  ____  _    _ _ _           _  ___        
 / ___|| | _(_) | |___      (_)( _ ) _ __  
 \___ \| |/ / | | / __|_____| |/ _ \| '_ \ 
  ___) |   <| | | \__ \_____| | (_) | | | |
 |____/|_|\_\_|_|_|___/     |_|\___/|_| |_|

Skill i18n · powered by Lingo.dev

                                                   📁 Skills in example_skills                                                    
┏━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Name           ┃ Description                                                            ┃ License    ┃ Path                    ┃
┡━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ code-review    │ Performs thorough code reviews covering bugs, security                 │ Apache-2.0 │ code-review/SKILL.md    │
│                │ vulnerabilities, performa…                                             │            │                         │
│ pdf-processing │ Extract text and tables from PDF files, fill PDF forms, merge and      │ Apache-2.0 │ pdf-processing/SKILL.md │
│                │ split document…                                                        │            │                         │
│ readme-writer  │ Creates and writes professional README.md files for software projects. │ Apache-2.0 │ readme-writer/SKILL.md  │
│                │ Use when …                                                             │            │                         │
└────────────────┴────────────────────────────────────────────────────────────────────────┴────────────┴─────────────────────────┘

3 skill(s) found.

List Locales📝

Currently, lingo.dev supports an array of locales, and I have tried to port in most of them, which ideally means some are pending for sure. Feel free to reach out to me in case a target language you are looking for is missing incase.

➜  skills-i18n git:(master) ✗ uv run skills-i8n list-locales                 
  ____  _    _ _ _           _  ___        
 / ___|| | _(_) | |___      (_)( _ ) _ __  
 \___ \| |/ / | | / __|_____| |/ _ \| '_ \ 
  ___) |   <| | | \__ \_____| | (_) | | | |
 |____/|_|\_\_|_|_|___/     |_|\___/|_| |_|

Skill i18n · powered by Lingo.dev

      🌍 Supported Locales (83+)      
┏━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Code       ┃ Language              ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━┩
│ af         │ Afrikaans             │
│ sq         │ Albanian              │
│ am         │ Amharic               │
│ ar         │ Arabic                │
│            │                       │
│ ...        │ ...                   │
│            │                       │
│ yo         │ Yoruba                │
│ zu         │ Zulu                  │
└────────────┴───────────────────────┘

83 locale(s) shown.

Detect 🕵️

You can also detect the language of the current SKILL.md file using the detect command. This will help you translate to the right target language and save time on debugging why your translation didn't succeed 😅

➜  skills-i18n git:(master) ✗ uv run skills-i8n detect ./example_skills/readme-writer/SKILL.md 
  ____  _    _ _ _           _  ___        
 / ___|| | _(_) | |___      (_)( _ ) _ __  
 \___ \| |/ / | | / __|_____| |/ _ \| '_ \ 
  ___) |   <| | | \__ \_____| | (_) | | | |
 |____/|_|\_\_|_|_|___/     |_|\___/|_| |_|

Skill i18n · powered by Lingo.dev

╭──────────────────────────────────────────────────── 🔍 Language Detection ─────────────────────────────────────────────────────╮
│ Skill:           readme-writer                                                                                                 │
│ Detected locale: en — English                                                                                                  │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Traversing the code 🧑‍💻

Keeping line-by-line code aside, summarized the overall repository structure and what each part achieves in its entirety.

.
├── example_skills
│   ├── i8n                         # Directory containing translated SKILL.md files (organized by locale)
│   │   ├── de
│   │   │   ├── code-review
│   │   │   │   └── SKILL.md
│   │   │   ├── pdf-processing
│   │   │   │   └── SKILL.md
│   │   │   └── readme-writer
│   │   │       └── SKILL.md
│   │   └── es
│   │       ├── code-review
│   │       │   └── SKILL.md
│   │       ├── pdf-processing
│   │       │   └── SKILL.md
│   │       └── readme-writer
│   │           └── SKILL.md
│   ├── pdf-processing
│   │   └── SKILL.md
│   └── readme-writer
│       └── SKILL.md
├── LICENSE
├── pyproject.toml                  # Project configuration and dependencies
├── README.md
├── skills_i8n
│   ├── __init__.py
│   ├── cli.py                      # Command-line interface for the tool
│   ├── parser.py                   # Parses SKILL.md files into structured data
│   ├── repo.py                     # Orchestrates skill discovery and parsing
│   └── translator.py               # Translation module with lingo.dev interaction
└── uv.lock                         # Lock file for dependencies

Next steps

I don't want to call it a Conclusion; instead, I would want you to give the tool a try as the next step. Furthermore, to improve this tool further, I have some ideas:

Make it part of the RFC standard of Agent Skills.
Integrate AI reviewer to validate Lingo.dev's localization engines' output statistics and confident translation results rendered.
Integrate as part of the CI/CD pipeline and also make it available as a git hook.

Since both of us have next steps, let us sign off and work on those steps. Until then, this is Sriniketh J | srini047 signing off. Hope you had a fruitful time reading this article.

GitHub Copilot: Assistant for my current Python workflow

srini047 — Fri, 06 Mar 2026 17:15:37 +0000

I have split my development workflow into three phases and will explain each of them in detail:

Development

This is the primary and most important phase for any developer. This can be further categorized into bugs and features, but for simplicity, let us stick to a common development workflow.
AI needs proper, enough, and precise context to produce the best results. In our case, we must provide the feature specifications or the bug details (possibly repro and collect logs) and feed these details to the assistant. Brownie points if you could attach the relevant functions instead of providing the entire codebase for fruitful results.

Primarily for feature implementation, if you could share any reference (ideally similar flow in the codebase) that would be the best for your assistant to refer to instead of hallucinating across its implementation.

Sharing an example prompt that I used for a small feature implementation:

Add count with filtering operations to the QdrantDocumentStore

`count_documents_by_filter`: count documents matching a filter
`get_metadata_fields_info`: get metadata field names and their types
`get_metadata_field_min_max`: get min/max values for numeric/date fields
`count_unique_metadata_by_filter`: count unique values per metadata field with filtering
`get_metadata_field_unique_values`: get paginated unique values for a metadata field  <<<<< Detailed explanation about each function

Both sync and async versions. Also, add integration tests for all new operations (sync and async) <<<<< Testing

Check `class WeaviateDocumentStore()` for reference <<<<<< Provide sample reference

One interesting thing I have encountered is regarding code formatting and static type checking. Whatever model you choose, the output delivered will be in the format the model has been trained. Hence, the solution would be to provide the pyproject.toml, which has ruff, lint, static-type checking options or definitions.

Use the following directions to format the code:

[tool.hatch.envs.default.scripts]
[tool.hatch.envs.test.scripts]
[tool.ruff.lint]

Best practice is to use this prompt after code generation, so that you preserve context and also allow the model to focus more on logic rather than cosmetic changes.

Documentation

This phase is the easiest and can save a ton of your time if utilized properly. Instead of writing from scratch, you can ask the assistant to generate:

Docstrings
API documentation
Usage Example
Release Notes

Write a changelog entry for this feature.

Feature: metadata filtering operations in QdrantDocumentStore

Include:
- summary
- new APIs added
- backward compatibility notes
- sample minimal usage

This approach ensures that documentation stays consistent, structured, and updated alongside code changes. Most importantly, you can generate the documentation for the older code base, which is a golden asset, and not just for the newer/updated code.

Testing

Testing is another niche area where AI assistants excel and push the limits of the code. Instead of manually writing test suites/cases, you can ask the assistant to generate:

Unit tests
Integration tests
Edge case
Mock APIs
Sync/Async-based testing

Sample prompt:

Write test cases for the APIs:

count_documents_by_filter
get_metadata_fields_info
get_metadata_field_min_max
count_unique_metadata_by_filter
get_metadata_field_unique_values

- cover both sync and async versions
- include realistic metadata examples
- validate correct filtering behavior

Using AI for testing ensures:

better code coverage even before hitting the codecov tools
faster test case generation
fewer overlooked edge cases

Sharing an example session that I used while adding support for a small feature that shows the request-response between the assistant and me:

GitHub Copilot Session

Final thoughts

Always remember, you are the reviewer of the response from the assistant. You can depend on AI and shouldn't become dependent on AI.

New year🗓️ New Portfolio🌐 Re🔁Fresh start⏭️

srini047 — Sat, 17 Jan 2026 17:31:40 +0000

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI

About Me

I'm a passionate Software engineer and Machine Learning enthusiast. Currently working as an SWE at Arrcus Networks. I have previously worked at Zoho, Audio ML side of things, and as a Software Developer Intern at naas.ai

With a strong foundation in data science, networking, and full-stack development, I enjoy building intelligent systems and scalable web applications. I'm a lifelong learner who believes in practical implementation through building projects and participating in hackathons.

In my free time, I contribute to open-source projects, write technical blogs, and explore deep learning and web development. I'm currently learning German and love playing football whenever I get the chance.

Portfolio

How I Built It

Next.js — Structured the app with a fast, scalable React framework
Antigravity — Orchestrated backend logic and agent workflows
Gemini 2.5 Flash (AI Studio) — Powered real-time AI reasoning and responses
ElevenLabs Agent — Enabled natural, expressive voice interactions. LLM using Gemini 2.5 Flash
Google Cloud Run — Deployed and scaled the app serverlessly
Tailwind + shadcn — Designed a clean, modern UI with reusable components
Email.js - Seamless contact form page integration with just a few steps.

What I'm Most Proud Of

First and foremost, before any statistical datapoint, I wanted to have some change personally in different aspects of my lifestyle and hence a makeover of my portfolio.
Achieved 100/100 Lighthouse Performance on multiple factors of Next.js production build
Recorded 0.3s FCP and 0.4s LCP, far exceeding Core Web Vitals targets
Maintained 0 ms Total Blocking Time with near-zero main-thread work
Kept Cumulative Layout Shift under 0.005, ensuring visual stability
Scored 100 SEO and 96 Best Practices, meeting production-grade standards
Improved performance from 83 → 100 by optimizing images, JS payloads, and caching
Delivered a fully AI-powered app while remaining sub-second load time

React:

NextJS:

What Next?

Improve the accessibility since the website would be viewed for a few seconds and a maximum of a minute. So, providing most of the user's time is important.
Need some more thought process to make the landing page still close to what I do.
Integrate my demo videos and photos of hackathons as reels/shorts.
Last but not least, keep doing more to add more content to the site.

IRIS Dataset Implementation

srini047 — Sat, 11 Sep 2021 13:53:26 +0000

Introduction

IRIS DataSet consists of 150 rows and 5 columns where the columns are namely sepal length in cm, sepal width in cm, petal length in cm, petal width in cm, and Species. There are 3 species namely Iris Setosa, Iris Versicolor, and Iris Virginica.

Dataset can be accessed through this Link.

Another feature of this dataset is it has the right proportion of data for each species. Meaning it has 50 rows of data for each Species. Also, this dataset is very clean and hence liked by most beginners to start with ML.

These are the 3 different species of the IRIS Dataset pictorially.

Ref: Different IRIS Species

Now let's get our hands dirty by coding. For which you require Google Colab, Visual Studio Code (or any IDE), Dataset (downloaded from the above link in the form of CSV), and excitement to learn something.

Framing the Problem

Our ultimate goal is to describe the Species to which the flower belongs provided length and width of sepal and petal.

Data Preprocessing and Visualization

Importing Necessary Libraries
Initially let us import all the necessary libraries that are required to run the code.

import numpy as np
import pandas as pd

import seaborn as sns

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

Here we import NumPy, Pandas, Matplotlib, Seaborn, and other necessary modules from Sklearn.

After importing the necessary libraries let's import the IRIS Dataset that we are going to work on.

Importing Dataset

To import, we have to use the pandas library which has the 'read_csv' function which takes the file path to import the necessary dataset.

data  = pd.read_csv('iris_data.csv')
data

After importing if we print the data we find that there are 150 rows and 5 columns. Further, if we dig deeper we find no null values, meaning all the rows and columns are filled and reduce the huge burden. After that I have encoded (to change into a form that is better usable) the Species as follows:

Iris Setosa
Iris Virginica
Iris Virginica

The code for the same is given below:

onehot = []

for i in data['Species']:
    if (i == 'setosa'):
        onehot.append(1)
    elif (i == 'virginica'):
        onehot.append(3)
    else:
        onehot.append(2)
data['Species'] = onehot

Visualizations

I have implemented it understandably but it could be implemented in many ways at your convenience. Then now it's time to visualize the data using Matplotlib and Seaborn.

Using the 'countplot' function I have plotted the count of each Species which is found to be 50 each (same as the statement mentioned at the beginning). Code to implement the same is:

sns.countplot(data['Species'])
plt.show()

Ref: CountPlot Output

Now there is something called a FacetGrid plot where we can plot dataset onto multiple axes arrayed in a grid of rows and columns that corresponds to levels in the dataset. Code to implement the same is:

sns.FacetGrid(data, hue ="Species",height = 6).map(plt.scatter, 'Sepal.Length', 'Petal.Length').add_legend()
plt.show()

Ref: FacetGrid Output

There is one more interesting plot called a "pairplot" where we plot many scatter plots with the data available in the total number of numerical columns. For better understanding let's consider our dataset which has 4 numerical columns. So there would be 4 * 4 possible scatter plots available. Sounds interesting right it will look even better while we visualize it.

Code to implement the same (small code, big difference):

sns.pairplot(data, hue="Species")
plt.show()

Ref: PairPlot Output having 16 different Graphs

Hope it's understandable after visualizing it though it looks messy while understanding it. Now it's time to build our model. Now let's move on to the model building.

Model Building:

It is considered one of the most important parts of any ML Workflow. I have addressed in this blog one classification algorithm i.e. Logistic Regression. But the code contains its implementation using KNN and Decision Tree Classifier as well.

Before directly building the model we have to separate the independent and dependent variables. In our case, the Independent variables are columns Length and Width of Sepal and Width. We can easily separate it using the "iloc" function.

X = data.iloc[ : , : 4]
y = pd.DataFrame(data['Species'])

Now we have to split the data for Training and Testing. Now a doubt arise in what ratio are we supposed to split to get optimal results. It's actually a trial and error method but most often it is preferred to have a 70:30 or 75:25 split as they work in most cases. In our case, I have used a 75:25. There is no hard and fast rule. You can try different split sizes and get better results as well.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)

After successfully splitting the train and test data we have to fit the train data on the Logistic Regression model.

model = LogisticRegression()
model.fit(X_train, y_train)

Hurrah!! The model has been successfully trained now we have to actually test the working of the model where I provide some random values as input and predict the output provided by the model.

X_new = np.array([[5, 2.9, 1, 0.2]])
print("X_new.shape: {}".format(X_new.shape))

If you feel that the output for the set of input values provided is perfect then Congratulations on that note, you have successfully build your model. Now we come to the end of this blog and I hope it was very much useful and has given clear insights on how to process with the IRIS Dataset.

This is the GitHubLink for the code used in the blog.

Please feel to post your views and comments on how to improve and if I have had some Typos in the Blog as well.

Feel free to connect with me through LinkedIn.

Happy Learning and Blogging!!!

HackThisFall 2.0

Hey folks,

I am thrilled to inform you that I have been accepted as a “Hackathon Evangelist” for Hack This Fall 2.0!🎉

Super excited to bring a change and contribute to the hacker community in a meaningful way!🚀

Do Register for Hack This Fall 2.0 here🔗:

Register in the hackathon by heading over to the link given above and enter the special code "HTFHE067" to earn some exclusive participation goodies along!!

InnovateForGood #HackathonEvangelist #Hackathon