smithery/samarv

deep-dive-portfolio-management

A high-leverage leadership framework for maintaining a high quality bar across a large volume of projects.

Installation

$ npx skills add smithery/samarv --skill deep-dive-portfolio-management

Summary

  • A high-leverage leadership framework for maintaining a high quality bar across a large volume of projects.
  • Instead of staying "high-level" on everything, leaders select a subset of high-impact projects to review at the "bare-metal" level (code, screens, and regulations).
  • Use this when managing a team with 20+ concurrent workstreams, when quality starts to slip across a portfolio, or when building a culture of autonomous ownership.

Similar popular skills

Related neighbors and high-traction skills in the same topics — useful to compare before installing.

Also in this package

Other skills from smithery/samarv · top by installs.

npx skills add smithery/samarv

Browse all from smithery/samarv

More details

Agent compatibility

Declared targets from SKILL.md / docs. Unmarked agents are not listed — the skill may still install via the CLI.

Claude Code Not declared
Cursor Not declared
Codex Not declared
GitHub Copilot Not declared
Windsurf Not declared
Gemini CLI Not declared
Cline Not declared
OpenCode Not declared

Package contents

Files included with this skill beyond the listing page.

  • skill md SKILL.md 4,910 B
  • docs SUMMARY.md 472 B

History

  1. First recorded snapshot · 0 installs

SKILL.md

The Deep-Dive Portfolio Management framework solves the "Manager’s Dilemma": the choice between staying high-level and being uninformed, or micromanaging and becoming a bottleneck. By going extremely deep on a rotating 10% of projects, you create a signaling effect that raises the standard for the remaining 90%.

The Selection Process

Identify 7–10 high-impact projects from your total portfolio (e.g., out of 100 active workstreams) to scrutinize each cycle.

  • Impact-Based: Projects that represent the core business or have massive downside risk (e.g., a new mortgage product in a new country).
  • Strategic Bets: New "wow" features that define the brand (e.g., loyalty programs or crypto integration).
  • Performance Signals: Projects where metrics are not hitting targets or where team velocity has stalled.

The Deep-Dive Execution

Once the 7–10 projects are selected, move from "Helicopter View" to "Bare-Metal View." Conduct these reviews weekly.

1. Technical & Data Scrutiny

Do not accept high-level summaries.

  • Read the Code: Sit with engineers to understand the underlying system architecture.
  • Review the Root Cause: If a bug or delay exists, find the technical or regulatory blocker yourself.
  • Quantify Everything: Map out exactly how the product increment drives a specific business metric.

2. The "Wow" UX Audit

The product must be "lovable," not just functional.

  • Screen-by-Screen Review: Review 100% of the screens being shipped.
  • Eliminate Friction: Audit the number of clicks and the "look and feel" of every flow.
  • Apply "Founder Logic": Ask, "Does this feel like we really cared about the customer?"

3. Regulatory & Stakeholder Steamrolling

In complex industries (like FinTech), the leader’s job is to unblock the team through sheer force of will or creative problem-solving.

  • Manual Consensus: Get stakeholders in a room to reach a decision immediately rather than waiting for email threads.
  • Automate Compliance: Look for ways to build the regulation into a scalable platform rather than a custom manual process for every country.

The Signaling Effect

The goal of the deep-dive is not just to fix those 10 projects, but to influence the 90 projects you aren't reviewing.

  • Discipline through Scrutiny: Teams should know that any project could be selected for a bare-metal review next.
  • Autonomous Standard: When teams see the level of detail you expect in a deep-dive, they begin to apply that same rigor to their own autonomous work to avoid being "the team that needs a deep-dive."
  • The 99% Rule: Socialize the principle that if a product is 99% done, it is 0% done. Nothing is "shipped" until the customer care, marketing, and legal components are fully operational.

Examples

Example 1: Launching in a New Jurisdiction

  • Context: A PM is launching a banking branch in a new country with complex reporting laws.
  • Standard Approach: The leader asks for a status update and a "Green/Yellow/Red" status.
  • Deep-Dive Application: The leader sits with the PM to review the exact data fields being reported to the regulator. They discover a data mapping error that would have delayed the launch by three months. They fix the framework so it applies to the next 10 countries.

Example 2: UX Refinement for a Core Feature

  • Context: The team is adding "Joint Accounts" to the app.
  • Standard Approach: The leader looks at the final prototype and approves the "vibe."
  • Deep-Dive Application: The leader reviews every edge case—what happens if one user loses their phone? What if the currency is different? They demand a "video selfie" check for high-value transfers to ensure "Wealth Protection," raising the bar for the entire security suite.

Common Pitfalls

  • Surface-Level Deep Dives: If you don't actually look at the code or the specific pixels, you aren't doing a deep-dive; you're just having a longer meeting.
  • Becoming the Bottleneck: The goal is to steer, not to approve every ticket. If you find yourself reviewing the same 10 projects for months, you aren't signaling; you're micromanaging.
  • Ignoring the "Boring" Details: Focusing only on the "Wow" UX while ignoring regulatory or technical debt. The deep-dive must cover the "schlep" (the hard, annoying parts) to be effective.