Quick Tips To Get Higher Quality Code Reviews Faster

In this segment, we focus on how to **ramp up effectively and build trust through proactive code review habits**. By learning from past diffs, referencing previous work, and anticipating reviewer questions, we strengthen both our code and our relationships with teammates.

### Key Takeaways:

- **We study past code reviews to ramp up faster**: Reviewing recent diffs helps us identify codebase hotspots and learn how experienced teammates structure context, write test plans, and address feedback.
- **We reference prior diffs to preempt questions**: When making similar changes, we compare our approach to earlier ones (especially from tech leads) and explain why we took a different route—saving reviewers from needing to ask.
- **We proactively comment on our own code**: By flagging areas we’re unsure about and inviting feedback up front (e.g., naming choices or design alternatives), we guide reviewers toward the most relevant parts and show that we care about quality and collaboration.
- **We show respect for reviewer input**: Code review isn’t just about getting approval—it’s about listening. Ignoring thoughtful feedback undermines trust. We strive to acknowledge and incorporate suggestions to create a positive, team-first review culture.
- **We demonstrate maturity through initiative**: These habits—referencing historical context, asking for help, and valuing reviewer input—aren’t just tactical. They signal leadership and self-awareness, accelerating our growth and reputation on the team.

One Diff, One Thesis - What Every Code Review Should Be Like

In this segment, we focus on the powerful practice of **“One Diff, One Thesis”**, along with a recap of three foundational principles for writing high-quality diffs. These habits dramatically improve your velocity, code quality, and perceived maturity as an engineer—especially early in your career.

### Key Takeaways:

- **We follow the “One Diff, One Thesis” principle**: Each code change should focus on a single, clearly defined purpose. Large, unfocused diffs (e.g., 5,000+ lines) dilute review quality and lead to blind approvals or unclear feedback.
- **We break big features into smaller, stackable diffs**: By submitting changes in 50–250 line chunks with logical dependencies, we keep discussions focused, reduce cognitive load for reviewers, and maintain a clear project history.
- **We pay the “20-minute tax” for high-quality diffs**: Investing time in writing strong context, test plans, and clear, focused diffs pays off by dramatically speeding up approvals and reducing iteration cycles.
- **We see these habits as promotion-worthy**: The most common reason junior engineers struggle during performance reviews is neglecting these basics. Conversely, those who consistently apply them stand out and accelerate their growth.
- **We optimize for long-term velocity and trust**: Thoughtful, well-structured diffs help reviewers engage more quickly and confidently, enabling faster delivery and demonstrating leadership-level attention to detail.

These three practices—**providing strong context, writing solid test plans, and submitting focused diffs**—are low-effort, high-return habits that every engineer, especially early in their career, should master.

This Is What A Good Code Review Test Plan Looks Like

In this segment, we highlight a real-world example of an **exceptional test plan** that showcases how thoughtful demos not only validate functionality but also build confidence and trust before a single line of code is reviewed.

### Key Takeaways:

- **We use test plans to demonstrate functionality and edge cases**: In this example from the Random Name Picker app, the test plan includes both the core feature (removing images from names) and handling an edge case (screen rotation), showing completeness and attention to detail.
- **We treat test plans as trust tokens**: A strong demo assures reviewers that the author has thoroughly tested their changes, reducing fear or hesitation around approving the diff.
- **We provide a positive starting point for reviewers**: Watching the video demo first puts reviewers in the right mindset—making them feel confident that the code works as intended, even before reading the diff.
- **We recommend test plans for all product-facing diffs**: Especially when there’s a visual or user-facing component, attaching a video or GIF dramatically improves understanding and quality of collaboration.
- **We invest a few minutes to add a lot of value**: Creating a short demo takes just 5–10 minutes, but it adds context, transparency, and professionalism that elevate the entire code review experience.

Learning A New Codebase? Here's How To Figure Out What Matters

In this video, we explore how a strong **test plan** benefits not just the immediate code review process but also long-term codebase understanding and team efficiency. As engineers join new teams or revisit legacy code, test plans become invaluable guides for understanding and validating past changes.

### Key Takeaways:

- **We use test plans to unlock team knowledge**: In large codebases, no one fully understands every part of the system. A clear test plan helps future engineers (and our future selves) grasp what a change does and why it was made.

