Claude Code

Adaptive Evaluation Over Static Benchmarks

Measure AI robustness with attackers that learn, not with a frozen dataset of yesterday's attacks

Adversarial Dogfooding Loop

Force all your work through your own product even when it's the wrong tool, so it becomes the right tool

Adversarial Multi-Model Peer Review

Have rival LLMs review each other's code and fight it out until no issues remain

AI as Your Learning Engine

Stop only asking AI to do work for you — spend your spare hours making it train you

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

Bad vs Sad Quality Tiers

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

Best-Model-First Agent Workflow

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

Be The User Reset (Jobs-to-be-Done)

Zoom out and ask what the user hires your product for — then be that user and ask if you'd even buy what you made.

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-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

Builder vs. Information Mover

Diagnose which half of your role AI kills and which half it supercharges.

Build for the Current Model, Prototype for the Next

Elicit max capability from today's model while pre-building the products the next model will unlock

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 for the Model Six Months Out

Design your AI product for the model that ships in six months, not the one you have today.

Build Only at the Magic Intersection

Don't ship what anyone could build off the shelf — build only where model and product uniquely meet.

Peak Performance3 steps

Build-With-The-Tools Assessment

Don't test people on doing work without AI — hand them the tools and score what they can build in an hour

Build Your Own Senior-Engineer Benchmark

Measure AI honestly by scoring new models against real human experts rewriting your actual broken work.

CaMeL Permission Pre-Restriction

Grant an agent only the permissions its stated task needs, decided before it runs

CEO-Led AI Adoption Playbook

The single predictor of AI adoption is whether the CEO uses it daily — then amplify your 10% early adopters

Clear-Goal Ambiguity Cut

Because general LLMs can do anything, a sharp key-user + problem + use-case triad is what rules approaches out

