Frameworks

Automated Interview Recruiting Loop

Let customers opt in and schedule themselves while their attention is available.

Decision Importance Triage

Spend judgment on the few decisions that matter and keep everything else moving

LNO Framework

Match your effort to each task's leverage, neutrality, or overhead

Two-Hour Daily Hiring Cadence

Reserve one hour for outreach and one for conversations every working day

Four-Stage AI Inbox Triage

Filter visibility, urgency, and decisions before AI drafts the response.

Manufactured Momentum

Create an explicit deadline so important work cannot drift indefinitely

Objective-Motivation Topic Selection

Choose writing topics by pairing a clear finish line with durable motivation

Understand Work (Understand → Identify → Execute)

Budget intentional time to understand a problem first, so your team ships fewer things with a far higher win rate.

The Three Questions to End Every Meeting

Close every meeting with: what did we decide, who does what by when, and who else needs to know

Appetite-Driven Product Cycles (Shape Up)

Fix the time budget, not the scope: six-week appetites, two-person teams, and work that dies on time

Commit Only to Dates Within Your Control

Roadmap the phase, not the feature: Discovery, then Solutioning, then Build, then a ship date.

Compounding Engineering

Spend a little effort now so each repeat of a task is cheaper than the last

Context Is All You Need Prompting

Treat the model as a brilliant stranger with zero context, and supply what a colleague would already know.

Daily Goal-and-Three-Actions Ritual

Each day write your aspirational identity, then three actions to move toward it.

Few-Shot Prompting

Show the model examples of what good looks like instead of describing it

Fixed Time, Variable Scope (Appetite-Based Planning)

Set the max time you'll spend first, then design a solution that fits it — instead of estimating a concept.

Friction Logging

Adopt a specific user's identity, walk your own product end-to-end, and log every point of friction.

Impact-Over-Output Operating Model

Measure teams by validated impact on customers, not by features shipped — and prove the needle moved

Make Time: Highlight, Laser, Energize, Reflect

A daily four-step loop that changes your defaults instead of making you faster at the wrong things

Manufactured Deadlines

Impose external constraints so solo creative work actually ships

Measurements vs. Insights Instrumentation

A measurement is an observed fact; an insight answers 'why' and changes what you do — instrument for the latter.

One Agent Per Lane

Beat context overload by running many narrow, purpose-built agents instead of one do-everything agent.

One Click Faster (Clock Speed Management)

Three tactics to raise an organization's pace without lowering its bar

Problem-People-System (PPS)

Diagnose a systems request by problem and people first, never jump straight to the tool.

Saying No by Trading Off

Never say no. Say yes, name what it displaces, and hand the prioritisation back.

The 10% Working-Version Rule

Have a testable working version by the time 10% of your time budget elapses, not at the halfway point

The Daily Highlight

Pick the one thing you want to name as today's highlight, size it to 60-90 minutes, write it down

The Decision Meeting Operating System

Pre-read 24h before, three options plus a recommendation, a traffic-light table, notes 24h after.

The DORA Four Keys

Measure software delivery with two speed and two stability metrics that move in tandem.

Productivity7 steps

The Seven-Command Build Loop

Six slash-commands turn vibe-coding into disciplined software delivery for non-coders

The SPACE Framework

Pick balanced developer productivity metrics across five dimensions — never rely on one.

Timeboxing Your Values (Make Time for Traction)

Replace the to-do list with a weekly timeboxed calendar built from your values across three life domains.

Worse Is Better, Tech Debt Is a Champagne Problem

Ship the embarrassing version — you only earn tech debt if people actually use the thing

Cut Scope, Not Quality

When time is short, strip features down to the core instead of shipping the same feature badly

Context Loading (Additional Information)

Front-load all relevant task information — and put it at the top for caching

Cycle-Time Is the Enemy (Ship Ship Ship)

The gap between knowing something is good and users seeing it is your biggest enemy — attack the decision time, not the work time.

Red/Green TDD for Coding Agents

Force agents to write the test first, watch it fail, then pass — the compressed prompt is just 'red/green TDD'.

Scope-by-Time Traps

Box work by a fixed deadline, cut scope to fit, and ship early enough that the feedback is 'this is premature'

Self-Criticism Loop

Get the model to critique its own answer, then implement its own critique

The 4x4 Debugging Framework

Four escalating ways to unstick a broken build, each tried exactly once, ending by teaching the agent.

The Bits and Bobs Idea Distillation Loop

Capture everything, filter weekly by resonance, distil, publish — a compounding personal insight engine.

The Weekly Focus Ritual

Post what you're focused on this week, and whether last week's focus actually landed.

Top-Down / Bottoms-Up Core Action Analysis

