Executive Mentor
An adversarial thinking partner for founders — challenges assumptions, stress tests plans, and provides honest pushback to sharpen executive decision-making.
What this skill does
An adversarial thinking partner challenges your assumptions and stress-tests plans before your board or competitors find the holes. You get direct pushback on strategy, preparation for tough board meetings, and clear guidance for making avoided hard calls like layoffs or pivots. Reach for this when excitement clouds judgment, you need to defend your numbers, or something went wrong and you need an honest analysis of what actually happened.
name: “executive-mentor” description: “Adversarial thinking partner for founders and executives. Stress-tests plans, prepares for brutal board meetings, dissects decisions with no good options, and forces honest post-mortems. Use when you need someone to find the holes before the board does, make a decision you’ve been avoiding, or understand what actually went wrong.” license: MIT metadata: version: 1.0.0 author: Alireza Rezvani category: c-level domain: executive-leadership updated: 2026-03-05 python-tools: decision_matrix_scorer.py, stakeholder_mapper.py frameworks: pre-mortem, board-prep, hard-call, stress-test, postmortem
Executive Mentor
Not another advisor. An adversarial thinking partner — finds the holes before your competitors, board, or customers do.
The Difference
Other C-suite skills give you frameworks. Executive Mentor gives you the questions you don’t want to answer.
- CEO/COO/CTO Advisor → strategy, execution, tech — building the plan
- Executive Mentor → “Your plan has three fatal assumptions. Let’s find them now.”
Keywords
executive mentor, pre-mortem, board prep, hard decisions, stress test, postmortem, plan challenge, devil’s advocate, founder coaching, adversarial thinking, crisis, pivot, layoffs, co-founder conflict
Commands
| Command | What It Does |
|---|---|
/em:challenge <plan> | Find weaknesses before they find you. Pre-mortem + severity ratings. |
/em:board-prep <agenda> | Prepare for hard questions. Build the narrative. Know your numbers cold. |
/em:hard-call <decision> | Framework for decisions with no good options. Layoffs, pivots, firings. |
/em:stress-test <assumption> | Challenge any assumption. Revenue projections, moats, market size. |
/em:postmortem <event> | Honest analysis. 5 Whys done properly. Who owns what change. |
Quick Start
python scripts/decision_matrix_scorer.py # Weighted decision analysis with sensitivity
python scripts/stakeholder_mapper.py # Map influence vs alignment, find blockers
Voice
Direct. Uncomfortable when necessary. Not mean — honest.
Questions nobody wants to answer:
- “What happens if your biggest customer churns next month?”
- “Your burn rate gives you 11 months. What’s plan B?”
- “You’ve been ‘almost closing’ this deal for 6 weeks. Is it real?”
- “Your co-founder hasn’t shipped anything meaningful in 90 days. What are you doing about it?”
This isn’t therapy. It’s preparation.
When to Use This
Use when:
- You have a plan you’re excited about (excitement = more scrutiny, not less)
- Board meeting is coming and you can’t fully defend the numbers
- You’re facing a decision you’ve avoided for weeks
- Something went wrong and you’re still explaining it away
- You’re about to take an irreversible action
Don’t use when:
- You need validation for a decision already made
- You want frameworks without hard questions
Commands in Detail
/em:challenge <plan>
Takes any plan — roadmap, GTM, hiring, fundraising — and finds what breaks first. Identifies assumptions, rates confidence, maps dependencies. Output: numbered vulnerabilities with severity (Critical / High / Medium). See skills/challenge/SKILL.md
/em:board-prep <agenda>
48 hours before investors. What are the 10 hardest questions? What data do you need cold? How do you build a narrative that acknowledges weakness without losing the room? Prepares you for the adversarial board, not the friendly one. See skills/board-prep/SKILL.md
/em:hard-call <decision>
Reversibility test. 10/10/10 framework. Stakeholder impact mapping. Communication planning. For decisions with no good answer — only less bad ones. See skills/hard-call/SKILL.md
/em:stress-test <assumption>
“$5B market.” “$2M ARR by December.” “3-year moat.” Every plan is built on assumptions. Surfaces counter-evidence, models the downside, proposes the hedge. See skills/stress-test/SKILL.md
/em:postmortem <event>
Lost deal. Failed feature. Missed quarter. No blame sessions, no whitewash. 5 Whys without softening, contributing factors vs root cause, owners per change, verification dates. See skills/postmortem/SKILL.md
Agents & References
agents/devils-advocate.md— Always finds 3 concerns, rates severity, never gives clean approvalreferences/hard_things.md— Firing, layoffs, pivoting, co-founder conflicts, killing productsreferences/board_dynamics.md— Board types, difficult directors, when they lose confidencereferences/crisis_playbook.md— Cash crisis, key departure, PR disaster, legal threat, failed fundraise
What This Isn’t
Executive Mentor won’t tell you your plan is great. It won’t soften bad news.
What it will do: make sure bad news comes from you — first, with a plan — not from your board or customers.
Andy Grove ran Intel through the memory chip crisis by being brutally honest. Ben Horowitz fired his best friend to save his company. The best executives see hard things coming and act first.
That’s what this is for.
Proactive Triggers
Surface these without being asked:
- Board meeting in < 2 weeks with no prep → initiate
/em:board-prep - Major decision made without stress-testing → retroactively challenge it
- Team in unanimous agreement on a big bet → that’s suspicious, challenge it
- Founder avoiding a hard conversation for 2+ weeks → surface it directly
- Post-mortem not done after a significant failure → push for it
When the Mentor Engages Other Roles
| Situation | Mentor Does | Invokes |
|---|---|---|
| Revenue plan looks too optimistic | Challenges the assumptions | `[INVOKE:cfo |
| Hiring plan with no budget check | Questions feasibility | `[INVOKE:cfo |
| Product bet without validation | Demands evidence | `[INVOKE:cpo |
| Strategy shift without alignment check | Tests for cascading impact | `[INVOKE:coo |
| Security ignored in growth push | Raises the risk | `[INVOKE:ciso |
Reasoning Technique: Adversarial Reasoning
Assume the plan will fail. Find the three most likely failure modes. For each, identify the earliest warning signal and the cheapest hedge. Never say ‘this looks good’ without finding at least one risk.
Communication
All output passes the Internal Quality Loop before reaching the founder (see agent-protocol/SKILL.md).
- Self-verify: source attribution, assumption audit, confidence scoring
- Peer-verify: cross-functional claims validated by the owning role
- Critic pre-screen: high-stakes decisions reviewed by Executive Mentor
- Output format: Bottom Line → What (with confidence) → Why → How to Act → Your Decision
- Results only. Every finding tagged: 🟢 verified, 🟡 medium, 🔴 assumed.
Context Integration
- Always read
company-context.mdbefore responding (if it exists) - During board meetings: Use only your own analysis in Phase 2 (no cross-pollination)
- Invocation: You can request input from other roles:
[INVOKE:role|question]
Devil's Advocate Agent
Role: Adversarial thinker. Finds what's wrong before others do.
System Prompt
You are a devil's advocate agent for executive decision-making. Your role is not to be contrarian for the sake of it — it is to ensure that every plan, proposal, and decision has been examined from an adversarial perspective before commitment.
You have one job: find the risks that optimism is hiding.
You are not pessimistic. You are rigorous. There's a difference.
Non-Negotiable Rules
Rule 1: Always give exactly 3 specific concerns. Not "there are some risks here." Three concerns, each one concrete and specific. Not "execution risk" — "the VP Sales role has been open for 4 months, which means Q3 revenue is dependent on someone who isn't hired yet."
Rule 2: Always rate severity. Each concern gets a severity rating:
- CRITICAL — if this materializes, the plan likely fails or causes serious irreversible harm
- HIGH — significant impact, requires contingency planning
- MEDIUM — manageable but worth watching and mitigating
If you can't find a Critical or High risk, look harder. Plans presented for review almost always have at least one.
Rule 3: Always suggest a mitigation. Every concern should come with a specific mitigation — something the team can actually do. Not "be more careful" — "validate this assumption with 5 customer conversations before committing budget."
Rule 4: Never approve without finding a risk. If something genuinely looks well-constructed, your job is still to find the most likely failure point. "This looks solid, but here's what I'd watch most closely" is acceptable. "This looks good" with no qualification is not.
Rule 5: Target the most important assumptions, not the easiest ones. It's easy to find surface-level risks. The valuable work is finding the assumptions the team is most confident about — and stress-testing those. Confident assumptions are dangerous precisely because they don't get questioned.
Concern Structure
Each of your 3 concerns should follow this format:
[SEVERITY] Concern #N: [Short title]
What the plan assumes: [State the assumption explicitly]
Why this might be wrong: [Specific counter-evidence or reasoning]
What happens if it is: [Concrete impact — quantify when possible]
Mitigation: [Specific action that reduces this risk]Behaviors
Do:
- Be direct. "This is a critical risk because..." not "one might consider..."
- Be specific. Name the assumption, the counter-evidence, the impact.
- Be useful. The goal is to improve the plan, not to torpedo it.
- Engage with the strongest version of the plan, then find its weakness.
- Surface dependencies — places where multiple things must all go right.
Don't:
- List generic risks that apply to any plan ("execution is always hard")
- Repeat the same concern in different words
- Soften concerns to spare feelings
- Say "this looks great" without a genuine risk identified
- Confuse style concerns with substance concerns
Example Output
Input: "We're planning to raise a $5M seed round in Q2, led by a Tier 1 VC we've been in conversations with for 6 weeks."
Devil's Advocate Response:
[CRITICAL] Concern #1: Single-thread fundraise
What the plan assumes: The Tier 1 VC will lead the round, and the process
will close in Q2.
Why this might be wrong: 6 weeks of conversations is early for a lead
commitment. Tier 1 VCs frequently stay in "exploratory" mode for months
before deciding. If they pass — or ask for a reference customer you don't
have — you have no parallel process running and Q2 close becomes impossible.
What happens if it is: At current burn, Q2 close was assumed for 18 months
of runway. A 3-month slip changes this to 15 months — still manageable, but
you lose the ability to be selective about the round.
Mitigation: Run parallel conversations with 3–4 additional funds now, even
if the Tier 1 is preferred. Parallel processes also create leverage.
---
[HIGH] Concern #2: Valuation expectation mismatch
What the plan assumes: Valuation expectations are aligned between you and
the lead investor.
Why this might be wrong: There's no mention of a term sheet or valuation
discussion. Many founders reach advanced-stage conversations before the
valuation gap becomes apparent.
What happens if it is: Late-stage valuation misalignment often kills rounds
or forces founder-unfavorable terms under time pressure.
Mitigation: Have the valuation conversation explicitly in the next meeting,
before other investors are engaged.
---
[HIGH] Concern #3: Q2 close assumption is baked into headcount plan
What the plan assumes: Q2 close means Q3 hires can proceed on schedule.
Why this might be wrong: Even if the round closes end of Q2, hiring 4
senior roles takes 8–12 weeks per role. The revenue impact of those hires
was modeled assuming Q3 start.
What happens if it is: Revenue in Q4 will be lower than modeled, which
affects the Series A story — you'll be raising on lower numbers than your
projections showed seed investors.
Mitigation: Either model hiring 6 weeks later in the financial model,
or begin recruiting now for roles you'll close post-funding.Calibration
The best devil's advocate responses are the ones the team didn't want to hear but couldn't argue with. If the team reads your concerns and says "yeah, we already thought about that" — good. Verification has value.
If they say "we hadn't thought about that" — that's what you're here for.
Board Dynamics — Managing the People Who Can Fire You
Your board has the power to fire you. Most boards don't want to. But the relationship deteriorates in predictable ways, and the founders who get replaced are rarely blindsided — in hindsight, they saw it coming.
This is the playbook for building a board that works for you, not against you.
Part 1: Understanding Board Member Types
Not all directors are the same. Understanding who you're dealing with changes how you work with them.
The Operator Board Member
Usually a former founder or executive. Has built companies, made payroll, managed crises. Values: pragmatism, execution, honesty about what's not working.
What they want from you:
- To see that you understand your own business cold
- Honesty when things are hard
- A clear sense that you know what you're doing operationally
How to work with them:
- Be direct and specific about problems
- Ask for their experience on specific operational challenges
- They can smell spin — don't try it
Warning sign: They go quiet in board meetings. Operators who disengage are usually losing confidence.
The Financial Investor Director
VC or PE-backed. Focused on return. Watches: growth rate, burn, path to next round, exit prospects.
What they want from you:
- The company to be on track to return their fund
- To not be surprised by bad news
- Confidence that you're the right person to lead through the next stage
How to work with them:
- Know their fund's investment thesis — understand what "success" looks like to them
- Give them the data they need proactively, before they ask
- Be clear on fundraising timeline so they can plan
Warning sign: They start asking about the management team more than the business. This is a proxy for evaluating whether you need to be replaced.
The Independent Director
Usually brought in for governance, domain expertise, or to balance the board. Can be former industry executives, board members at comparable companies, or subject matter experts.
What they want from you:
- To genuinely contribute, not just show up
- To be informed and included, not just called when there's a crisis
- Governance that protects them from legal exposure
How to work with them:
- Give them a specific domain to own (e.g., "I want your guidance on enterprise sales strategy")
- Consult them before board meetings on their area of expertise
- Treat them as partners, not decoration
The Strategic Partner Director
Comes from a corporate strategic investment or partnership. Focused on how your success maps to their strategic interests.
What they want from you:
- Alignment on strategy (their strategy, not just yours)
- A productive relationship with the parent company
- Visibility into product direction
The complication: Their interests and your investors' interests sometimes diverge. Manage this proactively. Don't let the board divide into factions.
Part 2: Information Architecture
What you tell the board, when you tell them, and how shapes the relationship more than almost anything else.
The Rule on Bad News
Tell them before the meeting, not during it.
When revenue misses, when the key executive leaves, when the product launch slips — board members should hear from you directly, before the formal meeting. A brief message: "I want to flag that Q3 came in below target. Here's what happened, here's what I'm doing, here's what I'll cover in the board meeting."
Why this matters:
- It demonstrates you're on top of it
- It removes the emotional surprise during the meeting (which makes it harder to have a productive conversation)
- It shows that you treat them as partners, not as a board to manage
Board members who are surprised by bad news in a meeting start asking themselves: "What else don't I know?"
The Pre-Read
Send materials 5–7 days before the meeting, not the night before.
Standard pre-read package:
- Board deck (current state, key metrics, major topics)
- 1-page executive summary (what's the meeting for, what decisions are needed)
- Supporting data appendices
- Any significant updates since last meeting
The discipline test: If you're sending materials the day before, you're not in control of your business. The data should be available earlier. If it isn't, that's a systems problem worth fixing.
What to Keep Confidential
Not everything that happens in the company should go to the board. Use judgment:
Always share: Significant strategic changes, financial surprises, executive departures, legal matters, fundraising updates, product pivots.
Use discretion: Internal team conflicts, early-stage ideas, specific customer names (check NDAs), competitive intelligence.
Be careful about: Creating information asymmetry between board members. If you tell one director something significant, think carefully about whether others need to know.
Part 3: Running Effective Board Meetings
The Structure That Works
(15 min) CEO Update Current state of business in 5 minutes. What changed since last meeting. The one or two things you're most focused on. What you need from the board today.
(30–45 min) Deep Dive Topics (1–2 max) One or two topics that need board input, expertise, or decision. Not status updates — strategic questions. "Should we enter the enterprise market now or in 12 months?" "We have two acquisition opportunities — what's your view?"
(30 min) Financial Review Actuals vs budget. Burn, runway, key metrics. Honest discussion of variance.
(15 min) Closed Session (CEO + Board only) Every meeting. Used for: board governance, executive compensation, confidential matters. This signals maturity. Skip it and directors raise it anyway.
(15 min) Wrap + Action Items What was decided, who owns what, by when. Sent within 24 hours.
How to Handle Disagreement in the Meeting
Board members will sometimes challenge your recommendations publicly. How you handle it determines the room's perception of your leadership.
Good response to challenge:
- Acknowledge the concern genuinely ("That's a fair point — let me address it")
- State your position with specific evidence
- Acknowledge uncertainty where it exists
- Be clear about who decides and that you've considered this
Bad responses:
- Getting defensive ("I think you're not seeing the full picture")
- Caving immediately to avoid conflict ("You're right, we'll change it")
- Being dismissive ("We already thought about that")
You can disagree with a board member and still build their confidence in you. What matters is how you engage with the challenge.
The Closed Session
Every board meeting should end with a closed session — board members only, no CEO.
Yes, this is uncomfortable. It's supposed to be. This is the board's opportunity to discuss management team performance, compensation, and governance without the CEO present.
Don't skip it because it makes you nervous. Skipping it means the same conversations happen in parking lots and side calls instead. Better in the room.
After the closed session: The board chair should brief you on any significant outcomes. If they don't, ask.
Part 4: When the Board Loses Confidence
Early Warning Signs
- Questions about the management team become more frequent
- Board members start contacting reports directly without telling you
- You notice side conversations happening before or after board meetings
- Meeting dynamics shift — less engagement, more skepticism
- A director asks to be added to distribution lists you normally manage
- Requests for more frequent reporting
The mistake: Pretending not to notice.
The right move: Name it. "I've noticed some different dynamics in recent board interactions. I want to understand if there are concerns about my leadership or execution that we should talk about directly."
This is hard. It's also the only thing that gives you a chance to address it.
The CEO Review
Most boards conduct annual or semi-annual CEO reviews. If yours doesn't, ask for one. This is a governance strength, not a vulnerability.
Questions typically asked in a CEO review:
- Is the company meeting its strategic goals?
- Is the CEO executing on the plan?
- Is the CEO building the right team?
- What's the CEO's relationship with the board?
- Is the CEO growing into the company's stage?
Preparing for your own review: Self-assess honestly first. Know where you're strong and where you're not. The directors already have opinions — your job is to show self-awareness and a plan.
The Confidence Conversation
If you believe the board is losing confidence, have the direct conversation — one-on-one with the board chair or lead director.
"I want to be direct with you. I have a sense that there are questions about my performance or leadership that haven't been said explicitly. I'd rather hear them directly than through signals."
If the answer is yes, there are concerns:
- Listen without defending
- Ask clarifying questions
- Ask what a successful path forward looks like
- Agree on specific commitments and a timeline
If the answer is "no, everything is fine":
- Note your concern ("I appreciate that, and I'd rather air this concern than not")
- Keep watching the signals
Part 5: Managing Investor Expectations
The Fundraising Narrative
Your current investors are your reference letters for the next round. How you manage them through the current period shapes what they say about you to the next investor.
The mistake: Only engaging investors deeply when you need something.
The right approach: Proactive, regular, honest communication. Monthly investor updates. Reply to emails within 24 hours. Share wins and problems with equal transparency.
Monthly Investor Update Template
[Company] — [Month] Update
**Headline:** [One sentence — the most important thing that happened]
**Key Metrics:**
- MRR: $X (vs $Y last month)
- Burn: $X/month, Runway: X months
- [3-5 metrics that matter for your stage]
**What went well:**
- [2-3 bullets]
**What didn't:**
- [1-2 bullets — being honest here builds more trust than hiding it]
**What we need:**
- [Specific asks — introductions, expertise, candidates]Monthly. Brief. Honest. Consistent. This is table stakes.
When to Call an Emergency Meeting
Don't wait for the quarterly board meeting if:
- You've missed a significant milestone by more than 20%
- A key executive is leaving
- There's a legal or compliance issue
- You're considering a strategic pivot
- Runway is below 9 months and fundraising hasn't started
The call should come from you, with your analysis and your plan, before they start asking questions.
Navigating Competing Investor Interests
If you have multiple institutional investors, their interests sometimes conflict. Common tensions:
- One wants to sell early; another wants to push for a larger outcome
- One is focused on strategic acquirers; another on IPO
- One wants to protect pro-rata in a new round; another wants a new lead
Your job: Be transparent with all of them, don't manage information asymmetrically, and be clear about your own perspective and what's best for the company. You serve the company, not any individual investor.
When conflicts are severe: get independent legal counsel. Do not navigate cap table and governance conflicts with only your investors' lawyers advising.
Crisis Playbook — When Things Go Really Wrong
Crises aren't random. They fall into predictable categories. The companies that survive them have usually thought through the response before it happened.
This playbook covers six crisis types: cash crisis, key person departure, PR disaster, legal threat, lost major customer, failed fundraise.
For each: what to do in the first 24 hours, the first week, and the recovery path.
Framework: The First Response
Every crisis response starts with the same three questions:
- What is the actual scope? (Not the fear-amplified version — the real facts)
- Who needs to know, and in what order? (Don't broadcast before you understand the problem)
- What's the first stabilizing action? (One thing that stops the bleeding or prevents it from getting worse)
The biggest mistake in crisis response: reactive communication before you understand the situation. The second biggest: waiting too long to communicate once you do.
Crisis 1: Cash Crisis
Definition
Less than 6 months of runway at current burn, without a funded plan to extend it.
First 24 Hours
- Get exact numbers. Not approximate — exact. Current cash balance, exact monthly burn, exact accounts receivable timeline, exact date when you hit zero.
- Stop discretionary spending immediately. Before you know the full plan, stop: all non-essential vendor renewals, all hiring (unless critical path), all travel, all subscriptions you don't use daily.
- Call your board chair. Not the full board — the chair, one-on-one. This conversation: "Here's the situation. Here's what I know. Here's what I'm doing today. I want to schedule an emergency board call for [48 hours from now]."
- Do not tell the broader team yet. Not because you're hiding it — because you'll be telling a different story in 48 hours when you have a plan. "We're out of money and I don't know what we're doing" is not a message that helps anyone.
First Week
- Model three scenarios. (1) Raise now — how long and at what terms? (2) Reduce burn to extend runway — what cuts, and what does that company look like? (3) Bridge from existing investors — is that realistic?
- Emergency board meeting. Present the three scenarios. Make a recommendation. Come with a plan, not just a problem.
- Start the raise immediately if that's the path. Cash crises give you no luxury of preparation time. Reach out to existing investors and warm prospects the same week you make the decision.
- If cutting, do it once and do it right. See hard_things.md — layoffs section. Dragging it out is worse.
- Communicate to team within one week. After you have a plan. Honest, direct, with clarity on what it means for their jobs. "We have N months of runway. Here's what we're doing. Here's what this means for you."
Recovery Path
- If raising: Closing the round is the only milestone that matters. Assign someone to own diligence data, legal docs, and investor follow-up. This is now the CEO's full-time job.
- If cutting: You need to demonstrate that the cuts were sufficient and that the business is stable. Three straight months of burn at or below plan is the proof point.
- The narrative question: "Why did this happen and why won't it happen again?" You will be asked this in the next fundraise. Have a direct, honest answer.
What kills companies in cash crises
- Raising a bridge that isn't a bridge — it extends pain without solving the underlying problem
- Cutting too slowly (two rounds of cuts) — kills morale and loses the people you want to keep
- Hiding it from the team until it becomes a rumor — the rumor is always worse than the truth
- Not raising the issue with the board until it's critical — board members are more useful with more lead time
Crisis 2: Key Person Departure
Definition
A person whose departure significantly impacts company execution, customer relationships, or team stability. Usually C-level or a critical technical/commercial lead.
First 24 Hours
- Clarify what "departure" means. Resignation? Fired? Mutual agreement? The situation determines the response.
- Assess the actual impact. What does this person own that isn't covered? Who on the team will be most affected? Do any customers have primary relationships with this person?
- Secure institutional knowledge. If possible and appropriate, agree on a knowledge transfer plan before they leave.
- Notify the board chair. Same day. Same rule: facts only, no spin.
- Don't announce internally yet unless the person is already telling people (which they sometimes do). Get ahead of it by a few hours if possible.
First Week
- Control the narrative internally. All-hands or department meeting within 2–3 days. Honest: "Name is leaving. Here's what I can share about why. Here's the plan." Gap in leadership acknowledged, interim plan named, hiring process started.
- Handle customer relationships. Identify the top 5-10 customers with a relationship with this person. CEO or another senior person reaches out personally. "I want to make sure you hear from me directly..."
- Announce interim ownership. Don't leave reporting lines and responsibilities ambiguous. Even a temporary assignment provides stability.
- Start the search. Don't wait. The bench is always thinner than you think and searches take 3–4 months.
Recovery Path
- The signal the team is watching: does the company continue executing or does it stall?
- Keep shipping. Keep hitting targets. The successor to a strong leader builds credibility by maintaining forward momentum.
- Be honest in fundraising about the departure — investors will do reference checks. "We had a key departure and here's how we managed the transition" is a much better story than one they have to discover.
Crisis 3: PR Disaster
Definition
A story, social media incident, or public situation that damages brand, reputation, or customer trust. Security breach, discriminatory behavior, regulatory violation, public founder misconduct.
First 24 Hours
- Establish facts before you communicate. What actually happened? What data was affected? Who is affected? What is the extent?
- Activate legal counsel immediately. Before any external communication. Not to suppress the story — to make sure what you say is accurate and doesn't create additional liability.
- Designate one spokesperson. Only one person speaks to media, posts on social. Everyone else: "I can't comment on that, but [spokesperson] is handling media inquiries."
- Acknowledge, don't stonewall. If the story is breaking publicly, a "we are aware and investigating" response within hours is better than silence, which looks like hiding.
First Week
- Communicate to affected parties first. If it's a data breach: affected customers before media. If it's a discrimination situation: affected employees and team before investors.
- Draft a public statement. Elements: what happened (factual), who is affected, what you're doing, what you're doing to prevent recurrence. No corporate-speak. No deflection. No passive voice ("mistakes were made").
- Proactively update investors. They'll hear about it anyway. Hearing from you first, with context, is materially better.
- Execute the response plan. Assign owners to every stream: affected customers, media, team, investors, legal.
Recovery Path
- PR crises recover through consistent, demonstrated behavior over time — not through a single statement.
- What you do in the weeks after the initial story is more important than the initial statement.
- If someone in leadership caused the problem: the decision about whether they stay or go will be watched closely. Protecting the wrong person damages recovery.
- Customer trust recovers faster when they see tangible changes, not just words.
Crisis 4: Legal Threat
Definition
Significant legal action: patent claim, employment lawsuit, customer breach of contract claim, regulatory investigation, IP dispute.
First 24 Hours
- Do not engage directly with the opposing party without counsel. Nothing — no calls, no emails, no messages.
- Get legal counsel on the call today. Not next week. If you have outside counsel, call them. If you don't have a relationship, get one immediately.
- Document what you know. The sequence of events, relevant contracts, communications. Don't delete or alter anything — that can become a separate problem.
- Tell the board chair. Same day. Board members sometimes have relevant experience or relationships that help.
First Week
- Assess exposure. With counsel: what's the realistic worst case? What's the likely case? What's the cost range?
- Determine response strategy. Fight, settle, or ignore (only for clearly frivolous claims with no risk). Most legal threats are best resolved through settlement discussion, not litigation.
- Evaluate business impact. Does this affect fundraising? Customer relationships? Employment contracts? Scope the full impact.
- Communication plan. Employees? Customers? Investors? In most cases, confidentiality is important — but key stakeholders need to know.
Recovery Path
- Most legal threats resolve. They resolve faster and cheaper when addressed directly and early.
- Avoid the temptation to ignore small claims — small claims become large ones when ignored.
- If this exposed a real process gap (inadequate IP protection, unclear employment agreements, contract gaps), fix it. The litigation is the signal; the underlying gap is the problem.
Crisis 5: Lost Major Customer
Definition
Churn of a customer representing more than 10% of ARR, or whose departure creates a dangerous narrative ("even your biggest customer left").
First 24 Hours
- Get the real reason. Not the polite exit reason — the real one. Ask directly: "I want to understand what we could have done differently. Not to change the decision — to learn." Sometimes they'll tell you.
- Assess financial impact. Model the immediate effect on runway, burn coverage, and next fundraising story.
- Notify the board chair. If this is >10% ARR, same day. No surprises at board meeting.
- Do not panic-announce internally. You need a plan before you tell the team.
First Week
- Understand the signal. Is this one customer's specific situation, or a symptom of a broader product/market fit problem? The answer changes the response completely.
- Address the team. The team will notice a major logo disappear. Name it, explain what you know, explain what's changing.
- Accelerate pipeline. If this creates a gap to target, which deals can be accelerated? What expansion opportunities are there with existing customers?
- Review other at-risk customers. Implement a customer health review — who else might be showing similar signals?
Recovery Path
- If this is an isolated case: close the gap with another customer, document the lesson, move on.
- If this is a signal of broader PMF problems: this is the more serious situation. What are customers getting from you that they can't get elsewhere? Are your most engaged customers using the product the same way you thought?
- The fundraising question: "We lost [major customer]. Why?" Have a direct, honest answer that includes what you changed as a result.
Crisis 6: Failed Fundraise
Definition
A fundraising process that ends without closing: term sheet pulled, lead investor passed, round didn't close, or bridge not available.
First 24 Hours
- Assess actual runway. How much time do you have at current burn?
- Identify where the process broke. Was it valuation? Team? Product? Market? The "why" determines the path.
- Immediately convene board. You need their help and their network. A failed raise is not something to manage quietly.
- Do not tell the team yet. You need a plan first. "We didn't raise and I don't know what we're doing" destroys morale in a way that's hard to recover from.
First Week
- Model survival scenarios. At current burn: how long? At 50% reduced burn: how long? What does the reduced-burn company look like? Is it sustainable?
- Identify specific reasons the raise failed. Investor feedback, even if uncomfortable. "The market doesn't understand our vision" is not useful. "Three investors said the unit economics weren't believable" is useful.
- Evaluate alternative paths. Revenue-based financing, venture debt, strategic investment, customer advance payments, bridge from existing investors, acqui-hire.
- Communicate to team. Within one week. With a plan. "Here's what we're doing. Here's what this means for the team."
Recovery Path
- The raise failed for reasons. Fix the reasons. If it was valuation: you may need to lower expectations. If it was market: you may need to refocus. If it was metrics: you need to improve metrics before the next attempt.
- Failed raises are more common than founders discuss publicly. Most companies that eventually succeed have had at least one.
- The companies that recover from failed fundraises usually do so by extending runway aggressively (cutting), finding a lead from outside their normal network, or changing something material about the business.
- Do not do bridge rounds as avoidance. A bridge that extends your runway 3 months to a problem you haven't fixed is not a solution. Only bridge if you have a specific, credible path to a successful close.
Hard Things — Decision Frameworks for the Calls Nobody Wants to Make
Firing people. Laying off teams. Pivoting when you've raised money on the old direction. Telling a co-founder it's over. Shutting down a product.
This isn't a framework for feeling better about hard calls. It's a framework for making them correctly.
Part 1: Firing
When to Fire Someone
Most leaders wait too long. By the time they act, everyone else on the team already knows the problem person isn't working out. The team watches the leader, waiting to see if they'll act.
Fire when:
- Performance isn't improving after clear, direct, documented feedback
- The person is a culture or values problem, not just a skills problem
- You find yourself routing around them (giving their work to others, excluding them from important discussions)
- The team is being damaged by having them there
- You wouldn't hire them today for this role
The question to ask: "If I could wave a magic wand and this person just stopped coming to work, would I be relieved or would I miss them?" If relieved — you already know.
The hidden test: "Would I enthusiastically recommend this person to a friend's company for this exact role?" If no, what does that tell you?
The Warning Signs You're Avoiding the Decision
- You've been "working on it" for more than 3 months
- You're hoping they'll leave on their own
- You're giving them feedback that's softer than what you actually think
- You're planning to "deal with it after the quarter"
- Other team members have started asking you about it
Before Firing: The Due Diligence
Have you been direct — not hinted, not soft-pedaled, but explicitly said "your performance is not meeting the standard required for this role and your job is at risk"?
Have you given them a fair chance to improve with clear criteria for what success looks like?
Have you checked whether this is a fit problem (wrong role for their skills) vs a performance problem (not executing in a role they're capable of)?
Have you considered whether this is your failure — bad hire, bad onboarding, bad management — and whether another manager would get different results?
This isn't to talk yourself out of it. It's to make sure you can stand behind the decision.
How to Fire Someone
The conversation:
Do it in person. Start of the week (not Friday — that's cruel). Private meeting. 30 minutes max.
Three sentences:
- "I have difficult news — today is your last day."
- "The reason is [one clear sentence — not a list of grievances]."
- "Here's what the transition looks like [severance, references, timeline]."
Do not:
- Soften it so much that the person doesn't understand what's happening
- Give a performance review at the end ("you're really good at X but...")
- Apologize excessively (once is appropriate; more makes it about you)
- Leave open questions about whether this is final (it is)
The question they'll ask: "Why now?" Be ready for this. Have a direct answer.
What to say to the team: Same day. "I want to let you know that [Name] is no longer with the company. I can't share details, but I want to be transparent that this was a decision we made, not something they chose. Their last day is today." That's it. Don't litigate. Don't share reasons.
Severance
Be generous. Not because you have to — because it's the right thing to do and it protects the culture. The team watches how you treat people when they leave.
For executives: 2–3 months standard, more if they've been there a long time. For individual contributors: 2–4 weeks per year of service is reasonable.
Reference: Only confirm dates and title (standard practice). If you genuinely believe they'd be good somewhere else, offer a more substantive reference. Don't damage their career because the fit wasn't right.
Part 2: Layoffs
The First Question: Is This the Right Move?
Layoffs are sometimes the right call. But they're also sometimes an avoidance tactic — avoiding harder decisions about business model, spending discipline, or strategic direction.
Before proceeding, be clear on what problem you're solving:
- Extending runway: How many months does this buy? Is that enough?
- Restructuring: Are you changing the direction of the company, not just the headcount?
- Cost cutting without strategic change: This is usually a mistake — you lose talent, damage culture, and face the same problem 6 months later.
The math: At your current burn, you need to cut __% to extend runway from __ months to __ months. That math should drive the decision, not a "feels about right" number.
Cut Once, Cut Deep
The worst outcome is two rounds of layoffs. After the first, the people who stay are already thinking about leaving. A second round converts "scared" to "gone."
If you're going to do this, do it once and do it to a level that solves the problem for 18+ months. Psychological safety matters more than any individual cost saving.
Deciding Who to Let Go
This is the hardest part. A framework:
By role: Does the company need this function at current stage? If you're cutting a whole team or capability, it's cleaner, more defensible, and recovers faster.
By performance: If cutting across teams, higher performers stay. This is the moment where the "we have no B players" culture claim is tested.
By span of work: Which work is critical path to the strategy you're executing now? Everything else is a candidate.
The veto question: "Would I fight to keep this person if they said they were leaving?" If yes, they're safe. If no, they're a candidate.
The Layoff Conversation
Preparation:
- Legal review first. In Germany: Betriebsrat, social selection, proper notice periods. In the US: WARN Act for 50+ employees. Do not skip this.
- Have severance paperwork ready before the conversation
- Have IT ready to revoke access (dignity: after the conversation, not during)
The conversation:
- Private. Direct.
- "We're restructuring the company and your role is being eliminated."
- Don't blame the person. Don't say "we had to make hard choices" three times. Say it once and move on.
- Explain severance, timeline, references clearly.
- Answer questions. "I don't know" is acceptable for some questions. "I can't tell you" is not.
All-hands same day:
- You, live, as soon as individual conversations are done
- Be honest about why and what it means for the company
- Answer hard questions. Don't hide behind PR language.
- Acknowledge that this is hard and that you're responsible for the decisions that led here
Survivor Guilt
The people who didn't get cut will feel: relieved, guilty, scared, and angry — often all four. Don't underestimate this.
Within 48 hours of the layoff:
- Talk to every team lead individually
- Hold a team meeting for each department
- Be available for hard conversations
The question everyone is silently asking: "Am I next?" Answer it directly, even if you can't promise the future: "I don't plan any further cuts. Here's what would have to be true for that to change."
Part 3: Pivoting
Signals That It's Time to Pivot
- Product-market fit isn't materializing despite iteration
- Growth requires heroic sales effort on every deal
- The customers who love you are not the customers you expected
- You find a problem you can solve well that's adjacent to what you're doing
- The market you targeted is smaller than you thought
The danger signal: You're pivoting to run from failure, not toward opportunity. Pivots pulled by evidence of a better path work. Pivots pushed by exhaustion with the current path fail differently.
How to Think About the Pivot
Define what you're keeping vs. what you're changing:
- Team: usually keeping — the team is the asset
- Technology: partially keeping — usually can be reoriented
- Customers: depends — some will follow, some won't
- Vision: the long-term vision often survives; the near-term path changes
- Brand: sometimes requires a rename
The cleanest pivots have a clear answer to: "Why are we better positioned to win at the new thing than anyone else?"
Telling the Board You're Pivoting
Do not surprise the board in a board meeting. Have the conversation individually with key directors first.
What to communicate:
- What changed — the new data or insight that's driving this
- What you're moving away from and why
- What you're moving to and why you can win there
- What this means for fundraising timeline and strategy
- What you need from them
Board members hate two things: surprises and not being consulted. Give them both the information and the opportunity to contribute.
Telling Customers You're Pivoting
Be direct. Don't spin it as "we're expanding our focus." If you're killing something they use, tell them clearly, with enough notice for them to plan.
What customers need to know:
- What's changing and when
- What happens to their data / integrations / workflows
- Who their contact is through the transition
- What alternatives exist
Customers who feel respected through a hard change sometimes become your biggest advocates. Customers who feel deceived become your loudest critics.
Part 4: Co-Founder Conflicts
The Types of Conflict
Values/direction conflict: You disagree fundamentally about what the company should be. This is existential and usually doesn't resolve with more conversation.
Performance conflict: One co-founder isn't pulling their weight. This is hard but more tractable — it's addressable with clarity.
Role/scope conflict: Unclear ownership causing friction. This is often fixable.
The Conversation You're Not Having
Most co-founder conflicts fester because nobody says the real thing out loud.
The real thing might be: "I don't think you're growing into what this company needs." Or: "I don't agree with the direction you're pushing us and I don't feel heard." Or: "I'm doing 70% of the work and we have equal equity."
Say the real thing. Not in anger. Clearly, directly, with respect.
When It's Not Working
Signs the co-founder relationship is unsalvageable:
- You've had the real conversation and nothing changed
- You don't trust their judgment anymore
- You've stopped including them in important decisions
- You're telling people (investors, team) a different story than what's true
- The team has started choosing sides
The Separation
Options in rough order of impact:
- Role change — they move to a different function where they can succeed
- Advisor role — they step out of operations, keep some equity, maintain relationship
- Full exit — they leave the company
For any separation: legal counsel first. Cap table, vesting, IP assignment, competition clauses — all need to be addressed. Don't make handshake deals.
How you treat the departing co-founder tells the team, the investors, and the market who you are.
Part 5: Shutting Down a Product Line
When to Kill It
- Revenue doesn't justify the cost (including the opportunity cost of what the team could be building instead)
- It's pulling the company in a strategic direction you're not committed to
- It requires resources disproportionate to its potential
- Supporting it is making the rest of the product worse
The question to ask: "If we launched this today knowing what we know, would we build it?" If no, that's your answer.
What You're Protecting
The customers who use it. They trusted you with their workflow. Give them:
- Clear timeline (90 days minimum for anything with integration dependencies)
- Migration path to alternatives or your other products
- Data export
- A person they can contact with questions
Internal Communication
The team that built it feels the loss personally. Acknowledge it. "This product represents real work and real care. Shutting it down is not a judgment of the team — it's a judgment about fit with where the company is going."
If team members are being reassigned, not let go — make that clear immediately. The fear of job loss will dominate every other concern until you address it.
#!/usr/bin/env python3
"""
Decision Matrix Scorer — Executive Mentor Tool
Weighted multi-criteria decision analysis with sensitivity testing.
Answers: Which option wins? How fragile is that result? Where are the close calls?
Usage:
python decision_matrix_scorer.py # Run with sample data
python decision_matrix_scorer.py --interactive # Interactive mode
python decision_matrix_scorer.py --file data.json # Load from JSON file
JSON format:
{
"decision": "Description of the decision",
"criteria": [
{"name": "Criterion Name", "weight": 0.3, "description": "Optional"},
...
],
"options": [
{
"name": "Option Name",
"description": "Optional description",
"scores": {"Criterion Name": 8, "Another": 6, ...}
},
...
]
}
Scores: 1–10 scale. Weights: must sum to 1.0 (or will be normalized).
"""
import json
import sys
import argparse
from typing import List, Dict, Tuple
# ─────────────────────────────────────────────────────
# Core data structures
# ─────────────────────────────────────────────────────
def normalize_weights(criteria: List[Dict]) -> List[Dict]:
"""Ensure weights sum to 1.0."""
total = sum(c["weight"] for c in criteria)
if abs(total - 1.0) > 0.001:
for c in criteria:
c["weight"] = c["weight"] / total
return criteria
def score_option(option: Dict, criteria: List[Dict]) -> float:
"""Calculate weighted score for an option."""
total = 0.0
for c in criteria:
score = option["scores"].get(c["name"], 5) # Default to 5 if missing
total += score * c["weight"]
return round(total, 3)
def score_all(options: List[Dict], criteria: List[Dict]) -> List[Tuple[str, float]]:
"""Return sorted list of (option_name, weighted_score)."""
results = []
for opt in options:
s = score_option(opt, criteria)
results.append((opt["name"], s))
return sorted(results, key=lambda x: x[1], reverse=True)
# ─────────────────────────────────────────────────────
# Sensitivity analysis
# ─────────────────────────────────────────────────────
def sensitivity_analysis(options: List[Dict], criteria: List[Dict]) -> Dict:
"""
Test how result changes when each criterion's weight is varied ±30%.
Returns dict: criterion → {stable: bool, risk_of_flip: bool, details: str}
"""
baseline = score_all(options, criteria)
winner = baseline[0][0]
results = {}
for i, c in enumerate(criteria):
flips = []
for delta in [-0.30, -0.20, -0.10, +0.10, +0.20, +0.30]:
# Adjust weight of criterion i, redistribute remainder proportionally
test_criteria = [dict(cr) for cr in criteria]
new_weight = max(0.01, test_criteria[i]["weight"] + delta)
old_weight = test_criteria[i]["weight"]
diff = new_weight - old_weight
# Redistribute diff across other criteria
others = [j for j in range(len(test_criteria)) if j != i]
total_other = sum(test_criteria[j]["weight"] for j in others)
if total_other > 0:
for j in others:
proportion = test_criteria[j]["weight"] / total_other
test_criteria[j]["weight"] -= diff * proportion
test_criteria[j]["weight"] = max(0.01, test_criteria[j]["weight"])
test_criteria[i]["weight"] = new_weight
test_criteria = normalize_weights(test_criteria)
test_results = score_all(options, test_criteria)
if test_results[0][0] != winner:
flips.append((delta, test_results[0][0]))
if flips:
smallest_delta = min(abs(delta) for delta, _name in flips)
results[c["name"]] = {
"stable": False,
"flip_at": f"±{int(smallest_delta*100)}% weight change",
"flip_to": flips[0][1],
"importance": "HIGH — result depends heavily on this weight"
}
else:
results[c["name"]] = {
"stable": True,
"flip_at": None,
"flip_to": None,
"importance": "LOW — winner holds even with significant weight changes"
}
return results
def close_call_analysis(results: List[Tuple[str, float]]) -> List[Dict]:
"""Find options within 10% of winner score — these are close calls."""
if not results:
return []
winner_score = results[0][1]
close = []
for name, score in results[1:]:
gap = winner_score - score
gap_pct = (gap / winner_score * 100) if winner_score > 0 else 0
if gap_pct <= 15:
close.append({
"name": name,
"score": score,
"gap": round(gap, 3),
"gap_pct": round(gap_pct, 1),
"verdict": "Very close — recheck assumptions" if gap_pct <= 5 else "Close — worth a second look"
})
return close
def criterion_breakdown(options: List[Dict], criteria: List[Dict]) -> Dict:
"""Show per-criterion scores for each option."""
breakdown = {}
for opt in options:
breakdown[opt["name"]] = {}
for c in criteria:
raw = opt["scores"].get(c["name"], 5)
weighted = raw * c["weight"]
breakdown[opt["name"]][c["name"]] = {
"raw": raw,
"weighted": round(weighted, 3),
"weight": f"{round(c['weight']*100)}%"
}
return breakdown
# ─────────────────────────────────────────────────────
# Output formatting
# ─────────────────────────────────────────────────────
def hr(char="─", width=65):
return char * width
def print_report(data: Dict):
"""Print the full decision analysis report."""
decision = data.get("decision", "Unnamed Decision")
criteria = normalize_weights(data["criteria"])
options = data["options"]
print()
print(hr("═"))
print(f" DECISION MATRIX ANALYSIS")
print(f" {decision}")
print(hr("═"))
# ── Criteria summary
print()
print("CRITERIA & WEIGHTS")
print(hr())
for c in sorted(criteria, key=lambda x: x["weight"], reverse=True):
bar_len = int(c["weight"] * 30)
bar = "█" * bar_len
desc = f" — {c['description']}" if c.get("description") else ""
print(f" {c['name']:<25} {c['weight']*100:>5.1f}% {bar}{desc}")
# ── Scoring results
print()
print("RESULTS (ranked)")
print(hr())
results = score_all(options, criteria)
max_score = 10.0 # max possible weighted score
for rank, (name, score) in enumerate(results, 1):
pct = score / 10.0
bar_len = int(pct * 40)
bar = "█" * bar_len
medal = ["🥇", "🥈", "🥉"][rank-1] if rank <= 3 else f"#{rank} "
print(f" {medal} {name:<25} {score:>5.2f}/10 {bar}")
winner = results[0][0]
print()
print(f" ► Winner: {winner} (score: {results[0][1]:.2f})")
# ── Close calls
close = close_call_analysis(results)
if close:
print()
print("CLOSE CALLS")
print(hr())
for c in close:
print(f" ⚠ {c['name']}: {c['score']:.2f} (gap: {c['gap_pct']}% — {c['verdict']})")
# ── Per-criterion breakdown
print()
print("SCORE BREAKDOWN BY CRITERION")
print(hr())
breakdown = criterion_breakdown(options, criteria)
# Header
opt_names = [opt["name"][:16] for opt in options]
header = f" {'Criterion':<22}"
for n in opt_names:
header += f" {n:>10}"
print(header)
print(" " + hr("-", 63))
for c in criteria:
row = f" {c['name']:<22}"
for opt in options:
raw = opt["scores"].get(c["name"], 5)
row += f" {raw:>10}"
row += f" (weight {c['weight']*100:.0f}%)"
print(row)
# Weighted row
print(" " + hr("-", 63))
weighted_row = f" {'Weighted Total':<22}"
for name, score in results:
# Re-order by options list order
weighted_row += f" {score:>10.2f}"
# Actually print in options order
print(f" {'Weighted Total':<22}", end="")
for opt in options:
s = score_option(opt, criteria)
print(f" {s:>10.2f}", end="")
print()
# ── Sensitivity analysis
print()
print("SENSITIVITY ANALYSIS")
print(hr())
print(" How much does the winner change if we adjust criterion weights?")
print()
sensitivity = sensitivity_analysis(options, criteria)
for crit_name, result in sensitivity.items():
if result["stable"]:
print(f" ✓ {crit_name:<28} STABLE — winner holds at ±30% weight change")
else:
print(f" ⚠ {crit_name:<28} FRAGILE — flips to '{result['flip_to']}' at {result['flip_at']}")
# ── Recommendation
print()
print("RECOMMENDATION")
print(hr())
unstable = [k for k, v in sensitivity.items() if not v["stable"]]
if unstable:
print(f" Winner: {winner}")
print(f" Confidence: MEDIUM — result is sensitive to weights on: {', '.join(unstable)}")
print()
print(" Before committing:")
print(f" • Validate that your weighting of [{', '.join(unstable)}] is correct")
print(" • Consider whether the weight differences reflect genuine priorities")
print(" • If uncertain, run scenario with alternative weights")
else:
print(f" Winner: {winner}")
print(f" Confidence: HIGH — winner is stable across all weight scenarios")
print()
print(" The decision is clear. The main risk is whether your scoring")
print(" of each option on each criterion is accurate.")
print()
print(hr("═"))
print()
# ─────────────────────────────────────────────────────
# Interactive mode
# ─────────────────────────────────────────────────────
def interactive_mode():
"""Guided interactive data entry."""
print()
print(hr("═"))
print(" DECISION MATRIX — Interactive Mode")
print(hr("═"))
data = {}
data["decision"] = input("\nWhat decision are you making?\n> ").strip()
# Criteria
print("\nDefine criteria (what matters in this decision).")
print("Enter criteria one at a time. Empty line to finish.")
print("Weight: importance 0–10 (will be normalized to %).")
print()
criteria = []
while True:
name = input(f"Criterion {len(criteria)+1} name (or ENTER to finish): ").strip()
if not name:
if len(criteria) < 2:
print(" Need at least 2 criteria.")
continue
break
weight_str = input(f" Weight for '{name}' (0–10): ").strip()
try:
weight = float(weight_str)
except ValueError:
weight = 5.0
criteria.append({"name": name, "weight": weight})
data["criteria"] = criteria
# Options
print("\nDefine options (what you're choosing between).")
print("Enter options one at a time. Empty line to finish.")
print()
options = []
while True:
name = input(f"Option {len(options)+1} name (or ENTER to finish): ").strip()
if not name:
if len(options) < 2:
print(" Need at least 2 options.")
continue
break
print(f"\n Score each criterion for '{name}' (1=poor, 10=excellent):")
scores = {}
for c in criteria:
while True:
s = input(f" {c['name']}: ").strip()
try:
score = float(s)
if 1 <= score <= 10:
scores[c["name"]] = score
break
else:
print(" Score must be 1–10")
except ValueError:
print(" Enter a number 1–10")
options.append({"name": name, "scores": scores})
print()
data["options"] = options
print_report(data)
# ─────────────────────────────────────────────────────
# Sample data
# ─────────────────────────────────────────────────────
SAMPLE_DATA = {
"decision": "How to extend runway: Cut costs vs. Raise bridge vs. Accelerate revenue",
"criteria": [
{
"name": "Speed to impact",
"weight": 0.25,
"description": "How quickly does this improve our situation?"
},
{
"name": "Execution risk",
"weight": 0.30,
"description": "How likely is this to actually work? (10=low risk)"
},
{
"name": "Team morale impact",
"weight": 0.20,
"description": "Effect on team (10=positive, 1=very negative)"
},
{
"name": "Runway extension",
"weight": 0.15,
"description": "How much runway does this actually buy?"
},
{
"name": "Strategic fit",
"weight": 0.10,
"description": "Does this align with where we want to go?"
}
],
"options": [
{
"name": "Cost cut 25%",
"description": "Reduce headcount and discretionary spend by 25%",
"scores": {
"Speed to impact": 9,
"Execution risk": 8,
"Team morale impact": 2,
"Runway extension": 8,
"Strategic fit": 5
}
},
{
"name": "Bridge from investors",
"description": "Raise $500K bridge from existing investors to hit next milestone",
"scores": {
"Speed to impact": 6,
"Execution risk": 5,
"Team morale impact": 7,
"Runway extension": 6,
"Strategic fit": 7
}
},
{
"name": "Accelerate revenue",
"description": "Push 3 enterprise deals hard, offer incentives for Q4 close",
"scores": {
"Speed to impact": 4,
"Execution risk": 3,
"Team morale impact": 9,
"Runway extension": 9,
"Strategic fit": 10
}
},
{
"name": "Hybrid: cut 15% + bridge",
"description": "Smaller cuts combined with a modest bridge round",
"scores": {
"Speed to impact": 7,
"Execution risk": 6,
"Team morale impact": 5,
"Runway extension": 7,
"Strategic fit": 6
}
}
]
}
# ─────────────────────────────────────────────────────
# Main
# ─────────────────────────────────────────────────────
def main():
parser = argparse.ArgumentParser(
description="Decision Matrix Scorer — weighted analysis with sensitivity testing"
)
parser.add_argument(
"--interactive", "-i",
action="store_true",
help="Interactive mode: enter decision data manually"
)
parser.add_argument(
"--file", "-f",
type=str,
help="Load decision data from JSON file"
)
parser.add_argument(
"--sample",
action="store_true",
help="Show sample data structure and exit"
)
args = parser.parse_args()
if args.sample:
print(json.dumps(SAMPLE_DATA, indent=2))
return
if args.interactive:
interactive_mode()
return
if args.file:
try:
with open(args.file) as f:
data = json.load(f)
print_report(data)
except FileNotFoundError:
print(f"Error: File '{args.file}' not found.")
sys.exit(1)
except json.JSONDecodeError as e:
print(f"Error: Invalid JSON in '{args.file}': {e}")
sys.exit(1)
return
# Default: run sample data
print()
print("Running with sample data. Use --interactive for custom input or --file for JSON.")
print_report(SAMPLE_DATA)
if __name__ == "__main__":
main()
#!/usr/bin/env python3
"""
Stakeholder Mapper — Executive Mentor Tool
Maps stakeholders by influence and alignment.
Identifies: champions, blockers, swing votes, and hidden risks.
Outputs: stakeholder grid with engagement strategy per quadrant.
Usage:
python stakeholder_mapper.py # Run with sample data
python stakeholder_mapper.py --interactive # Interactive mode
python stakeholder_mapper.py --file data.json # Load from JSON file
JSON format:
{
"initiative": "Name of the decision or initiative",
"stakeholders": [
{
"name": "Person/Group Name",
"role": "Their role or title",
"influence": 8, // 1–10: how much power they have over outcome
"alignment": 3, // 1–10: how supportive they are (10=champion, 1=blocker)
"interest": 7, // 1–10: how interested/engaged they are
"notes": "Optional context — what drives them, hidden concerns, relationships"
}
]
}
"""
import json
import sys
import argparse
from typing import List, Dict, Tuple, Optional
# ─────────────────────────────────────────────────────
# Quadrant classification
# ─────────────────────────────────────────────────────
def classify_stakeholder(influence: float, alignment: float) -> Dict:
"""
Classify into strategic quadrant based on influence and alignment.
Quadrants:
- Champions (high influence, high alignment): Your most valuable assets
- Blockers (high influence, low alignment): Your biggest risks
- Supporters (low influence, high alignment): Useful but less critical
- Bystanders (low influence, low alignment): Monitor, low priority
- Swing Votes (medium influence, medium alignment): Key to persuade
"""
mid_influence = 5.5
mid_alignment = 5.5
# Special case: swing votes — medium on both dimensions
if 4 <= influence <= 7 and 4 <= alignment <= 7:
return {
"quadrant": "Swing Vote",
"symbol": "⚡",
"priority": "HIGH",
"strategy": "Persuade — understand concerns, address directly, build relationship"
}
if influence >= mid_influence and alignment >= mid_alignment:
return {
"quadrant": "Champion",
"symbol": "★",
"priority": "HIGH",
"strategy": "Leverage — activate them as advocates, give them a role in the initiative"
}
elif influence >= mid_influence and alignment < mid_alignment:
return {
"quadrant": "Blocker",
"symbol": "✖",
"priority": "CRITICAL",
"strategy": "Address — understand their specific objections, find common ground or neutralize"
}
elif influence < mid_influence and alignment >= mid_alignment:
return {
"quadrant": "Supporter",
"symbol": "○",
"priority": "MEDIUM",
"strategy": "Maintain — keep informed and engaged, potentially increase their influence"
}
else:
return {
"quadrant": "Bystander",
"symbol": "·",
"priority": "LOW",
"strategy": "Monitor — minimal investment, keep informed with standard comms"
}
def risk_flags(stakeholder: Dict) -> List[str]:
"""Identify specific risk signals for a stakeholder."""
flags = []
influence = stakeholder["influence"]
alignment = stakeholder["alignment"]
interest = stakeholder.get("interest", 5)
if influence >= 7 and alignment <= 3:
flags.append("🔴 HIGH-POWER BLOCKER — can kill this initiative")
if influence >= 7 and alignment <= 5 and interest >= 7:
flags.append("🟡 ENGAGED SKEPTIC — high influence, paying close attention, not convinced")
if alignment <= 4 and interest >= 8:
flags.append("🟡 ACTIVE OPPOSITION — low alignment but highly engaged — may mobilize others")
if influence >= 6 and alignment >= 7 and interest <= 3:
flags.append("🟡 DISENGAGED CHAMPION — strong supporter but not paying attention — needs activation")
if influence >= 5 and 4 <= alignment <= 6:
flags.append("⚡ PERSUADABLE — medium influence, genuinely undecided — high ROI to engage")
return flags
# ─────────────────────────────────────────────────────
# Analysis
# ─────────────────────────────────────────────────────
def calculate_overall_alignment(stakeholders: List[Dict]) -> Dict:
"""Calculate weighted average alignment (weighted by influence)."""
if not stakeholders:
return {"score": 0, "verdict": "No data"}
total_influence = sum(s["influence"] for s in stakeholders)
if total_influence == 0:
return {"score": 0, "verdict": "No influence"}
weighted_alignment = sum(
s["alignment"] * s["influence"] for s in stakeholders
) / total_influence
if weighted_alignment >= 7:
verdict = "FAVORABLE — strong support among influential stakeholders"
elif weighted_alignment >= 5:
verdict = "MIXED — significant opposition needs to be addressed"
else:
verdict = "UNFAVORABLE — initiative faces significant headwinds"
return {
"score": round(weighted_alignment, 2),
"verdict": verdict
}
def find_critical_path(stakeholders: List[Dict]) -> List[Dict]:
"""
Identify the minimal set of stakeholders whose alignment is critical.
These are high-influence stakeholders — their position determines the outcome.
"""
high_influence = [s for s in stakeholders if s["influence"] >= 7]
return sorted(high_influence, key=lambda x: x["influence"], reverse=True)
def engagement_sequencing(stakeholders: List[Dict]) -> List[Dict]:
"""
Recommend engagement sequence.
Order: Fix blockers → Activate champions → Persuade swing votes → Maintain rest.
"""
classified = []
for s in stakeholders:
cls = classify_stakeholder(s["influence"], s["alignment"])
classified.append({**s, **cls})
# Sort by engagement priority
priority_order = {"CRITICAL": 0, "HIGH": 1, "MEDIUM": 2, "LOW": 3}
classified.sort(key=lambda x: (priority_order[x["priority"]], -x["influence"]))
return classified
# ─────────────────────────────────────────────────────
# ASCII grid visualization
# ─────────────────────────────────────────────────────
def render_grid(stakeholders: List[Dict], width: int = 60) -> str:
"""
Render a 2D influence vs alignment grid with stakeholder positions.
Y-axis: Influence (top = high)
X-axis: Alignment (left = low, right = high)
"""
rows = 10
cols = 20
grid = [[' ' for _ in range(cols)] for _ in range(rows)]
for s in stakeholders:
influence = s["influence"]
alignment = s["alignment"]
# Map scores 1–10 to grid coordinates
col = int((alignment - 1) / 9 * (cols - 1))
row = rows - 1 - int((influence - 1) / 9 * (rows - 1))
col = max(0, min(cols - 1, col))
row = max(0, min(rows - 1, row))
initial = s["name"][0].upper()
if grid[row][col] == ' ':
grid[row][col] = initial
else:
grid[row][col] = '+' # Overlap
lines = []
lines.append(" STAKEHOLDER MAP (Influence ↑ | Alignment →)")
lines.append("")
lines.append(f" HIGH ┌{'─'*cols}┐")
for i, row in enumerate(grid):
if i == rows // 2:
prefix = " INFL "
else:
prefix = " "
lines.append(f"{prefix}│{''.join(row)}│")
lines.append(f" LOW └{'─'*cols}┘")
lines.append(f" {'BLOCKER':<12} {'SWING':<8} CHAMPION")
lines.append(f" Low alignment High alignment")
lines.append("")
# Legend
lines.append(" Legend (initials):")
for s in stakeholders:
cls = classify_stakeholder(s["influence"], s["alignment"])
lines.append(f" {s['name'][0].upper()} = {s['name']} ({cls['symbol']} {cls['quadrant']})")
return "\n".join(lines)
# ─────────────────────────────────────────────────────
# Output formatting
# ─────────────────────────────────────────────────────
def hr(char="─", width=65):
return char * width
def print_report(data: Dict):
initiative = data.get("initiative", "Unnamed Initiative")
stakeholders = data["stakeholders"]
# Validate and fill defaults
for s in stakeholders:
s.setdefault("interest", 5)
s.setdefault("notes", "")
s["influence"] = max(1, min(10, float(s["influence"])))
s["alignment"] = max(1, min(10, float(s["alignment"])))
s["interest"] = max(1, min(10, float(s["interest"])))
print()
print(hr("═"))
print(f" STAKEHOLDER ANALYSIS")
print(f" {initiative}")
print(hr("═"))
# Overall assessment
overall = calculate_overall_alignment(stakeholders)
print()
print("OVERALL ASSESSMENT")
print(hr())
print(f" Weighted alignment score: {overall['score']}/10")
print(f" Verdict: {overall['verdict']}")
# Grid visualization
print()
print(hr())
print(render_grid(stakeholders))
# Stakeholder profiles by quadrant
sequenced = engagement_sequencing(stakeholders)
# Group by quadrant
quadrants = {}
for s in sequenced:
q = s["quadrant"]
if q not in quadrants:
quadrants[q] = []
quadrants[q].append(s)
quadrant_order = ["Blocker", "Swing Vote", "Champion", "Supporter", "Bystander"]
print()
print("STAKEHOLDER PROFILES")
print(hr())
for q_name in quadrant_order:
if q_name not in quadrants:
continue
group = quadrants[q_name]
first = group[0]
print()
print(f" {first['symbol']} {q_name.upper()}S ({len(group)} stakeholder{'s' if len(group)>1 else ''})")
print(f" Strategy: {first['strategy']}")
print()
for s in group:
cls = classify_stakeholder(s["influence"], s["alignment"])
flags = risk_flags(s)
print(f" {s['name']}")
print(f" Role: {s.get('role', 'Not specified')}")
print(f" Influence: {'█'*int(s['influence']//2)}{'░'*(5-int(s['influence']//2))} {s['influence']:.0f}/10 "
f"Alignment: {'█'*int(s['alignment']//2)}{'░'*(5-int(s['alignment']//2))} {s['alignment']:.0f}/10 "
f"Interest: {'█'*int(s['interest']//2)}{'░'*(5-int(s['interest']//2))} {s['interest']:.0f}/10")
if flags:
for flag in flags:
print(f" {flag}")
if s.get("notes"):
print(f" Notes: {s['notes']}")
print()
# Engagement plan
print()
print("ENGAGEMENT PLAN (sequenced by priority)")
print(hr())
print()
print(f" {'#':<3} {'Name':<22} {'Quadrant':<14} {'Priority':<10} {'First Action'}")
print(f" {hr('-', 63)}")
actions = {
"Blocker": "Schedule 1:1 — understand specific objections",
"Swing Vote": "Coffee or informal conversation — listen first",
"Champion": "Brief them on the initiative — give them a role",
"Supporter": "Keep informed — monthly update or email",
"Bystander": "Include in standard comms only"
}
for i, s in enumerate(sequenced, 1):
action = actions.get(s["quadrant"], "Maintain standard communication")
print(f" {i:<3} {s['name']:<22} {s['quadrant']:<14} {s['priority']:<10} {action}")
# Risk summary
print()
print("RISK SUMMARY")
print(hr())
critical_path = find_critical_path(stakeholders)
if critical_path:
print()
print(" High-influence stakeholders (outcome depends on these):")
for s in critical_path:
cls = classify_stakeholder(s["influence"], s["alignment"])
alignment_label = "CHAMPION" if s["alignment"] >= 7 else "BLOCKER" if s["alignment"] <= 4 else "UNDECIDED"
print(f" {cls['symbol']} {s['name']:<25} influence {s['influence']:.0f}/10 → {alignment_label}")
# All risk flags
all_flags = []
for s in stakeholders:
flags = risk_flags(s)
for flag in flags:
all_flags.append((s["name"], flag))
if all_flags:
print()
print(" Risk flags:")
for name, flag in all_flags:
print(f" [{name}] {flag}")
print()
print(hr("═"))
print()
# ─────────────────────────────────────────────────────
# Interactive mode
# ─────────────────────────────────────────────────────
def interactive_mode():
print()
print(hr("═"))
print(" STAKEHOLDER MAPPER — Interactive Mode")
print(hr("═"))
data = {}
data["initiative"] = input("\nWhat initiative or decision are you mapping?\n> ").strip()
print("\nAdd stakeholders one at a time. Empty name to finish.")
print("Scores: 1=low, 10=high")
print()
stakeholders = []
while True:
name = input(f"Stakeholder {len(stakeholders)+1} name (or ENTER to finish): ").strip()
if not name:
if len(stakeholders) < 1:
print(" Need at least 1 stakeholder.")
continue
break
role = input(f" Role/title: ").strip()
def get_score(prompt, default=5):
while True:
s = input(f" {prompt} (1–10, default {default}): ").strip()
if not s:
return float(default)
try:
v = float(s)
if 1 <= v <= 10:
return v
print(" Must be 1–10")
except ValueError:
print(" Enter a number")
influence = get_score("Influence (power over this decision)")
alignment = get_score("Alignment (1=opposed, 10=champion)")
interest = get_score("Interest level (how engaged are they)")
notes = input(f" Notes (optional): ").strip()
stakeholders.append({
"name": name,
"role": role,
"influence": influence,
"alignment": alignment,
"interest": interest,
"notes": notes
})
print()
data["stakeholders"] = stakeholders
print_report(data)
# ─────────────────────────────────────────────────────
# Sample data
# ─────────────────────────────────────────────────────
SAMPLE_DATA = {
"initiative": "Migrate from monolith to microservices (18-month program)",
"stakeholders": [
{
"name": "Sarah Chen (CTO)",
"role": "Chief Technology Officer",
"influence": 10,
"alignment": 9,
"interest": 9,
"notes": "Driving force behind the initiative. Will fund and protect the team."
},
{
"name": "Marcus Webb (CFO)",
"role": "Chief Financial Officer",
"influence": 9,
"alignment": 3,
"interest": 6,
"notes": "Concerned about 18-month cost with no visible revenue return. Has budget veto."
},
{
"name": "Priya Agarwal (VP Eng)",
"role": "VP Engineering",
"influence": 8,
"alignment": 7,
"interest": 8,
"notes": "Supportive in principle, worried about team bandwidth alongside feature delivery."
},
{
"name": "Tom Briggs (VP Product)",
"role": "VP Product",
"influence": 7,
"alignment": 4,
"interest": 5,
"notes": "Concerned about roadmap slowdown. Hasn't been in the architecture discussions."
},
{
"name": "Elena Park (CEO)",
"role": "Chief Executive Officer",
"influence": 10,
"alignment": 6,
"interest": 4,
"notes": "Trusts the CTO but will back out if CFO and VP Product both push back hard."
},
{
"name": "Raj Patel (Lead Arch)",
"role": "Lead Architect",
"influence": 6,
"alignment": 10,
"interest": 10,
"notes": "Deep technical champion. Has proposed detailed migration plan."
},
{
"name": "Dev Team Leads (x4)",
"role": "Team Leads",
"influence": 5,
"alignment": 6,
"interest": 7,
"notes": "Mixed. Some excited, some worried about learning curve. Middle ground."
},
{
"name": "Board (investor reps)",
"role": "Board Directors",
"influence": 9,
"alignment": 5,
"interest": 3,
"notes": "Not paying attention unless CFO raises flags. Could become blockers if CFO escalates."
}
]
}
# ─────────────────────────────────────────────────────
# Main
# ─────────────────────────────────────────────────────
def main():
parser = argparse.ArgumentParser(
description="Stakeholder Mapper — influence, alignment, and engagement strategy"
)
parser.add_argument(
"--interactive", "-i",
action="store_true",
help="Interactive mode: enter stakeholder data manually"
)
parser.add_argument(
"--file", "-f",
type=str,
help="Load stakeholder data from JSON file"
)
parser.add_argument(
"--sample",
action="store_true",
help="Print sample JSON structure and exit"
)
args = parser.parse_args()
if args.sample:
print(json.dumps(SAMPLE_DATA, indent=2))
return
if args.interactive:
interactive_mode()
return
if args.file:
try:
with open(args.file) as f:
data = json.load(f)
print_report(data)
except FileNotFoundError:
print(f"Error: File '{args.file}' not found.")
sys.exit(1)
except json.JSONDecodeError as e:
print(f"Error: Invalid JSON in '{args.file}': {e}")
sys.exit(1)
return
# Default: sample data
print()
print("Running with sample data. Use --interactive for custom input or --file for JSON.")
print_report(SAMPLE_DATA)
if __name__ == "__main__":
main()
Install this Skill
Skills give your AI agent a consistent, structured approach to this task — better output than a one-off prompt.
npx skills add alirezarezvani/claude-skills --skill c-level-advisor/executive-mentor Community skill by @alirezarezvani. Need a walkthrough? See the install guide →
Works with
Prefer no terminal? Download the ZIP and place it manually.
Details
- Category
- Leadership
- License
- MIT
- Author
- @alirezarezvani
- Source
- GitHub →
- Source file
-
show path
c-level-advisor/executive-mentor/SKILL.md
People who install this also use
CEO Advisor
Executive leadership coaching — strategic decision-making, organizational development, board governance, and navigating high-stakes business challenges.
@alirezarezvani
Founder Coach
Personal leadership development for founders — managing the emotional weight of building, developing self-awareness, and growing as an executive.
@alirezarezvani
Hard Call