GitVenture

Inspiration

Whenever we wanted to improve our coding skills, we would hop on LeetCode and solve the same types of problems that have existed for years. While LeetCode is great for learning algorithms and data structures, we felt like something was missing: real-world development experience.

In the real world, developers aren't given a neatly formatted problem statement with a known input and output. They have to understand an existing codebase, figure out what is broken, work with other developers, and actually contribute something useful.

We wanted to make that process more fun while still helping people improve their coding skills. That's what inspired us to build GitVenture.

What it does

GitVenture turns real GitHub issues into coding challenges.

Users can explore issues from real open-source repositories, choose challenges that interest them, and work directly within the project's existing codebase.

Once a user solves an issue, they submit a pull request. When the repository owner merges their contribution, the user earns XP and progresses on the GitVenture leaderboard.

Instead of solving another artificial coding problem, users get rewarded for making real contributions to real projects.

How we built it

We started by creating a mind map of what we wanted GitVenture to become. This helped us break down the idea into the core features required for our MVP and gave the team a clear direction before we started coding.

From there, we divided the project into different components and worked on them simultaneously. Once we had the MVP working, we focused on adding features that would make the experience more engaging and game-like.

A major part of the project was integrating GitHub so that GitVenture could connect coding challenges to actual repositories, issues, pull requests, and contributions.

Challenges we ran into

One of our biggest challenges was working on the same codebase as a team under a tight hackathon deadline.

We ran into numerous merge conflicts as different features were being developed simultaneously. At several points, merging one feature would unexpectedly affect another part of the application.

We also had to deal with the complexity of working with GitHub's ecosystem and figuring out how to reliably connect repository activity with our game's progression system.

And, of course, there was the classic hackathon problem:

"It works on my machine."

With only a limited amount of time, we had to constantly decide whether a problem was worth fixing immediately or whether we should prioritize getting another core feature working first.

Accomplishments that we're proud of

We came up with the idea five hours into the hackathon.

By the end of the first 12 hours, we had already completed our MVP.

What we're most proud of isn't just that we got the MVP working, but that we were able to keep moving despite the problems we encountered along the way. Between merge conflicts, debugging, changing requirements, and trying to connect multiple parts of the system, there were plenty of opportunities to get frustrated.

Instead, we worked through the problems together and kept improving the project.

Going from an idea to a working MVP in such a short amount of time is something we're genuinely proud of.

What we learned

The biggest thing we learned was that building a real application is very different from solving isolated coding problems.

We learned how important communication and version control are when multiple developers are working on the same project. A small change in one part of the application can have unexpected consequences somewhere else.

We also learned how important it is to build the core functionality first instead of spending too much time trying to make everything perfect.

Most importantly, we learned that hackathons are about adapting. Our original idea evolved throughout the event, and we had to continuously make decisions about what was realistic to build within the time we had.

What's next for GitVenture

We want GitVenture to become more than just a way to find GitHub issues.

Some of the features we want to explore next include:

Difficulty ratings for issues based on the complexity of the task
Streaks and challenges to encourage consistent open-source contributions
Team-based challenges where developers can compete or collaborate
Open-source contribution analytics to help developers visualize their growth over time

Ultimately, we want GitVenture to make contributing to open source feel less intimidating and more like an adventure.

Instead of asking:

"What LeetCode problem should I solve today?"

we want developers to ask:

"What can I build today that actually helps someone?"