Cross two analyses — return-propensity ranking and product purpose — to find the one action worth optimising

Your Problem Isn't Unique

Never start from scratch; find who already solved your problem and patternize the solution.

Appetite Bracketing

Set a time budget, then ask what you'd do with more and less — the bracket reveals the efficient frontier.

Celebrate Adoption, Not Shipping

Replace hours and feature counts with customer-adoption outcomes teams can actually steer toward

Do Half, Then Go on a Killing Spree

Build half the features, then remove things until the one core action runs at 10x velocity.

Excellence Is the Outcome, Not the Artefact

Ask what the meeting is actually for, then spend the effort there — not on the last 20% of polish.

First-Step Onboarding (Lower Barriers, Raise Delight)

Beat the blank page by walking users through tiny surprising steps until they surprise themselves

Hoard What You Know How To Do

Keep a searchable backlog of verified, working experiments so agents can recombine them into new solutions.

Homogenize the Early Experience for Retention

Move retention by fixing unlucky bad first experiences, not by nudging people about to churn

Internal Tools as a Product (The Crying Octopus)

Run your dev-productivity team like a product team: monthly surveys, hard metrics, and one-click paper cuts.

Output as the Leading Indicator of Outcomes

Outcomes are the goal, but shipping rate is the only early signal you'll get that you'll hit them.

Prompt Decomposition

Make the model list the sub-problems first, then solve each before the whole

The 20-Minute Focus Ignition

Beat the hardest part of deep work — starting — by force-blocking distractions for 20 minutes

The One-on-One Diet

Hold direct-report 1:1s sacred; cut nearly all the rest — relationship-by-1:1 doesn't scale

The Research Coordinator Role

Borrow the recruiting-coordinator role to schedule all customer research, so PMs never lose time to logistics.

The Source-of-Truth PRD Cascade

Spend a day writing five layered docs so the agent, not you, carries the context on every build.

RICE with Deferred Confidence and Effort

Score reach and impact first; sit with the innovative bets before letting C and E kill them.

The Four Levers of Velocity at Scale

Small missions, a real platform, leaders in the trenches, and a team you keep recalibrating.

The One-Month Experimentation Rule

If you can't collect the sample size in a month, don't A/B test it; ship it and measure pre vs. post.

Bad vs Sad Quality Tiers

Classify every failure as bad (irrecoverable) or sad (recoverable pain) so teams triage quality across many surfaces.

Build It Wrong Before You Know It's Right

Use AI to test a hundred ideas a day as a failure machine, not to polish one idea for three months

Chaos Buffers: Planning Around Users Who Don't Owe You Time

Every plan carries a backup and a scope-sized buffer, because your users' real job always wins

Chop-It-Up AI Collaboration Loop

Don't hand AI one giant spec — specify a little, review a little, repeat in tight loops.

Closing the Loop with Community

Systematically collect, route, ship, and close every customer request as a product engine.

Context-First Agent Debugging

When a coding agent won't do what you want, treat it as a missing-context problem, not a model problem.

Data Is a Compass, Not a GPS

Data disproves the ridiculous — it rarely hands you the answer, so validate findings before you trust them

Deep Work vs. Ping-Pong Day Design

Split every day into deep work and reactive time, and refuse to open Slack before noon.

Design Your Day (Calendar as Canvas + Groundhog Day Iteration)

Draw the day you want on the calendar, run it, see what actually happened, adjust, repeat

Draft-First LLM Augmentation

Never ask the model to do your job — write your version first, then have it improve it.

Flow-Preserving AI Assistance Design

Design AI suggestions around the user's flow state: no panel switches, no waiting, ephemeral by default

Focused Hours Over Long Hours

Overwork lets you skip the hard work of deciding what matters — force the constraint that makes you decide

Frontier of Understanding (Goal by Risk Type)

Before committing to an outcome goal, set the goal at the true edge of what your team knows — understanding, dependency, execution, or strategic risk.

Hunting New Bottlenecks When AI Writes the Code

When AI removes the coding bottleneck, constraints shift up and downstream — go find them.

ICE Prioritization

Score every experiment idea on Impact, Confidence and Ease to run a high-velocity testing program fairly

ICE Prioritization (Impact, Confidence, Ease)

Score each idea on Impact, Confidence, and Ease to bubble the best ideas up without over-engineering the math

Impact Estimation in the Unit of Your Goal

Prioritize by estimating each option's impact in the exact same unit as your team goal, not an abstract score.

Imperfect Metrics as Education

Report an imperfect engineering metric on purpose, then use every question about it to educate upward.

Intentional Remote Operating Model

Make remote work productive by scheduling connection in bursts, protecting synced deep-work blocks, and banning status meetings.

