Bringing a new developer onto the team is a multiphasic process that builds on hiring. We don't just sign the employment contract and drop the new person into the mix. Instead, we need to continually build a team development environment and culture in which a new member can quickly thrive.
Once we have communicated the essentials of the codebase and the team's common workflow, our new developer needs to start writing code.
Typically, it’s prudent to assign some low-hanging fruit - smaller issues related to a specific place in an app that need brief, focused attention.
It's not the time to discuss major architectural issues or far-sweeping refactors. Those can come later as our nascent developer builds their mind map of the code.
But how do we maintain a high level of code quality when a new team member is unfamiliar with our common patterns?
That's where code reviews come in.
Code review should be part of your team culture, but it is especially important during the onboarding and ramp-up phases. It’s a time to exhibit radical candor, enforce consistency, and be open to feedback yourself.
When your new hire posts a pull request, that's the time to hold the line on code quality, architecture, testing, awareness of vulnerabilities, and everything else that comprises our concept of worthy software.
Radical Candor
Code review is a wonderful time to employ radical candor. We need to call out things that need improvement quickly and concisely.
Done correctly, this is not a time to count positives and negatives and ensure they come out even. Reviews should be as objective as possible and unforgiving of things that could compromise an app's foundation.
That's not to say we should become one of the notoriously acerbic developers who use personal attacks and caustic responses to bully their points. Quite the opposite: quality code can quickly become messy.
The desire to maintain good code and architecture should be the driving force to focus on the code and keep the personal out of it. The goal of feedback is to demonstrate the standard and hold the bar high for the new developer to shine.
Make your new hire aware during onboarding that their early code reviews will be verbose: "Don't take it personally. Everyone gets that here."
Consistency
The more consistent the review process and feedback are during onboarding, the more comfortable a developer will be to hold to the standard themselves. What is acceptable cannot be a moving target.
For example, if we call out the separation of model and view code once but accept a PR later that combines them, we send the message that we either don't care or aren't paying attention.
Be Open to Feedback
Code review goes both ways, too. We have a lot of input on the new hire's reviews, but we should also be open to input ourselves. To that end, expose other team members' PRs to the newcomer's input.
This accomplishes two purposes for the benefit of the team. First, the less-experienced developer (in this codebase) gets an idea of the improvements needed and how one of the more-experienced developers proposes to do so. Second, our new hire gets to develop a voice on the team.
Future Onboardings
Doing this review process consistently and maintaining code quality will pay off in future onboardings.
As we bring other new developers onto the team later, will we take pride in how we did it this time? Or did we cut corners in hopes of just adding capacity to get things done faster? If the latter, we'll have some egg on our face when we introduce someone to the code next time.
A Culture of Code Reviews
Ultimately, onboarding a new developer is an investment in both individual and team growth. Instead of creating a gauntlet of criticism, we build a collaborative environment where all developers understand, respect, and collectively maintain high standards.
The code review process is a quality control mechanism and a cultural touchstone that communicates your team's values, expectations, and commitment to excellence.
By approaching each new team member with radical candor, maintaining consistent feedback, and creating opportunities for two-way communication, onboarding becomes less of a mere administrative task and more of a strategic opportunity. We cultivate a shared understanding of what makes great software and a team that continually elevates its craft.
Every line of code reviewed, every piece of feedback given, and every collaborative moment shapes not just the current project but the future of your team's technical excellence.