What matters is the conversation. If you decide not to promote internally, then tell them yourself, and tell them why. Many dodge this discomfort. The news travels through the grapevine instead of coming in directly. That damages trust, and starts their disengagement.

You don’t lose people due to a missed promotion, but due to missed honest conversations. So schedule that hard conversation, to build a culture where you give others the dignity of hearing “not this time.”

Precise plans give an impression of accuracy and correctness. That’s the danger of a detailed plan: you believe you’re ready, that you’ve mitigated the risks, that it’s smooth sailing from here. That’s false confidence.

A budget that says $35k–$40k, 95% confidently, is more trustworthy. Range estimates are more believable. But it’s not about the range really. Whenever I see a detailed plan, I ask: have you talked to the people who have the power and the incentive to derail it, or at least question it?

Talking to them is a good starting point. Don’t fool yourself with details. Draw the sequence, put the names down, then go talk to people.

Minimize complaints and you go back and forth on your decisions. Let’s say after you migrate the team from Codex to Claude Code, someone says the new tool is disrupting their workflow.

Ask what support looks like for them, individually, but do not reopen the decision.

Three layers under the complaints sits something else. Fear of irrelevance, as AI coding assistants disrupt what engineers do. Or fear of looking incompetent, because a new workflow turns a productive engineer into a confused one.

Those fears are the focus, not your initial decision. Your job is to bring empathy and offering support. In the example above: clarifying why the engineering still matters, or setting the expectation that in the next two months the timelines will get a 20-30% hit while the team relearns the tool.

Handle the complaint. Don’t let it walk back your decision.

Say there are 10 relevant details buried: user base size, latency requirements, label distribution and noise, legal deployment limits, and so on. A senior candidate surfaces six or seven of them before proposing anything. A junior candidate jumps straight to an answer, making things up as they go.

What interviewers get wrong is the evaluation part. The rubric is adjusted to level but for the fully-specified problem — the one with all ten details known, the version in your head. The candidate answers a problem that’s different from it.

Grade them against your original problem and you’re underscore them. Grade them against the problem they built through their own questions.

At times it doesn’t work because the people inside saw it coming and didn’t believe it. That’s how IBM and Kodak died. No amount of premortems could have helped. People inside were not ready, as a group, to suspend their existing world model and imagine their own demise.

It reminds me of a story about a big tech ML team manager who hired a visiting researcher to tell the team how to improve the model. After the analysis, the researcher said: your pre-training adds no value, no per-task head architecture changes will help you. The manager had years invested in the existing architecture and didn’t want to even consider looking at any alternative. The idea was dismissed even after some evidence was provided.

The value of premortems comes from giving people space to voice their existing concerns. That means allowing people to wear a black hat, capturing it all, then having another session on mitigating strategies. Unfortunately, it often gets down to the team “pessimist” raising real concerns and those most vested optimistically dismissing the surfaced risks. A rather pointless exercise.

Learning takes effort, and the willingness to drop a belief you’re attached to. Judgment needs a struggle.

What we’ll pay for, once AI does even more, is people who take effort, thrive in uncertainty, and face discomfort.

I passed. There was too little incentive for me. She wrote back: “If you cannot see the reward in it, then I hope you never will — because one day you’ll wish you’d taken it. You’re out.”

It’s hard to be a founder. There’s a fine line between vision and delusion. It needs conviction, but conviction that can’t share the pie never grows the pie.

You either get equity as an employee/founder or buy it as an investor — a founder asking for both is detached from reality.

A year later, the product launched as a small pilot. We met once again. I wished her well. Not long after, it was gone. I don’t regret saying no. She needed someone, but it wasn’t me.

We’re told to regret the risks we didn’t take. Some risks were never ours to take. Let them go, and let someone else pick them up.

Consider the inverse. Look at the outcomes you hated last year — unmet SLAs, customer complaints, reduced availability, critical errors — and build the bonus around avoiding them. It’s about rewarding people for the discipline that prevents screw-ups. In an age where AI lets teams ship at any speed and at any cost, it’s a helpful balancing force.

