20 Years Of Fighting Procrastination [Part 8] - Do Work When You're Working

When engineers say they’ve been “working all day,” that time often includes distractions, shallow tasks, or unnecessary overhead. To truly be productive, you have to focus on high-leverage, distraction-free work. Here are the core points from the lesson:

- Real productivity comes from deep work—uninterrupted, focused effort on cognitively demanding tasks—not from staying busy or checking email 50+ times a day
- Recognize and minimize "startup costs" like syncing code, building the app, and reviewing changes, so you can spend more time in the value-generating loop of building and debugging
- Block off long stretches of time for deep work rather than relying on scattered 30–45 minute sessions that get consumed by overhead
- Automate or script repetitive setup tasks (e.g. syncing and builds) to reduce friction and start meaningful work faster each day
- Prioritize difficult, ambiguous tasks early—they often influence downstream work, and avoiding them leads to fake progress and missed deadlines

20 Years Of Fighting Procrastination [Part 7] - Just One Thing

20 Years Of Fighting Procrastination [Part 6] - The #1 Way To Create Accountability

When motivation fades, there's a simple yet powerful way to regain momentum—build accountability into your workflow. Here are the key ideas from the lesson:

- Social pressure is more powerful than self-discipline alone, making accountability partners or group settings highly effective for staying on track

- Benefits of accountability include learning from others, drawing inspiration, and getting called out when you're making excuses or losing focus

- Tactics include going into the office, joining virtual co-working platforms, setting review checkpoints, or scheduling deadlines—even artificial ones—to create external motivation and structure

20 Years Of Fighting Procrastination [Part 5] - Debug Your Productivity

Procrastination thrives when you confuse learning with progress. Here are the core points from the lesson:

- Jumpstarting productivity means producing *before* you feel ready — even a rough draft unlocks momentum
- Replace the one-way flow of tutorials with a feedback loop: code → learn → refine
- Writing personal notes or process logs boosts clarity and reduces future ramp-up time
- Systematize repeatable work into reusable components to move faster with each project
- Build a library of “done before” artifacts you can copy, tweak, and ship again and again

20 Years Of Fighting Procrastination [Part 4] - The Most Important Productivity Tip Nobody Follows

Productivity isn't just about doing things faster - That’s only half the story. Here are the core points from the lesson:

- Productivity isn't just about efficiency, it's about working efficiently on *important* tasks that actually move the needle
- Prioritization requires painful trade-offs—you must let go of low-impact activities even if they're easy, fun, or popular
- Define your personal values and consciously deprioritize areas that don’t align with them, like staying updated on politics or reading a book a week
- A simple yet powerful framework for teams is evaluating tasks based on impact and time required, then prioritizing high-impact, low-time work first

20 Years Of Fighting Procrastination [Part 3] - Build A System

Most people rely on fluctuating willpower to be productive—but the most effective creators use systems. Here are the core points from the lesson:

- Systems make good behavior automatic by reducing cognitive load and accounting for natural fluctuations in willpower, energy, and focus
- Structure your day around your strengths—use mornings for disciplined deep work, afternoons for accountability-based tasks, and evenings for creative exploration
- Focus on generating artifacts like notes, calendar blocks, or test plans to capture progress, clarify your thinking, and preserve valuable context
- Habit stacking and predefined triggers make consistent output easier and help you avoid relying on short-term motivation or memory

20 Years Of Fighting Procrastination [Part 2] - The Right Mentality For Productivity

Many engineers think their lack of productivity is a motivation issue, so they start off by focusing on that. However, this is usually not the right way to go. Here are the core points from the lesson:

- Action creates motivation, not the other way around—starting small builds momentum
- Progress triggers a positive spiral: productivity → feeling good → more productivity
- You only need discipline for the first 5 minutes—after that, the task usually becomes easier

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>

Become A Debugging Master [Part 19] - Go Deeper: Follow Through

Start a discussion in the Taro forum: <https://www.jointaro.com/questions/create/>

See Rahul's upcoming Group Office Hours: <https://www.jointaro.com/p/rahul-pandey/>

Related courses:

- [Ask Great Questions That Get Great Answers Quickly](https://www.jointaro.com/course/ask-great-questions-that-get-great-answers-quickly/)
- [Level Up Your Code Quality As A Software Engineer](https://www.jointaro.com/course/level-up-your-code-quality-as-a-software-engineer/)

Become A Debugging Master [Part 18] - Build The Infra

Building debugging infrastructure is a powerful way to level up your team and career. Here are the core points from the lesson:

- Invest in infrastructure like logging, dashboards, session recordings, bisect tools, and experiment tracking to make debugging easier for everyone

- Plan ahead by adding useful logging into products before bugs occur to speed up investigations and root cause analysis

- Funnel logging is especially valuable because it formalizes the end-to-end data flow, making it easier to spot where issues happen

- Building internal tools, even simple ones like the Log Insight tool at Meta, can lead to major team-wide adoption and career milestones

- Internal tooling projects are great side projects because they serve engineers directly, have less red tape, and can be very high impact

Rahul's internal tool case study: [\[Case Study\] Building A Meta Internal Tool To Empower An Entire Org: Staff Promotion Story](https://www.jointaro.com/lesson/qvp2quodqAEWSkN7sayt/case-study-building-a-meta-internal-tool-to-empower-an-entire-org-staff-promotion-story/)

Become A Debugging Master [Part 17] - Share The Learning

A lot of engineers move on immediately after landing a fix, but the best ones take the time to reflect and prevent similar issues in the future. Here are the core points from the lesson:

- Retrospectives help you identify root causes and system weaknesses so you can either prevent a future incident or make it much easier to detect and fix
- A good postmortem analyzes what went well and what didn’t across detection, notification, response, mitigation, and analysis, with detailed documentation to capture all learnings
- Writing a clean, detailed doc with screenshots and explanations makes it much easier for future engineers to learn from the incident without having to dig through chaotic logs or chat threads
- Big tech cultures like Facebook normalize failure and focus on minimizing damage and learning quickly, often using formal SEV reviews to improve systems and processes over time

Become A Debugging Master [Part 16] - Retrospect

One of the best ways to turn a bug fix into long-term engineering growth is to reflect on what happened and how to prevent it next time. Here are the core points from the lesson:

- After a fix, run a retrospective to figure out how to prevent or better handle similar issues in the future
- Writing a clean, detailed doc about the incident helps future engineers quickly learn without digging through scattered updates
- Big tech companies like Meta normalize failure and use formal SEV reviews to systematically improve after incidents

Meta's SEV culture: <https://atscaleconference.com/videos/metas-sev-culture-how-todays-sevs-create-tomorrows-reliability/>

Become A Debugging Master [Part 15] - Monitor System Health

Fixing a bug isn’t the end — true resolution means confirming the fix worked at scale. Here are the core points from the lesson:

- Always monitor system health after a fix using real metrics, not just local device testing, to verify the problem is truly resolved
- Track both user-facing metrics (like revenue, call minutes, login attempts) and code-facing metrics (like error rates, ingress/egress traffic, build failures)
- Be aware of natural variations in user metrics across days, weekends, and holidays so you don’t misinterpret normal fluctuations
- Revisit your original blast radius notes and make sure the impacted areas are reflected in your dashboards to fully validate recovery
- Understand the difference between root causes (e.g., spike in Firestore reads) and lagging indicators (e.g., billing costs) when monitoring your fix

Example metrics dashboard: <https://convertkit.baremetrics.com/>

Become A Debugging Master [Part 14] - Debugging Case Study: Meta

Let's make things concrete with a clear debugging case study from Meta. Here are the core points from the lesson:

- Mastering the deployment process (web continuous deploys vs mobile gated releases) and internal tools like “Where Is My Diff” at Meta can make it faster to rule out likely causes
- Being deeply familiar with experiments, gatekeepers, and other release tooling can help you spot issues like sudden error spikes or QA/test build failures without needing to dig into the code immediately
- Effective debuggers can quickly answer questions like when a code change deployed, what experiments launched, and what version a user was on during a bug report
- Going deep into tooling and metrics, not just code, lets you identify root causes faster, communicate precisely with teams, and resolve issues much more efficiently

How Facebook does continuous deployment: <https://engineering.fb.com/2017/08/31/web/rapid-release-at-massive-scale/>

Become A Debugging Master [Part 13] - Create A Real Fix

Quick fixes are tempting, but true engineering excellence comes from addressing the real problem. Here are the core points from the lesson:

- A surface-level fix, like returning null to avoid an exception, hides the real issue and often leads to worse problems later
- Always stress-test your fix, check nearby features, and invite feedback instead of hoping a band-aid fix is “good enough”
- If you must land a short-term patch, clearly document it and create a task for a proper fix to maintain team trust
- Use the “Five Whys” method to dig deep into the root cause rather than stopping at the first obvious error

Become A Debugging Master [Part 12] - Take Breaks

Sometimes the smartest move when debugging isn’t pushing harder—it’s stepping away. Here are the core points from the lesson:

- Taking breaks is critical to avoid getting trapped in unproductive rabbit holes and to regain a fresh perspective on tough bugs
- If you haven’t made meaningful progress after an hour, switching tasks, taking a walk, or asking for help can prevent burnout and unlock new ideas
- Breaks scientifically boost memory consolidation, accuracy, and problem-solving by giving your brain time to process and connect scattered information
- Studies show staying awake too long severely impairs your mental performance, making rest essential for effective debugging and clear thinking

Become A Debugging Master [Part 11] - The 2 Styles Of Bug Searching

When you’re stuck on a tough bug, how you approach it can make a huge difference in how quickly you find the root cause. Here are the core points from the lesson:

- Top-down debugging starts from the full application and removes pieces to isolate the bug, while bottom-up starts with a clean slate and adds code until the bug appears
- Bottom-up debugging can dramatically speed up iteration and discovery in large, complex codebases, even if it requires more upfront effort
- A key mindset is to “move the ball forward” by adding logs, setting alerts, or gathering information that will help your future self debug faster
- Forming clear written updates or questions based on your debugging history allows you to get much higher-quality help from others

Become A Debugging Master [Part 10] - Document Your Process

If you want to debug faster and avoid getting stuck, one of the best habits you can build is writing everything down. Here are the core points from the lesson:

- Document your hypotheses, tests, and findings continuously during debugging to create clarity, reduce mistakes, and avoid repeating the same experiments
- Writing things down makes it easier for teammates to jump in, share context quickly, and collaborate effectively when tackling complex bugs
- Even when debugging alone, written notes help you stay organized, maintain momentum, and prevent morale-killing mistakes like redoing work you already tried
- Good documentation habits (like clear pull requests and linking to issues) allow future debuggers to “time travel” and understand why code was written a certain way
- Strong debugging cultures start with individuals — write as you debug today, and your future self (and team) will thank you

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

Become A Debugging Master [Part 9] - Understand The End-To-End Flow

Most engineers waste time guessing at random fixes instead of methodically understanding the flow of what’s actually happening. Here are the core points from the lesson:

- Before you fix a bug, deeply understand the end-to-end flow, the intended behavior, and where reality deviates
- Avoid “blind fixes”—randomly adding things like null checks without fully identifying the root cause leads to fragile software
- Break down the system into smaller steps, narrow down the problem area through a process of elimination, and ask better questions based on where things fail
- Understand which components are involved, how they communicate, and what data formats they expect to quickly spot mismatches or errors
- Strong debuggers act like detectives: they map out the flow precisely, isolate the problem, and only fix after gaining clarity on why things broke

Become A Debugging Master [Part 8] - Write Down All The Context

One of the easiest ways to massively speed up your debugging (and make yourself look way more senior) is simple: write things down early and often. Here are the core points from the lesson:

- Don’t wait for clarity to write—writing your thoughts down is what *creates* clarity and uncovers next steps
- Always document repro steps, failed attempts, blast radius info, and hypotheses while debugging
- Writing things down improves your retention, narrows the search area, gives credit to others, and makes handing off bugs much smoother
- Even half-baked notes are powerful because they build momentum, reduce confusion, and help you communicate progress to others effectively

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.