Codex

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

Influence4 steps

Anchor the Pitch to the Exec's Incentives

Find the metric, OKR, or board pressure they own, then show how your idea moves it.

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.

Productivity5 steps

Best-Model-First Agent Workflow

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

Marketing3 steps

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.

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

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

Build for Where the Models Are Going

Design products for the capability one to two years out, not today's model ceiling.

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.

CEO-Led AI Adoption Playbook

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

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

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.

Continuous Calibration, Continuous Development (CCCD)

A CI/CD-style loop for non-deterministic AI: scope, evaluate, deploy, then calibrate against surprises.

Critique in Public, Build Trust in Private

Invert the management-book rule: debate directly in public, lavish reassurance in private.

Mindset4 steps

Crossing the Chasm from Fear to Joy

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

Self-Mastery4 steps

Cultivate Agency, Not Skills

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

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.

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.

Influence3 steps

Don't Be Stingy With Words

People can't read your mind — make appreciation explicit, and never fake it.

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

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.

Evals-Plus-Production-Monitoring Dual Feedback Loop

Reject the false dichotomy: evals catch what you know, production monitoring catches what you don't.

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.

Self-Mastery4 steps

Exposure Time for Taste

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

Productivity5 steps

Flow-Preserving AI Assistance Design

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

Follow the Breadcrumbs and Calibrate Urgency

Act fast on an exec's subtle hints, but ask how strongly they actually feel first.

Mindset3 steps

Frozen Competence: Where Human Value Survives

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

Give It Your Hardest Task

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

Go All-In When the Experiment Works

Big companies experiment plenty — they fail by hedging instead of doubling down on what works.

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.

Hire an AI Operations Lead

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

Hire Yourself First (Build in Public)

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

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

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

Live in the Future, But Not Too Far

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

Marketing3 steps

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.

Match the Medium to the Point

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

Marketing5 steps

Meet-The-Customer-Where-They-Are Marketing

Put your product into the customer's context and re-tune the message for each adopter tier and market.

Mega Trend vs Hype Cycle — The PhD Test

If you need a PhD to understand it, it's not a mega trend. Don't fight mega trends.

Micromanage the Decision, Not the Operation

Sweat only the few details that matter for the customer — control the decision, delegate the doing.

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

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.

Leadership5 steps

Opinion-Based Decisions for 1.0 Products

For a first-of-its-kind product, empower a tiny 'tastemaker' team to make gut calls — data can't yet exist.

Own the Story — No Packet Loss

The leader is the custodian of the message — deliver it to the front line yourself, never via cascade.

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.

Innovation5 steps

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

Innovation5 steps

Persona-Framing for AI Product Behavior

Pick a human metaphor for your AI, then derive its behavioral guardrails from that role

Pick Hard Problems to Attract the Best Team

Hard, important problems attract the best people — and business is a team sport.

Mindset4 steps

Positive Delusion, Bounded by Learning

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

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.

Ramble-Mode Onboarding

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

Innovation7 steps

Research-to-Product Graduation

Move an incubated moonshot from the research lab to a product team without killing it or trapping the researchers

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.

Right to Win via Permission to Play

Before building, ask if it's logical that YOU built it — and whether you have a route to market.

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

Influence3 steps

Shrink the Change to Build Trust

De-risk a scary idea into a two-week experiment with a fixed check-in date.

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.

Steering AI to a Non-Obvious Strategy

AI gives predictable strategy when asked lazily — enumerate every input first, then make it argue back

Stewart Plus Two More

Never bring one option; show a Goldilocks three and hold the rest in the appendix.

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.

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.

Productivity5 steps

The 4x4 Debugging Framework

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

Strategy5 steps

The 60/30/10 Portfolio Capacity Split

Allocate team capacity across incremental wins, operations, and audacious bets before priorities compete

The 60-Second Meeting Reset

Buy a context-starved exec 30 seconds of orientation before you pitch.

The Agency-Control Autonomy Ladder

Ship AI in graduated versions, trading human control for machine agency only as trust is earned.

The AI-as-CTO Persona Project

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

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

The AI Success Triangle

Successful AI adoption is a people problem first: great leaders, good culture, and technical progress.

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.

Mindset4 steps

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

The Benevolent Dictator Labeling Model

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

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

Self-Mastery4 steps

The Exposure-Therapy Tool On-Ramp

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

The Fast-Feedback Flywheel

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

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

Themes for Discussion at the Top of the Doc

Bubble up the spiciest 3 topics live; answer the hundred nitpicks offline.

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.

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

Strategy6 steps

The Six-Factor Company Stack Rank

Timing > market > team > product > brand > distribution — you need all six, ranked.

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 Surgeon Management Model

Spend over half your time making your top 10% feel like a supported surgeon who can't be blocked.

Communication5 steps

The Teach-Me-Something-In-One-Minute Interview

A 60-second timed teaching exercise scored on completeness, complexity, and clarity

The Teammate Onboarding Model for AI Agents

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

The Three Generations Rule

Make the product, fix the product, then fix the business — innovation almost never lands in one generation.

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.

Three Tenets: Can-Do, High Standards, Intensity

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

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

Influence4 steps

Treat the Executive as Your Key User

Run stakeholder conversations as discovery interviews, not approval requests.

Truthful Storytelling Through Relentless Refinement

Sell the why, not the what — and refine the story out loud on real listeners until it comes off effortlessly.

Two-Sided AI Adoption

Pair top-down executive buy-in with a bottom-up tiger team of excited power users.

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

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

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

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