Skip to main content

P — Practice

Practice is the fourth step of The RAMP Method. It's about learning by doing—building real things with guided feedback.

Why Practice Matters​

You can read about swimming all day. You can watch videos about swimming. You can diagram the physics of swimming.

But you won't learn to swim until you get in the water.

The same applies to codebases. Understanding comes from doing:

  • Writing code teaches patterns better than reading code
  • Debugging teaches architecture better than documentation
  • Shipping teaches process better than meetings

The Practice Loop​

   ┌───────────────────────────────────────────┐
   │                                           │
   ▼                                           │
┌──────┐    ┌──────┐    ┌──────┐    ┌──────┐  │
│ Try  │───▶│ Fail │───▶│ Ask  │───▶│ Fix  │──┘
└──────┘    └──────┘    └──────┘    └──────┘

This is the fastest learning loop:

  1. Try something
  2. Fail (or succeed—both teach)
  3. Ask for help or explanation
  4. Fix and understand why
  5. Repeat

What to Practice​

Day 1: Get It Running​

Your first practice goal: run the application locally.

git clone <repo>
cd <repo>
npm install
npm start

If it doesn't work, this is practice. Debugging the setup teaches you about dependencies, configuration, and environment.

Week 1: Make Small Changes​

Start with trivial changes:

  • Fix a typo in a comment
  • Update a string in the UI
  • Add a log statement

These teach the contribution workflow:

  1. Branch
  2. Change
  3. Test
  4. Commit
  5. PR
  6. Review
  7. Merge

Week 2: Complete Real Tasks​

Ask for "good first issues"—small, well-defined tasks:

  • Add a new field to a form
  • Create a simple API endpoint
  • Write tests for existing code
  • Fix a small bug

Month 1: Ship Features​

Graduate to full features:

  • Implement a user story end-to-end
  • Own a small project
  • Pair on larger features

Progressive Complexity​

PhaseTask ComplexitySupport Level
Week 1Trivial changesHigh support
Week 2Small tasksPaired or guided
Week 3-4Medium featuresAvailable support
Month 2+Large featuresIndependent

Don't skip phases. Each builds on the last.

Practice Safely​

Use the Safety Net​

  • Tests — Run them before committing
  • Staging — Deploy there first
  • Code review — Fresh eyes catch mistakes
  • Feature flags — Ship dark, enable gradually

It's Okay to Break Things​

In a well-run engineering org:

  • Mistakes are expected from new engineers
  • Tests and review catch most issues
  • Rollbacks are easy
  • Learning > avoiding all risk

Practice Feedback​

Good practice requires feedback. Sources:

Code Review​

Every PR is a learning opportunity:

  • Read all comments carefully
  • Ask "why?" when feedback isn't clear
  • Look at how seniors review others' code

Tests​

Tests are instant feedback:

  • Red = something's wrong
  • Green = probably right
  • Learn to write tests that give good feedback

Pair Programming​

Pair with experienced developers:

  • Watch how they navigate code
  • Ask about their decision process
  • Learn keyboard shortcuts and tools

Ramp​

Get feedback as you code:

ramp voice
> "Is this the right way to handle errors in this codebase?"
> "What's wrong with this approach?"
> "How would a senior engineer do this differently?"

Practice Habits​

1. Ship Every Day​

Even if it's small. Momentum matters.

2. Review Before Requesting Review​

Read your own PR as if someone else wrote it. Catch obvious issues yourself.

3. Read Others' PRs​

Learn by seeing how teammates solve problems.

4. Keep a Log​

Write down what you learned from each practice session:

  • What did I build?
  • What was confusing?
  • What patterns did I learn?

5. Teach What You Learn​

Explaining to others (or to Ramp) solidifies understanding.

Practice Mistakes to Avoid​

1. Waiting Too Long​

Don't wait until you "understand enough." Start practicing Day 1.

2. Only Easy Tasks​

Push yourself. If you're never struggling, you're not learning.

3. Not Asking for Feedback​

Shipping code without review means shipping without learning.

4. Ignoring Feedback​

Code review comments are gold. Implement them and understand why.

5. Not Reflecting​

Practice without reflection is just repetition. Ask yourself: "What did I learn?"

Practice Checklist​

Week 1​

  • Ran the application locally
  • Made first commit
  • Merged first PR
  • Completed 3+ small tasks

Week 2​

  • Shipped first feature
  • Paired with a senior developer
  • Reviewed someone else's PR
  • Wrote first test

Week 3-4​

  • Working independently on medium tasks
  • Giving useful code review feedback
  • Contributing to design discussions
  • Can estimate task complexity

Month 2+​

  • Leading small projects
  • Mentoring newer team members
  • Proposing improvements
  • Shipping with confidence

Using Ramp for Practice​

Ramp supports practice by providing instant feedback:

# Get help while practicing
ramp voice
> "I'm trying to add a new API endpoint. What's the pattern?"
> "This test is failing—can you help me understand why?"
> "Is this the right approach for handling this error?"

# Before submitting PR
ramp ask "Are there any issues with my changes in src/auth/login.ts?"

The RAMP Method Complete​

You've now learned all four steps:

  1. Recognize — Scan and identify patterns
  2. Ask — Get context without friction
  3. Map — Build mental models
  4. Practice — Learn by doing

These steps aren't linear—they're a loop. As you practice, you'll recognize new patterns, ask new questions, and update your maps.

Ready to practice with AI-powered guidance? Try Ramp free →