Building Trust In Software

I am a software engineer at Google who's worked in the UK, USA, and India offices, all because of the opportunities I've had here. During my first 3 months at Google, I went through the official Google guide on "How to handle reviewer comments" on a CL (which is like a pull request)...If you're a junior engineer reading this, always remember this:  1 // Don’t take it personally. When someone reviews your code, it’s not about you. It’s about the codebase. It’s about the company. And it’s about long-term quality. Think of it like this: If someone says, “This logic is unclear,” they’re not saying you’re unclear. They’re saying, “This piece of code won’t make sense to the next engineer who reads it 6 months from now.” It’s a conversation, do not get offended, but seek clarity…  2 // Clarify the code, not the comment box. One mistake I used to make early on: When someone didn’t understand my code, I’d explain it in the review thread. But the real fix is this: make the code speak for itself. If your reviewer doesn’t get it, a future dev won’t either. Rewrite. Refactor. Add a comment if needed. The review thread is temporary. The code is forever.  3 // Don’t react. Respond. Some feedback will sting. Some comments will be blunt. That’s okay. Never respond in anger. Walk away if you have to. Think. Reflect. Then respond with clarity and respect. Some of my biggest growth moments have come from pull requests where I was wrong, and someone cared enough to show me how to do it better. So here’s my advice: Treat code reviews as part of your learning loop.  That will make you a better teammate and a better engineer.

𝐖𝐡𝐲 𝐰𝐨𝐮𝐥𝐝 𝐈 𝐫𝐞𝐯𝐢𝐞𝐰 𝐲𝐨𝐮𝐫 𝐏𝐑? 𝐘𝐨𝐮 𝐡𝐚𝐯𝐞 𝟏𝟎 𝐲𝐞𝐚𝐫𝐬 𝐦𝐨𝐫𝐞 𝐞𝐱𝐩𝐞𝐫𝐢𝐞𝐧𝐜𝐞 𝐭𝐡𝐚𝐧 𝐈 𝐡𝐚𝐯𝐞. Early in my career, I said this to a Senior Engineer. I thought code reviews were just a "safety net" for juniors. I thought seniority meant you had stopped making mistakes. His reply changed my 𝐓𝐞𝐚𝐦 𝐎𝐒 forever: “If you don't review my work, you don't learn how I think. And if I don't get your eyes on it, I lose the chance to be questioned. The day I’m 'too senior' to be reviewed is the day I stop growing.” That conversation stayed with me for 15 years. Later, I saw the opposite. An Architect who only shared Design Docs with other Architects. It evolved into classic “ivory tower architecture”, decisions made far from the people who had to live with the consequences. The result? • Privilege replaced trust. • Knowledge became a bottleneck. • Juniors learned that their silence was expected. That is how 𝐜𝐨𝐥𝐥𝐚𝐛𝐨𝐫𝐚𝐭𝐢𝐨𝐧 𝐜𝐮𝐥𝐭𝐮𝐫𝐞𝐬 die. 𝐒𝐞𝐧𝐢𝐨𝐫𝐢𝐭𝐲 𝐢𝐬𝐧'𝐭 𝐚 𝐬𝐡𝐢𝐞𝐥𝐝 𝐟𝐫𝐨𝐦 𝐜𝐫𝐢𝐭𝐢𝐜𝐢𝐬𝐦. It’s a platform for transparency. When Seniors keep their work in a "private club," they aren't saving time; they are creating a 𝐒𝐢𝐧𝐠𝐥𝐞 𝐏𝐨𝐢𝐧𝐭 𝐨𝐟 𝐅𝐚𝐢𝐥𝐮𝐫𝐞. If the context only lives in your head: • You scale output, not judgment • You become the bottleneck • You can never truly unplug When a Junior reviews a Senior’s Work: 1️⃣ The Junior gains 6 months of context in 60 minutes. 2️⃣ The Senior is forced to simplify, and simplicity is the hallmark of great engineering. 3️⃣ The "Bus Factor" of the team doubles instantly. 𝐈𝐧 𝐬𝐭𝐫𝐨𝐧𝐠 𝐭𝐞𝐚𝐦𝐬, 𝐜𝐨𝐦𝐦𝐮𝐧𝐢𝐜𝐚𝐭𝐢𝐨𝐧 𝐢𝐬 𝐛𝐢-𝐝𝐢𝐫𝐞𝐜𝐭𝐢𝐨𝐧𝐚𝐥. Seniority isn’t where questioning stops. It’s where the openness should be highest. #EngineeringLeadership #CodeReview #WorkCulture #TeamOS