Main Quest vs Side Quest Focus Filter

Filter every opportunity by 'does this advance the main quest, and is it important now or later?'

Match the Medium to the Point

When implementation is cheap, the skill is choosing document vs prototype for the point you're making

Meeting Priming Before Decision-Making

Every meeting has a priming phase and a decision phase; skipping or reversing them guarantees dysfunction

Obsolete Yourself

Treat every repeatable thing you do as something to replace with software or an agent.

Outside-the-Building Product Management

Spend 80% of your time thinking outside the building and argue every case from the market's point of view

Productivity2 steps

Poor Man's Fine-Tuning (Few-Shot + Role Priming)

Steer a model with in-prompt examples and a role identity instead of a full fine-tune.

Precision Prompting for AI Builders

Never tell the AI 'it doesn't work' — state exactly what you expected and which parts do and don't.

Prescriptive vs. Framework Metrics

Know whether your metric is a recipe or a lens — and never misuse a recipe

Problems One and Two

Stop reporting your productivity on problems 3-100; get stuck on the two hardest ones

Product Scrapbooking

Continuously file every real-world clue about every opportunity so it's ready when the roadmap arrives.

Prompt Sets Are the New PRD

Communicate product ideas by building the prototype, not writing the doc — demos before memos

Root-Cause Context Engineering for AI Coding

Don't just fix the AI's bad code — root-cause the missing context so it's right next time.

Root-Cause Tooling Post-Mortem

When AI botches something, ask what in its prompt caused it — then patch the tooling

Ship-to-Learn Research Allocation

Reserve scarce user research for high-uncertainty, high-leverage problems; ship to learn everywhere else

Spec-as-What-Good-Looks-Like Verification

Check your definition of good into the repo so AI code review can automatically validate work against it.

Stratified Design Work

Split your time between supporting engineers' execution and setting a 3-6 month vision, not polishing mocks.

Systems Not Goals

Build a default-on repeatable system instead of chasing a one-off target.

Tasks, Not Problems

Delegate to AI agents by handing them scoped, verifiable tasks — never open-ended problems.

The 100%-or-Nothing Automation Rule

An automation that works 95% of the time isn't an automation — push it to 100% or don't rely on it

The 10x Leverage Desk

Spend your finite time only on problems with 10x positive or negative impact — and physically move yourself into the details until they're solved.

The Circuit Breaker (Back to Shaping)

When a project overruns its appetite, don't extend it or gut the agreed value — pull it back into shaping mode.

The Effort Metric (Measure Attention, Not Completion)

Track 'did I do what I said for as long as I said without distraction' instead of whether you finished.

The Meeting Operating System

Version your team's meetings like a product — ship a new rev every 90 days.

The Nielsen Number: Right-Size Your Research

Interview 7-14 people — fewer teaches too little, more teaches nothing new

The Nine-Scopes Kickoff

At kickoff, have the builders translate the shaped idea into nine-or-fewer implementation chunks to test scope and build clarity.

The Parallel Agent Workflow

Run several AI agents at once and insert yourself only where your expertise actually matters.

The PLG Data & Infrastructure Stack

The three infrastructure layers plus per-funnel-stage tools every PLG motion needs

The Subtractive Goal-Shrinking Exercise

Make a bloated set of goals smaller and more concise each round until one specific, urgent number survives.

The Switch Log

Log every task-switch in real time so your actual work trail — not your calendar — reveals where your time really goes

The Teammate Onboarding Model for AI Agents

Adopt a coding agent the way you'd onboard a new intern — pair first, then delegate.

The Thin Skeleton Template

Start every project from a minimal template — agents copy its style far better than they follow prose instructions.

The Three Pillars of Product Operations

Scale product management with internal data & insights, customer research at scale, and standardized strategy cadences.

The Top-Three Weighted DevX Survey

Force a top-three, weight by frequency, and never ask four questions at once

The "What's Holding You Back" Office Hour

Replace status updates with one question that surfaces the single true bottleneck

The YOLO Rule: When Not to Run an Experiment

Experiments have a cost — sometimes shipping 40 things fast beats testing 10 things properly

Three-Legged Model Evaluation

Judge a model-harness combo with heavy usage, a trusted five-person taste panel, and ~10 sharp evals

Velocity Guardrails: Ship Freely Until the Metrics Go Red

Standardize a few quality metrics per team; below the line they ship anything, above it they fix before they ship.

Best-Model-First Agent Workflow

Use the most capable model on max effort, start in plan mode, then auto-accept — counterintuitively cheaper.

Compounding Urgency: Pull the Roadmap Up a Week