Codify Your Judgment into Prompts (Don't Repeat Yourself)

Turn every piece of feedback you give into a reusable prompt so you never say it twice

Compounding Engineering

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

Connect-Users-to-Value Journey Staffing

Growth's job is to connect users to your product's value — so staff teams around each stage of the user journey.

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

Crossing the Chasm from Fear to Joy

Reinvent yourself by manufacturing one small moment of building joy, not by studying harder.

Cultivate Agency, Not Skills

When AI hands everyone the skills, agency becomes the only differentiator — and you build it by making things.

Defensible Moats for AI Startups

Four durable places to build in AI where foundation-model labs are least likely to squash you.

Demos Not Memos

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

Design in the Material

PMs and designers should code — not to ship, but to master the material and truly understand what they're designing.

Determinate vs Indeterminate Optimism (Betting Under Deep Uncertainty)

Founders need one specific plan; allocators need many bets and a discount on their own forecasts

Detune Precision by Time Horizon

The shorter the horizon, the more detail; keep long-range plans deliberately hazy to avoid false precision

Diagnose Agent Failure as Structural, Not Stupidity

When an agent does the wrong thing, check its context, tools, and scope — not its intelligence.

Marketing4 steps

Distribution Beats a Commodity Product

When products in a category are basically interchangeable, an adequate product with superior distribution wins

Dive-In Career Strategy for a Platform Shift

Facing a disruptive technology, submerge yourself in it and aim to hold at least two of three career pillars

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.

Elastic-Demand Career Bet

Invest in domains where making people 10x more productive increases demand rather than reducing it

Communication4 steps

Emotional Journey Design for Content

Content is predicting reader reactions: hook them, pace the emotion, make people likable.

Equally Disappoint Everyone

In your power years, prioritize by spreading disappointment evenly to protect time for reinvention.

Innovation6 steps

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 Triage: Decide What Actually Deserves an Eval

After counting failures, route each one to a prompt fix, a code check, or an LLM judge — not all three.

Existing-User Retention & Resurrection Priority

As a consumer subscription matures, the biggest lever isn't new users — it's current-user retention and resurrecting the dormant.

Explore & Exploit at the Insight Level

Oscillate between finding the right mountain and climbing it — but do it insight by insight, not just at strategy level.

Exponential Bet Allocation

If AI is your core value, shift the growth portfolio from micro-optimizations to large bets

Exposure Time for Taste

Deliberately spend more time learning than building to develop the judgment AI can't give you.

Fear-to-Agency Reframe

When AI change triggers fear, lean in and ask what's within your control — turn it happening to you into happening for you.

Leadership5 steps

Friction Smells: Signs Your Team Can Move Faster

The tell-tale signals that friction, not capability, is capping your team's speed

Mindset3 steps

Frozen Competence: Where Human Value Survives

Models commoditize yesterday's competence; your value is using that cheap competence to make something new.

Frustration-Log Micro-Tool Ideation

Beat the idea crisis: log a week of frustrations, then build tiny AI tools to kill them.

Full-Value Free Sampling (Reverse Free Trial)

Make your free product a live, rationed taste of everything paid can do — not a walled-off basic tier.

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.

Give It Your Hardest Task

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

Harder Is Easier (The Figure-It-Out Principle)

Commit to the costly right thing up front, and the trust it earns makes everything else easier.

High Agency, High Accountability

Pair the freedom to solve problems your own way with clear ownership of the hypothesis and the outcome.

Hire an AI Operations Lead

Give one person the dedicated job of automating everyone else's repetitive work with AI

Hire by Repelling: The Distinctive Bat Signal

The best talent magnets deliberately turn some people off — clarity on who you're NOT for is the point

Hire Yourself First (Build in Public)

Do the job professionally in public before anyone hires you — then the hire is just changing the vehicle.

Hiring for the Extra 20%

Skills are table stakes — screen for the people who'll chase the real outcome, using lateral personality signals

Hoard What You Know How To Do

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

Hunting New Bottlenecks When AI Writes the Code

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

Just-in-Time Planning

Shrink long roadmaps to a lightweight monthly priority list and grant explicit permission to kill dead processes.

Kind and Candid

Reframe candor as an act of kindness so you actually deliver the hard message.

Label the Process Stage, Not the Polish

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

Latent Demand Mining

Watch for people jumping through hoops to make your product do something, then make that the smooth path.

Latent Demand Product Discovery

Find your next product by watching people misuse your current one for something it wasn't designed to do.

Leader Dogfooding for Product Pulse

Live and breathe your product as a real user (or meet customers) and trust the anecdote over the dashboard.

Lean-Into-Organic-Sharing Virality

Don't manufacture virality — instrument where users already share, then make those exact moments 5-10x more delightful.

Self-Mastery5 steps

Lean Into Your Spike

In the AI era, double down on your unfair advantage and stack disciplines to become a unicorn

Live in the Future, But Not Too Far

Hold the far-future vision, but land with users where they already work today.

Make the End User Feel Like a Winner

Design agents that don't just do tasks — they make the user look good and feel like a winner.

Communication4 steps

Make the Other Mistake (Prompting for Brutal Feedback)

To get honest AI critique, over-correct toward brutal — the model won't actually overshoot.

Manager-as-IC Onboarding

New managers ship as individual contributors first — and keep doing it — before and while they manage people.

Manager Visibility via an Always-On Agent

Enlist a standing AI session across all repos and channels to stay on top of 8x throughput and drive conversations.

Many Bets, Charge Early

Maximize the number of fast bets, then force a verdict by asking the customer to pay a lot — now

Marginal-Impact Reasoning Under Tail Risk

Prioritize catastrophic low-probability risks by expected value and by how few people are already working on them

Match the Medium to the Point

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

Mission-Above-Product Prioritization

Route every cross-org tradeoff through a single shared mission so decisions are fast and everyone stands behind them

Mission Drive Audit

Prove you're mission-driven by showing you cannot profit except by achieving the mission.

Entrepreneurship5 steps

Mission-Protective Provisions Playbook

Lock in founder and mission protections now, while you still have the leverage to do it.

Mixed-Initiative Contextual Assistance

Surface AI help at the moment it's relevant instead of interrupting with notifications.

Model Casting by Personality

Route each task to the model whose 'personality' matches, and split plans to fit

Model Introspection Harness Repair

When an AI agent misbehaves, ask it why — its explanation reveals the harness gap to fix

Obsolete Yourself

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

Obviously Good, Then Incremental Correctness

Only make obviously good stuff, ship it in iterations, then reconcile the sprawl back to a naked robotic core.

One Agent Per Lane

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

Output-Toward-Outcome Measurement

Don't forsake motion for progress — keep asking whether the metric you climb still serves the outcome.

Parallel Draft Divergence

Start one idea 4-5 times in parallel, each with more precision, then pick the obvious winner.

Patient-Then-Floor-It Hiring

Be obsessively patient hiring the founding team; step on the gas the moment demand exceeds what you can handle

Pivot to the Burning Problem

Founders are usually too anchored to their own product vision — index to the customer's real fire instead

Positive Delusion, Bounded by Learning

Assume everything is possible until proven wrong — but keep learning what's actually possible.

Prescriptive vs. Framework Metrics

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

Presume Radical Uncertainty (The 1997 Lens)

Treat an emerging platform as if it were 1997 for the internet: assume most of it doesn't work and you can't yet name the winners

Price-Elasticity Three-Response Model

When a technology makes something cheaper, work out which of three demand responses your market will take

Prime-Then-Parallelize AI Coding Workflow

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

Pull-Based Product-Market Fit

Be stubborn on your thesis but open on its form — chase the customer who is surprisingly easy to sell, not the one you must force

Pull the Thread on New Tools

Judge a new AI tool by where it'll be in a week or a month, not where it is on day one.

RAG Data Preparation Over Database Tuning

The biggest RAG quality wins come from preparing data for retrieval, not picking a database.

Ramble-Mode Onboarding

Onboard an AI agent by voice-rambling everything you need, not by wiring up APIs and structured fields.

Randomized Tiered Trial for AI Productivity

Measure whether AI tools help by running a randomized trial split across performance tiers.

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'.

Communication5 steps

Reframe Metrics to Leadership's Language

Pick two or three metrics that speak the exact word your leaders keep repeating

Resting in Motion

Treat the busy, working state as your normal baseline so heavy long-term work stays sustainable

Ride the Models

Stay valuable in AI by playfully applying each new model to your own work and re-testing what it couldn't do before.

RLAIF Reward Design

Have an expert define success criteria and a rubric once, then let AI reinforce the capability — more scalable than labeling examples

Root-Cause Tooling Post-Mortem

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

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

Mindset3 steps

Show Me the Apparatus Test

A value is only real if there's an expensive apparatus that enforces it every time, no exceptions.

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.

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.

Spiritual Holding Company (Mission Guardian Selection)

Give the mission its own sovereignty by appointing a renewable guardian that outlives any founder.

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.

Marketing4 steps

Strategic Friction

Add friction that helps a user understand why the product is for them; cut friction that doesn't

Super Agent With a Forward-Deployed Human

Give the whole company one shared agent, owned by a human who keeps it working — not personal agents for everyone.

Task Loss, Not Job Loss

Your job won't vanish — analyze it as a bundle of tasks and keep swapping the tasks AI absorbs

Task vs. Job Automation Test

Before predicting a role's automation, ask whether the automatable task IS the job or just one piece of it

Taste as a Trainable Model

Taste is a virtual machine in your head that predicts whether your in-group will like an idea — built by reps with feedback.

The 1,000-Experiments 'What Would Need To Be True' Goal

Set an audacious experiment-volume goal — not to hit it, but to force the conversations that unlock a whole experimentation culture.

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 10-to-1 Input/Output Kill Test

When you pour 10 units of effort in for 1 unit of output, the project has run its course.

The 4x4 Debugging Framework

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

The AI-as-CTO Persona Project

Cast the AI as an opinionated technical co-founder to kill sycophancy and premature coding

The AI Deployment Risk Triage

Classify any AI deployment into one of three risk tiers before spending a dollar on defense

The AI-Document Slop Test

An AI-written document is fine — as long as you can stand behind every line and it took longer to make than to read.

Peak Performance5 steps

The AI Interview-Prep Coach System

Build an AI coach, mine the real question bank, drill weak spots — then mock with humans

Strategy5 steps

The AI Security Vendor Due-Diligence Test

Five questions that expose whether an AI guardrail vendor is selling real protection or theater

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 Allocation Economy: Manage Models Like a First-Time Manager

AI turns everyone into a manager — the valuable skills become the ones first-time managers must learn

Mindset3 steps

The Angry-God Containment Lens

Assume the AI is a malicious agent trying to hurt you, then engineer so it structurally can't

The Automatable Growth Loop (CACHE)

Break growth experimentation into four evaluable stages an AI can hill-climb, keeping humans on alignment

The Barbell Media Diet

Read only the up-to-the-minute and the timeless — distrust everything in the middle

The Benevolent Dictator Labeling Model

Appoint one trusted domain expert to own eval judgments instead of running it by committee.

The Cold-Pattern Positivity Flip

Find the moments where users feel bad, and flip the product to reinforce progress instead of failure.

Sales4 steps

The Conversion-Funnel Cold Email

Treat a cold email like a growth funnel: open, then read, then reply — optimize each stage separately

The Culture Bank (Todd Park's Deposit Rule)

Treat trustworthiness as an asset: only ever make deposits, never intentionally make a withdrawal.

The Curator Leader (Not the Visionary)

The best product leaders don't own the ideas — they build environments where great ideas bubble up and get chosen

The Dark Factory Software Model

Ship production software no human writes or reads — replace review with simulated-user QA swarms.

The DevX Listening Tour

Before you build a tool, walk developers through their yesterday

The Economic Turing Test

Measure transformative AI by whether you'd hire an agent for a real job without knowing it's a machine

The Eval ROI Decision

Build evals where failure is catastrophic or you must win; vibe-check the rest.

The Exposure-Therapy Tool On-Ramp

Ease into coding tools in graduated steps so code stops being terrifying

Communication4 steps

The Fast-Feedback Flywheel

Fix every piece of user feedback within minutes so people feel heard and give you even more.

The Forward Deployed Engineer Loop

Embed a real engineer inside the customer's building and run a build-show-iterate cycle every single day

Leadership7 steps

The Frictionless Seven-Step DevX Program

A start-anywhere playbook to stand up a developer-experience initiative

The Hire-an-Agent Onboarding Model

Set up an AI agent exactly like you'd onboard a human EA: own identity, delegated access, earned trust.

The Learning-Opportunity Command

Turn every confusing moment into an 80/20 lesson aimed at your current skill level

The Lethal Trifecta

Any AI agent that combines three capabilities can be tricked into stealing your data — cut one leg.

The Murder Board

Before starting a project, invite smart outsiders whose only job is to tear your two-page plan apart

The Pod + Product Staff Team Model

Replace the 13-person specialist team with a 6-person generalist pod plus one summoned specialist

The Reach Test

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

The Scheduled AI Chief of Staff

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

Productivity7 steps

The Seven-Command Build Loop

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

Finance4 steps

The Sip Seed Round

Get capital committed but pull it down only when needed, so you keep optionality and psychological freedom

The Skip — Plan the Move After Next

Optimize career decisions for the job two moves out, not the next job.

Productivity6 steps

The Source-of-Truth PRD Cascade

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

The SPACE Framework

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

The Superpowered Individual (Combination-of-Skills Career Moat)

Go deep in one craft, then use AI to add adjacent crafts until you become un-replaceable

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-Part AI Product Utility Equation

A useful AI product needs model intelligence, context/memory, and application/UI to all converge.

The Three-Trait Hire Plus Two AI-Era Premiums

Grit, quick-learning, self-awareness get you hired anywhere — curiosity and putting yourself out there keep you relevant

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 Top-Three Weighted DevX Survey

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

The Two-Bucket Controversial-Test Triage

Sort every risky experiment into a red-line 'never run' bucket or a 'run it if the return justifies the cringe' bucket

Leadership5 steps

The Two-Week Deputization Rule

Under two engineering weeks, the engineer is the PM; over two weeks, the PM owns it

The Vibe-Coding Blast-Radius Rule

Vibe-code freely when only you get hurt by bugs; stop and take responsibility the moment others could.

Three-Legged Model Evaluation

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

Three-Prototype Ideation

Since prototypes are now free, build a feature three ways and let real use pick the winner.

Three Tenets: Can-Do, High Standards, Intensity

The three cultural tenets Foody credits for the fastest revenue ascent in history

Three Worlds Theory of Change

Decide what to actually do about a hard problem by naming the pessimistic, optimistic, and pivotal worlds you might be in

Finance3 steps

Token Budgets as a Trust-Proportional Resource

Kill the token-spend leaderboard; cap AI spend like any resource, sized to trust in someone's ROI judgment

Two-Question New Technology Adoption Test

Before adopting any new AI tool, ask: how big is the gain, and how painful is the exit?

Unblock the Review Bottleneck

The limiting factor on AI productivity is human review speed — engineer the agent to validate its own work.

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

Under-Resource to Force Automation

Deliberately under-staff projects and hand out unlimited tokens so people are forced to automate with AI.

Value-Chain Eval

Before applying AI to your business, build a systematic test that measures how well it automates your core value chain

Strategy5 steps

Value-Up-The-Stack Test

To find where the money accrues in a platform shift, test the infrastructure layer for network effects, differentiation, and pricing power

Vision-Strategy-Execution Split (and the Controversy Test)

Vision is the destination, strategy is an opinionated path — and a real strategy must be disagreeable

What Actually Improves AI Apps

Stop chasing AI news and vector DBs; the real levers are users, data, and prompts.

When-It-Leaks Communications Pre-Mortem

At scale you can't test quietly — decide the message before you even know you want to launch

Zone Defense for Product Work

Spread taste-makers out to cover the whole field instead of clustering on the same problem