Tech leaders who rule by fear don't build reliable systems. They build engineers who hide failures until they're catastrophic. I've debugged enough production incidents to know the pattern: The bug was discovered 3 sprints ago. Nobody spoke up. Here's the unspoken truth: Your engineers aren't incompetent. They're psychologically unsafe. That fear is killing both your culture AND your code quality. When you shame developers during code reviews, they stop asking questions. When you blame teams during incident postmortems, they stop reporting near-misses. When you punish engineers for surfacing problems, they hide critical issues until your next major outage. Hidden failures compound until your entire stack becomes a ticking time bomb. The cost of fear-based leadership: TECHNICAL COST: ↳ 67% longer incident resolution times ↳ 40% slower sprint velocity ↳ Technical debt accumulates 300% faster ↳ Critical bugs discovered in production, not development HUMAN COST: ↳ $180K average replacement cost per senior engineer ↳ 73% of engineers leave managers, not companies ↳ Fear-driven turnover destroys institutional knowledge ↳ On-call becomes punishment instead of growth The identity shift isn't about "being nicer." It's about regulating your own fear response when systems fail. Most technical leaders panic when things break. That panic spreads. FEAR-BASED LEADERS: Blame individuals during incidents Use code reviews to demonstrate superiority Punish engineers who surface concerns Hide behind "accountability" to justify shame EQ-DRIVEN LEADERS: Debug systems, not people Use stack traces to improve processes, not assign blame Reward early problem identification Model curiosity instead of certainty Create psychological safety that prevents catastrophic rollbacks When you stop ruling by fear: Teams surface issues during standups instead of hiding them. Engineers ask questions in architecture reviews instead of pretending they understand. Code quality improves because people aren't afraid to experiment. On-call becomes a learning opportunity instead of blame assignment. Your emotional regulation under pressure determines whether your team builds reliable systems or unstable environments. The hardest debug you'll ever do isn't in your codebase. It's in your own leadership identity. ♻️ Share this if your network needs permission to create psychological safety in technical environments. 🔔 Follow Dan Tudorache for leadership insights that help technical experts build both reliable systems and emotionally intelligent teams.

I am an engineering manager, and I have spent close to two decades in software engineering. During my career, I have been on both sides of a code review. The person writing comments, and the person reading them while wondering, "Do they think I am bad at my job?" Taking feedback personally is far more common than people admit. You worked hard on that PR. You thought through the approach. You probably stayed late fixing it. So when someone leaves ten comments, questions your design, or asks you to rewrite a section, it can feel like they are questioning you. But please understand, they are reviewing the work in front of them, not your worth as a person. Your code may have a bug. Your design may need another pass. Your assumptions may be wrong. None of that means you are a bad engineer. It means the review process is doing its job. I have received feedback that frustrated me. I have also given feedback and later realised that my tone could have been better. Both sides carry responsibility. The reviewer should be respectful, clear, and focused on the code. The engineer receiving it should try to separate effort from outcome. You can work very hard and still miss something. That happens to senior engineers too. When feedback feels loaded, pause before replying. Read it again after a few minutes. Ask, "What is this person trying to protect here? Reliability? Simplicity? Security? Maintainability?" That question changes the conversation. You stop defending yourself and start discussing the engineering decision. This skill takes time. It does not come naturally to everyone, especially when you care deeply about your work. But once you learn it, reviews become less painful. You ask better questions, learn faster, and build much stronger relationships with senior engineers. A review comment is feedback on a piece of work. It is not a verdict on who you are.

