How To Actually Learn Software Engineer Skills

A very common trap among software engineers is that they end up merely acquiring knowledge instead of actually learning software engineer skills. This is especially true when you're onboarding into a new team or company.

Here are the core points from the video:
- **Learn how to fish** - If you are growing as a software engineer, you want to make sure that you're actually learning the systems underneath instead of just acquiring surface-level solutions to your problems. "Receiving fish" is knowing that solution X solves your problem Y. "Learning how to fish" is understanding how solution X was crafted.
- **Get maximum value per answer** - Learning is largely absorbing support from other software engineers. When this happens, make sure to deeply understand how they arrived at their support. This can be when they give you an answer to your question or leave a comment on your pull request. *Ask follow-up questions to "download" their thought process.* It's much better to take full advantage of each interaction all in one go, so you don't need to ask them other simple questions in the future.
- **Example:** A teammate helps you debug. You can ask them the following:
  - How did you identify the breaking code?
  - Why did you choose this approach for the fix vs. others?
  - If you couldn't understand the code immediately, how did you figure out who to ask to get this understanding?

This clip is from our masterclass on how to succeed at a new team or company as a software engineer. [Click here to watch the full thing.](https://link.jointaro.com/9sJzfDeH3JdWzZRg9)

Related resources:
- [This Is How Software Engineers Should Initially Learn](https://link.jointaro.com/hoL4o29S3YsGsR9i7)
- [Building Software For Optimal Learning Example - Login Flow](https://link.jointaro.com/BjyeKesdaZt7SrwJ8)

Ace The ML System Design Interview [Part 4] - Data

Data is the foundation of machine learning, and a thorough discussion of data is essential in any machine learning system design interview. Here are the core points from this lesson:

- Discuss labels, features, and data set splitting, understanding the trade-offs involved in each area
- Explore various methods for generating data labels, such as human annotation, synthetic data, and LLMs, while considering the pros and cons of each approach
- Focus on high-level feature sources, providing relevant examples and selecting predictive features while avoiding sensitive topics
- Understand feature encoding techniques, such as one-hot encoding and embeddings, and their impact on model performance
- Weigh the trade-offs between cross-validation and train-validate-test splits, while considering issues like data leakage and imbalances in the data set

If you like what Ilya has to say, subscribe to his YouTube for more high-quality ML/AI career guidance: [MLEpath - YouTube](https://go.mlepath.com/taro-youtube-mlepath)

If you want hands-on support from Ilya to crack the FAANG ML interview, join his coaching program: [MLEpath - Coaching Program](https://go.mlepath.com/taro-march-25)

Ace Your Tech Interview As A Software Engineer [Part 22] - Behavioral Interviews

Behavioral interviews are omnipresent across software engineer interviews. They are also excellent at filtering out problem candidates. This lesson teaches you:

- When you can see behavioral interviews
- What the purpose of behavioral interviews is
- Why software engineers often underappreciate and underrate behavioral interviews, leading to their failure
- Why behavioral interviews are the *most important interview round in any hiring loop*
- The 3 core principles you should always have in mind when answering a behavioral interview question

To master the behavioral interview, follow the resources here: [\[Taro Top 10\] Behavioral Interviews](https://www.jointaro.com/playlist/IPFmEPUhAmizNe9ZUWV5/)

Alex's blog post about behavioral interviews: [Software Engineer Interview Guide - Behavioral Questions](https://www.jointaro.com/blog/software-engineer-interview-guide-part-2-behavioral-questions/)

Making Every Single Meeting You Have Effective

What do you absolutely need to do with every single meeting in order to make it effective?

What is the most important question you should be asking yourself constantly during a meeting?

Setting clear goals for every meeting ensures focus, alignment, and efficiency. Rather than drifting through discussions, this mindset helps make the most of everyone's time.

- **Define the meeting goal upfront**: Whether the goal is to build a relationship, align on a decision, or explore a specific topic, clarify it before stepping into the meeting.
- **Hold the goal in mind throughout**: Actively track whether the conversation is moving toward the intended objective—even as you engage in real-time dialogue.
- **Course-correct if needed**: If the meeting strays off-topic or stalls, use the goal as a guidepost to refocus the discussion or adjust expectations.
- **Reflect afterwards**: Evaluate whether the meeting achieved its intended outcome. If not, determine what adjustments can improve the effectiveness of future meetings.
- **Build the habit**: With consistent practice, goal-oriented thinking during meetings becomes second nature, enhancing both productivity and influence.

Become An Open Source Master [Part 4] - Open Source Terminology: Projects, Repos, Issues, PRs

We'll focus on GitHub, a popular platform for open-source software, to understand key terms and concepts.

- Projects and repositories (repos) are the core units of open-source projects on GitHub.
- You can view source code, metadata, and community activity within a repository.
- Issues are used to report bugs or request features, while pull requests propose code contributions.
- Pull requests are reviewed and discussed by the community before being accepted into the project.

Connect with James: 

- GitHub: <https://github.com/jamesgpearce>
- Twitter (X): <https://twitter.com/jamespearce>

Ace Your Tech Interview As A Software Engineer [Part 14] - Referrals

Having a current employee put you into their hiring pipeline via a referral is one of the most powerful ways to level up your job search. However, referrals are often misunderstood by software engineers. This lesson teaches you:

- The 2 different types of referrals and which one is better (spoiler: engineers usually struggle getting the better one)
- The massive difference between *weak referrals* and *strong referrals*
- Why you are more special than you realize and how you can leverage that to get more strong referrals
- How to approach professional networking properly to cultivate huge amounts of strong referrals over time

To help you get strong referrals, check out our networking course: [Networking Guide: Build Deep Relationships Quickly In Tech](https://www.jointaro.com/course/networking-guide-build-deep-relationships-quickly-in-tech/)

15 SWE Years In 1.5 Hours [Part 13] - The Secret To Growing Fast

Getting better isn't about which AI tool you use or what books you read or even which company you work for. How fast you improve comes down to one fundamental skill that most people struggle with. This lesson teaches you:

- Why feedback is the fuel for rapid engineer growth
- How many engineers respond incorrectly when it comes to getting feedback
- The right mentality to have when it comes to feedback overall
- Why an incorrect piece of feedback can actually be a good thing

Ace Your Tech Interview As A Software Engineer [Part 28] - How Much LeetCode Should I Grind?

If you're this deep in the course, you now know that grinding 1,000 LeetCode problems doesn't lead to a Google hiring manager magically appearing on your doorstep with a fresh offer letter in hand. This lesson teaches you:

- Why data structures and algorithms are more damaging to the overall health of a job search than software engineers realize
- Exactly how over-indexing on data structures and algorithms and LeetCode completely destroys the job search of many software engineers
- The framework you should apply on whether you should be grinding LeetCode

Senior Staff Engineer (L7) Describes Most Important Skill - Rahul Malik

Rahul is a Senior Staff Engineer at Meta.

- **Most important skill**: dealing with ambiguity and working through others. Senior Staff Engineers operate in a broad space, so they have to be independent enough to make impact without a specific problem.
- **Advice**: figure out how decisions are made. Who makes the decisions, and what is the underlying value system?

Here's the full playlist asking engineers what the most important skill is for their level: [Asking 7 Levels Of Engineers The Most Important Skill](https://www.jointaro.com/playlist/J9Io5lDGaYUpI8vGrUyI/)

Helpful links:
- [SWE2 --> Principal Eng in 4 years](https://www.jointaro.com/lesson/Lvf1TDKt1R4ZJSCr9BVv/rockstar-software-engineer-story-sw2-greater-principal-in-just-4-years/)
- Taro's top 10 to get promoted from [senior to staff engineer](https://www.jointaro.com/playlist/YD8LMCSlE71VUGUbNAWM/)
- [David Pan on what makes a great tech lead](https://www.jointaro.com/lesson/uHqZZ15SK19MatEvLSO6/what-makes-a-truly-great-tech-lead-a-vp-of-engineerings-perspective/)
- [Rahul on LinkedIn](https://www.linkedin.com/in/rahulbmalik/)

Ace Your Tech Interview As A Software Engineer [Part 6] - Having The Right Mentality

A lot of software engineers actually have all the necessary skills to pass the interview - They just choke when the time finally comes. Why is that? Well, let's dive into why. This video teaches you:

- The terrible unhealthy mentality software engineers often have going into tough tech interviews, particularly with top companies like FAANG
- What mentality you should have instead to unlock your full potential and why it's hard to ascend to this level of mental clarity
- How having the right mentality greatly improves your interview performance, far more than any amount of preparation ever can

Maximize Your Productivity As A Software Engineer [Part 8] - Touch Grass

Let's be real: Most software engineers are out of shape. While this isn't too bad early on, things quickly get worse. This lesson teaches you:

- How to get into exercising as easily as possible
- The many benefits of regular exercise
- A way to hack your brain to make yourself more likely to exercise

Maximize Your Productivity As A Software Engineer [Part 13] - Decomposition

When you get a huge project as a software engineer, it's easy to get overwhelmed and just sort of... do nothing (or close to it). This lesson teaches you:

- What a well-decomposed project looks like with a concrete example
- How decomposing projects hacks your brain to make it more motivated and productive

To dive deep into tactics on decomposing projects, check out our in-depth explainer: ["How do I make software less overwhelming?"](https://www.jointaro.com/question/YseMPDw538jhyS1MWlTs/how-do-i-make-software-less-overwhelming/)

Learn from the code quality course here: [\[Course\] Level Up Your Code Quality As A Software Engineer](https://www.jointaro.com/course/level-up-your-code-quality-as-a-software-engineer/)

Maximizing a Severance Package 3/9 - Termination Circumstances

Let's talk about the different circumstances where you may need a package or to try and get a severance from a company.

- 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)

DSA Crash Course [Part 20] - Sum Numbers Recursive Approach

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

> Write a function *sum_numbers_recursive* that takes in an array of numbers and returns the sum of all the numbers in the array. All elements will be integers. Solve this recursively.

```
sum_numbers_recursive([5, 2, 9, 10]); # -> 26
```

```
sum_numbers_recursive([1, -1, 1, -1, 1, -1, 1]); # -> 1
```

```
sum_numbers_recursive([]); # -> 0
```

```
sum_numbers_recursive([1000, 0, 0, 0, 0, 0, 1]); # -> 1001
```

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/>

Figuring Out What Matters In A Codebase

In a large codebase, the code will follow the Pareto Principle (the 80/20 rule): 20% of the components account for 80% of the impact. So your goal as the engineer is to spend most of your time on the 20% of code that matters to the business and matters to your coworkers.

How do you figure out where that 20% comes from?

- Talk to people
- Use blames to find hotspots
- Look for patterns in code reviews
- Look at past alerts and what triggered them

Onboarding Tips For Senior+ Engineers

As a Senior Engineer (or Staff or Principal) coming into a new company, there will be some expectation that you are bringing in domain knowledge. Your opinion can be valuable. A few ways to have immediate impact:

- Contrast how your current company operates compared to past companies
- Ask questions about why certain processes exist or don't exist

As you ramp up, remember to "**respect what came before.**" You don't want to disparage existing systems without realizing that it was best designed at the time of construction with the constraints and knowledge *at the time*.

As a senior engineer, you also need to lay the foundation for team and org-level impact. This means you invest extra time in building relationships and meeting other senior/staff/principal engineers.

Senior Engineer video from krazam: <https://www.youtube.com/watch?v=eSqexFg74F8>

Level Up Your Code Quality As A Software Engineer [Part 19] - Code Review Feedback

If you want to grow lightning fast as a software engineer, you need code quality feedback. This is the primary goal the entire "Pull Requests" section of this course is building up towards. This lesson will teach you:

- The algorithm for leveling up incredibly quickly as an engineer, especially for junior and mid-level engineers
- How NOT to respond to code review feedback
- How to gracefully respond to code review feedback to maximize your learning and deepen relationships with your teammates by going through an in-depth example

If you want to dive even deeper into code review, check out our masterclass: [\[Masterclass\] How To Do Amazing Code Review](https://www.jointaro.com/lesson/rhRFh49oouaUDhWUvkQb/masterclass-how-to-do-amazing-code-review/)

Meta Case Study - Debugging A Massive Production Issue

Here we go through an example bug at Meta. Given the information, we need to figure out what kind of root cause is behind the issue. This case study shows:
- Why it's important to understand the blast radius of a bug
- How knowing the context behind a bug can help you locate the problem area
- The value of having robust analytics

This video is a clip from our debugging masterclass. You can watch it here: [[Masterclass] How To Become A Debugging Master And Fix Issues Faster](https://www.jointaro.com/lesson/ioR6WzamAIUTpySLAr7o/masterclass-how-to-become-a-debugging-master-and-fix-issues-faster/)

Related resources:
- [[Case Study] Solving A Multi-Million $$ Instagram Bug](https://www.jointaro.com/lesson/WYk4J05iBqOuPtD0CYKX/case-study-solving-a-multi-million-dollardollar-instagram-bug/)
- ["How can I become more independent and better at unblocking myself with tricky technical issues?"](https://www.jointaro.com/question/QhqQQGrDgFjZbqohpKe0/how-can-i-become-more-independent-and-better-at-unblocking-myself-with-tricky-technical-issues/)
- ["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/)

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.

Become A Debugging Master [Part 3] - Debugging Is A Premium Skill

Debugging is one of the most difficult yet valuable skills you can develop as a software engineer. Here are the core points from the lesson:

- Debugging isn’t just one skill—it involves asking sharp questions, deductive reasoning, clear communication, systems thinking, and holistic understanding
- As AI-generated “vibe coding” becomes more common, engineers who can deeply understand and fix code will become even more valuable
- Successful debugging requires patience and true technical mastery, far beyond just prompting an AI or relying on automated solutions
- Beyond fixing bugs, top engineers also prioritize which bugs matter most, combining technical problem-solving with smart decision-making for maximum impact

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.