Top System Design Interview Mistakes [Part 4] - Don't Introduce Tools You Don't Know

In system design interviews, it's important to avoid introducing tools you’re not familiar with, as this can lead to unnecessary challenges. This video highlights the pitfalls and best practices:

- Introducing tools you don’t fully understand can backfire, especially when follow-up questions arise
- Candidates may nervously drop buzzwords or advanced concepts to prove seniority, leading to mistakes
- We gave a demonstration of how panicking during follow-up questions can derail the interview
- Emphasizing the importance of admitting when you don’t know something, allowing the interview to move forward
- Clear communication about your knowledge level helps focus the interview on areas where you can truly showcase your expertise

If you need extra help with your system design interview, [Formation.dev](https://formation.dev/partners/taro) can provide you hands-on, personalized support. Join us here: <https://formation.dev/partners/taro>

20 Years Of Fighting Procrastination [Part 1] - Rahul's History With Procrastination

Welcome to our "20 Years Of Fighting Procrastination In 1 Hour" course! Here are the core points from the lesson:

- Your instructor Rahul Pandey goes through his personal experience struggling to get stuff done (and learning how to fix that)
- Focus on building systems that make it easy to do the right thing and hard to do the wrong thing, rather than relying on willpower
- The advice is tailored for people with autonomy over their time, not for those in reactive or manager-style roles

Manager vs. Maker schedule: <https://paulgraham.com/makersschedule.html>

[Case Study] Mentoring Junior SWEs [E3] to Senior [E5] In Just 2.5 Years At Meta

For the key points, you can find them in the slides (linked below), so the summary will be framed more as action items.

**If You're Pushing For Senior/Are Senior+ Already**

- Mentorship is a core part of healthy senior engineer behavior, so invest in it if you aren't already.
- Now you need to find good mentees. *The main thing to look for is their coachability, which largely depends on how smoothly they process feedback*.
- How can you tell if someone is coachable?
  - They go the extra mile making sure their code is clean.
  - They respond to code review comments (particularly yours) with enthusiasm and speed. They're hungry to learn more and go deeper into feedback on their code.
  - They go out of their way to help others as opposed to many people who just help reactively (or not at all).
  - They have a good cadence with you when you spend time with them (e.g. it's easy to have a fun conversation with them over lunch).

**If You're Mentoring Other Engineers**

- *If the extent of your mentorship is that you answer a lot of your mentee's question, you're not truly a mentor.*
  - True mentorship is being proactive and having a clear vision for what your mentee will become. Create a growth plan for them to get to the next level and outline deltas to make it clear.
- If you haven't already make sure that your manager and the manager of your mentee (if they're on a separate team) are aware of your involvement. This is vital for getting proper credit and not growing them incorrectly.
- Your mentality should be that you serve your mentee, not the other way around.
- To build a ton of trust quickly, tell your mentee this: *"No matter what happens, I'll do whatever extra work is necessary to make sure that you're okay."* You are majorly responsible for your mentee's well-being.
- Always call out when your mentee does good work, even if it's something small like a well-written commit. Do it in your 1:1 where it has more gravity. Showing appreciation as a trust/morale building technique is *severely* underutilized.

**If You're A Mentee Looking For A Mentor**

- Show strong gratitude for code review comments on your commits. Don't just give them a thumbs up or worse, silently make the change. For deeper feedback (often times coming from senior engineers who you want to mentor you), go the extra mile giving thanks.
- Put yourself out there: Don't be a hermit. Go to team lunch, offsites, coworking - Become known as a friendly face within your team. Strike up conversations with engineers more senior than you just to get to know them.
- Strive to write good code. It can scary as a junior engineer in particular and default to churning out tickets as fast as possible with bare minimum quality; avoid that instinct and try to spend an extra 30 minutes to 1 hour trying to build things out properly (and then talk about your thought process on your pull requests). You want to show senior+ engineers that your hunger to be an actually good software engineer instead of a commodity coder is there.

Related Resources:

- [Presentation Slides](https://docs.google.com/presentation/d/12OelIHF08oBZwe-TzVlz8fqp4WiOTem_e9KsGe7X8XA/edit?usp=sharing)
- [Meta E4 To E5 Growth Plan (Pretty Applicable To Any Large Company)](https://firebasestorage.googleapis.com/v0/b/tech-career-growth.appspot.com/o/articles%2Fmeta_e4_to_e5_growth_plan.pdf?alt=media&token=e13d88fd-9356-4c20-a229-cf0cad78a9af)
- ["How do you get the most out of mentorship?"](https://www.jointaro.com/question/IbuZydz0QzsVVqESVaxQ/how-do-you-get-the-most-out-of-mentorship/)

Maximize Your Productivity As A Software Engineer [Part 4] - Stay The Course

It's incredibly easy to get distracted with random incoming tasks, especially at a fast-paced company like FAANG. This lesson teaches you:

- The importance of staying the course and sticking to your high-impact, ruthlessly prioritized tasks
- How to diplomatically push back and say "No" (saying "Yes" to everything is one of the easiest ways to destroy your productivity as a software engineer)

How To Get FAANG Interviews

Getting into FAANG is the dream of most software engineers in the world. However, it's much easier said than done, and there's a lot of misinformation about what Big Tech companies look for in interview candidates.

Here are the main points from the video:
- **It's near impossible to break in as a junior dev** - The demand (i.e. the number of junior engineers looking to break into FAANG) far outstrips the supply (the number of L3 and SDE 1 level FAANG openings). If you don't have a warm lead like a strong referral, a DEI program you qualified for, a Big Tech internship to covert, or a career fair at your prestigious university, you can easily spend hours applying into a black hole. *If you've already tried many times and you can't get in, just stop.* 
- **You don't need to get into FAANG right now** - Your career is a marathon, not a sprint. You can get into FAANG later in your career; don't compare yourself to others who made it in early and become obsessed with Big Tech. Focus on growing yourself as a software engineer, and you will eventually make it in.
- **Get past 2 YOE** - If you live in a relevant geography (e.g. SF Bay Area, London) and have more than 2 years of experience, Big Tech companies will generally start reaching out to you. This is because hiring junior engineers is very risky, and Big Tech generally likes to rely on converting interns to fill out that pool. Once you cross 2 YOE, you are considered mid-level and a more worthwhile hire.
- **Build massive side projects** - There is one "nuclear" level you can pull if you really want to get into FAANG ASAP, and that's making a side project with 10k+ users. Alex was able to do this, and he knew a few college dropouts who got into FAANG early doing the same. [Here's our masterclass on how Alex built side projects with 500k+ users](https://link.jointaro.com/fGuprKS4HT7VpVBL9).
- **Make major open-source contributions** - Big Tech has very strong open-source culture, so they have a lot of public libraries you can contribute to on GitHub. They monitor the pull requests into these libraries for potential talent, and many engineers get in that way. However, this is much easier said than done, and side projects are generally more approachable for junior software engineers.

Related resources:
- [The Pros And Cons Of Working At FAANG And Big Tech](https://link.jointaro.com/bw1bEKRxmZPXKiQP9)
- ["What technologies or stacks should I create a project to add in my resume for entry level software jobs?"](https://link.jointaro.com/A9Vugp1jcNQEsvaMA)
- [How To Ace Your Big Tech Interview [Data Structures & Algorithms]](https://link.jointaro.com/iTNxPCvkdGite4wT9)

Master The Behavioral Interview [Part 3] - The 3 Keys To Behavioral Interviews

In a behavioral interview, you can say literally anything. So what should you say? This lesson teaches you:

- The 3 keys to any effective behavioral interview answer
- How to specifically show each of the 3 keys
- What a good behavioral interview answer looks like vs. a bad one (hint: the good ones integrates the 3 keys while the bad one doesn't)

To learn how Alex built 30 side projects with 5 million+ users combined: [\[Taro Top 10\] Building Impressive Side Projects](https://www.jointaro.com/playlist/vKUWMgmmaEvzcYUXZs4B/)

How Do Effective Engineering Leaders Help Their Teams Achieve More?

3 questions engineering leaders ask to increase the impact of their team without burning the midnight oil: 

1. What parts of this project are most critical? Who is most important for success? 
2. Can I optimize/shortcut some part of this project? 
3. Can I propose scope reductions for this project? 

Rachel also talks about the iron triangle often used for project management (time, scope, cost).

For more resources on engineering leadership:
- [This Is Why Most Engineering Managers Are Terrible](https://www.jointaro.com/lesson/4NJbAn0uTDUPfYfa859V/this-is-why-most-engineering-managers-are-terrible/)
- [[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/)
- [[Case Study] Becoming A Tech Lead Again In Just 1 Month After Joining Robinhood From Meta](https://www.jointaro.com/lesson/X8vpfJooDpsX915ouC00/case-study-becoming-a-tech-lead-again-in-just-1-month-after-joining-robinhood-from-meta/)

How To REALLY Level Up Your Coding Ability With Side Projects

There is no secret to getting better at coding: As a software engineer, you will become faster at coding when you write more code. This is where side projects can really come in.

Here are the core points from the video:
- **Side projects are a productivity "hack"** - They allow you to write more code without overworking yourself. The self-guided, free nature of side projects essentially make them a hobby that also helps your performance at work.
- **When to consider side projects** - There are 2 factors that make this lever far more powerful:
  - You work at a startup: Startup code will be much more "vanilla" and closer to the code you find online. This means that it won't be too different from side project code.
  - You work on the front-end: If you're a web/iOS/Android developer and are working with pixels on screen, this puts you in a great position to do side projects as your work is inherently more sharable.
- **Side projects develop other important skills** - On top of raw coding, side projects also help you dabble in the skills of product managers, designers, data scientists, user researchers, and a whole lot more since you own the product entirely. These skills are also important for software engineers, especially those pursuing senior levels.

This highlight is from our masterclass about becoming a better coder. You can watch the full video here: [[Masterclass] How To Write Better Code Faster As A Software Engineer](https://www.jointaro.com/lesson/iYpRj8XfyzCSaTYnce3y/masterclass-how-to-write-better-code-faster-as-a-software-engineer/)

Related resources:
- [[Masterclass] How To Come Up With 100k+ Users App Ideas You Can Build For Free](https://www.jointaro.com/lesson/AI4zi759PSGn6RwIFT6f/masterclass-how-to-come-up-with-100k-users-app-ideas-you-can-build-for-free/)
- [[Masterclass] How To Build And Grow Tech Products To 500k+ Users For Free](https://www.jointaro.com/lesson/OEuX0KMhcnNSTJ50Voee/masterclass-how-to-build-and-grow-tech-products-to-500k-users-for-free/)
- ["What technologies or stacks should I create a project to add in my resume for entry level software jobs?"](https://www.jointaro.com/question/c0DiG5ureLbkZ1mKD9Rf/what-technologies-or-stacks-should-i-create-a-project-to-add-in-my-resume-for-entry-level-software-jobs/)

Growing To Meta Tech Lead And Then Entrepreneurship - By Jocelin Ho

If you use WhatsApp web, level up your experience with the Cooby (the company Jocelin is cofounder and CTO of) plug-in: [Cooby: Best WhatsApp Extension for Work](https://chrome.google.com/webstore/detail/cooby-best-whatsapp-exten/hcikfoejbgdmajlbhadhfchoekcoablm)

To level up your software engineering knowledge, follow Jocelin on LinkedIn: [Jocelin Ho - LinkedIn](https://www.linkedin.com/in/jocelinho/)

Jocelin's presentation is **filled** with gems (including a fun video by Mark Zuckerberg), so we're just going to share her core learnings here:
1. **You need to be versatile to survive** - One of the biggest misconceptions about software engineering is that it's mostly about writing code: This couldn't be further from the truth. In order to be a genuinely stellar engineer, you need to have a vast array of skills on top of coding like communication, the ability to smoothly process feedback, multi-tasking, and much more. Jocelin excelled at developing these skills, which is why she was able to get promoted from E3 -> E4 at Meta (junior -> mid-level) in just 6 months, faster than 95% of FAANG engineers.
2. **Don't get emotionally attached to what you built** - Tech is always fast-moving and chaotic, and this is accentuated when you work at a top company like Meta. Organizational priorities change all the time, and this can mean that your hard work gets thrown out. Don't take it personally and continue striving to deliver impact and grow.
3. **Don't be afraid to take the leap** - You will literally never be ready for that big career or life change, whether it's taking your first FAANG interview, switching to management, or starting your own company. Once you have conviction in knowing what you want to do, make that jump and focus on growing and adapting as fast as possible. It's not about where you are now but rather where you can go in the future.
4. **Live up to your own expectations instead of others'** - While we should always try to add value to other people's lives and help one another, this doesn't mean we should derive our happiness from what they believe we should be. You own your own happiness - Set goals that are both feasible and exciting for you and ignore all the noise. This is especially relevant in tech where there's so many brilliant people, and it's tempting to compare yourself to others.

Related resources:
- ["What's the core insight behind quick growth?"](https://www.jointaro.com/question/nJ762p255cGyuth36H6w/whats-the-core-insight-behind-quick-growth/)
- [[Taro Top 10] Junior Engineer To Mid-Level Engineer (L3 To L4)](https://www.jointaro.com/playlist/iBKHYpkjd0BRWWLKQG2j/)
- [Presentation slides](https://docs.google.com/presentation/d/1BkaaiKQXXx6eUi5heaNiNmPgBriK9rr5UdTfHfd2K5k/edit?usp=sharing)

Managing Up: Introduction

Managing up is the skill of building ethical and effective relationships with your boss and senior peers. This course will teach you how to do that.

- Connect with [**Ethan on LinkedIn**](https://www.linkedin.com/in/ethanevansvp/)
- Taro members get a discount to join [Ethan's Level Up community](https://levelupwithethanevans.substack.com/taro25)

[**Ethan Evans**](https://www.linkedin.com/in/ethanevansvp/) is a retired Amazon Vice President, now sharing his leadership expertise.

He spent 12 years in startups (10 in leadership roles), and then had a 15 year career at Amazon. He has led global teams of 800+ and products with annual revenue above $500M. He holds over 70 patents.

What Software Engineers Don't Get About Clean Code

Back at Instagram, Alex was able to grow very quickly. This was largely due to his coding ability. In his 1st half at Instagram, he pushed \~125 commits to production. In his 2nd half, he pushed \~185 commits to production. In his 3rd half, he pushed \~275 commits to production, making him a Top 5 code committer within his org of 50+ software engineers.

Here are the core points from the video:

- **You don't need to sacrifice quality for velocity** - This is one of the biggest misconceptions about code. You can both write a lot of code while keeping the polish high. In fact, high code quality and velocity naturally go hand-in-hand.
- **Messy code is a defining trait of a weak SWE** - 99% of bad software engineers have poor code quality, and conversely, you will rarely meet a high-performing software engineer that puts out messy code. Optimizing your code quality is one of the most powerful ways to avoid being a low performer, especially if you work at FAANG or Big Tech in general where the scale and stakes are much higher for code.
- **80/20 rule applies to code quality** - It usually doesn't make sense to cover 100% of edge cases, but you can generally cover \~80% of them with \~20% of the maximum effort, even if you're a tiny startup. Don't make excuses for broken, unreadable code by saying "We have to move fast"; strive to find that 80/20 path.

Related resources:

- ["What's the difference between a low performer software engineer and a high performer?"](https://www.jointaro.com/question/nMxx2EMVIlJbl1oK4SGu/whats-the-difference-between-a-low-performer-software-engineer-and-a-high-performer/)
- ["How can I write great code faster?"](https://www.jointaro.com/question/ciE9a2TZ7rZNyYP8HbeJ/how-can-i-write-great-code-faster/)

System Design Series: Taro Playlists [Part 4] - Covering Edge Cases

The tactics are covered in the doc linked above, so this summary will focus on the "meta" context behind this part and additional commentary:

- You should *always* at least try to cover all the edge cases when building out a product, even if you're a small startup.
  - If you're at Big Tech in particular, you absolutely need to have amazing coverage on edge cases as even an issue affecting just 1% of users could be breaking the experience for 10 million+ people.
- A lot of edge cases are quite easy to cover and are low-hanging fruit. Bad engineers will be lazy and ignore these, supposedly in the name of velocity.
  - **Example:** You have a login form that takes in email. Instead of no-oping, throwing a generic error, or letting them login with an invalid email, validate the email upon submission and show an error message if it's invalid. This will almost always be a 5-10 minute change.
- There's many "playbooks" of edge cases, so coming up with edge cases isn't rocket science - It's largely a solved problem. Here are some examples:
  - **Generic edge cases that apply to any user input:**
    - Input is blank
    - Input is overly long
    - Input is very strong
  - **Generic edge cases that apply to any content collection:**
    - No content
    - A lot of content
    - Content fetch fails
- *Being very diligent around edge cases is also crucial for interviews, both DSA and system design, and is often how Big Tech interviewers differentiate the great candidates from the mediocre ones.*

You can [find the full system design doc here](https://docs.google.com/document/d/15WaM8Ojan82g0m2mtz6kC2Hiyj0Q6VbjfqRmVNDI3qw/edit?usp=sharing) - Feel free to use it as a template for when you're designing systems at your job!

DSA Crash Course [Part 8] - Anagrams Approach

In this lesson, Alvin explores the strategy to solving the following interview problem:

> Write a function, *anagrams*, that takes in two strings as arguments. The function should return a boolean indicating whether or not the strings are anagrams. Anagrams are strings that contain the same characters, but in any order.

```
anagrams('restful', 'fluster') # -> True
```

```
anagrams('cats', 'tocs') # -> False
```

```
anagrams('monkeyswrite', 'newyorktimes') # -> True
```

```
anagrams('paper', 'reapa') # -> False
```

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). You can try out the concepts yourself in their interactive code editor and learn advanced DSA patterns like stack exhaustive recursion.

Use [**this link to get 20% off**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: <https://www.linkedin.com/in/alvin-zablan-b73a92117/>

Noob Software Engineer vs. Pro Software Engineer

The best software engineers proactively front-load the work to write clean code. They do this by planning ahead to find the best approach and taking the time to "dress up" their code review really well.

Here are the core points from the video:
- **Noob Engineer** - Their goal is just to get the code to work. As soon as they get the happy flow functional, they submit the code for review. Their pull request doesn't have good context attached, and the test plan isn't thorough at all. They have to go through many revisions of teammates rejecting their code before they can finally land the commit. After it's landed, there's a high chance it breaks, and now they have to go back to their code to patch it up (or hard revert it).
- **Pro Engineer** - They come up with a plan to implement the best approach and vet it with their teammates. They make sure the code is polished and covers edge cases thoroughly before submitting the pull request. Their PR clearly explains the purpose of the code and has a very detailed test plan demonstrating what it does. Their teammates quickly and smoothly read their code and accept it on the first try. The pro engineer is able to land their commit shortly after submission, and the entire process was smooth for everyone. The pro engineer's reputation within the team grows with every masterful commit they push to production.

This highlight is from our masterclass on "How To Write Better Code Faster As A Software Engineer". [Click here to watch it.](https://link.jointaro.com/v6zEgUfQTxoSj33Z7)

Related resources:
- [One Diff, One Thesis - What Every Code Review Should Be Like](https://link.jointaro.com/5Ehehxt6jBR42ui1A)
- ["What can I do to quickly build my reputation as a junior engineer?"](https://link.jointaro.com/hxCTvumsQhUqRAbn6)

Explaining Your Experience In A Meaningful Way On A Resume

Is this a good resume snippet: Worked on the SIVAD system, using Room, AndroidX, Activities, and Java

How do you make the experience portions of your resume stand out?

Is this a good resume snippet: Champion for unit test coverage for Cool Company's iOS app, increasing it by 20% and reducing the amount of new iOS user issues by 10%

What is the main way people struggle with their resumes?

Is this a good resume snippet: Led the JavaScript migration effort with strong communication, architectural, and code quality skills

- The most common way resumes struggle is that they tell instead of show
- Here's an example:
  - **Telling:** Added unit tests to the Android app with JUnit and Java
  - **Showing:** Increased test coverage of the Android app by 80%, which reduced bug tickets from users by 50%
- In a nutshell, don't just say what you did - Adding an adjective like "great" doesn't automatically make your feat impressive. Prove that you did something great by talking about how you did it and the actual result (which is ideally business impact).
- This method of communication is especially important for resumes as their audience is mainly non-technical: Recruiters. They aren't going to understand the more specific tech buzzwords. You need to write things in more "plain English", so that your accomplishments can be understood as impressive by almost anyone.

Related resources:

- [\[Course\] Get More Interviews: Write A Stellar Resume As A Software Engineer](https://www.jointaro.com/course/get-more-interviews-write-a-stellar-resume-as-a-software-engineer/) - By taking the course, you get access to Alex's most recent resume!
- [Your Tech Resume Should Look Boring](https://www.jointaro.com/lesson/WFJYebwJW2rhviTrQrB3/your-tech-resume-should-look-boring/)
- ["What high-impact achievements should a full-stack engineering intern target for a stronger resume?"](https://www.jointaro.com/question/cnEgJuQMKI3G4rqhEkp4/what-high-impact-achievements-should-a-full-stack-engineering-intern-target-for-a-stronger-resume/)

15 SWE Years In 1.5 Hours [Part 2] - Learning How To Code

In order to become a software engineer, you need to learn how to code. This lesson teaches you:

- The optimal way to use tutorials
- Why tutorials can easily start *hurting* your learning progression
- The dubious value of books when it comes to learning how to code
- An incredibly effective and altruistic way to truly learn technical material

Follow the advice here to understand any new codebase fast: ["What is the effective way to understand new repository in order to make the required changes in that repo?"](https://www.jointaro.com/question/KoxB3UU2zWC9pdYU6Rx0/what-is-the-effective-way-to-understand-new-repository-in-order-to-make-the-required-changes-in-that-repo/)

Level Up Your Code Quality As A Software Engineer [Part 4] - What ACTUALLY Makes Code Good

Code quality is one of the most misunderstood topics in software engineering due to a combination of engineering laziness and misinformation. This video will teach you:

- What ACTUALLY makes code good and high-quality and why we're even software engineers to begin with
- How to have proper empathy for the end-user
- The common mistakes software engineers make when determining how good code is, including a very common misconception about how FAANG works
- The true value of clean code patterns and how they add value to the end-user instead of just being buzzwords (that can potentially make the code worse when used incorrectly)
- The #1 guiding principal when it comes to writing truly high-quality code

The Real Pros And Cons Of Working At FAANG And Big Tech

Working at FAANG and Big Tech is general is put on a pedestal by the vast majority of the industry, but it's not all sunshine and roses. Here's the complete pictures:
- Pros:
  - **Prestige** - If you don't already have one of these names on your resume, adding one makes it 10x better automatically.
  - **Compensation** - This one is the most obvious: These companies pay extremely well.
  - **Consistent foundation** - The biggest one is the learning, especially for earlier-in-career software engineers. It is hard to go into these companies, do well there for a couple years, and not come out as a significantly better engineer. You will get more consistency by setting a baseline for your compensation and level.
- Cons:
  - **Hard to find scope** - In particular, growing to senior can be difficult. So many of the hard technical problems at these companies are already solved, and there are thousands of super talented software engineers looking for scope as well.
  - **You're just a cog in the machine** - At FAANG, you are one talented engineer out of literally 10,000+. The majority of engineers will be doing very incremental work that doesn't feel very fulfilling - There are literally engineers whose job it is to optimize a single button. This is all very connected to the aforementioned con of not being able to find scope.
  - **Work-life balance is dicey** - These companies pay you well for a reason: The bar is high. It can be stressful and tiring to meet expectations, especially if you're transitioning from a non-FAANG company.
- It's also important to remember that you need a much more holistic set of skills on top of coding most of the time to succeed at these companies. For many, this is a pro as it leads to more well-rounded growth, but for others who want to focus more on being builders, it can be incredibly draining.

For a deeper look into what life at FAANG is actually like, join us for our upcoming event: [Should You Work At FAANG? - What Big Tech Is Like For Software Engineers](https://www.jointaro.com/event/should-you-work-at-faang-what-big-tech-is-like-for-software-engineers/)

This clip was taken from our [1.5 hour masterclass on finding the best company/team for you, which you can click here to watch](https://link.jointaro.com/F4DDyKfuo3hMhj868).

Related resources:
- [Why You Should Start Your Career At A Big Tech Company](https://link.jointaro.com/9k3HkgfJsTp1Nd2w5)
- ["What's the difference between Big Tech and startups in terms of learning and growth?"](https://link.jointaro.com/n57gbTWERveGTQuM9)

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.

[Become A Go-To Person 1/18] How This Course Works

A course by [Jordan Cutler](https://www.linkedin.com/in/jordancutler1/), Senior Software Engineer at Pinterest and Author of the [High Growth Engineer Newsletter](https://read.highgrowthengineer.com/)

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.