The best engineering teams I've worked with argue constantly. Not personal attacks or ego battles. Technical arguments. Vigorous debates about architecture, trade-offs, and implementation approaches. Bad teams avoid conflict. Everyone nods along. Decisions get made by whoever speaks loudest or has the fanciest title. Good teams argue productively. They challenge assumptions. Question requirements. Push back on timelines. Debate whether to optimize for speed or maintainability. The difference? Psychological safety and shared goals. When people trust each other and align on outcomes, disagreement becomes a tool for finding better solutions. I learned this the hard way early in my career. I thought harmony meant everyone agreeing. Turns out harmony means everyone feeling safe to disagree. The strongest technical decisions come from tension between competing viewpoints.  Should we build this quickly or build it right?  Do we optimize for current needs or future scale? No single person has all the answers. But a team that argues well can find solutions none of them would have reached alone. Red flags:  Teams where junior developers never challenge senior ones.  Meetings where everyone agrees too quickly.  Architecture decisions made without debate. Green flags:  Teams where the best idea wins regardless of who suggests it.  Productive conflict about technical approaches.  Decisions that feel hard-fought but well-reasoned. The goal isn't to avoid disagreement. It's to disagree better. What's the best technical argument you've been part of that led to a better solution?

I debugged a critical system failure in 12 minutes. Then spent the next hour defending why my solution was correct. Same technical accuracy. Same problem-solving speed. Same expertise. Different room energy. Different career trajectory. I believed competence was currency. I thought being right was being valuable. I thought technical excellence spoke for itself. 𝗧𝗵𝗲 𝗿𝗲𝗮𝗹𝗶𝘁𝘆: 𝗜 𝘄𝗮𝘀 𝗯𝗿𝗶𝗹𝗹𝗶𝗮𝗻𝘁 𝗮𝗻𝗱 𝗲𝘅𝗵𝗮𝘂𝘀𝘁𝗶𝗻𝗴. Every code review: "This approach won't scale." Every architecture meeting: "That's technically incorrect." Every project standup: Leading with what was broken. → I thought I was adding value ↳ They experienced me as adding friction The competence-warmth tradeoff in action: → High competence + Low warmth = Respected but avoided ↳ People trust your technical judgment, not your judgment about them I watched less technical people get promoted around me. Not because they wrote better code. Because they made others feel smarter in their presence. While I was correcting syntax errors, they were building trust equity. While I was solving problems, they were solving problems AND making others feel heard. 𝗧𝗵𝗲 𝘁𝘂𝗿𝗻𝗶𝗻𝗴 𝗽𝗼𝗶𝗻𝘁: 𝗔 𝘀𝗲𝗻𝗶𝗼𝗿 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿 𝗜 𝗿𝗲𝘀𝗽𝗲𝗰𝘁𝗲𝗱. She found a major bug in our deployment pipeline. Instead of: "This is wrong, here's the fix." She said: "I'm seeing something interesting here. Walk me through your thinking on this section?" → Same technical outcome ↳ The junior developer felt curious, not criticized She didn't dim her expertise. She delivered it through questions that made others think harder, not feel smaller. 𝗧𝗵𝗲 𝗶𝗻𝘁𝗲𝗿𝗻𝗮𝗹 𝗿𝗲𝘀𝗶𝘀𝘁𝗮𝗻𝗰𝗲 𝗜 𝗳𝗲𝗹𝘁: "But I shouldn't have to sugarcoat facts." "Why should I make incompetence comfortable?" "This feels fake and manipulative." The truth: It's not about sugarcoating. It's about strategic delivery that amplifies your impact. 𝗛𝗲𝗿𝗲'𝘀 𝘄𝗵𝗮𝘁 𝗰𝗵𝗮𝗻𝗴𝗲𝗱: Instead of: "That won't work because..." I tried: "I see what you're optimizing for. Have you considered the edge case where..." Instead of: Immediately proposing the better solution I tried: "What's your experience been with this approach?" Instead of: Correcting misconceptions in public I tried: Slack DM with resources and context → Same technical standards, zero compromise ↳ Different delivery system that builds rather than burns bridges 𝗧𝗵𝗲 𝗿𝗲𝘀𝘂𝗹𝘁: 6 months later, I was invited to lead the architecture review committee. Not because my technical skills improved. Because my influence did. Same expertise. Different invitation level. Same standards. Different leadership opportunities. 𝗧𝗵𝗲 𝗳𝗼𝗿𝗺𝘂𝗹𝗮: Technical skills get you hired. Emotional intelligence gets you included in decisions. Relationship experience gets you promoted and recommended. → Excellence + Strategic warmth = Unstoppable ↳ People don't just want to work with brilliant engineers ↳ They want to work with brilliant engineers who make them feel brilliant too The women who rise fastest in engineering master this balance. They don't dim their technical edge. They sharpen it with strategic empathy. They understand their energy becomes their reputation. Your code quality opens doors. How people feel solving problems with you determines which doors lead to leadership. 𝗬𝗼𝘂𝗿 𝘁𝗲𝗰𝗵𝗻𝗶𝗰𝗮𝗹 𝗯𝗿𝗶𝗹𝗹𝗶𝗮𝗻𝗰𝗲 𝗱𝗲𝘀𝗲𝗿𝘃𝗲𝘀 𝗮𝗻 𝗮𝘂𝗱𝗶𝗲𝗻𝗰𝗲 𝘁𝗵𝗮𝘁 𝘀𝗲𝗲𝗸𝘀 𝘆𝗼𝘂𝗿 𝗶𝗻𝗽𝘂𝘁, 𝗻𝗼𝘁 𝗮𝘃𝗼𝗶𝗱𝘀 𝗶𝘁. ---- If you're a woman in engineering looking to land your next role or title promotion, DM me. I have 2 coaching seats available this month. ❤️ Repost if you're ready to turn technical excellence into career momentum 🔔 Follow Dima Abu-Khaled for strategic approaches that help you land your next role

