I have contributed to open source projects before, mostly in Python and in environments and languages I am familiar with.
This time was different.
The repository was written in TypeScript, a language I had only limited experience with. I could understand the general structure, follow the logic, and get a rough picture of how things worked—but I was definitely not a TypeScript developer.
That made this contribution interesting.
Could I still make a meaningful contribution to a project when I did not fully know the language?
It started with a small bug, not a big feature
The reason I looked into this repository was actually pretty simple.
I noticed a small bug in a typing animation generator project. The generated animation was not printing as smoothly as expected, and I thought it would be a nice improvement to fix that experience.
It was not a major architectural change or a large feature request.
It was just a small issue that bothered me as a user.
That is one of the things I enjoy about open source: sometimes a contribution starts from a simple thought:
"Could this work a little better?"
So I opened an issue, described the problem, and shared my thoughts.
I expected the discussion to stay at the issue level.
Instead, the maintainer asked:
"Would you like to fix this issue?"
My reaction was simple:
"Why not?"
So I started working on it.
Learning a new codebase with AI as a companion
I used Codex throughout the process.
But the goal was not to ask AI to generate code and blindly submit it.
I used it as a learning partner:
- Understanding unfamiliar TypeScript patterns
- Exploring the repository structure
- Discussing possible implementation approaches
- Reviewing my own assumptions
- Helping translate my existing engineering knowledge into a new ecosystem
AI helped reduce the friction of entering an unfamiliar codebase, but I still needed to understand the problem, make decisions, and validate the final implementation.
The contribution was not:
"I know TypeScript now."
It was:
"I understand this problem well enough to improve this project."
When AI reviewers disagreed with my implementation
After submitting the PR, I received feedback from several AI-powered code reviewers.
One suggestion caught my attention. The checker recommended changing my implementation slightly.
At first glance, the suggestion looked reasonable.
But instead of immediately accepting it, I investigated.
I discussed the feedback with Codex, reviewed the surrounding code, checked the existing tests, and looked deeper into the design intention behind the change.
After that investigation, I decided not to make the suggested change.
I explained my reasoning in the PR:
- Why the original implementation matched the existing project structure
- Why the suggested change was not necessary
- How the tests supported the current approach
This was a small but meaningful moment.
AI review is valuable, but it is still feedback—not an automatic decision.
The responsibility of engineering judgment remains with the contributor.
The result surprised me
Eventually, the AI review passed, the maintainer approved my original implementation, and the PR was merged.
The interesting part was not that AI wrote code for me.
The interesting part was that AI helped me participate in a project where I previously would have hesitated because of the language barrier.
This experience also changed how I viewed TypeScript.
Instead of seeing it as an unfamiliar language that was "not mine," I became more interested in learning it further.
Sometimes the best way to learn a technology is not through tutorials.
Sometimes it is by trying to contribute something meaningful with it.
Open source contribution is evolving
Traditionally, contributing to a project often felt like:
"I need to already know this technology before I can help."
But that barrier is starting to change.
The important skills are becoming:
- Understanding problems
- Reading unfamiliar systems
- Asking good questions
- Validating ideas
- Communicating clearly with maintainers
- Knowing when to trust or challenge suggestions—including AI suggestions
The fundamentals of engineering have not changed.
We still need curiosity, judgment, and the ability to adapt.
But the tools available to us have changed.
Maybe the future open source contributor is not someone who knows every language.
Maybe it is someone who can continuously learn, collaborate, and contribute—even when stepping into unfamiliar territory.
Have you ever contributed to a project outside your main programming language or comfort zone?
Transparency Note: I used AI as an editor—not as the author. For this article, it helped refine the structure and improve the English grammar. The technical content, experiments, opinions, and conclusions are my own and were reviewed by me before publishing.
Top comments (0)