Balance the metric so nobody games a single number: at least 100 customers and fewer than 5 complaints. $3M in revenue and no more than three delivery delays, none longer than seven days.

Also get the attribution right. If a CTO overrides engineer’s call, they are not on the hook.

Assign the hero/wizard who will fix it, even on the weekends (and pay them for that), but don’t celebrate it. It’s either their regular job (e.g. SREs) or a one-off — send them a thank-you note and a spot bonus.

What you don’t want is to send a message to the team that this kind of heroism is what gets fireworks and the CEO’s attention. You don’t want people creating fires so they can put them out heroically. This cobra effect isn’t helpful.

Ask what they changed in the last months, and what convinced them to switch. (That shows they stay current and evolve their workflow, not just their opinions about it.)

Ask what impact their setup has on others. The engineer who ships 10k lines a day and hands it to a teammate for review isn’t helping the team. Individual speed that creates someone else’s bottleneck isn’t speed.

Ask how they balance writing fast against maintaining what they wrote. You don’t want someone who optimizes myopically.

The blocker is often banal: people predict they won’t feel good after the change. That’s affective forecasting, guessing your future emotional state, and people are bad at it. They overestimate how a change will bother them, imagine the worst.

The remedy is removing the lengthy transition that allows for overthinking and making a temporary change, as an experiment. It’s the provisional self. “Try it two weeks. Don’t like it, we adjust.” You make it reversible and low stakes. No need for forecast, they will feel it tomorrow.

As with every change, the steps are:

1. Show the new possibility concretely. Make it concrete.

2. Clear the barriers, esp. fear.

3. Turn it into a practice — something we do.

It’s OK to jump before you look, when it’s bungee jumping.

The second manager showed me that expertise matters. But also mistreated those who didn’t have it yet.

Another one showed how to bring empathy and understanding, but also that overprotecting people can burn out the manager and prevent the team from learning how to handle adversity.

Another one showed how to keep a large team on schedule, but also how it can kill innovation and push your best people out.

What made them good managers backfired in certain contexts.

Direct feedback is good, until it’s done all the time, then it’s pestering. Checking in with team members is good until it’s intruding on privacy.

Sometimes, it’s about not doing more. Sometimes you need to pause and let it go.

It all sounds... nice. Yet that’s not great! What about: “it’s a terrific place to work. He’s an honest guy. My manager is supportive”?

Nice exists in this comfortable space that doesn’t make you move — somewhere between getting an A minus and getting caught in a downpour when you’re already soaked through. You wouldn’t bother to move. It’s nice, and that’s enough.

The same goes for the company culture. Nice is not bad. It’s also hard to complain about. But there’s a better state: kind.

Kind means telling a colleague: slide 4 will land better if you rephrase it; asking for more integration tests; nitpicking to add a confidence interval in your plot. It’s noticing something outside your area of responsibility that can be better and showing those responsible for it how.

Aim for kind, not merely nice.

Non-engineers are shipping AI-generated production code and calling done.

Watching Gordon Ramsay plate a dish doesn’t make you a chef. Bingeing Bake Off doesn’t make you a pastry expert. Watching it made is not making it. AI coding tools are fooling you.

Build that Lovable prototype and send it to five people. Find out what resonates, instead of winging it or handing the eng team a Gantt chart. But production code needs someone with its mental model and the ability to reason about it to debug when it brings your service down.

Use AI, sure, but also: build it right. That’s not your PM’s or CEO’s job.

Here are a few generic questions good in scoping meetings and in interviews.

• What’s the current approach, and why isn’t it good enough?

• What are the objectives (always plural!) and how do you trade them off? (Concrete options, not principles.)

• What’s the hardest part, and why?

• What have you tried, what happened, and why? Don’t let “we tried that” put you off. Often the “same” idea works the second time around, for various reasons.

• What did you consider and dismiss, and why?

