Project Onboarding Agent

zero to contributor in one prompt

Comment

Inspiration

I came across FOSS over a decade ago as a teenager. But the meaningful projects appeared very big and intimidating for a newbie contributor like me. I dreamt of a tool which would simplify any project, regardless of complexity, for any developer to understand and start contributing.

What it does

It maps the repo using GitLab Orbit and produces a detailed issue which can be referred to get hands-on with the code.

Why this agent

let us understand why such an agent would be needed vs just using an llm.

1. How Tokens Are Consumed (Standard LLM vs. GitLab Orbit)

When you run a standard LLM tool (like a local CLI assistant) inside a folder, it uses a brute-force document stack approach. It reads the actual text contents of your files, concatenates them, and shoves thousands of lines of raw source code into the prompt context window.

The Brute-Force Local Approach (High Token Burn)

If you point a standard LLM at a modest repository with 50 files (averaging 200 lines of code each), the math gets expensive quickly:

  • Input: ~10,000 lines of code $\approx$ 30,000 to 40,000 tokens per single prompt execution.
  • Cost/Limits: If a user asks three follow-up questions, you are re-sending that entire codebase stack every time, easily burning over 100,000 tokens in minutes. If the repo is larger, you will completely crash or saturate the model's context window. #### The GitLab Orbit Graph Approach (Token-Optimized) GitLab Orbit acts as a caching abstraction layer. Instead of feeding the raw text of the files to the LLM, the orbit_context_graph tool passes highly condensed structural metadata.

Instead of reading lines 1–200 of userController.js, Orbit provides a tiny JSON structure to the LLM that looks like this:

  • { "file": "controllers/userController.js",
    "dependencies": ["middleware/auth.js", "config/db.js"],
    "commit_frequency_rank": 2,
    "lines_of_code": 140
    }
    ### 2. Why Orbit Wins Over Local Folder Tools (The Core Benefits)

Local tools like antigravity or folder-level AI search bots are excellent for localized code navigation, but they fall short for this specific onboarding use case because they lack DevOps lifecycle awareness.

Here is why your Orbit agent provides far better architectural blueprints than a local folder scanner:

A. Historical Centrality vs. Static Analysis

A local tool only sees the code as it exists right now. It treats a 500-line utility file written two years ago with the same importance as a 500-line core application router written last week.
The Orbit Advantage: Orbit knows the Git history. It tells the LLM: "This file has been modified in 45 different Merge Requests by 6 different developers over the last 3 months." The LLM uses this metadata to instantly identify that this file is the active "heart" of the project's logic, placing it precisely in Tier 2 of your learning path.

  • #### B. Issue and PR Grounding

A local tool has no idea why a piece of code was written.
The Orbit Advantage: Orbit links files to completed GitLab Issues and Merge Request discussions. If a new contributor wants to know how features are structured, the agent can look at the metadata graph to see which files are consistently grouped together in historical feature deployments, allowing it to build highly accurate functional groupings rather than just scanning directory paths. (include diagram)

  • Instead of using brute-force text extraction that forces an LLM to read thousands of lines of source code—burning through context windows and token budgets—our agent leverages GitLab Orbit. By feeding the model a highly optimized metadata graph of file dependencies and Git commit centrality records instead of raw file contents, we reduce input token overhead by over 90% while generating a more accurate, history-aware architectural blueprint

Challenges we ran into

Joined the gitlab discord late so misunderstood some of the instructions and workarounds. Especially token limits.

Accomplishments that we're proud of

Built this agent over 2 days.

What we learned

For the demo we used the code for wakatime . a great tool for devs. We uncovered fascinating insights into its code and architecture within 5 moinutes with the help of this agent instead of spending hours reading the code. Refer the demo video for output.

What's next for Project Onboarding Agent

Built With

Share this project:

Updates