Early feedback is underrated. Now AI is making it even more relevant. I've always believed in sharing work before it's "ready." Tech design? Send it before it's finalized. Code? Same. Process doc? Absolutely. I know this might annoys people. The conventional wisdom says if something isn't polished, you're wasting the reviewer's time. I disagree. When I have something written down—doc or code—it's a forcing function. It's forward motion. The alternative is analysis paralysis, endlessly refining something in my head that never becomes real. But here's the thing: in the AI-native era, this approach is accelerating. I chat with Claude, get an idea, get a structure, and I'm already sharing it. The iteration cycle is tighter than ever. AI first, humans second. Which raises an uncomfortable question—but not the one you'd expect. It's not "am I overloading reviewers?" It's "how well am I handling, emotionally, the fact that I'm constantly putting out work that will be criticized, and it's not perfect?" Because that's the real cost of early feedback. You're exposing yourself, repeatedly. Your half-baked ideas. Your rough drafts. Your not-quite-there-yet thinking. And every time, someone will point out what's wrong with it. It might look pretty, as you wrote it with AI. But it's not 100%. The engineers who thrive in this mode aren't the ones with thick skin. They're the ones who've learned to separate their ego from their artifacts. The doc isn't me. The code isn't me. It's just the current state of my thinking, and thinking is meant to evolve. That's harder than it sounds. But I suspect it's becoming a core skill.

