The full index
Frameworks
Every named framework pulled from the show — searchable, filterable, and structured down to the steps, examples, and mistakes.
293 frameworks
The Creativity Faucet
Empty weak ideas until pattern recognition produces an original one
Consumer Stack Scorecard
Grade five capabilities that give consumer products a chance to succeed
Continuous Discovery Feedback Loop
Run customer learning beside delivery so each product bet improves over time.
Problem-First Product Development
Give teams behavior problems to solve, then measure outcomes instead of feature output
Product-Native Onboarding
Design the path to value as part of the product, not a layer added later.
V0-Devin-Cursor Build Flow
Prototype in V0, delegate to Devin, then finish and verify in Cursor.
Value-Ease-Delight Feedback Ladder
Synthesize broad feedback in order: value first, ease second, delight last.
15-out-of-10 Lovable Product
Design the unconstrained ideal in one place, then scale only what proves valuable.
Small-Team Incubation Ladder
Start with a tiny team, prove real behavior, then add resources after fit.
The Delta 4 Framework
Score old vs new solution out of 10; if the efficiency gap isn't 4+, the product won't stick.
Three-Solution Assumption Testing
Compare three ideas by testing their riskiest assumptions in small, fast cycles.
Product Sense Observation Loop
Build product judgment by observing, comparing perspectives, and testing hypotheses.
AI-First Product Leadership: Hold the Paddles
If AI steers your product, the product leader must own the objective, features, data and infra.
Alpha Co-Creation Loop
Pick the users who are already pushing the boundary, build with them in a shared channel, ship only when they're thrilled.
Bridging-Based Agreement
Surface content only when people who normally disagree agree — that's the signal of truth.
Design for the Most Complex Use Case First
Architect for the hardest customer you'll ever have, then choose what to ship first.
Dogfooding to Build for Creators
Become a real user of your own product so you feel the problems instead of just reading feature requests
Error Analysis: Open Coding to Axial Coding to Count
Turn messy LLM logs into a prioritized list of failures before you write a single test.
Eval-Driven Product Development
Design the test for your AI product alongside the product, then hill-climb the model against it.
Fault-Tolerant User Interfaces
Design your UI to match the real hit-rate of your machine learning, not a fantasy of 100% accuracy.
Fight for Simplicity: The Third-Order Cost of Complexity
Entropy always wins unless you fight it — price every feature at its dimensional cost, not its build cost.
Human-in-the-Loop Algorithm Design
Decide explicitly what the algorithm owns, what the human owns, and how the handoff works.
Intuition as Hypothesis Generator
Treat product taste as a hypothesis machine, not an oracle — then debate it down to a working hypothesis
Latent Demand Detection
Find product ideas where people already fight through a distorted process to get a value
Leap-of-Faith MVP Scoping
Scope the smallest build that tests your riskiest assumption, not a stripped-down product
Live Shaping Session
Put product, a senior engineer, and a designer in a room to sketch and break ideas until one is clearly buildable in the appetite.
Long-Term Holdout Experimentation
Ship experiment winners fast, but keep the exposed cohort held and re-check GMV impact at 3, 6, and 12 months.
Optimizing for Feelings
Name the emotion the product must evoke, build to that, and use metrics only as an honesty check.
Pain-Plus-New-Technology Idea Selection
Judge what's worth building by pairing a habituated pain with a newly-arrived technology that can finally solve it.
Proven Better New
Master the proven, add a verifiable better, gamble one risky new — to stack the odds a product wins
Rank, Don't Filter
Every user-facing filter silently carves out your supply — turn preferences into ranking signals.
Reference Customer Discovery
Build with a fixed number of real customers until they'll stake their reputation on your product
Strategy Salons (Nerd Clubs)
Seed a small, opt-in, yes-and idea group that spins off strategy insights as a side effect.
Study Group
A one-hour role-play where employees forget they work at your company and try to use your product
Systematized Creativity by Extremes
Build the most extreme version along one attribute, feel it, repeat in the opposite direction, then find where they meet
The Agency-Control Autonomy Ladder
Ship AI in graduated versions, trading human control for machine agency only as trust is earned.
The Behavioral Diagnosis
A journey map on steroids: every micro-step to the behavior, with the blocking psychology named at each one.
The Bullseye Customer Sprint (5 + 3 in 1)
Interview five hand-picked customers against three prototypes in one team-watched day to learn who to build for
The Confidence Meter
Score how much evidence actually backs an idea, from a shiny pitch deck (0.1) to a live A/B test (10)
The Data-Informed Product Loop
Strategy to models to measurement to bets to impact to learning — find the broken link.
The Delight Model
A 4-step process to find the highest-ROI delight opportunities instead of shipping low-value confetti
The Design-Partner Pod Model
Give each cross-functional pod 6-12 real customers to co-build with, so features ship pre-validated.
The Extreme Dog-Fooding Loop
Use your own product at scale, document every flaw with screenshots, then personally drive the fixes to closure.
The First Mile: Lazy, Vain, and Selfish
Design onboarding for the first 30 seconds, when every new user is lazy, vain, and selfish.
The Four Forces of Progress
Model demand as a tug-of-war: two forces push people to switch, two hold them back.
The Four Freedoms Test for Real Open Source
Judge whether software is truly open source by four inviolable user freedoms, not marketing claims.
The Four Principles of Building Hardware Fast
Sequence the work so hardware's un-updatable, one-shot nature can't sink you.
The Full-Stack Builder Model
Empower one builder to take an idea to market end-to-end, regardless of role or team
The GIST Model
Split product work into Goals, Ideas, Steps, and Tasks so evidence — not opinion — drives what gets built
The Inflection Stress Test
Four questions that separate a real inflection from a vague 'why now'
The Minimum Lovable Product (MLP)
Ship five things people love, not fifteen things that merely work
The PRFAQ Working Backwards Document
Write the launch press release before you build, so every word forces a real decision
The Sean Ellis Scale Gate
Never scale a product until a calibrated share of users would be 'very disappointed' without it.
The Subversive Mindset (System Awareness → Novelty → Disagreeability)
Get a system to behave in a way its creators didn't intend, in three learnable steps.
The Three B's (Behavior, Barriers, Benefits)
Pick an uncomfortably specific behavior, strip its barriers, then engineer an immediate benefit.
The Three Pillars of Delight
Create delight by removing friction, anticipating needs, or exceeding expectations
The Two-of-Three Inflection Test
Only build a new zero-to-one product when at least two of three inflections line up
The Utility Curve
Use the S-curve of effort-to-value to decide whether a feature is under-invested or already maxed out
The Weekly Marketable Feature
Every engineer ships one feature per week that a user would pay or show up just for
The Wizard of Oz Validation Method
Validate a feature's value and conversion rate before building anything by faking the backend manually.
The Wonder-Explore-Make-Impact Incubation Gate
A four-stage vocabulary with 6-pager gates that lets a big company incubate new bets without prematurely scaling them
The Working Backwards PR/FAQ Process
Start every new product from the customer's problem, written as a press release, before any constraint enters the room.
What-If Before Why-Not
Evaluate a disruptive idea by imagining its upside first, then treat the objections as your build list.
Working Backwards (Problem-First Product Development)
Start from the customer problem, not the ingredients you happen to have in the pantry
Aha Moment Discovery via Correlation-Then-Experiment
Brainstorm high-value actions, correlate them with conversion and retention, then experiment to prove causation
Delay the Primal Mark
Stay in low-fidelity blocks and conversation as long as possible before drawing anything that looks real.
Incremental OFAT Over Big-Bang Redesign
Decompose big redesigns into one-factor-at-a-time tested steps because ~80% of ideas fail
Innovation by Isolation
The beneficial silo: how to actually make a startup-within-a-company work.
Minimum Viable Experiment + The Dogfood Gate
Ship the cheapest version of an experiment — but use it yourself before you trust its null result
Research-to-Product Graduation
Move an incubated moonshot from the research lab to a product team without killing it or trapping the researchers
The Underserved-Status Network Bootstrap
Seed a network with overlooked status, then grow its own native stars.
Artificial Density Testing
Manually cram enough users into one cluster to get a clean yes/no on a social product
Automated User Research Pipeline
Wire sales-call keywords to Slack to email to your calendar so customer interviews book themselves.
Build With, Not For: The Product Lab Cohort
Stand up a permanent invite-only user cohort so no fundamental change ever ships cold.
Chaos to Clarity
Move any big idea from your head to reality one clarity-adding step at a time.
Continuous Calibration, Continuous Development (CCCD)
A CI/CD-style loop for non-deterministic AI: scope, evaluate, deploy, then calibrate against surprises.
Designing a Zero-to-One Incubator Inside a Giant
Fix the incentive system and the time horizon first — everything else about internal incubation follows.
Evaluative User Research (Hunt for Reasons They Won't Use It)
Test prototypes to find every reason people won't use it — and never let the researcher go alone
Golden Samples Over Full Corpus
Curate a small set of gold examples for your AI, don't dump your whole knowledge base on it
Hypothesis-First Customer Discovery
Bring a crisp hypothesis to the interview — then be its judge, not its lawyer.
Irreducible Complexity — The Simplicity Audit
1 + 1 = 1.5, not 3 — every addition subtracts, so audit the system, not the local decisions
MAYA: The Right Amount of Weird
Ship the most novelty a market will swallow — one notch past familiar, never past comprehensible.
Naivety Hiring Lens
Use informed outsiders to question assumptions insiders no longer see
Problem-First AI Adoption
Start from the customer problem and ask where AI helps — never from 'what do we do with AI?'
Protected Deep-Dive Time
Goal the team on self-directed insight and use hackathons to stop exploratory work being eaten by inbound asks
Ship-to-Learn: The Emergent-Product Loop
When product properties are emergent, launching is how you discover them
Ship-Ugly-Then-Polish Craft Loop
Combine shipping fast with fixing fast: get rough builds in front of real users, reserve polish for general release.
Simplest-V1-Then-Amplify Experimentation
Ship the barest encapsulation of a hypothesis, confirm it has legs, then beat the heck out of it.
Systematic Invention (Expertise + Scheduled Thinking + Recombination)
Be an expert, book two hours a month, and fuse two things that already exist.
The Acqui-Hire Silo
Buy a founder, hand them the riskiest bet, and spend your capital shielding them from the org.
The Aligned Binary LLM-as-Judge
Build a one-failure, pass/fail judge and align it to a human with a confusion matrix before you trust it.
The Gravity Model for Zero-to-One Products
Ship new products with tiny shielded teams, then let traction—not headcount—pull in resources.
The Made-Up Name Reset
Give a team or feature a name nobody recognizes, so nobody can skip the argument about what it should be.
The Open Core Line: State and Collaboration
Open-source the standard where logic is written; charge for stateful and cross-team work
The Person Is the Product
Find one person with an extraordinary workflow, shadow them, then compress their expertise into software
The Same-Day Prototype Validation Loop
Idea in the morning, real users testing by afternoon, decision by evening
The Seedling Model for Going Multi-Product
Incubate new product lines as separate 'seed companies' with dedicated teams and adjacency-based selection
The Three Dimensions of an Agent
Score any 'agent' on autonomy, complexity, and natural interaction — each a spectrum
Volume-of-Ideas Design Velocity
Great ideas come from many ideas; build a high-velocity, no-gate, ego-free making-and-critique culture.
Backcasting & Reject the Premise
Stand in the future you designed and look back — don't forecast forward from today's constraints.
Context Over Models: The Data-Management Bet
AI products win on getting good, timely, well-structured data to the model — not on the model itself
Discover Pain by Watching, Not Asking
Find the real intensity of a problem by watching people work, because they can't self-report it
Earn the Secret by Savoring Surprises
There's no recipe for a breakthrough — hunt surprises at the edge instead of validation
Empathize-Then-Invent (The Stories Method)
Listen deeply to users for hours, then build something new — never the literal feature they asked for.
Fake the AI Before You Build It
Never train a model for an MVP — prototype the AI's output and test demand first.
First-Principles Re-Derivation (Rerun the Decision Tree)
Rebuild any product decision from today's building blocks instead of copying path-dependent solutions.
Hypothesis-Driven Experimentation: Learning as a Win
Reframe experiments from winners/losers to hypotheses; run more, run shorter, and carry priors forward.
NLX: Designing the Natural-Language Interface
Conversation is an interface with real constructs — design it, don't just let the model lead
Opinionated Defaults for Onboarding
Encode what you've learned works into product defaults — make the right choice easy and the wrong choice hard, without removing choice.
Right Model for the Right Use Case
Route each AI feature to a model chosen for that job, not one popular LLM stretched over everything
Scaling Expert Judgment Through Algorithms
Structure your experts' judgment into a signal, train on that — not only on engagement
Separating Change-Aversion from Real Problems in a Redesign
After a redesign, split 'upset because it changed' from 'upset because it's worse' before you react.
Server-Side Events as the Default
Track events from your servers, not your clients — logs with a user ID are already events.
Ship-in-Research-Preview Speed Loop
Cut idea-to-user time from months to a week by branding launches as previews and pre-wiring the launch chain
Stage-Gated Product Incubation
Grow new products through five funded stages — wonder, explore, make, impact, scale — validating at each gate.
Technology-First Discovery with a Shape Hypothesis
When you start from a capability instead of a problem, form a hypothesis about its shape before you ship it
The AI-as-CTO Persona Project
Cast the AI as an opinionated technical co-founder to kill sycophancy and premature coding
The AI Startup Moat: Data Flywheel + Crafted Workflow
Defensibility for AI apps comes from a proprietary data flywheel and a deeply crafted vertical workflow.
The Cold-Pattern Positivity Flip
Find the moments where users feel bad, and flip the product to reinforce progress instead of failure.
The Five-Day Design Sprint
Go from zero to a tested prototype in five days — decide with customer reactions, not hunches
The Four Product Risks and Their Owners
Valuable, usable, feasible, viable — any one fails and the product fails
The Love-Hate Disruption Test
Gauge whether an idea is truly disruptive by how polarized the reactions are, not how positive.
The Marquee Mock Exercise
Hand everyone blank App Store screenshot panels and make them draw the world where the problems are solved.
The Object Model: Three Questions Every Screen Must Answer
On every screen, a user should know how they got here, what to do now, and what to do next.
The Pickle: Iterated Product Quality List
A lightweight, memorably-named ship checklist you grow one line at a time from every miss.
The Single Affordance Rule
One product, one job. Added functionality can subtract value by destroying clarity of purpose.
The Three Innovation Blockers
Diagnose why a team plays it safe by checking the three specific things that quietly kill big thinking
The Three-Part AI Product Utility Equation
A useful AI product needs model intelligence, context/memory, and application/UI to all converge.
The Users Having a Bad Day Chart
Emit a log line every time a user hits pain, stack them in a bar chart, and burn the bars down
The Zero-Ask Assistant (Copilot Design Philosophy)
If the user has to ask for it or wait for it, they won't adopt it — build assistance that infers.
You Only Get to Compile Five Times
Treat every hardware build as one of a handful of irreversible compiles a year.
AI Paved Paths
Encode shared building blocks and guardrails so humans and agents can move safely
De-Risk the Biggest Swings First
Run discovery and delivery in parallel — and put the top-right, riskiest bets into discovery first.
Manufactured Dogfooding
Invent internal reasons for every function to live in your product — quality follows hours logged.
Persona-Framing for AI Product Behavior
Pick a human metaphor for your AI, then derive its behavioral guardrails from that role
The Determinism Test for AI Verticals
Favor AI domains where outputs can be tested quickly and objectively.
The Magic Test for Control Surfaces
Users ask for knobs and sliders; shipping them literally is how a magical product becomes an ordinary one
Absorb the Pirates
When a fraudulent clone steals your users, ship its best features instead of fighting its code
Adapt the Model, Don't Build One
Post-training is the new pre-training — steer an off-the-shelf model to your outcome instead of pre-training your own
Add a Zero (10x First-Principles Reframing)
Force a 10x version of the goal so the team must rethink the problem from first principles, not optimize the current process.
Adversarial Multi-Model Peer Review
Have rival LLMs review each other's code and fight it out until no issues remain
AI Computer Interfaces (ACI)
Give AI agents purpose-built text interfaces, not the human GUIs they were never designed for
Architect-Then-Delegate AI Product Building
Use AI to prototype and fill scoped sub-segments, but architect and lock the system yourself — don't cognitively surrender.
Blow Their Socks Off: The 10x Word-of-Mouth Bar
To earn recommendation, give users an experience they didn't know was previously possible
Build-and-Bake: Ship the Same Feature Until the Model Catches Up
Prototype ambitious features now, let them sit, and re-release the same shape each time models leap
Build Zero-to-One in the Dark
Inside a big company, new products die of attention. Ask for less scrutiny, fewer resources, and room to fail.
Business-to-Human (Humanization Delighter)
Ask 'if my product were a human, how would the experience be better?' to raise the bar
Cannibalize Your Own Product Every 6-12 Months
Make your current product look silly on a fixed cadence instead of only shipping what users ask for
Complaint Storms
A team ritual to see your own product with fresh, critical eyes — by first ripping apart someone else's.
Context and Outcome over Pain and Gain
Study the context that makes the irrational rational, not just the pain to be relieved.
Conviction-Building for Low-Volume Experiments
When you can't run a clean A/B test, stack alternative signals to raise conviction instead of faking precision
Core-Behavior Synthetic Training
Ship an AI feature by naming its 3-4 core behaviors and teaching them with model-generated data
Customer Research as a Documentarian
Observe like a non-judgmental documentarian, find the pattern, then validate the truth with data
Decompose-and-Ensemble
Break a broad problem into specific tasks, then solve each with a specialized model in an ensemble.
Disassemble the Lego Set
Don't digitize the old thing — reassemble the pieces into an experience native to the new platform.
Diverge-Then-Converge Roadmap Reset
On a platform shift: drop the roadmap, keep the objective, let teams go crazy, then pick 4-5 bets.
Don't Box the Model In
Give the model tools and a goal, not a rigid workflow — scaffolding gains get wiped out by the next model.
Don't Default to the Chatbot: Choosing the Right AI Interface
Reject the intuitive AI copy; ask what problem your business actually needs solved.
Ensembling (Mixture of Reasoning Experts)
Solve the same problem several ways and take the most common answer
Fail-Fast Iterative Validation
Since ~80% of hypotheses fail, use cheap validation methods first and reserve A/B testing for pre-vetted ideas
Fairer Marketplace Rating System Design
Fight rating inflation and averaging bias with renormed labels, priors, blind reviews, and the sound of silence.
Frameworks as Job Aids, Reps as the Goal
Adopting a framework is never the goal; getting reps through the full loop is.
Future-Backward Aspirational Strategy (Big-s)
Design-led, ~6-month process that imagines distinct 5–10 year futures and prototypes them as concept cars.
Game Design, Not Gamification (Build Toys, Then Games)
Make software fun by designing real toys that reward playful exploration — not by bolting on points and badges
Go All-In When the Experiment Works
Big companies experiment plenty — they fail by hedging instead of doubling down on what works.
Incubate-Iterate-Integrate for Innovating Inside a Mature Product
Build the new experience beside your core product, perfect it, then fold it back in — so you don't break existing customers
Learn by Making, Test the Extremes
Stop debating consequential decisions — run the experiment that shows the upper and lower bounds now.
LLM-Optimized Codebase Architecture
Structure your repo so the AI writes the least code possible — infrastructure absorbs the complexity.
Manufactured Chaos: The Artificial Time Constraint
When things feel too calm, inject an absurd deadline to force intuition and creative leaps
Maximize the Treatment Effect to Fail Conclusively
In low-sample B2B tests, throw every tactic at a hypothesis at once so a failure kills the idea for good instead of resurfacing for years.
Micro and Macro Barrier Removal
Grow by systematically removing both structural (macro) and friction (micro) barriers.
Model Introspection Harness Repair
When an AI agent misbehaves, ask it why — its explanation reveals the harness gap to fix
Multi-Prototype Comparison Testing
Show three distinct concepts instead of iterating one, so users can compare and you avoid over-commitment
New Products as Internal Startups
Incubate new products like funded startups: tiny teams, prove ROI before funding, keep them separate
North Star Exploration
Turn aimless tech-tinkering into learning by chasing an arbitrary-but-real goal and being stubborn about reaching it.
Off-the-Shelf to Prove It, Custom to Ship It
Prototype with whatever works fastest; go custom only when KPIs demand it.
Parallel Draft Divergence
Start one idea 4-5 times in parallel, each with more precision, then pick the obvious winner.
Pattern-Breaking Inside a Big Company
Make small bets that can fail a lot — and hide them from the mother ship
Perceived Simplicity
Keep advanced power in the product but discoverable only to those who go looking — invisible to everyone else.
Play-First AI Fluency
Build real AI intuition by playing — invent fun side projects, use everything, and share the artifact not the doc.
Problem-First, Wheelhouse-Checked, Unit-Economics-Proven
Three gates a product idea must pass before you build the solution you already fell in love with.
Product as Organism: the metabolic loop
Treat an AI product as a living system that ingests signals, tunes on rewards, and improves with every interaction
RAG Data Preparation Over Database Tuning
The biggest RAG quality wins come from preparing data for retrieval, not picking a database.
Reset Through Better Abstractions
Don't fear throwing work away — a better abstraction compounds and recovers sunk cost fast.
Ship Neutral Experiments on Intuition (Aim-Heavy)
When a test comes back neutral, ship the version you'd have built from a blank slate, not the incumbent control.
Solution-Weighted Discovery
Spend a little time validating the problem; spend most of it winning on the solution
Solve the Problem Behind the Problem
When an agent can't do a task, escalate API-to-browser, then reframe to the underlying need it can solve.
Stated vs Revealed Preferences: Holding Conviction Through User Outrage
When users scream and keep refreshing, believe the behaviour — then debug details, not vision.
Structural Conditions for Innovation
Companies that say they tolerate failure but punish it in comp and career don't get innovation. Change the structure.
Tar Pit Idea Detection
Spot the seductive ideas that draw everyone in and trap them — they validate but never work
The 10x Lens on New Ideas
For every promising idea, ask where it could go in 3-5 years if it were 10x bigger — and let that reshape it now.
The Better Tool, Same Problems Lens
Every model leap gets normalised within months — build for the boring future, not the euphoric one.
The Crux: Insight Through Immersion
Find the single hardest solvable part of the problem, immerse in it, and let insight emerge.
The Escape Hatch Principle
Abstractions should let power users drop to raw control when the model doesn't fit their problem
The Four Springs of Startup Ideas
Generate startup ideas from a problem journal, niche communities, behavior shifts, and tech shifts — then justify why now
The Horizon-3 Research Team That Ships
Fund a 3-5 year research team, then bolt it to product so ideas actually reach production.
The Levels of Quality Ladder
Rate every feature 1-5: works → error-free → usable → desirable → surprisingly great.
The Minimum Viable Experiment Trap
A lean test that strips out the mechanism doesn't test the idea — it buries it.
The Pantry Test
If the idea starts with the ingredients you already have, you are not working backwards
The Parallel Sweet Spot: Psychological, Technological, Economic
Solve all three constraints at once — running them in series is how great products die.
The Three B's of Behavior Change
Change user behavior by picking a specific Behavior, removing Barriers, and adding immediate Benefits.
The Tiny Core Principle
Every enduring product has one tiny thing that is a superpower — find it, protect it, and stop bolting on features.
The Two Paths to Opinionated Software
Either encode a best practice that already exists without technology, or teach a better way and enforce it in the product
The Validation Gamut (Assessment, Data, Tests, Experiments, Release)
Validate an idea's assumptions cheaply first — assessment and data before you ever build, fakes before you build for real
The Zone of Benefit (3x Rule)
A product must make the customer at least 3x better before they notice enough to switch and pay.
Three-Prototype Ideation
Since prototypes are now free, build a feature three ways and let real use pick the winner.
Three-Team Blind Briefing
Disguise the real assignment across parallel teams so creatives are free to make useful mistakes.
Turn the Recurring Break into a Strategic Moat
When the same problem breaks a third time, stop patching — pull your best people off features and solve it for 100x as a competitive edge
Two-Mode Product Teams
One team, two clocks: ship at the speed of the moment, and build the system between moments
Unbundle Expensive Services into AI Apps
Find a service only the rich could afford, do it with a general chatbot, then spin the working ones into apps
Understand Users by Watching Failures in the Funnel
Watch real users, and interview the ones who failed in your funnel — they know what you need to fix.
Value-Chain Eval
Before applying AI to your business, build a systematic test that measures how well it automates your core value chain
Vibes Before Evals
For a genuinely new AI feature, start with open-ended vibes testing; add evals only once the use-case cluster is clear.
Wow-First MVP
Cut scope to the critical few features, but never compromise quality — so a flop can only mean the idea was wrong
The Technology Wave Specialization Ladder
Ratchet down on a new technology while it's still weird — teardown, no-code, then fun build
Adversarial Dogfooding Loop
Force all your work through your own product even when it's the wrong tool, so it becomes the right tool
AI at the Core vs AI at the Edge
Decide whether to sprinkle AI onto existing code or rebuild the workflow with the LLM as the core
Be Your Own First Customer: Internal Tools to Product
Turn the ugly tools your team builds to serve customers into the product — most of the value is below the waterline
Build for Your Best User, Not Your Worst
In early product development, design for the user who gets it instantly, not the edge-case abuser
CaMeL Permission Pre-Restriction
Grant an agent only the permissions its stated task needs, decided before it runs
Constitutional AI Self-Critique Loop
Align a model to written principles by having it critique and rewrite its own outputs, then train on the fix
Designing Robots That Feel Non-Threatening
Make robots soft, attentive, and telegraph intent before they move.
Documentation vs Storytelling Safety Framework
Sort every AI-video use case into documenting reality (block) or storytelling (enable)
Finding High-Leverage AI Ideas
Give AI work a metric, run hackathons, and study what makes AI products feel magical.
First to Hit the Brick Wall
In innovation, speed is the biggest determinant of success because you learn what doesn't work before anyone else.
Jobs-to-Be-Done Agent Mapping
Bring order to AI chaos by listing every stakeholder's jobs-to-be-done, then mapping agents onto them.
Latent Demand Mining
Watch for people jumping through hoops to make your product do something, then make that the smooth path.
Markets as Currents, Not Bodies of Water
Chase the change dynamic pulling the market, not the size of the market
Minimum Lovable Product
Viability is no longer enough — the bar is a product people love and want to talk about
Opinionated Software: Good Defaults Over Flexibility
Ship the one best workflow as a strong default so users spend time on their work, not on configuring your tool.
Own-the-Framing Design Partnerships
Design partners guide the build — set the pricing frame up front and filter feedback 80/20.
Price-Elasticity Three-Response Model
When a technology makes something cheaper, work out which of three demand responses your market will take
Ride the AI Value Wave
Treat today's AI capability as the worst it will ever be and expand where it's most efficacious
Steering AI to a Non-Obvious Strategy
AI gives predictable strategy when asked lazily — enumerate every input first, then make it argue back
Step-Wise Eval Design for Multi-Step AI Apps
Don't evaluate agents end-to-end; put an eval on every step until you hit coverage.
Tension at the Center of Strategy
Every great strategy creates 'it might not work' tension — the possibility a customer falls in love with.
The AI Expertise Layer
Don't outsource all AI to foundation models — keep expertise and measurement to break the quality glass ceiling.
The Dark Factory Software Model
Ship production software no human writes or reads — replace review with simulated-user QA swarms.
The Design Sprint Scorecard
Break your founding hypothesis into rows and grade each one red/yellow/green after head-to-head customer tests
The Easiness Ladder: Default, Then Rule of Thumb, Then Decision
First line of defence is always a default. If you can't default it, give people a heuristic — never a calculation.
The Three-Pillar AI Integration Model
Build where you have data advantage, partner for commodities, and open an app ecosystem for the rest
The Two-Sided Quality Signal
Great curation does two opposite jobs at once: kill the worst, surface the best.
Throwaway Prototyping To Discover The Product
Build disposable prototypes on real data to feel what works before writing any production code.
Write the Press Release First
Before building anything, write the launch press release as if the product shipped today.
10x vs 10% Thinking
Deliberately reserve space for moonshot bets instead of settling for safe incremental improvements.
Design in the Material
PMs and designers should code — not to ship, but to master the material and truly understand what they're designing.
LLM as Disconfirmation Engine
Point the model at where your strategy does NOT fit — and reverse-engineer competitors from their public docs
Lower the Courage Required
The scarcest resource is courage, not genius — so design products and decisions to need less of it.
Prompting-as-Prototyping
Validate a product idea by prompting a model in a local browser before building anything
The Design-Led Architecture Stream
Give design a protected block to define the product's building blocks — or it will smuggle scope in at the end.
Three Ways to Find Marketplace Whitespace
Unbundle a low-NPS segment, own an ignored niche, or change the atomic unit of supply
Complementary Format Integration
Bring a proven new format into a mature product so it expands, not contorts, the core
Gamification's Three Pillars: Core Loop, Metagame, Profile
Durable habit-forming products stand on three legs: a tight core loop, a long-horizon metagame, and an accumulating profile.
Objective-Data Alignment Test
Before betting on an AI capability, check that your training data is the same shape as your desired output.
Adaptive Evaluation Over Static Benchmarks
Measure AI robustness with attackers that learn, not with a frozen dataset of yesterday's attacks
AI Rep-Loop Compression
Build AI tools that give you feedback 80% as good as an expert's, on demand, to get years of judgment-building reps in a fraction of the time.
Build for the Exponential (Skate to Where the Puck Is Going)
Build products for the model that arrives in 6-12 months, betting that today's 20%-working features hit 100%
Build Your Own Senior-Engineer Benchmark
Measure AI honestly by scoring new models against real human experts rewriting your actual broken work.
Championing Big Bets Inside a Company
To win support for audacious product bets, repeat the vision relentlessly, state your intent, and optimize for impact.
Change the Rules of the Game
When the game is rigged against you, don't optimize — invent a new model.
Cohort-and-Control Data Reading
Never trust pre/post dashboards — read behavior by cohort and judge changes by variant-vs-control so the macro can't fool you.
Complement-the-Frontier Model Strategy
Don't rebuild foundation models — train small specialty models that attack their weaknesses in speed, cost, and niche tasks.
Fear-Origin Audit for Product Bets
Products built from competitive fear fail; audit the motivation before you audit the roadmap.
Frustration-Log Micro-Tool Ideation
Beat the idea crisis: log a week of frustrations, then build tiny AI tools to kill them.
Information-Diet Idea Divergence
Same inputs produce same ideas — mine your unique experience and starve the herd feed
Innovate Inside a Big Company as a Separate C-Corp
Spin new products into their own C-Corp with a founder-type lead reporting to the CEO, bypassing core-code review
Legibility Framework for Spotting Frontier Ideas
Hunt for illegible ideas — the ones with real energy that nobody can quite articulate yet — and translate them.
Live in the Future, But Not Too Far
Hold the far-future vision, but land with users where they already work today.
Minimum Lovable Product Ladder
Replace the MVP with a three-rung ladder: minimum lovable, lovable, absolutely lovable.
Mixed-Initiative Contextual Assistance
Surface AI help at the moment it's relevant instead of interrupting with notifications.
Press-Release-First Product Ideation
Write the launch press release before you build to keep products marketable
Product-First, Add-AI-Later
Design the end-to-end product experience first, then add AI to solve specific problems — never retrofit AI into a broken flow.
Reason About It Like a Human
To design or debug AI behavior, ask what an equivalent human would do in the same situation.
Reinforcement Learning Environment Design
Build a fully-fleshed simulated world, inject real chaos, and reward the trajectory, not just the answer.
RLAIF Reward Design
Have an expert define success criteria and a rubric once, then let AI reinforce the capability — more scalable than labeling examples
Second- and Third-Order Effect Mapping
In connected systems, trace a change's ripple effects before you ship it
The 20/80 Willingness-to-Pay Axiom
20% of what you build drives 80% of willingness to pay — and it's usually the easiest 20% to build.
The Automatable Growth Loop (CACHE)
Break growth experimentation into four evaluable stages an AI can hill-climb, keeping humans on alignment
The Double Diamond Product Process
Alternate broad exploration and narrow selection across customer, problem, and solution
The Middleman-Signal Disintermediation Play
When middlemen and end-customers both come to you directly, that's the signal to build the business yourself
The Ugly Baby Test
Seek ideas that make smart peers laugh — real alpha lives in the ugly babies everyone dismisses.
Trapped Value and the 10% Capture Rule
Find the pool of value your technology unlocks — you keep roughly 10% of what you release.
Wide Aperture, Then Coalesce
Keep considering many ideas — including ones that look bad — and test cheap versions until the signals converge on one
Embrace-the-Next-Thing Mindset
Greet each new technology wave with 'I can't wait for the next thing' instead of resentment.
Optical Correction X-Ray
Blow a single letter up huge and probe its joints to see where a real type designer breaks geometry to look perfect.
New-Idea Validation Bar
Prove real demand with 'duct tape', then prioritize ideas by pain-point sharpness and reach
Physical-System Reality Check
For anything embodied, budget for three things — a brain, a body, and real application scenarios.
Reverse Engineering to Build Openness
Two reverse-engineering habits that let a conscientious brain manufacture the openness it lacks
The IKEA Effect for AI Products: Leave Knobs and Levers
Don't automate everything away — give users enough control to feel ownership.
The Pilot Program for De-Risking Launches
Build a diverse champion network of real customers to test new features in the wild before you ever launch.
AI Possibility-Space Mapping
Use AI to enumerate the full combinatorial space of a multi-dimensional decision and build intuition fast.
Principles for Building Trustworthy AI Products
Match UI confidence to data quality, be transparent about sources, and design virtuous data cycles.
Stuck-Point Scaling Law
Reliably improve an AI system by hunting where it gets stuck and tuning those spots with a fast feedback loop.