Ship a week earlier, start the next thing a week sooner, and the gap compounds into a lap.

Eval-First AI Product Development

Define what 'correct' looks like as evals first; the spec becomes the scorecard, not the build instructions

Grade for Learning, Not Precision

Hand-wave the OKR score; spend your energy on the retrospective 'why' behind it.

Label the Process Stage, Not the Polish

A production-looking prototype no longer means it's production-ready — say the stage out loud

Product-First AI Prompting

Steer AI builders by describing the end-user experience ambitiously, then iterate like you're coaching a collaborator

P-Stage Cycle-Time Benchmarking

Stage-gate every initiative (PStrat→P0→P1→P2), size it S/M/L, and benchmark cycle time against yourself like golf.

Strike Down the Blockers (Time to Value)

Removing what stops adoption beats adding shiny features; hunt blockers and watch the retention graph move.

The Tomorrow Test for Saying No

Decide whether to accept a distant commitment by imagining you had to do it tomorrow

Two-Mode Prioritization for AI Products

Prioritize backward from model magic AND forward from customer needs

Ambitious Retry (Pass@N) Tool Use

Get more from AI tools by asking for the ambitious change and fully restarting on failure instead of hammering the same attempt

Tuning Your Operating Cadence

Set review rhythm by two signals: too fast if no progress, too slow if content is stale

Demos Not Memos

The first 10% of every project is now free — so build something to react to instead of writing documents.

Single-Owner Review Limits

Cap reviews, approvals, and meeting size so one accountable owner drives the pace

Use AI As Leverage On Your PM Time

Assign the model a role, feed it more context than you could read, and iterate the prompt until it works.

AI as Your Personalized Just-In-Time Tutor

Feed AI a curriculum tuned to how you learn, then prove understanding by teaching it back.

Delete-First Lean Engineering

On a small team, deleting code beats writing it — audit for features whose maintenance cost exceeds their gain.

Dictate-and-Template AI Story Scaling

Prime ChatGPT with your team's exact template, then dictate context naturally to generate an org's worth of specs.

Escape-Velocity Activation Metric

Identify the specific actions a user must take in their first window to become durably active, then make one team obsess over driving them.

Give It Your Hardest Task

Evaluate a serious AI tool on your gnarliest real problem, not a dumbed-down toy.

Greedy-but-Smart Compute Allocation

Throw hundreds of dollars of inference at high-value problems — the value-to-cost ratio is absurd in your favor.

Hand the Toil to the Model First

Delegate the boring, repetitive parts of engineering to agents before anything else, and collapse the path to production.

Hills-and-Valleys: Getting Value From Probabilistic AI Tools

Be patient and explicit, start small, and learn where the model is strong vs weak

Kernel-of-Truth Signal Triage

Product is finding the one thing that really matters in a sea of inputs — capture everything, then ruthlessly filter

Mandatory vs. Optional Onboarding Split

Split onboarding into a spare mandatory setup and a random-access optional layer — model the buyer's mind, not your features.

Meeting Armageddon

Once a year, delete every recurring meeting and forbid new ones for two weeks.

Processing Over Memory: A Task System for the Overwhelmed Manager

Write everything down at the moment it's owed, groom into logical chunks, and free your head for thinking not remembering.

Set the Pace Through Decisiveness (Bias for Action)

A company's speed is governed by how fast it decides, not how hard it works — so refuse to 'circle back.'

The $10 Game for Personal Priorities

Allocate a notional $10 across your priorities to expose where your time actually goes versus where it should.

The 10% Planning Rule

Never spend more than 10% of an execution period planning it.

The Agent Foothold Onboarding

Onboard an AI agent like a new hire: environment first, easy tasks next, then scale.

The Reach Test

Judge whether an AI tool is truly useful by whether you reach for it unprompted each morning.

The Weekly State-of-Me Email

Write a self-initiated weekly note of what worked, what didn't, and what's blocked

Think It, Build It, Ship It, Tweak It

Four product phases where spend rises stage by stage — so you must retire risk before the money starts.

Top Goal with an Accountability Partner

Protect a daily block for your own priority and have a human physically present to force you to do it

Orange and Red Priorities Planning

Leaders name the non-negotiable 'big rocks' up front, then teams plan around them

PM Prototype-to-Production Handoff

PMs build a working V1 with AI, validate it with real users, then hand a working artifact to engineering

Prime-Then-Parallelize AI Coding Workflow

Front-load the architecture, fan out to agents, then step back and evaluate

Async Priority Codes for Small Teams

Tag every Slack message with a response-window code so nobody has to monitor the channel.

The Scheduled AI Chief of Staff

Put proactive agents on a schedule to watch your metrics, surface misalignment, and coach you weekly