- **We prioritize hotspots over ancient code**: When onboarding to a team, we focus on recent changes in active areas of the codebase—not the 1,000 untouched lines at the top. Test plans tied to recent diffs help us make sense of these hotspots quickly.

- **We support testability with repeatable artifacts**: Whether it’s a video, screenshot, or command-line script, we include a way to replicate and verify our changes. This ensures others can validate functionality easily and efficiently.

- **We aim for speed and clarity**: For front-end work, visual demos (videos or GIFs) help reviewers instantly see the impact. For backend or logic-heavy changes, unit tests and integration scripts are more scalable and maintainable.

- **We build infrastructure for long-term velocity**: Investing early in test infrastructure—like command-line test runners—makes it easier to validate changes quickly and helps teams move faster as the codebase grows.

Ultimately, we think of test plans not just as review aids, but as **living documentation** and a **key onboarding tool** for future engineers working in our code.

What A Test Plan Is And Why Every Code Review Needs One

In this video, we explore the value of including a **clear test plan or demo** with every code review. This simple but often overlooked practice builds trust, improves collaboration, and turns code reviews into lasting pieces of product and engineering history.

### Key Takeaways:

- **We always include a test plan or demo**: Whether it's a video, GIF, image, or command-line instruction, we attach an artifact that shows what our code does—especially when it impacts visual or user-facing components.
- **We demonstrate the *actual* behavior of our code**: A video showing the happy-path functionality proves the feature works and saves reviewers from guessing or manually testing our changes.
- **We create long-term product context**: Test plans turn code reviews into searchable, durable documentation. They help future engineers (including ourselves) understand *why* a piece of code was written and what it was supposed to do.
- **We reduce risk when extending legacy code**: When we need to modify or build on old code, a past test plan often reveals how that code works, what features it powers, and how to avoid breaking it.
- **We invest a few minutes now to save hours later**: Including a test plan takes only 5–10 minutes but dramatically improves team empathy, speeds up reviews, and enhances the maintainability of the entire codebase.

This practice is one of the easiest and most impactful ways we show care for our teammates—and for the long-term health of the code we ship.

Amazing Pull Request Example - Showing The Context

In this video segment, we highlight a real-world example of a **high-quality code review** that demonstrates how providing strong context can dramatically improve the review process. This example reinforces the idea that well-documented pull requests reduce friction and foster better collaboration.

### Key Takeaways:

- **We showcase an exemplary pull request**: Submitted by a community member to the Tech Career Growth app, this PR included everything a reviewer needs—clear references, detailed explanations, and strong rationale.
- **We value clear linkage to issue tracking**: By referencing the related GitHub issue, the diff immediately communicates *why* it exists and what it’s solving—eliminating ambiguity.
- **We appreciate front-loaded context**: The PR offered an in-depth explanation of the author’s approach and alternatives considered, allowing us to understand the logic behind each code decision before even reading the code.
- **We reduce review overhead with context**: This kind of thoughtful diff saves time, prevents unnecessary back-and-forth, and lets reviewers dive straight into meaningful feedback.
- **We encourage others to learn from good examples**: We’re sharing this PR and slide deck so our community can use it as a model for writing better pull requests and improving team productivity.

**Here's why this pull request is great:**

- Has the relevant context behind why this PR exists and what it does
- Goes through the considered approaches to the problem and why the current one was chosen
- Links relevant resources that helped write the code

You can find the pull request that is shared in the video here: <https://github.com/Gear61/tcg-android-archive-and-feedback/pull/19>

The Most Common Mistake Made When Authoring Code Reviews

In this video, we focus on the **critical importance of providing context** when submitting code for review. As codebases grow in size and complexity, understanding the "why" behind a change becomes just as important as the code itself. Without clear context, reviewers are left in the dark—and teams lose valuable time and trust.

### Key Takeaways:

