Avoid These Junior Engineer Mistakes With Code Review

In this video segment, we reflect on common mistakes and best practices around code submissions, especially relevant to early-career engineers. The discussion centers around how to be thoughtful and intentional in code reviews to earn trust and increase velocity over time.

- **We don’t treat code review as a speed game.** Moving fast at the cost of quality—like deferring fixes or separating tests from the initial diff—often backfires. We strive to bundle fully thought-out changes with tests as one atomic, reviewable unit.
- **We use RFC diffs to gather early feedback.** When we're unsure of direction, we create “Request for Comment” diffs clearly labeled as such. This helps reviewers give high-level input without getting stuck on minor details.
- **We always show proof of testing, even for small changes.** Even if our change is minimal (e.g., a refactor or doc update), we still confirm it compiles and passes existing tests to signal due diligence.
- **We think like reviewers.** Providing context, test signals, and clarity up front not only earns trust but speeds up the feedback loop and helps us land code more efficiently.

3 Ways To Write Deeper, More Impactful Code Review Comments

In this video, we explore how to give more impactful code reviews by moving beyond surface-level feedback and investing in deeper understanding and learning from experienced peers. The focus is on practical habits that help us become more thoughtful, effective reviewers.

- **We rely on automation for style and formatting.** It's not our job to catch syntax or stylistic issues—those should be handled by IDEs and CI systems with pre-agreed style rules.
- **We review code with a clear perspective.** Before reading the diff, we mentally plan how *we* would solve the same problem, which helps us offer more meaningful, constructive feedback beyond just approving what “looks fine.”
- **We learn by watching the best.** One of the fastest ways to improve as reviewers is to observe how senior engineers reject code—what they flag, how they communicate, and the patterns they look for.
- **We replicate good habits.** By studying thoughtful reviewers—like those who consistently flag performance issues like mobile frame drops—we can develop our own review instincts and level up faster.
- **We treat reviewing as an intentional skill.** There are no shortcuts; it takes practice, pattern recognition, and curiosity to become great at it. But by mimicking smart peers, we shortcut years of trial and error.

Don't Forget: Code Review Is Public And Has Huge Consequences

In this final segment, we emphasize how **code review is not just a technical exercise—it’s a public, cultural signal**. Especially for tech leads and senior engineers, the way feedback is delivered in code review has real consequences for team morale, inclusion, and career development.

### Key Takeaways:

- **We treat code review as a public cultural forum**: Comments are visible to others on the team and can impact how engineers—especially juniors or new hires—are perceived. Feedback that embarrasses someone publicly can harm confidence and even affect performance reviews.
- **We avoid harsh criticism in public threads**: If we’re truly concerned about someone’s patterns (e.g., lack of testing mindset or carelessness), we give that feedback in private, not in a code review. We follow the rule: *Praise in public, critique in private.*
- **We understand the leadership signal we send**: As tech leads, our tone sets the bar. If we leave demoralizing or curt comments, we implicitly encourage others to do the same—fostering a negative or toxic culture.
- **We handle serious feedback face-to-face**: When needed, we schedule a quick 15-minute conversation to deliver constructive criticism with nuance and care—ensuring it’s received in the spirit of growth, not shame.
- **We use code reviews to build people up, not tear them down**: Every interaction is a chance to create a safer, stronger engineering culture. We remember that what we say—and how we say it—has lasting impact.

Ultimately, we believe that **code review is leadership in action**—and great leaders use it to uplift their teams, not diminish them.

Don’t Do THIS Kind of Code Review - Healthy vs Unhealthy Comment Example

In this segment, we explore a crucial cultural principle in code review: **“You are not your code.”** The way we give feedback deeply influences team trust, learning, and psychological safety. Our goal isn’t to be “right”—it’s to help each other grow and to build a healthy, collaborative engineering culture.

### Key Takeaways:

- **We critique code, not people**: Everyone—from interns to staff engineers—writes imperfect code. We give feedback without attacking the author, always assuming good intent and shared goals.
- **We use empathy-driven language**: Ending comments with a question mark (“Have you considered…?”) or using tentative language (“This might miss an edge case…”) keeps feedback constructive and opens the door to discussion, not defensiveness.
- **We avoid destructive comments**: Terse feedback like “Did you even test this?” not only fails to help—it can demoralize authors and harm team culture. Being “right” is meaningless if it alienates collaborators.
- **We model humility, especially as senior engineers**: Seniority should amplify empathy, not authority. Even if we're confident, we acknowledge the possibility we're wrong and focus on dialogue, not dominance.
- **We prioritize helpfulness over harshness**: Great reviewers point to specific issues, offer reasoning, and invite collaboration. They focus on moving the work forward—not “winning” a debate.

By reviewing with empathy, humility, and clarity, we turn every code review into an opportunity to strengthen our team and elevate everyone’s craft.

The “Do No Harm” Principle In Coding

In this segment, we discuss the principle of **"Do No Harm"**—a foundational mindset for writing safe, reliable code. While it's great to break large features into smaller diffs, it's essential that each individual diff **stands alone** as non-destructive and does not degrade the product or infrastructure if applied independently.

### Key Takeaways:

- **We ensure every diff is safe in isolation**: Even in stacked diffs, each change must not break functionality or expose incomplete features. Every diff should be self-contained and ideally improve (or at least preserve) the integrity of the codebase.
- **We avoid relying on future diffs to patch behavior**: It's risky to land an unstable or unfinished diff assuming a follow-up will fix it. If that follow-up is delayed or rolled back (e.g., due to a production issue), the earlier diff could introduce bugs or break the app.
- **We use feature gates wisely and early**: When launching features behind flags, we gate the feature at the very beginning—not in later diffs—to avoid exposing half-baked functionality in production.
- **We’re cautious with shared infrastructure**: If a diff touches a shared module or critical system, we proactively reach out to other teams to confirm our changes won’t unintentionally break their workflows or apps.
- **We understand our code lives in a larger system**: Like parts of a giant elephant, changes in one place can affect parts we can’t see. Practicing empathy and caution helps us prevent cascading issues in complex, multi-team environments.

The “Do No Harm” principle reminds us that good engineering isn’t just about adding features—it’s about protecting trust, stability, and the broader system our code lives in.

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.

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.