Insights

Ramp Up on Any Codebase in Hours, Not Weeks

Written by Agustin Calabrese | Sep 25, 2025

 

Starting fresh in a large, unfamiliar codebase is usually very hard. AI won’t do your job for you, but it can be the fastest partner you’ve ever had. You can use it to:

  • Generate reliable onboarding context files
  • Spin up local environments and seed realistic data quickly
  • Interrogate subsystems before you dive in
  • Plan in small phases and document as you go
  • Keep yourself in the driver’s seat with reviews, branches, and tests.

Done right, you’ll be productive in a matter of hours instead of slogging through weeks of trial and error.

 

If you’ve been in software long enough, you know this feeling: you join a new project, open the repo for the first time, and suddenly realize you’re staring into a jungle. Hundreds of files, inconsistent patterns, cryptic data models, missing docs. The pressure to “be productive fast” collides with the reality that you don’t even know where to start.

 

Twenty years in, I still face that moment every time I step into a fresh codebase. The difference is that today, I have an ally: AI.

 

Imagine AI not as a magical coder, but as an intelligent partner. This sharp assistant has absorbed vast knowledge, can analyze codebases in mere seconds, and is always ready to answer your questions, identify patterns, or even help build experiments. When utilized effectively, this partnership can drastically reduce the time it takes to become productive, transforming weeks into just a few hours.

 

Here’s how I do it.

Context is king

AI is only as useful as the context you feed it. It has read all the books but it doesn’t know what the project is about or what you are trying to accomplish. These days all of the main agentic coding tools use and recommend creating a base context markdown file that explains what the project is, what technologies it uses, best practices, Do’s, Don'ts, and the like.. So on day one, I always generate such a context file if the project doesn’t already have one. Think of it as onboarding notes for both me and the AI. With that in place, I can ask  a question and get a reliable answer without expending tokens analyzing the codebase to get it right. Nowadays most tools have their own name for this kind of context file, but the industry seems to be moving into standardizing it as Agents.md. At the point of writing all the CLI agentic coding tools have a /init command that auto-generates this file. You can further customize it later if needed.  

Use AI for the boring parts first

The fastest wins are in setup:

  • Spinning up the dev environment
  • Running tests end-to-end
  • Seeding meaningful demo data
  • Switching between runtime modes (self-hosted vs. cloud, debug flags, etc.)
  •  

For example, in a Rails finance app I tested, the agent quickly found a rake task to generate demo data. I asked it to extend the script with an Argentine peso account and transactions. Suddenly, I had real-looking balances and UI flows to click through — without digging through migration files or writing seed data by hand.

That single step shaved hours off my ramp-up.

Never hand over the wheel*

AI doesn’t absolve you from engineering discipline.

  • Use version control
  • Write/generate meaningful tests
  • Make sure they pass 👆
  • Carefully review diffs before merging.
  • Make sure the code adheres to project conventions and best practices
  • Refactor
  • Test locally if needed.

* We could dive into how to let the agent run on its own for longer, but that's a whole other conversation for a different article. 

From idea to implementation: a small real feature

Here’s a realistic scenario. In Argentina, we work with multiple USD exchange rates: official, crypto, black market and others. The finance app I was testing only fetched the official rate. I wanted an alternate provider.

 

Step 1: Interrogate the system

I ask, “How do exchange rates work? Which models and jobs are involved?”

This doesn't only give me the information about how the system works, but also creates context for me and the agent to work with.

Step 2: Plan

Before I jump into changing any code, it's super important to have a solid plan. Following agile methods, like creating PRDs and user stories, really helps me here. I can even get the agent to whip up these documents with as much detail as I need. The main idea is to clearly understand what I'm trying to build and how to get there. Once that's all squared away, then I deploy the agent to tackle specific, manageable tasks.

Step 3: Capture the plan

Most of the agentic coding tools have a plan mode of sorts where I can trigger extended thinking modes/models to build my planning and implementation documentation. Well-structured documents work particularly well. I can structure my documents using XML, YAML, or Markdown. I usually use the latter since it's typically the format used natively by the developers of these tools. If possible, I dedicate a folder in my project to store documentation that can be leveraged by LLMs and humans alike. Updating these documents become part of my implementation plans so they don't become outdated.

Step 4: Implement by phase

Only after the plan looks good do I let the agent scaffold Phase 1 in a feature branch. Then I review, tweak, and test before moving on. This keeps me in control, while offloading boilerplate and discovery to the AI.

What changes with AI

AI doesn’t replace engineering. It shifts where you spend your mental energy.

  • Less: boilerplate, spelunking through config files, writing seed data.
  • More: designing systems, making trade-offs, validating assumptions.

In other words: less time fighting the jungle, more time designing the path forward.

Final thoughts

After two decades of coding, I’ve learned that tools change, but fundamentals don’t. You’re still responsible for design, safety, and clarity. What’s new is the leverage: an AI partner who makes the dull parts faster and the complex parts easier to reason about.

 

If you’re onboarding into a new project, here’s my quick recipe:

  1. Generate context.
  2. Use AI to handle environment setup and demo data.
  3. Interrogate subsystems before touching them.
  4. Create phased implementation plans in docs.
  5. Review every diff like it came from a junior teammate.

Follow that, and you’ll ramp up in hours, not weeks.