- **We explain the “why” behind every diff**: When submitting code, we clarify *why* the change exists, *why* we chose this approach, and *why* alternatives were rejected. This empowers reviewers to assess our choices without second-guessing or chasing us for clarification.
- **We include business, technical, and historical context**: Good diffs often explain the strategic purpose, relevant architecture, past experiments, and legacy code decisions—all of which help reviewers understand how our change fits into the larger system.
- **We reduce friction with thoughtful summaries**: A well-written diff summary is low-effort but high-impact. Taking 5–10 minutes to write it may feel like a tax, but it dramatically speeds up reviews and earns the gratitude of teammates.
- **We acknowledge that no one sees the whole system**: Using the “elephant” metaphor, we recognize that everyone sees only part of the codebase. Providing our view helps others see how our changes fit into the broader system, making collaboration more effective.
- **We write for humans, not just machines**: Code may be infinitely flexible, but humans need context to interpret it. By empathizing with reviewers and anticipating their questions, we make code review a faster, smoother, and more collaborative process.

The #1 Principle To Remember When Authoring A Code Review

In this video, we discuss the most important mindset shift for code authors: **writing code with empathy for reviewers**. Code review is a collaborative act, and how we prepare and present our diffs directly impacts team productivity, trust, and code quality.

### Key Takeaways:

- **We write diffs with empathy**: The most valuable thing we can do as authors is consider how to make the review experience smoother for others. Clear, concise diffs help teammates help us faster and more effectively.
- **We respect reviewers’ time**: Reviewers choose to help us—they’re not obligated. Reviewing interrupts their own deep work and requires mental context-switching, so we express appreciation by submitting clean, readable diffs.
- **We build trust and social capital through quality**: Writing thoughtful diffs with summaries and test plans helps us gain faster approvals and earns the trust of teammates and tech leads.
- **We know we’ll be reviewers too**: As we grow in our careers, we’ll spend more time reviewing others’ code. We want our teammates to be just as thoughtful when submitting their diffs to us.
- **We lead by example**: High-quality, empathetic diffs set the cultural tone for our team. We improve the entire engineering environment by holding ourselves to the same standards we hope to receive.

What The Optimal Discussion On Code Review Looks Like

In this video, we explore the **spectrum of code review discussions**, highlighting what kinds of conversations are appropriate—and which are not—for an effective and healthy code review process. We emphasize that great code reviews live in the middle: technical, constructive, and context-rich.

### Key Takeaways:

- **We avoid extremes on the code review spectrum**: Debates about architecture or product behavior should happen *before* the code is written. On the other end, trivial nitpicks like formatting should be automated with linters—not left to human reviewers.
- **We aim for meaningful middle-ground discussions**: The best code reviews focus on topics like naming clarity, input assumptions, and logic validation—things that improve understanding and code quality without being overly granular.
- **We talk about testing and future-proofing**: We use code review to validate testing strategies and anticipate how upcoming features or changes might interact with the current code—enabling forward-thinking design.
- **We reduce unnecessary friction with agreed standards**: By aligning on style conventions and automating formatting checks, we free up our code reviews to focus on higher-order thinking and shared learning.
- **We use code review to transfer experience and context**: A reviewer’s knowledge of future plans or broader system behavior adds lasting value. These discussions aren’t just about code—they’re how we build team wisdom.

Code Review Is NOT For Catching Bugs

In this follow-up video, we dive deeper into the **true purpose of code review**, challenging the misconception that its main goal is to catch bugs. Instead, we emphasize how code review plays a central role in shaping team culture, accountability, and knowledge sharing.

### Key Takeaways:

- **We see code review as a cultural engine**: It’s a key mechanism for how our team communicates, transfers norms, and builds a shared understanding of quality and standards.
- **We’ve learned that code reviews aren’t about bug-hunting**: Studies—including from Microsoft Research—show that code reviews are not effective at finding bugs, even with multiple reviewers or approval layers.
- **We hold ourselves accountable for our code**: The responsibility for quality and testing lies with the author—not the reviewer. Code review isn’t a safety net for catching functionality issues.
- **We avoid over-reviewing**: Adding more layers of review slows us down without meaningfully reducing bugs. Instead, we focus on meaningful reviews that support learning and alignment.
- **We use code reviews for knowledge and culture transfer**: Through thoughtful feedback and shared context, we reinforce how we build, think, and collaborate—making code review a vital part of team growth.