• What domain details or constraints trip up outsiders?

• What would you do with unlimited money, unlimited time, or neither?

Each question aims to get to specifics quickly. One of those is the game-changing lever.

“I’m disappointed“ doesn’t work either. It’s guilt-tripping, even if you get better outputs. Neither is inspiring.

Try: “I want you to be responsible for delivering X.“ Then follow up with either “this is within your capabilities“ or “you’ll have to learn a thing or two here, I’m here to support you.”

We ask people to be accountable and have more ownership. It’s more likely if they want to do better, not if we tell them they are supposed to.

Peer bonus is better. It’s unexpected, thus appreciated. Despite being 100x smaller than EOY bonus. It works because it normally doesn’t happen. (If you want EOY bonus to work, give it to 10-20% of people.)

The same is true for other positive rewards. They shape the culture if they are not expected. If you praise someone in your team/org every week, and you end up cycling through everyone each quarter, it’s meaningless.

The other mechanism that shapes behaviors and culture is what doesn’t get rewarded at all and what gets actively punished.

What do you do when a dev breaks prod, delays a project by a month or tells the client a lie to “protect” the project? Do they get embarrassed in front of others or told angrily to “never do it again”?

I learned it years ago. Google used to onboard people with the “ask for forgiveness, not permission“ motto. The motto was empty until I did something and someone told me I’d done the wrong thing. I said “sorry”, they showed me the right way, and we moved on. I didn’t feel scolded, shamed or punished. I understood that saying sorry and fixing what seemed broken mattered more than asking permission first. This made the motto real. It’s what I passed to dozens of people I managed over the years.

You build the culture when a newbie screws something up for the first time.

Many schools do the same to people. You’re handed a question with an answer the teacher already has, and you’re graded on how close you get to it. Nobody asks you to invent a new answer or ask a better question. The answer exists, your job is to find it.

Real problems don’t work that way. The ones worth solving have no known answer, and often few can even validate your answer.

That’s why discovery and optimization need different people, or at minimum different mentalities. Six Hats gets this right: you don’t run the black hat and the green hat at the same time, because they pull in opposite directions: optimization wants convergence, discovery wants divergence.

A good leader is a learner, not a knower. Someone who thinks in hypotheses and adjusts the plan based on observations, not a person with a confident answer. The opposite of the “mental waterfall”.

Hire discovery-minded people first. Measure them on what they learned, not what they shipped. Bring in the optimizers once there’s something worth optimizing.

Easy to call him stupid. He’s not here to defend himself.

Maybe he was tired. He misheard the price. He did the math wrong and didn’t want to ask again. It can be any of those.

That’s the job of a leader when a story starts about someone on the team. “He’s lazy” is a narrative and you should stop it immediately with alternatives.

“Maybe he’s carrying a deadline you set that was never realistic. Maybe something at home is falling apart.” You don’t need the real reason. You need enough plausible ones to make “lazy” look uninformed and ignorant.

Performance reviews are where it shows up a lot. Limited data points, power games, and oversimplified narratives that become someone’s record (without them knowing!)

AI agent can write a function that passes all tests and still be poorly written: an O(n²) loop over a dataset sample (where the real thing is millions of entries), or a database query filtering in Python instead of pushing the filter to the database engine.

If you’re not reading the code carefully, you’ll miss them. Coding agents were trained to meet functional requirements, optimized for what gets measured and allowed.

No one reads the code so a god object gets yet another responsibility without a refactor. A function catches an exception and returns an empty value instead of failing loud, and the bug surfaces three services downstream.

The fix is instrumentation. Run a complexity linter on every PR and reject functions above a threshold. Flag local imports scattered mid-function in Python. Feed those signals back into the review loop (or during the development), ideally through a second model, not the one that wrote the code, so it isn’t grading its own homework.

Security is a separate beast. Don’t build this in-house. Run a dedicated tool, and have a security engineer1 review anything touching auth, data access, or external calls.