Adam’s Advice to His Younger Self

In this final lesson, **Adam Ernst**, Software Engineer at **Meta**, reflects on his career journey and the advice he would give to aspiring engineers. Looking back, Adam believes he would not change the path he took because it aligned with his genuine interests and strengths. He emphasizes that long-term success comes from enjoying the work itself—especially the challenge of solving difficult problems—rather than chasing titles or following trends. By pursuing work that naturally fuels curiosity and motivation, engineers are more likely to sustain high performance and meaningful career growth.

- **Follow Work You Genuinely Enjoy:** Adam believes the best career decisions come from pursuing work that you find intrinsically rewarding. Passion creates the motivation needed to continually learn, improve, and produce high-quality work over the long term.
- **Love Solving Problems, Not Just Writing Code:** While not every task is enjoyable, Adam finds fulfillment in tackling challenging engineering problems. A genuine curiosity for problem-solving is what keeps difficult work engaging and ultimately leads to sustained success.
- **There's No Perfect Career Blueprint:** Rather than trying to optimize every career decision in hindsight, Adam's experience suggests that success comes from consistently following opportunities that align with your interests and strengths. When what you enjoy also meets the needs of the industry, you're in an ideal position to thrive.

Original podcast link: [**https://www.youtube.com/watch?v=YA_OYJF3Mmw**](https://www.youtube.com/watch?v=YA_OYJF3Mmw)

Senior Managers Adam Admires

In this lesson, **Adam Ernst**, Software Engineer at **Meta**, reflects on the engineers he most admires throughout his career and the qualities that set them apart. Rather than attributing success to a single skill, Adam highlights how exceptional engineers excel in different ways—from writing code and debugging complex systems to communicating ideas, launching new initiatives, and aligning teams. He emphasizes that there is no single blueprint for becoming a high-impact Individual Contributor.

- **Exceptional Engineers Have Different Superpowers:** Adam highlights colleagues who excel in distinct areas, including high-volume coding, deep debugging, launching ambitious projects, technical communication, and organizational alignment. There is no single path to becoming an outstanding engineer.
- **Leverage Your Strengths While Appreciating Others':** Adam recognizes that his own strengths lie in hands-on engineering, while others surpass him in areas such as cross-team leadership, strategic communication, and stakeholder management. Great engineering organizations thrive because individuals bring complementary skills.
- **Learn from Role Models, Not Copies:** Rather than trying to emulate one person completely, Adam encourages engineers to study the specific qualities they admire in others—whether it's technical depth, problem-solving, writing, or leadership—and incorporate those strengths into their own unique career path.

Original podcast link: [**https://www.youtube.com/watch?v=YA_OYJF3Mmw**](https://www.youtube.com/watch?v=YA_OYJF3Mmw)

IC9 Expectations

In this lesson, **Adam Ernst**, Software Engineer at **Meta**, shares how his mindset evolved after reaching the highest levels of the Individual Contributor career path. Rather than obsessing over whether his work was "IC9-level," Adam explains why he stopped measuring success by job expectations and instead focused on solving meaningful problems. He discusses the importance of trusting feedback from managers, staying aligned with organizational priorities, and pursuing work that is both impactful and personally motivating.

- **Stop Chasing the Title, Start Solving Problems:** Adam believes that constantly worrying about whether your work is "senior enough" is counterproductive. Instead, focus on delivering meaningful solutions to the most important problems facing your organization.
- **Use Feedback as a Course Correction:** Regular check-ins with your manager help ensure you're investing your time in high-impact work. Honest performance feedback should be viewed as guidance to adjust direction—not as a measure of personal worth.
- **Do Work You Enjoy:** Adam attributes much of his long-term success to working on problems he genuinely enjoys. By aligning personal interests with organizational priorities, engineers can produce their best work without becoming consumed by the pressure of meeting a particular career level.

Original podcast link: [**https://www.youtube.com/watch?v=YA_OYJF3Mmw**](https://www.youtube.com/watch?v=YA_OYJF3Mmw)

Technical Depth vs Breadth

In this lesson, **Adam Ernst**, Software Engineer at **Meta**, shares his perspective on what it takes to reach the highest levels of the Individual Contributor (IC) career ladder. Rather than choosing between technical depth and breadth, Adam explains how he developed both by following curiosity and solving real engineering problems. He describes a practical approach to learning unfamiliar systems, collaborating effectively across teams, and continuously expanding his expertise through hands-on experience instead of formal study.

- **Develop Both Depth and Breadth:** Adam believes senior engineers benefit from deep expertise in their primary domain while gradually building knowledge across adjacent systems. This combination enables engineers to solve complex cross-functional problems and make a broader organizational impact.
- **Learn Through Real Problems:** Instead of studying technologies in isolation, Adam dives deeply into unfamiliar systems only when they become relevant to the problem at hand. Solving real engineering challenges creates meaningful learning opportunities and builds lasting expertise.
- **Become Self-Sufficient and Collaborative:** By investigating issues independently before asking for help, engineers not only reduce the burden on partner teams but also arrive with informed questions and potential solutions. This approach accelerates learning, builds credibility, and strengthens cross-team relationships.

Original podcast link: [**https://www.youtube.com/watch?v=YA_OYJF3Mmw**](https://www.youtube.com/watch?v=YA_OYJF3Mmw)

Thoughts On Management

In this lesson, **Adam Ernst**, Software Engineer at **Meta**, explains why he chose to remain on the **Individual Contributor (IC)** career path instead of transitioning into engineering management. He discusses how understanding his strengths, interests, and motivations helped shape his career, why deep technical expertise can be more valuable than constantly switching domains, and how long-term specialization enabled him to become a trusted expert within Meta's mobile engineering organization.

- **Know What Motivates You:** Adam chose to remain an Individual Contributor because his greatest passion is writing code and solving technical problems. He recognized that management requires a different skill set—such as organizational leadership, direction setting, and people management—that did not align with his strengths or interests.
- **Build Deep Expertise Over Constant Change:** Rather than frequently changing teams or technologies, Adam stayed within mobile engineering, allowing him to develop deep institutional knowledge and become an expert in the architecture, tooling, and infrastructure that powered Meta's iOS ecosystem.
- **Career Paths Should Match Your Strengths:** Adam emphasizes that there is no universally "correct" career path. While some engineers thrive by exploring new domains such as AI or AR/VR, others create greater impact by mastering a specific area. The key is aligning your career choices with the type of work you genuinely enjoy and excel at.

Original podcast link: [**https://www.youtube.com/watch?v=YA_OYJF3Mmw**](https://www.youtube.com/watch?v=YA_OYJF3Mmw)

How To Handle a Failed Project

In this lesson, **Adam Ernst**, Software Engineer at **Meta**, reflects on the difficult decision to end **ComponentScript** after realizing it was not achieving the impact it was designed for. He discusses how performance reviews provided honest feedback, why responsibly shutting down a project can strengthen rather than damage your reputation, and the importance of recognizing when persistence becomes counterproductive. Adam offers valuable advice for engineers navigating ambitious projects that may not succeed.

- **Performance Reviews Should Inform, Not Define You:** Receiving a "Meets Most" performance rating helped Adam recognize that ComponentScript was no longer delivering the expected impact. Rather than viewing the feedback as a failure, he used it as a signal to reassess the project's direction.
- **End Projects Responsibly:** Instead of abandoning ComponentScript, Adam personally helped teams migrate to alternative solutions, removed the framework entirely from the codebase, and documented the lessons learned. Taking ownership of the cleanup earned trust and demonstrated strong engineering leadership.
- **Listen to Early Warning Signs:** Looking back, Adam realized he had sensed for nearly a year that the project was losing momentum. His instinct was to write more code in hopes of turning things around, but he later learned that recognizing when to pivot—or stop altogether—is just as important as technical execution.

Original podcast link: [**https://www.youtube.com/watch?v=YA_OYJF3Mmw**](https://www.youtube.com/watch?v=YA_OYJF3Mmw)

The Story Behind Component Script

In this lesson, **Adam Ernst**, Software Engineer at **Meta**, reflects on one of the most ambitious—and ultimately unsuccessful—projects of his career: **ComponentScript**, a cross-platform UI framework designed to unify iOS and Android development. Although the framework was technically sophisticated and solved many engineering challenges, it failed to gain widespread adoption. Adam shares the key lessons he learned about product strategy, developer adoption, and why technical excellence alone is not enough to ensure success.

- **Technical Success Doesn't Guarantee Product Success:** ComponentScript delivered strong technical capabilities—including type safety, seamless integration with native frameworks, and bidirectional interoperability—but these strengths were not enough to drive widespread adoption.
- **Know Your Users and Focus Your Strategy:** One of the project's biggest shortcomings was failing to identify a clear target audience. By trying to appeal to both native mobile engineers and JavaScript developers, the framework ultimately resonated with neither. Adam also learned the importance of concentrating efforts on winning over a single committed team before attempting broad adoption.
- **Embrace Failure as a Learning Opportunity:** Adam openly documented ComponentScript's failure through a detailed postmortem, using the experience to share hard-earned lessons with the engineering community. His reflection highlights the value of transparency, continuous learning, and recognizing that successful engineering requires balancing technical excellence with usability, adoption, and organizational alignment.

Original podcast link: [**https://www.youtube.com/watch?v=YA_OYJF3Mmw**](https://www.youtube.com/watch?v=YA_OYJF3Mmw)

Getting Promoted to Senior Staff Engineer

n this lesson, **Adam Ernst**, Software Engineer at **Meta**, shares the story behind **ComponentKit**, the declarative UI framework that played a pivotal role in his promotion to **Senior Staff Engineer (E7)**. Faced with a rapidly growing Facebook News Feed that was becoming difficult to maintain, Adam and his team reimagined iOS development by adapting the core ideas of React for native mobile applications—years before SwiftUI and React Native became mainstream. He also discusses how he overcame resistance to a radically new approach and the leadership lessons he learned while driving large-scale technical change.

- **Reinventing UI Architecture at Scale:** To address performance issues, crashes, and increasing complexity in Facebook News Feed, Adam developed **ComponentKit**, a declarative UI framework inspired by React that improved maintainability, rendering performance, and developer productivity long before similar technologies became industry standards.
- **Winning Adoption Through Evidence and Collaboration:** Convincing engineers to embrace a new programming paradigm required more than technical excellence. Adam demonstrated tangible improvements through cleaner code and better performance, leveraged trusted allies to advocate for the framework, and found compromises that incorporated ideas from competing internal projects.
- **Strong Conviction with Practical Flexibility:** Adam remained confident that ComponentKit was the right solution for Facebook's highly dynamic feed while acknowledging that no architecture is universally optimal. His experience highlights the importance of understanding trade-offs, tailoring solutions to the problem at hand, and leading innovation through collaboration rather than ideology.

Original podcast link: [**https://www.youtube.com/watch?v=YA_OYJF3Mmw**](https://www.youtube.com/watch?v=YA_OYJF3Mmw)

Code Review is Undervalued

In this lesson, **Adam Ernst**, Software Engineer at **Meta**, explains why code reviews are one of the most powerful—and often overlooked—tools for influencing engineering culture. Drawing from his experience reviewing more than **1,600 code changes** in just 18 months, Adam shares his philosophy on giving constructive feedback, mentoring engineers through review comments, and creating lasting improvements across a codebase. He emphasizes that effective code reviews are not about enforcing preferences but about teaching, understanding context, and helping others grow.

- **Code Reviews Are a Leadership Tool:** Adam views code reviews as an opportunity to mentor engineers, share best practices, and influence technical decisions in a practical, one-on-one setting rather than through broad directives.
- **Explain the "Why," Not Just the "What":** Great review comments focus on the reasoning behind a suggestion instead of simply requesting changes. By explaining trade-offs and remaining open to missing context, reviewers encourage learning instead of compliance.
- **Create a Multiplier Effect:** Constructive feedback helps engineers improve not only their current code but also the way they review others' work. This creates a ripple effect where good engineering practices spread organically throughout the team.

Original podcast link: [**https://www.youtube.com/watch?v=YA_OYJF3Mmw**](https://www.youtube.com/watch?v=YA_OYJF3Mmw)

Becoming a Staff Engineer at Facebook

In this lesson, **Adam Ernst**, Software Engineer at **Meta**, reflects on joining Facebook just before its IPO during the company's pivotal transition from an HTML5-based mobile app to a fully native iOS application. He explains how solving a major scalability challenge with Apple's Core Data framework led to his rapid promotion to Staff Engineer (E6). Adam also shares practical insights on influencing engineering teams without formal authority, driving large-scale architectural change, and building credibility through data, empathy, and hands-on execution.

- **Solving Large-Scale Engineering Challenges:** Adam joined Facebook during the native iOS rewrite and led the replacement of Apple's Core Data with a custom immutable model architecture ("Mem Models") that could scale to support hundreds of engineers and an ever-growing application.
- **Driving Adoption Through Influence:** Rather than relying on authority, Adam convinced teams to adopt the new architecture by understanding their concerns, presenting performance data, communicating face-to-face, and demonstrating why Apple's standard solutions no longer met Meta's scale.
- **Lead by Doing the Work:** One of Adam's most effective leadership strategies was minimizing friction for other teams. By implementing migrations himself and presenting completed solutions for review, he accelerated adoption and built trust across the organization.

Original podcast link: [**https://www.youtube.com/watch?v=YA_OYJF3Mmw**](https://www.youtube.com/watch?v=YA_OYJF3Mmw)

How It Started with CosmicSoft

In this lesson, **Adam Ernst**, a software engineer at **Meta**, shares the remarkable story of how his journey into software development began long before his professional career. He reflects on founding **CosmicSoft**, a software company he started while still in middle school, where he built and sold an online testing application for teachers. Adam explains how beginner-friendly programming tools enabled him to create real software, how he sold his products online before modern payment platforms like Stripe existed, and the entrepreneurial lessons he learned from launching a business at such a young age.

- **A Passion for Programming Began Early:** Adam Ernst discovered his love for software development in middle school, using the programming language **Real Basic** to build an online testing application inspired by his mother's work as a teacher.
- **Launching CosmicSoft:** Adam successfully sold his software to customers around the world using early e-commerce tools, accepting both online credit card payments and mailed checks—an impressive entrepreneurial achievement for a middle school student.
- **Foundations of a Software Career:** Adam's experience highlights how curiosity, accessible development tools, and a willingness to solve real problems laid the foundation for the engineering career that eventually led him to Meta.

Original podcast link: [**https://www.youtube.com/watch?v=YA_OYJF3Mmw**](https://www.youtube.com/watch?v=YA_OYJF3Mmw)

What Are Advanced Concepts I Should Know?

In this lesson we talk about how to effectively prepare for AI-assisted coding interviews, with a focus on shifting your study habits to match what these interviews actually test.

- **Learn the "why" before the "how"** — rather than drilling implementations, focus on understanding the canonical problem each data structure solves and practice explaining it in one sentence out loud; with AI handling the code, being unable to independently identify the right approach is now much harder to hide or compensate for.
- **Know the common gotchas for each pattern** — every classic structure has a specific edge case trap (e.g. the `is_end` flag in a trie, recency updates in an LRU cache, off-by-one errors in sliding windows); getting familiar with these upfront dramatically speeds up your ability to verify AI-generated output during the interview.
- **Practice reading code, not just writing it** — since interviews now involve more time spent reading starter code and verifying AI output than typing from scratch, deliberately train yourself to mentally trace logic quickly by reading existing solutions online or having AI generate code for problems you already understand, then tracing through them by hand.

How Should I Practice For These Interviews?

In this lesson we talk about how AI is making previously time-prohibitive advanced data structures and algorithms newly relevant in coding interviews, and what that means for how you should prepare.

- **AI unlocks harder concepts by handling the boilerplate** — complex structures like tries, heaps, and LRU caches were rarely testable in a 45–60 minute interview because implementation alone could eat up 15–20 minutes; with AI generating that scaffolding in seconds, interviewers can now reasonably include them, making them worth studying once you've solidified the fundamentals.
- **What you actually need to demonstrate has shifted** — since AI handles much of the implementation, your value lies in recognizing when a given data structure is the right tool, clearly articulating *why* it helps (e.g. "a trie eliminates the factor of M by checking all patterns simultaneously through shared prefix traversal"), and writing precise prompts that reflect that understanding.
- **Master the basics first, and don't over-rotate on this** — the vast majority of interviews (roughly 95%) will not require these advanced concepts, so treat this as the final 5–10% polish layer, not the foundation; verification of AI output remains just as critical here as everywhere else in the interview.

How Do I Talk Without Sounding Chaotic?

In this lesson we talk about how to communicate effectively during an AI-assisted coding interview without sounding scattered, frantic, or going completely silent.

- **Avoid the two extremes** — narrating every single keystroke comes across as junior, while going silent for several minutes leaves the interviewer in the dark; the goal is to sound controlled and intentional somewhere in between.
- **Choose the communication model that fits your thinking style** — Model A is light, continuous commentary as you work ("I'm pulling the date out of each event to populate the per-day set"), while Model B is stating your high-level intent upfront, working silently for 60–90 seconds, then summarizing what you did before repeating the cycle.
- **Practice talking while you work before the interview** — like touch typing, verbalizing your thought process while solving a problem is a skill that needs to be rehearsed, not figured out on the spot; a few mock sessions with a friend or mentor can make a significant difference.

How To Debug Effectively with AI As My Partner?

In this lesson we talk about how to debug effectively with AI as a partner during a coding interview, and when to use it versus when to rely on your own judgment.

- **Use AI to generate more test cases, but step through code yourself** — AI can rapidly produce test cases that would take much longer to write manually, but since it predicts words rather than executing code, it can reproduce the same bugs it originally introduced, making it unreliable for tracing logic line by line.
- **Avoid leaning on AI for debugging, but use it strategically when stuck** — rather than asking AI to find or fix a bug directly, prompt it to brainstorm multiple possible causes, which keeps you in the driver's seat, surfaces hypotheses for you to validate with your own judgment, and reduces the risk of confidently wrong AI suggestions.
- **Always rerun all tests after a fix, not just the failing one** — thorough test coverage lets passing tests serve as reliable verification; if your test suite is thin, compensate with more manual code inspection to avoid introducing regressions you won't have time to track down later.

What Should I Do In The First 10 Minutes?

In this lesson we talk about how to strategically approach the first 10 minutes of an AI-assisted coding interview to set yourself up for success.

- **Resist the urge to dive in immediately** — instead of jumping straight into coding or prompting the AI, start by restating the problem in your own words and doing a strategic skim of the codebase to understand existing functionality and function signatures.
- **Uncover hidden requirements** — as you explore the code, actively look for things like bot user filtering, non-active event handling, or data normalization that may not have been spelled out in the prompt, and clarify these with your interviewer.
- **Turn requirements into tests early** — unlike traditional interviews, convert each discovered requirement into an executable test case upfront (using AI to help generate them if needed), since verifying AI-generated code is a core part of the assessment.

When Should I Actually Use AI During The Interview?

In this lesson we talk about when and how to use AI effectively during an AI-assisted coding interview.

- **Find the right balance with AI:** Learn how to avoid over-delegating core logic to AI or underusing it and running out of time, by aiming for the “middle path” that maximizes leverage while minimizing risk.
- **Accelerate typing, not thinking:** Discover why you should use AI for scaffolding, boilerplate, and clearly defined test cases—but retain ownership over algorithms, data structures, and key design decisions.
- **Optimize for easy verification:** Understand that AI is most helpful when you already know what needs to be built and can quickly verify the output, and least helpful when you’re still figuring out the correct approach.

How Am I Being Evaluated Now?

In this lesson we talk about how candidates are evaluated in AI-assisted coding interviews and how the scoring rubric has shifted.

- **Understand what still matters—and what matters more:** Learn how the core engineering method (problem exploration, solution design, implementation, and testing) remains the foundation, but with greater emphasis on deep problem exploration and structured thinking before coding.
- **Recognize why problem solving is now the primary signal:** Because AI handles much of the typing, interviewers focus more heavily on your ability to form a clear plan, choose the right algorithms and data structures, and articulate trade-offs.
- **Master delegation and verification with AI:** Discover how execution now means directing AI effectively—accelerating typing but not thinking—and how careful verification of AI-generated code is a major part of your evaluation.

Introducing The Active Users Problem

In this lesson we talk about a realistic example problem used throughout the course to simulate an AI-assisted coding interview.

- **Understand the problem context and deliverables:** Build the back-end logic for an active users metrics dashboard, including calculating daily unique active users and rolling 7-day active user counts from messy, real-world log data.
- **Work within a structured codebase:** Learn how to navigate starter code with helper functions (e.g., ID normalization, bot filtering) and focus on implementing two core functions while leveraging provided tests.
- **Set expectations for interview complexity:** Explore how AI-assisted interviews can range from simple LeetCode-style tasks to multi-file, production-like environments—and how this example reflects an average level of complexity.

What's Changing With AI-Assisted Coding Interviews?

In this lesson we talk about the rise of AI-assisted coding interviews and how they are changing the technical interview landscape.

- **Understand the new AI-assisted coding interview format:** Learn how modern interviews place you in a lightweight codebase (not a blank file) with existing helper functions, tests, and to-dos—plus an integrated AI chat panel that can access and assist with your code.
- **Navigate increased problem complexity:** Explore how today’s interviews include more substantial starter code, realistic product requirements (e.g., time zones), and sometimes more advanced algorithms and data structures—reflecting real engineering work.
- **Collaborate effectively with AI while staying in control:** Discover best practices for using the built-in AI strategically, communicating your thinking clearly, and maintaining ownership of the solution in a rapidly evolving interview landscape.

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.