The MANY Benefits of Code Review (What You Didn't Realize)

In this video, we explore the deeper value of **code review**—going beyond its obvious impact on code quality to highlight how it shapes team culture, collaboration, and continuous learning. While improving code is a benefit, we emphasize that the long-term value lies in building a stronger, more aligned engineering team.

### Key Takeaways:

- **We use code review to improve code quality**: At a basic level, reviews catch issues and lead to cleaner, more maintainable code—but that’s just the surface-level benefit.
- **We treat code review as essential feedback**: Just like feedback in any other domain, having someone else evaluate our work helps us grow—technically and professionally.
- **We build team awareness and cross-pollination**: Code reviews help teams stay aligned and aware of each other’s work, which strengthens cohesion and product velocity.
- **We learn even when no changes are made**: Valuable discussions often emerge from understanding *why* code was written a certain way, even if the final diff remains unchanged. This raises the collective standards of the team.
- **We view code review as a cultural cornerstone**: We love it so much that reviewing code became a natural, even joyful, part of our daily routine—it’s how we grow, connect, and elevate our craft.

Voicing Your Problems And Frustrations Productively

Which of these are important things to remember as you are voicing your problems and frustrations?

Is the following a good way to voice a problem: I really hate how John thinks about the product. His vision does not make sense, and it will drag down the team. You can tell that he does not have enough experience.

"I really hate how John thinks about the product. His vision does not make sense, and it will drag down the team. You can tell that he does not have enough experience." - What is wrong with how this frustration is presented?

Effective communication of concerns in a one-on-one, especially with a manager, hinges on emotional intelligence and thoughtful phrasing. Expressing discontent is important, but how it’s framed can determine whether it leads to meaningful change or defensiveness.

- **Words and tone matter deeply**: It’s not about suppressing feelings, but about communicating them in a way that leads to constructive outcomes. Saying “This is holding me back” is more impactful than “I hate this person/project/org.”
- **Start with your experience**: Begin by describing how a situation makes *you* feel and the impact it's having on your work. This avoids sounding accusatory and centers the conversation on outcomes.
- **Avoid blaming language**: Statements that target others personally are rarely received well. Instead, focus on issues and processes rather than individuals.
- **Propose solutions thoughtfully**: Even if unsure, suggesting possible paths forward shows initiative. Phrasing like “One thing I was thinking about…” or “Could we try…” keeps the conversation collaborative and open-ended.
- **Frame feedback to enable support**: Managers are more able to help when you present challenges clearly and offer context. Productive expression of frustration builds trust and often leads to faster resolution.

By being candid *and* constructive, you increase the likelihood of being heard, supported, and ultimately driving the change you seek.

You Should Be Vulnerable With Your Manager

You are feeling burnt out at work. Should you share this with your manager?

You feel like you are slower than your other teammates and are afraid that you look bad amongst the team. Should you share this with your manager?

Your dog just died, and you are having a really tough time concentrating at work because of this. Should you share this with your manager?

Here are the core points from the lesson:

- Your manager is responsible for your performance at work. Therefore, it's in their best interest to help you resolve anything that is negatively affecting your work performance, even if it's something non-tactical.
- If you are having a deeper issue (e.g. you have imposter syndrome), this is something you should talk with your manager about. You shouldn't expect them to act as a full psychologist, but they should at least be receptive of your problem and lend an understanding ear.
- Venting and complaining are very natural and can act as a therapeutic exercise. Don't be afraid to do this with your manager once you have a good enough relationship.
- This gets easier over time. Once you start being honest and more transparent in your manager meetings, the trust between you two increases, making it smoother to continue being open in the future.

Related resources:

- [\[Masterclass\] What Software Engineers Should Look For In Their Engineering Manager](https://www.jointaro.com/lesson/oeY7ncZhzJ5NO6dij5e7/masterclass-what-software-engineers-should-look-for-in-their-engineering-manager/)
- [\[Course\] Networking Guide: Build Deep Relationships Quickly In Tech](https://www.jointaro.com/course/networking-guide-build-deep-relationships-quickly-in-tech/)

Make Sure To Get This Resource From Your Manager 1 on 1s

True or false: Your performance review result should not be a surprise, and the manager 1 on 1 is an instrumental mechanism towards ensuring that.

What are some ways to get the feedback flowing in a manager 1 on 1?

True or false: A simple "Do you have any feedback for me?" is a good way to ask for feedback from your manager.

One-on-one meetings are a crucial venue for growth-focused feedback. When approached intentionally, they can drive clarity, alignment, and personal development.

- **Feedback should be mostly positive and constructive**: Many people brace for criticism, but it's just as important to highlight wins. Sharing accomplishments helps managers advocate effectively during reviews or calibrations.
- **Effective solicitation matters**: Instead of vague prompts like “Do you have feedback?”, ask targeted, open-ended questions such as “How could I have handled that project better?” or “What would you have done differently in my place?” This encourages thoughtful responses.
- **Use self-reflection as a feedback tool**: Sharing your own doubts or observations (“I felt X didn’t go well—do you agree?”) helps deepen the conversation and opens the door to more candid advice.
- **Track progress consistently**: Keeping a running one-on-one doc helps you monitor growth, reflect on past feedback, and ensure you're aligned on expectations over time.
- **Avoid surprises in performance reviews**: By using regular one-on-ones to benchmark progress and confirm you're trending toward the right goals, formal review ratings (e.g., “meeting” or “exceeding expectations”) should never come as a shock.

Manager 1 on 1s Are A Litmus Test For Seniority

True or false: In tech, operating at senior levels means that you are driving more, if not most, of the conversation in your manager 1 on 1s.

Why do senior employees tend to drive more of the conversation in manager 1 on 1 meetings?

One-on-one meetings evolve as career levels advance. A key sign of professional growth is taking ownership of these conversations and using them to drive impact.

- **Initiative reflects seniority**: If recent one-on-ones are led primarily by a manager with direction and feedback, it's likely an early-career dynamic. As experience grows, the expectation shifts toward independently setting priorities.
- **Ownership of agenda is critical**: A senior-level contributor brings a clear agenda to one-on-ones, proactively using the time to align on strategy, surface blockers, or present ideas—not just receive instructions.
- **Setting direction is the goal**: Defining one’s own work and outlining what to focus on next are hallmarks of operating at a senior level. The more someone guides the conversation, the more they demonstrate leadership and self-management.

Having The Proper Mentality For Manager 1 on 1s

True or false: Your manager is your superior, so it is on them to ask the right questions and figure out what you need in your 1 on 1 meetings. You just need to show up on time.

Why is the burden on you to set the agenda and overall plan with your manager 1 on 1s?

True or false: It is better for your career growth to view your manager as being a resource for you instead of you being a resource for your manager.

True or false: A good manager 1 on 1 involves you giving status updates and then waiting for instruction on what to do next.

- *Your manager is a resource for you.*
- Don't just see your manager as a source of authority that gives you work. While this is true to some extent, having this mentality really holds back your growth.
- Go into your manager 1 on 1s with a plan on how you can extract the most value from them.
  - This onus is on you to set the agenda for this meeting, so you can get insights from your manager on how to best improve yourself. Let them know about this agenda beforehand, so they can think about how to best help you with each point.
  - Another way of seeing this is how can you make your manager's life easier. By setting the stage for your manager, you lower the barrier for them helping you as they don't need to figure out exactly what your work life looks like and what problems you have.
- A common failure mode for earlier-in-career engineers going into manager 1 on 1s is they go in, give a status update on what they're doing, and wait for more work to be given to them.

Related resources:

- [\[Masterclass\] How To Have Impactful 1 on 1 Meetings](https://www.jointaro.com/lesson/FEK6JZqW2Jg3rdN9yeGn/masterclass-how-to-have-impactful-1-on-1-meetings/)
- [\[Course\] Effective Communication For Engineers](https://www.jointaro.com/course/effective-communication-for-engineers/)

Why Infrequent Manager 1 on 1s Severely Hurt Your Career

True or false: Delayed and infrequent manager 1 on 1s can seriously affect your career growth long-term.

Why is it crucial to have frequent, consistent 1 on 1 meetings with your manager?

Recurring one-on-ones act as a safeguard against the buildup of unresolved issues and help maintain consistent focus on career development and workplace health.

- **Prevents goal procrastination**: Infrequent one-on-ones make it easy to delay important but uncomfortable topics like career growth. Weekly cadence creates timely check-ins that keep development top of mind.
- **Creates built-in accountability**: Knowing a one-on-one is coming up each week reinforces reflection on progress and keeps both parties aligned on priorities and goals.
- **Maintains workplace “cleanliness”**: Like cleaning a home regularly, weekly meetings prevent work challenges from piling up. When issues are cleared consistently, the work environment stays healthy and manageable.
- **Supports better quality of work life**: Regular check-ins help address interpersonal or project-related friction early, reducing stress and misalignment over time.
- **Reduces communication lag**: By clearing the "trash" of misunderstandings or confusion regularly, one-on-ones create a more fluid and responsive working relationship.

What To Do If Your Manager Keeps Canceling Your 1 on 1s

Your manager keeps canceling your 1 on 1s due to a perceived lack of discussion topics, even though you always have a lot to talk about. What do you do?

Your manager cancels your upcoming 1 on 1 meeting due to an unexpected, new fire that they have to deal with. However, you have a lot of important issues to talk about. What do you do?

Proactively managing recurring one-on-ones is crucial, especially given the inherent power and time imbalance between managers and their direct reports.

- **Acknowledge the power dynamic**: Managers are often busier and have more reports, which can lead to frequent cancellations. Recognizing this helps frame a constructive response.
- **Use a shared running doc**: If a meeting is about to be canceled due to “nothing to talk about,” reference specific bullet points in a shared one-on-one document to demonstrate the agenda and keep the meeting on the calendar.
- **Reschedule thoughtfully**: When a cancellation is due to emergencies or time constraints, acknowledge the situation but follow up by proposing specific alternative time slots based on their availability.
- **Reduce their friction**: Make it easy for the manager to say yes by combining two key tactics—propose a concrete reschedule and provide the meeting agenda in advance.
- **Leverage career growth principles**: Just like with asking for support or promotions, simplifying the decision-making for your manager increases the chances of success and strengthens your working relationship.

Structuring Your Manager 1 on 1

If you are working in a strong, high-growth tech company, what is a good frequency to meet with your manager?

True or false: Managers are extremely busy, so it is best to have ad-hoc 1 on 1 meetings with them based on whenever they are able to find a sliver of free time.

Weekly one-on-ones with your manager are essential for staying aligned, especially in high-growth tech environments where priorities shift quickly.

- **Weekly cadence is ideal**: Aim to meet with your manager every week; bi-weekly is acceptable at most. Anything less frequent than that is considered a red flag for team communication and alignment.
- **30-minute standard**: A 30-minute weekly meeting strikes the right balance—long enough to discuss key topics, but short enough to stay focused and avoid bloat.
- **Avoid reactive scheduling**: Don’t wait until problems arise to schedule one-on-ones. Recurring meetings prevent misalignment and build a strong, consistent feedback loop.
- **Proactive relationship management**: Regular one-on-ones foster stronger relationships, clearer communication, and better support between you and your manager.

How To Discover Your Work Passions And Hatreds

Which of the following should you do to discover your work passion?

What of these is a legitimate, strong sign that something is a work passion for you?

- *Regularly take time to reflect on how much you enjoy your work, especially when you're earlier-in-career*.
- Write down everything you do. Here are some examples of common things software engineers do:
  - Writing code
  - Reviewing code
  - Meetings
  - Working with JIRA
  - Talking with cross-functional stakeholders
  - Fixing bugs
- Split all the items into 3 buckets:
  - Things you genuinely enjoy: Tasks/behaviors you are excited to do and can lose track of time doing them.
  - Neutral: Things you can do a good amount of, but in the end, you do it for work.
  - Chores: You *only* do it for work, and you actively try to minimize doing these as much as possible.
- From the top bucket (enjoyment bucket), try to craft your work life around that.

Related resources about soul searching and find your own path:
- ["I feel like senior engineers tend to focus on a specific area. How can I pick a specialization that's still relevant in 5-10 years?"](https://www.jointaro.com/question/xFEhcvfbJ2P0pYzZ4r6f/i-feel-like-senior-engineers-tend-to-focus-on-a-specific-area-how-can-i-pick-a-specialization-thats-still-relevant-in-5-10-years/)
- [[Masterclass] How To Choose A Good Company And Team As A Software Engineer](https://www.jointaro.com/lesson/0WEmTNZOMIh8xAdfO3JH/masterclass-how-to-choose-a-good-company-and-team-as-a-software-engineer/)

Tech Career Growth Videos

Our instructional videos provide software engineers with insights needed for career growth. Masterclasses go incredibly in-depth on a specific tech topic while case studies are real examples from established engineering leaders.