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.

Take Some Time To Reflect

We wrap up by reframing layoffs as a rare opportunity to pause, reflect, and intentionally design the next chapter of your career. Here are the core points from the lesson:

- A layoff often comes with severance and time, which is an incredibly valuable resource that gives you space to step off the hamster wheel and think clearly.
- Taking days or even weeks to reflect is worthwhile, since deep self-introspection about career direction, values, and long-term goals is difficult but high leverage.
- Being laid off can surface important questions you may have ignored while grinding, including whether you enjoy your role, your function, or even the tech industry at all.
- Boredom and distance from day-to-day work can spark creativity, learning, and exploration that are nearly impossible when you’re constantly shipping and firefighting.
- With persistence, reflection, and conversations with trusted people, a layoff can become a pivot point that leads to a more aligned, fulfilling next step—even if that path looks very different than before.

Leverage Your Unfair Advantage

We explain how to accelerate your job search after a layoff by intentionally leveraging the advantages already on your résumé. Here are the core points from the lesson:

- We should leverage company brand as an unfair advantage, since recognizable names (Big Tech, well-known startups, or respected niche companies) carry trust and credibility that immediately raise our odds versus the average applicant.
- We can increase our chances by targeting adjacent companies, customers, or competitors where our background naturally fits, instead of applying randomly to roles with no contextual advantage.
- We should confidently lean into domain and product association—using the halo effect of teams, products, or problem spaces we worked on—because perceived relevance often matters more than perfect technical alignment.

Build Support Groups

We explain why building community after a layoff can dramatically improve both emotional resilience and job-search outcomes. Here are the core points from the lesson:

- Layoffs create a natural sense of solidarity, and bringing laid-off peers together helps transform an isolating experience into a shared support system.
- Being proactive about forming or joining support groups—through spreadsheets, LinkedIn, or communities like Taro—creates powerful networks of talented people who can help one another.
- Regular check-ins, shared encouragement, and activities like mock interviews provide structure, accountability, and momentum during the job search.

Verify Your Severance Package

We explain what to do immediately after a layoff to protect yourself financially and legally, and to reduce unnecessary stress. Here are the core points from the lesson:

- Most large tech companies provide severance due to legal requirements and long-term reputational incentives, but layoffs are messy, so you must carefully review all paperwork and verify dates, vesting, and severance amounts.
- Never sign termination documents on the spot; take time to review them, ask questions, and involve a lawyer if possible, especially for severance disputes or visa-related considerations.
- After a layoff, it’s critical to understand your personal burn rate and runway by reviewing your finances, since clarity around how long you can sustain yourself reduces anxiety and helps you plan your next steps.

There Is Nothing Wrong With You

We close by reframing layoffs as a survivable, even formative, career event rather than a personal failure. Here are the core points from the lesson:

- Being laid off is not a reflection of your ability or worth, since layoffs are driven by executives making decisions with incomplete information and often feel effectively random from an individual’s perspective.
- There is no value in self-blame or overanalyzing what you could have done differently, because once a layoff happens, the only productive move is to look forward.
- With severance as temporary financial runway, layoffs can be treated as a reset point to reflect, recover, and intentionally choose your next step, knowing this is a normal part of a long tech career.

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.