How I Developed My First Extension for Kiro
A practical look at how I turned a simple workflow problem into a published Kiro extension, including lessons learned about development, documentation, marketplaces, and AI-assisted code review with Kiro.
I have been using Visual Studio Code, also known as VS Code, since 2019, but always in its simplest form, mainly for reading and editing JSON documents, YAML files, Bash scripts for EC2, and plain text files, such as logs and
.txt files. To make my activities easier, I use extensions that add colors to text and make the visual experience more readable.But this year, I installed the Kiro IDE with two goals in mind:
- I want to gradually move away from VS Code.
- I want to learn how to use Kiro, mainly because it has now been added to the scope of the AWS Certified AI Practitioner exam .
However, during this change and migration of IDE tools, I found a problem. The color extension I used in VS Code to read plain text files was not available in the extension marketplace used by Kiro. And when I searched for an alternative, either it did not meet my needs, or even worse, it had been abandoned by its developer.
So I decided to turn this pain point into a personal challenge: to develop and publish my first extension for Kiro.
And in this article, I will explain what this learning journey was like.
Why did I decide to create an extension for Kiro?
Before thinking about developing a solution, I tried to understand why I could not find in the Kiro marketplace the same extensions that were available in the VS Code marketplace.
What I discovered was that Kiro uses the Open VSX Registry as its extension marketplace, while VS Code uses the Visual Studio Marketplace as its main and exclusive source.
I also found another critical point. The extension I was using in VS Code had not been updated for more than two years, had open issues on GitHub from other users that had not been answered by the author, and its source code included functions that made it heavy, along with features that were not part of my needs, such as adding colors to text containing Chinese ideograms.
That was when I saw an opportunity. Instead of waiting for someone to update that extension, which was not going to happen, I could create my own solution, focused on my use case: colored reading and editing of files such as
.txt, .log, .ini, .conf, .cfg, .env, and .properties.And that is how the idea for TXT Color was born.
Choosing the harder path
At the beginning, I could have forked the original repository or cloned the project to my machine. That was possible because the original project, abandoned for more than two years, used the MIT license, which gives freedom to use, modify, and distribute the code, as long as the license notice is preserved.
But I chose the harder path.
Instead of using GitHub resources to copy the repository, I manually recreated the structure on my local machine, creating each file, copying and pasting each code block, reviewing each configuration, and understanding each line of the extension.
This decision was very labor-intensive and, looking back, I still cannot fully explain why I chose that path. But now that the project is complete, I can see that doing this reverse engineering allowed me to understand more deeply how the extension works, and it also became the turning point in my learning process.
By manually recreating the structure, I was able to better understand how Kiro interprets a project and which parts of the source code needed to be discarded and which ones were truly necessary.
During this process, I also removed rules that did not meet my use case, defined new highlighting patterns, and made the project leaner.
For me, the extension did not need to solve every possible scenario for adding color. What it needed to do was solve one pain point, and that became the starting point of my development.
From local testing to publication on Open VSX
After developing the first alpha version,
0.0.1, I asked Kiro to evaluate the project.The result was that Kiro found improvement points, suggested corrections, and helped reduce some lines that were not necessary.
After applying the suggested corrections, I generated a new extension package and tested it locally in Kiro once again. And when I opened my
.txt files and saw the colors being applied, I saw my first proof of concept working.Next, I organized the project on GitHub, with a README, changelog, images, test file, license, icon, and support information.
Only after those initial adjustments at home did I move on to the next step, which was publishing the extension to the marketplace used by Kiro, the Open VSX Registry.
So I created an account on the Open VSX Registry and opened a ticket in the maintainers’ repository to validate the Você Certificado namespace, since I am the owner of the brand.
The validation was done through a DNS TXT record, which I created in the Cloudflare DNS manager, and it took a few hours to be approved because the whole process is handled by humans. But in the end, I was able to publish the first stable version of the TXT Color extension.
Project timeline
The Project Results
This project involved practically a complete product cycle, starting with:
idea > name > identity > code > documentation > versioning > packaging > publication > validation.
The result after publication was that, in 24 hours, the extension had 456 downloads and 2 five-star reviews on the Open VSX marketplace , as well as 91 downloads and 1 five-star review on the Visual Studio Marketplace .
And the coolest thing about all of this was that, at that moment, I realized that my pain point was not unique. Other people were going through the same difficulty. They wanted a simple, updated, and functional extension for reading text files, and it did not exist. And when I delivered what they were looking for, the product reception was excellent.
TXT Color light theme
Experience using generative AI in Kiro
One initial concern I had was about the costs I could have when using Kiro. However, right after installing it, followed by authentication and authorization through Amazon Cognito, I saw that I could choose to open a free account, with a limit of 50 free monthly credits. In my first interactions with Kiro’s AI, asking it to make code corrections and performance improvements, I used only 1.20 credits.
Later, after new commits and new versioning, I returned to Kiro and asked for suggestions to improve my code. And it did an excellent job analyzing the entire project. It did not limit itself only to reading and correcting a specific piece of code, but also pointed out grammar adjustments in the documentation, updates to naming conventions, and even corrections and standardizations of dates in the documentation.
To give you an idea of how good its suggestions were, I had dated the wrong month in the CHANGELOG, and it was able to identify that by cross-checking the information from the commits I had made on GitHub, without me needing to ask it to do that, and suggested that I needed to update the document.
In this second round, Kiro consumed an incredibly small amount of only 1.3 credits.
In the final total for the project, I used 3.1 credits out of the 50 available.
Another detail I enjoyed using in Kiro was its large language model, or LLM, selectors. First, I used Qwen3 Coder Next, because it had the lowest credit cost. Later, I switched to automatic mode, so Kiro itself could choose the most appropriate model for each task.
But I did not use Kiro to develop the extension. It would certainly have delivered the entire project if I had described a project plan in its specs. And if I had taken that path, I would not have achieved this learning curve while developing my first extension. So my insight was to use Kiro not to program for me, because that is my responsibility as a developer.
I used it as a senior developer to correct and review my code, and that was where it truly shined.
And once again, I take my hat off to Kiro on this point. It was able to suggest a performance improvement for the case where someone uses the extension to try to open and read a very large text file. Testing for this feature and validation had not even crossed my mind. In fact, I would only have implemented this improvement much later, and only if someone opened an issue on GitHub complaining about it.
In addition, with each improvement and correction suggestion, it opened the file it was working on and showed me what it had done. It was very easy to see which lines had been removed, which had been added, and the logic behind each change.
This reinforced a thought I have about the use of AI in development:
“We can, and even should, delegate repetitive tasks to AI, but this does not eliminate our human responsibility to read, study, learn, and reason whether something makes sense.”
Eduardo Lara, 2026.
What did I learn?
This project taught me that a good idea does not need to start big. It can start with a small pain point.
For example, in my case, I only wanted to read my text files better in Kiro. And while trying to solve that problem, I learned how the development and publication pipeline for marketplace extensions works, how packaging and submitting new versions works, how to better use GitHub resources, the importance of documentation, creating icons and screenshots, and even validating my profile by creating DNS records.
Today, I see Kiro as an assistant for reviewing my files, suggesting improvements, correcting code errors, and making faster decisions, without, of course, removing my responsibility to validate the result.
The biggest lesson learned was that I did not simply develop and publish an extension. What I built was a complete product that solved not only my own pain point, but also the difficulty many other developers were facing when trying to read unformatted text documents.
That is why my conclusion is that, if while using Kiro you feel that a feature or function is missing, it means there is an opportunity for you to develop your own solution, solve a pain point, and positively impact the lives of many developers.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article