Context

Following his earlier breakdown of why GPT-6 Astra should be judged as an "opportunity" model rather than an "efficiency" one, NLW tackles the follow-up problem directly: once you accept a new AI capability could unlock work you've never done before, how do you actually figure out what that work is? He argues most people hit a genuine blank-page problem, since nobody walks around with a mental inventory of everything they might build, and works through a set of concrete thought starters (playable marketing, interactive proposals, business-decision simulators, turning expertise into a product) designed to jog that inventory. For PMs, this is a structured method for translating "the model can do new things" into "here is specifically what my team or product should try."

The Big Idea

The hardest part of opportunity AI isn't technical capability, it's the blank-page problem of not knowing what to ask for; the fastest way past it is looking at what people in adjacent roles or industries are already doing with a new capability and asking how that pattern could transfer into your own work, rather than trying to invent a use case from nothing.

NLW is explicit that efficiency AI (doing existing work faster or cheaper) and opportunity AI (doing work you couldn't do at all before) aren't in conflict, efficiency AI will remain the foundation of most AI value, but argues companies that only think in efficiency terms will find those gains become table stakes, while companies that lean into finding new, even initially orthogonal opportunities are more likely to actually transform themselves for the new era.

Key Insights

1. The same new model can feel like a regression and a breakthrough depending on the use case

NLW cites several advanced users reporting they'd moved back to older models (GPT-5.6 Sol, Fable 5.1) for coding specifically because Astra's behavior felt inconsistent, one calling it "the smartest and dumbest model I've ever worked with," while OpenCode's team reported effective spend roughly doubling for comparable coding results. Yet the same model produced genuine excitement in 3D modeling, video editing, and interactive design, domains most of these same critics weren't testing. NLW's point: judging a model as simply "better" or "worse" misses the reality that its value is concentrated in specific, sometimes unfamiliar domains, and a fair evaluation requires testing outside your default use case, not just inside it.

2. Looking at adjacent roles is the fastest way past the blank-page problem

NLW's practical shortcut for opportunity AI is deceptively simple: rather than trying to invent an entirely novel use case from scratch, look at what people in other jobs or industries are already doing with a new capability and ask how that pattern could transfer to your own work. He frames most people's sense of "what's possible" as shaped narrowly by their job, tools, and the people immediately around them, which means genuinely new capabilities often go undiscovered not because they're not useful, but because nobody thought to look outside their usual frame of reference.

3. Interactive proposals can be efficiency and opportunity AI at the same time

• What: a traditional proposal hands a client one fixed plan and hopes they accept it, even though the author's head already contains an invisible model of how scope, resources, and timing trade off against each other (adding a department means adding facilitators or pushing the date).
• Why it matters: making parts of that invisible reasoning interactive, letting a client explore "we could finish sooner if the team meets more often" themselves, is a genuinely new way of engaging clients that didn't exist before, but it also collapses the back-and-forth negotiation cycle that normally requires the proposer to manually re-run their mental model every time a client asks "what if."
• Example: NLW predicts this kind of interactive proposal will become "completely de rigueur" quickly enough that its absence will feel outdated, since it solves a genuine efficiency problem (reducing negotiation latency) while also being a capability that essentially didn't exist as a self-service tool before.

4. Simulators expose hidden disagreements inside apparent agreements

NLW argues many surface-level business disagreements actually contain several different disagreements hidden inside them: a claim like "we need another hire" could mean the current process is too slow, work is unevenly distributed, or someone expects a future demand surge, and people often argue past each other because they're each silently assuming different starting conditions. Building a simple simulator forces those assumptions into the open, since you have to explicitly specify what happens at each stage, what limits it, and where unfinished work goes, turning an argument about a conclusion into an inspectable model whose assumptions can be individually tested and disputed.

5. Expertise itself can be turned into an interactive product, not just delivered as advice

NLW frames expert consulting or advisory work as containing several distinct steps beneath the visible advice: gathering context, recognizing patterns, noticing exceptions, ruling out inappropriate options, and deciding what someone is ready to hear next. His argument is that at least some of that underlying judgment process can be captured and turned into an interactive tool people can work through themselves, scaling an individual's expertise well beyond what one-on-one conversations could ever reach. He notes the very episode companion web experience he built alongside this podcast is itself an example: rather than personally advising each listener on opportunity AI ideas, he embedded a version of that judgment into an interactive tool anyone can use.

Mental Models & Frameworks

Efficiency AI versus opportunity AI (applied, not just conceptual)

• Efficiency AI: helps you do existing work faster, cheaper, or with less effort. It remains the foundation of most AI value and where the earliest, most obvious returns come from.
• Opportunity AI: unlocks work you couldn't do at all before, and by definition resists a simple checklist, since you haven't previously considered what it enables.

NLW's refinement in this episode is that with a model like Astra, this isn't purely a mindset distinction anymore, the model itself genuinely performs unevenly across the efficiency-versus-opportunity divide, doing familiar coding tasks inconsistently while enabling entirely new 3D and interactive capabilities. The practical implication: evaluate a new model separately on its efficiency merits (does it do my existing work better) and its opportunity merits (what can I now attempt that I couldn't before), since a weak score on one doesn't invalidate a strong score on the other.

"What-if machines" as a recurring pattern across use cases

Several of the episode's thought starters, interactive proposals, business-decision simulators, exploratory product demos, share an underlying structure NLW names directly: they're all "what-if machines" that let someone inspect the consequences of changing an assumption (what if we add a department, what if demand rises slower, what if I isolate this one component) rather than receiving a single fixed answer. Recognizing this as a repeatable pattern, rather than treating each use case as unrelated, makes it easier to spot where else in your own work a fixed, one-directional output (a report, a recommendation, a demo script) could become an interactive, explorable one instead.

Trade-offs & Nuance

Not every opportunity AI experiment will work, and that's expected, not a failure signal

Discussing the idea of building playable marketing experiences (games tied to a product's value proposition), NLW is candid that game design is a real discipline most people aren't trained in, and that far more games get built than ever become genuinely popular, even among professional game designers. His point isn't to discourage the attempt, but to set expectations correctly: opportunity AI lowers the cost of attempting something previously out of reach (a solopreneur can now prototype a marketing game in a weekend, something once requiring real development resources), which means more experimentation is now viable even though most individual experiments still won't land.

Don't try to perfect a one-shot output before evaluating whether the underlying idea has value

For both the customer-story video pipeline and the expertise-as-product ideas, NLW's specific advice is to let the AI attempt a full one-shot version of the idea first, rather than spending significant time upfront trying to get inputs or prompting exactly right. His reasoning: it's much easier to judge whether an idea is worth pursuing once you can see and interact with even an imperfect version of it, and over-investing in getting the first attempt perfect risks abandoning a genuinely promising direction before you've actually experienced what it could become.

Practical Application

Build a minimal interactive version of something you currently deliver as a fixed document

Take a proposal, product demo script, or recommendation you currently hand to clients or stakeholders as a one-directional document, and identify the invisible reasoning or trade-off model behind it (what changes if scope increases, what changes if the timeline shifts). Use a coding agent to build a simple interactive version that lets the recipient explore a few of those "what if" branches themselves, rather than having to ask you and wait for a manual re-calculation.

Test a new model specifically outside your default use case before judging it

Before concluding a new model release is a disappointment or a breakthrough, deliberately test it on a task type you don't normally use AI for (3D modeling, video editing, game creation, physical product prototyping), not just your usual workflow. Since capability gains are increasingly uneven across domains, a model that underwhelms on your default task may still unlock genuine new value elsewhere, and you won't find that out by only testing the familiar use case.

Prototype a decision simulator the next time a team disagreement seems to be going in circles

When a team is stuck disagreeing about a decision (a hiring need, a process change, a resourcing trade-off), try building a simple simulator that forces each stage of the underlying process to be explicitly specified (what happens at each step, what limits it, where backlog goes) rather than continuing to argue about the conclusion. Making the hidden assumptions inspectable often reveals that people are actually disagreeing about different starting conditions, not the decision itself.

Look at what an adjacent role or industry is doing with a new AI capability before assuming it doesn't apply to you

When a new model capability seems irrelevant to your work at first glance (3D modeling, video pipelines, game design), specifically look at how people in a different role or industry are already using it, and ask what the underlying pattern is rather than the surface-level application. The transferable pattern (interactivity, simulation, turning invisible reasoning visible) is often more broadly applicable than the specific example you first encountered.

Questions to Consider

• Is there a document or deliverable we currently hand to clients or stakeholders as a single fixed plan that actually contains an invisible trade-off model we could make interactive and explorable instead?
• Have we tested our team's current AI tools on a task type genuinely outside our normal workflow, or are we only judging a model's usefulness based on the one or two use cases we already had in mind?
• The next time our team argues in circles about a decision, could we build a quick simulator that forces the hidden assumptions (what happens at each stage, what the real constraints are) into the open instead of continuing to debate the conclusion?
• Is there a piece of our own judgment or expertise, currently only delivered one conversation at a time, that could be captured well enough to become an interactive tool other people could use themselves?

Bottom Line

The real obstacle to using powerful new AI capabilities well is rarely the technology itself, it's not knowing what to ask for. The fastest way through that blank-page problem is looking at what adjacent roles and industries are already doing with a new capability, recognizing the transferable pattern underneath (interactivity, simulation, turning invisible reasoning into something explorable), and testing a rough, imperfect version before trying to perfect the idea in your head first.