GitLab ran a hackathon in June around Orbit, their new knowledge graph for code. The rule for the Contribute track was pretty simple: the first forty merge requests merged into the Orbit codebase with the right label before the deadline would win a prize.

I do not write Rust, which is what almost the entire codebase is written in. I had never opened it, did not have a Rust toolchain installed on my laptop, and had never run their build system or read their contribution guide.

I got a merge request merged anyway, and it took an afternoon. The results came out in September, and I am on the Contribute Track winners list. Twenty six people merged sixty one changes into Orbit over the two weeks. Nineteen of us got cash prizes, as much for getting there early as for doing good work.

I did not write the code. I am not sure I could have. I pointed Claude Code at the project and told it to find me a contribution and ship it.

The code was the easy part, and it was not the point

The change was pretty small, a command called orbit list that shows which repositories you have indexed locally. About two hundred lines including tests. A competent Rust developer would not have found the ticket particularly impressive.

Writing that code was maybe a tenth of the work. The rest was the boring stuff that usually stops me from contributing to a project like this.

You have to read through the issue tracker and find something you can finish that someone actually wants. Then there is the toolchain to install, the build commands to learn, and the house style for comments and commit messages to figure out. Even the tests have to be written the way this project writes tests. All the linters have to pass before a human will look at it, and after that you still have to get through review without annoying the maintainers.

Getting through all that is the expensive part of contributing to a large project you do not already work on. I think it is why most people never send the patch. The agent handled it all.

The interesting failure was a wall, not a bug

My first attempt failed for a reason I would not have figured out on my own.

I pushed the branch from a personal fork and opened the merge request, and the pipeline went red. The tests all passed, so there was nothing wrong with the code. It turned out that personal forks on GitLab do not get the runners and the dependency proxy that the full test suite needs. I had working code and no way to get it through CI there.

The agent read the failed pipeline logs and worked out that the problem was with the setup. It also found that GitLab runs a community fork program for exactly this problem. Getting in required an access request and approval from a human, which took a few hours. Once that came through, the agent pushed to the community fork, opened a fresh merge request, and closed the old one with a note explaining why. The full suite passed there.

There was no code to fix here. The useful part was being able to read the error log and find out that a solution already existed. A lot of contributors hit the same red pipeline and got stuck without ever figuring out why.

The robots reviewed the robot

GitLab’s own AI reviewer, Duo, read the merge request and left two recommendations. A second review bot approved it with a couple of small notes. The agent fixed everything the two of them raised and replied to each thread, all within the hour. A human maintainer then approved it and merged it the same day.

So I had a bot write the change, two other bots review it, and the first bot fix what they flagged. After all that, a human decided it was worth merging. That was it. It bounced from bot to bot and only at the end did a human take a look.

What this changes

It is easy to forget how much would have been in the way a few years ago. I would have spent a weekend getting Rust installed and the project to build, given up somewhere around the third failing linter, and never sent anything. Between the unfamiliar language, the build system, the conventions, the CI quirks, the fork logistics, and the review etiquette, there was plenty to get stuck on.

I had no Rust, no toolchain, and no idea what this codebase even was. A few hours later, there was a change merged into GitLab with my name on it.