It takes a new developer up to three to six months to become fully productive in a new codebase. The exact number varies by organization of course, but the underlying problem is universal: the most important knowledge about how a codebase works isn’t written down anywhere. It lives in the heads of senior engineers, or old Slack threads, closed PRs, or stale READMEs.

Most managers approach this as a documentation problem when really it’s a knowledge representation problem, and it’s one that AI — specifically, AI augmented with codebase intelligence — is well-positioned to solve.

The Onboarding Problem

When a new developer joins a team, the technical onboarding process follows a pretty predictable arc. Week one involves setting up the dev environment and reading whatever documentation exists. Weeks two and three involve small bug fixes and getting familiar with the PR review process. Then over the following months, the developer gradually absorbs the unwritten rules as they take on larger and more impactful tasks. This process works fine, but it’s slow, not only for the dev onboarding but for the team they’re joining. A developer who doesn’t yet understand the team’s conventions will write code that works but doesn’t fit. Their PRs accumulate review comments about structural issues or team conventions rather than logic and solutions. Corrections about where certain services should go or domain-specific naming conventions aren’t about right or wrong in an absolute sense. They’re about consistency, and consistency is what makes a large codebase maintainable over time.

The cost of slow onboarding is significant. Senior engineers spend time reviewing code for convention violations instead of architectural issues. New developers feel frustrated by feedback that feels arbitrary, mainly because the conventions aren’t documented or they were never told where to find them. And the codebase itself accumulates inconsistencies during that whole period when new developers are still learning, which can snowball and lead a new dev to rack up major tech debt right out of the gate, which is no fun for anyone.

Traditional Approaches and Their Limits

Teams have tried to solve onboarding in several ways, each with real but limited effectiveness.

Documentation is the most obvious approach but also the most fragile. Onboarding guides are useful when they exist and are current, but here’s the thing: documentation is out of date almost the moment it’s written. The codebase evolves and conventions shift, and the docs drift out of sync. Most teams know this, which is why the documentation is often sparse or missing entirely.

The buddy system pairs a new developer with an experienced one. This works well for knowledge transfer but doesn’t scale. The senior developer’s productivity drops during the onboarding period, and the knowledge transferred is inherently limited to what that one person knows and remembers to mention.

Trial and error is what actually happens in most organizations. The new developer writes code, submits PRs, gets feedback, and gradually builds a mental model of the codebase’s conventions. It works, sure, but it’s slow. And it means every new hire repeats the same learning curve from scratch.

How AI Changes the Equation

AI coding tools have already changed how developers write code, but their impact on onboarding depends entirely on what context those tools have access to. A general-purpose AI assistant can help a new developer understand what a function does or how a library works, which is useful but doesn’t address the core onboarding problem. The new developer doesn’t need help understanding JavaScript syntax, they need help understanding this team’s JavaScript conventions. Big difference.

This is where Scrubby becomes critical. When an AI agent has access to Scrubby’s codebase intelligence, it can answer the questions new developers actually ask:

  • “Where should I put this new service?”
  • “What other files do I need to update when I change this model?”
  • “Is there an existing pattern for how this team handles error responses?”

These are the questions that currently require interrupting a senior engineer. With the right context, an AI agent can answer them immediately and accurately.

Automated Review as a Teaching Tool

PR review is one of the primary mechanisms through which new developers learn conventions, but human reviewers are inconsistent. They catch different things on different days, and they might not flag a convention violation if the PR is otherwise correct.

On the other hand, AI-powered code review that’s grounded in your codebase’s actual patterns provides consistent, immediate feedback. When a new developer’s PR deviates from an established convention, the review catches it. This accelerates the feedback loop and helps new developers internalize conventions faster.

Domain Maps for Architectural Understanding

One of the hardest things for a new developer to build is a mental model of the codebase’s architecture. Which modules belong to which domain? How do the domains relate to each other? Where are the boundaries?

Automatically generated domain maps give new developers a visual and queryable understanding of the architecture from day one. Instead of spending weeks building this mental model through exploration, they can see the structure immediately and understand where their work fits into the larger system, which is a huge head start and time-saver.

A Concrete Example

Consider a new developer tasked with adding a React component for displaying user notifications. Without codebase context, they might reasonably create the component in /src/components/Notifications.tsx, use PascalCase for the file name, and write a unit test in /src/__tests__/Notifications.test.tsx.

But this team has conventions. Components related to the notifications domain live in /src/features/notifications/components/. The team uses kebab-case for file names: notification-list.tsx. Tests are co-located with their components: notification-list.test.tsx in the same directory. And any change to the notifications feature directory historically includes an update to the feature’s barrel export file at /src/features/notifications/index.ts.

Without Scrubby, the new developer gets all of this wrong. Not because they’re careless, but because there’s simply no way to know these conventions without being told. Their PR gets four review comments about structural issues, they refactor, resubmit, and the cycle adds a day to what should’ve been a two-hour task.

With Scrubby, the AI agent guiding their work already knows the conventions. It places the file in the correct directory, uses the correct naming pattern, co-locates the test, and includes the barrel export update. The developer’s PR gets reviewed for the logic of the component itself, which is what code review should actually focus on.

The Role of Codebase Intelligence in Onboarding

Scrubby was built around a simple idea: the knowledge senior developers carry instinctively should be explicit, queryable, and available to everyone, including every AI agent that writes or reviews code in the repository.

For onboarding specifically, this means a new developer working with an AI coding agent that’s connected to Scrubby’s MCP server gets the benefit of that institutional knowledge from day one. They’re not waiting to absorb conventions through osmosis over six months. The conventions are surfaced in real time, as they write code.

Now, this doesn’t eliminate the need for human mentorship. There are aspects of joining a team that AI can’t replace. But the purely technical dimension of onboarding? The “how does this codebase work and what are its conventions” part? That can be dramatically compressed.

Getting Started

If onboarding is a bottleneck for your team (and let’s be real, for most growing teams it is) Scrubby is worth evaluating. The goal isn’t to remove humans from the onboarding process but to make the technical knowledge transfer instant and consistent.