Your first few 1-1s Transitioning into a new team as a senior engineer is less about proving your technical dominance and more about performing a delicate "cultural transplant." While your title implies authority, your initial status is that of an outsider. To succeed, you must navigate the complex intersection of social identity, psychological safety, and tribal knowledge. When a newcomer suggests an immediate "improvement," they aren't just critiquing a line of code; they are inadvertently critiquing the team's past decisions, late-night bug fixes, and the compromises they made to stay afloat. Psychologically, this triggers the Endowment Effect, where people value what they have built more than an objectively "better" alternative. Here is a collection of curiosity-based questions designed to bridge the gap between "outsider" and "trusted partner." These are framed to honor the team’s history while identifying where you can eventually add the most value. The "Context & History" Questions Before you can suggest a future, you must acknowledge the past. These questions help you understand Chesterton’s Fence—the reason why things are the way they are. • "I noticed we use [Technology X] for our data layer. I’d love to hear the story of how that was chosen—what were the big constraints or 'must-haves' at the time?" Why this works: It treats a technical choice as a narrative rather than a static (and potentially flawed) decision. It allows the veteran engineers to explain the "battle scars" that led to that choice. The "Empathy & Pain Point" Questions Trust is often earned by solving the "pebbles in the shoes" of your teammates—the small, recurring annoyances that they’ve become numb to. • "If you had a 'magic wand' and could fix one thing about our local development setup or CI/CD pipeline today, what would it be?" Why this works: It bypasses high-level architectural debates and focuses on daily friction. If you fix this, you become an immediate hero. The "Culture & Workflow" Questions Every team has a "shadow" workflow—the way things actually get done versus what is written in the handbook. • "Who is the 'go-to' person for [Specific Domain]? I want to make sure I’m learning from the right experts as I get up to speed." Why this works: It validates the expertise of your peers. By labeling them as the "expert," you move yourself into the "student" role, which is the safest psychological position for a new senior engineer. When you ask these, listen more than you speak. If they describe a process that seems inefficient, resist the urge to say, "At my last company, we did it better." Instead, try: "That’s an interesting approach. What do you feel are the biggest trade-offs of doing it that way?" This subtle shift in language keeps the conversation analytical rather than adversarial. You are gathering the "intel" you need to eventually lead, but doing so with the humility of a teammate.

You can be the smartest person in the room and still slow the team down. In AI systems, being right about the model, the architecture, or the benchmark means very little if no one can align with you long enough to ship. At senior levels, the question quietly changes. It is no longer “Can you build it?” It becomes “Can you build it with other capable people who see the world differently?” That is where many careers plateau. 1. Start on the same side of the problem Disagreements around AI often get personal fast. Models, vendors, latency, cost, safety. Everyone has an opinion. Reset the frame early. “We both want this agent to answer customers accurately without blowing up cost or trust. We disagree on how to get there.” That single sentence shifts the room. Now you are solving for outcomes, not defending identities. 2. Challenge assumptions, not intelligence AI debates die when they turn into proxy fights about competence. Instead of saying “This approach is over-engineered.” Try saying “This assumes retrieval will stay stable as data grows. What happens when the corpus doubles or the embeddings drift?” You are still pushing hard, but you are doing it at the assumption layer. Scale, failure modes, ownership, evaluation gaps. That is where real AI systems break. 3. Let the system speak AI gives you no excuse to argue emotionally. Bring evidence. Latency curves. Cost per query. Eval deltas before and after prompt changes. User drop-off when confidence is wrong. “When we added tool calls, accuracy went up 6 percent, but cost doubled. Are we aligned on that trade?” Data lets people change their mind without losing credibility. 4. Close the loop on ownership Disagreement without a decision is just noise. End with clarity. “We have two viable paths. You own the call. Let’s document the risks, define the evals, and agree on the rollback if this underperforms in production.” That is maturity. Not winning the argument. Winning the delivery. The uncomfortable truth is this: In complex systems like AI, ego becomes technical debt faster than bad code. Protect the goal. Protect the team. Your ideas will survive if they deserve to. #leadershipdevelopment #AIengineering #metashift #careerdevelopment