AI-assisted product development
Agency — not skill, title, or raw model intelligence — is what separates people and products that thrive in the AI era from those that don't; the source argues this agency is best built by tinkering directly in code as a malleable material, cultivating taste through repeated feedback loops, and orienting products around one small, exceptionally executed "tiny core" rather than accumulating features.
Agency, not skill, is framed as the true differentiator in the AI era: before AI, people could excuse inaction as a 'skill issue,' but now that AI puts skills within reach for everyone, what separates people who thrive from those who fall behind is whether they exercise agency — the same trait that historically separated founders from non-founders.
Designers and PMs are urged to think and build directly in code not so their code ships to production, but because doing so forces them to master the actual medium modern software is made of, producing better product thinking than staying in Figma or writing traditional PRDs.
The blurring of PM/design/engineering roles observed at Notion is presented as driven by individual employees exercising agency beyond their formal job descriptions, though the source flags a real risk that unchecked merging of roles could cause the loss of valuable specialists.
Current AI-era software discourse is criticized for over-indexing on volume metrics (tokens spent, features shipped, lines of code) while largely ignoring the engineering discipline needed for software to be reliable at scale, unlike mature physical manufacturing.
The source frames today's locked-down consumer software (apps whose UI, data, and behavior are fused together) as a design failure people would never accept in physical life, and argues AI/agents finally supply the practical motivation to fix this that was previously missing, though full 'malleable software' requires a platform that supports it without losing communal/collaborative benefits.
Predictions of a 'SaaS apocalypse' (that AI lets everyone rebuild their own Salesforce/Notion) are called greatly exaggerated, because what people actually pay for in SaaS is outsourced maintenance and specialist attention (the 'software is a garden' idea), not the raw difficulty of building software — so tools will likely become more general again but remain delivered as-a-service.
As building an initial working version becomes nearly free ('the first 10% of every project are now free'), the source argues the bottleneck shifts to the hardest, still-unchanged final stretch of correctness and polish ('the last 10% are still actually 90%'), and to how teams evaluate early ideas — favoring reacting to something concrete over reading written specs.
Raw model intelligence is argued to be becoming less of a bottleneck than UX, speed, and habitual work patterns; the source is skeptical that society or most companies are actually capped by intelligence, and expects near-term optimization to shift toward 'good enough,' cheaper, faster, locally-run models rather than the frontier.
Organizations are predicted to face an uncomfortable ROI reckoning on AI/token spend within 6–12 months, and the source warns against making spend itself a status/boast metric — the same mistake, it argues, as bragging about lines-of-code volume.
Rather than AI directly transforming non-coding disciplines, the source argues software-engineering cost is collapsing toward zero, so the effect is simply 'much more software' as coding practices spread into every domain; it interprets claimed AI progress in non-coding fields as usually just coding techniques applied there.
Drawing on a personal failure story — a 2014 Notion-competing startup that lost a term sheet the same week Notion pivoted, then over-invested in polishing markdown-editing niceties while Notion won with a deliberately bare-bones editor — the source argues that working diligently on the wrong layer of a product for too long is a distinct, serious failure mode from simply not working hard enough.
As AI increasingly handles execution/building, the source argues the differentiating human skill shifts to 'taste,' while explicitly questioning whether taste is even a uniquely human moat, since it is built through the same feedback/adjustment loop used to train AI models.
The source explicitly extends 'small group' thinking from personal life into product strategy, arguing a product like Notion should not chase every possible user because serving a specific high-end segment well requires deliberately not serving everyone — while distinguishing this from real-world exclusionary practices it does not endorse.
Career anxiety framed as needing to 'catch the last train' before AI changes everything is called a hollow way to live; the source argues that since no single move meaningfully shields anyone from broad technological change, agency- and curiosity-driven work is the sounder response regardless of how AI unfolds.
Playground codebase — A minimal, LLM/agent-friendly codebase kept separate from Notion's main production codebase, built to prototype AI chat interfaces that static Figma mockups couldn't capture. Apply: Give non-engineers a low-stakes, 'oneshotable' coding sandbox matched to current model capabilities so they can prototype dynamic AI behavior directly instead of faking it in a design tool.
Malleable software — The idea, developed partly with Ink & Switch, that software should work closer to the interest of the people using it than the interest of the company that made it, letting users reconfigure it like rearranging a room. Apply: Evaluate and design products by asking whether users can change or tweak the software's behavior themselves, not just consume it as fixed.
Dieter Rams 'useful first, beautiful second' critique — A design-evaluation lens, illustrated via a Dieter Rams video, that strips away a creator's reputation to judge whether an object is genuinely useful, using changeability as the test. Apply: Judge a design by whether it is useful and adjustable first, treating a famous creator's reputation as irrelevant to whether it actually works for the user.
Adaptive-building model (Timeless Way of Building / How Buildings Learn) — A model borrowed from architecture writing that the best-fitting environments are adapted incrementally over time by the people living in them rather than designed once by an expert. Apply: Let software slowly adapt to how people actually use it instead of shipping a single 'final,' expert-designed version.
"Software is a garden" (Brett Taylor) — Brett Taylor's framing that software needs ongoing tending, and that what customers pay for in 'as a service' products is that maintenance plus specialist attention, not just the initial build. Apply: When deciding whether to build vs. buy software, weigh the cost of continuous maintenance and specialist expertise, not just the initial version's cost.
Demos not memos — A GitHub product-review practice: give reviewers something concrete to react to (a working demo or the actual customer-facing copy) instead of a written spec or PRD. Apply: Replace planning documents with a rough working prototype or the real changelog/copy you'd publish, and get reactions to that instead.
Never bet against plain text — A durability principle that plain text, markdown, and code remain durable interchange formats even as specific tools change. Apply: When choosing how to express product ideas or specs, favor plain text/markdown/code over tool-specific formats that may not last.
Automation vs. augmentation — An analytic fork for categorizing how an AI tool gets used: either automating a task away entirely or augmenting a human performing it. Apply: When designing an AI feature, explicitly decide whether it should replace the human's direct manipulation or support it, and design accordingly.
Retina-display saturation analogy — An analogy that once cognitive-task intelligence crosses a 'you can't see the pixels' threshold, further raw intelligence gains matter less than speed and modality. Apply: Once a model is good enough for a task, stop optimizing for more intelligence and instead optimize for speed, cost, and running locally/cheaply.
Exoskeleton vs. 'god in a box' — A framing contrasting AI-as-tool-that-extends-human-capability ('exoskeleton') against AI as a centralized superintelligence humans passively wait on. Apply: Orient product and organizational strategy toward augmenting distributed human agency rather than betting everything on a single maximally capable centralized model.
Software factory — The industry term cited for building an automated pipeline or agent workflow around one's own individual work so repeatable tasks are handed to agents. Apply: Identify the repeatable 'outer loop' of your own job and deliberately hand it to an agent, treating your workflow like a production line to automate.
Verifiability loop / manual-intervention-as-bug-signal — Simon Last's view, endorsed by the guest, that manual human intervention in AI-written code usually signals a breakdown in the verification pipeline — except code review, which deserves more effort, not less. Apply: Treat a need to manually fix AI-generated code as a signal to improve automated testing/verification, while still investing extra effort specifically in human code review.
Jevons paradox (applied to Figma vs. vibe coding) — The concept that increased efficiency in a resource can increase total consumption, applied to the possibility that Figma usage and AI vibe-coding could rise together rather than one replacing the other. Apply: When a cheaper/faster substitute tool emerges, don't assume usage of the original must decline — check whether overall activity is simply expanding instead.
Cloud wars analogy — A prediction that stalled AI-lab competition would resemble the 'cloud wars,' where infrastructure layers commoditize and businesses resist single-vendor lock-in, illustrated by Heroku losing to Kubernetes despite worse UX. Apply: When betting on an AI vendor/platform, weigh customers' preference for choice and avoidance of lock-in as heavily as raw capability or ease of use.
Notion-as-operating-system framing — The claim that Notion functions more like a Unix-like operating system with heavy automatic permission handling than a document tool, which is why agents can 'roam around' it effectively as a context source. Apply: When building AI agents, provide a connected, permission-aware workspace of context rather than narrow, siloed data access points.
Shots on goal — Notion's internal phrase for the goal of increasing the number of product experiments attempted, made more affordable now that experimentation with AI is cheaper. Apply: Prioritize increasing the volume of tried product bets over polishing any single one, while resisting turning that volume itself into a vanity metric.
Incremental correctness — A stated core value of iterating toward correctness in public/production rather than isolating a team to perfect something before release. Apply: Ship early, imperfect versions and correct them through repeated iteration rather than withholding a feature until fully polished.
"Obviously good" bar — Notion's internal motto/sticker slogan for a quality bar that is intentionally undefined but instantly recognizable — citing that no one debated whether the first iPhone or first ChatGPT were 'obviously good.'. Apply: Before shipping, ask whether the result is self-evidently good to an outside observer rather than relying on a specified checklist.
Consolidation into the 'naked robotic core' — The practice of letting multiple overlapping feature ideas grow in parallel, then merging them back into one simplified core, even at the cost of delaying new shipped features. Apply: When a product accumulates redundant, parallel-evolved features, pause new development to reconcile them into a single simplified core instead of adding another variant.
"Virtual machine in your head" (taste) — An operational definition of taste as the ability to mentally simulate a chosen in-group's reaction to an idea before building it, developed through repeated feedback like training a model. Apply: Build taste deliberately by picking a specific audience, repeatedly testing ideas against their real reactions, and adjusting.
Jobs to be done — Clayton Christensen's framework, used as a check on whether a team has honestly thought through what job the user is hiring the product for, versus what the team wants the user to want. Apply: Periodically ask, as if you were the user, what job you'd actually be hiring this product for and whether you yourself would buy it.
"Be the user — would you buy this?" test — A self-check exercise for countering the common large-org failure mode where employees stop evaluating their own product as a genuine user would. Apply: Before shipping, step back and honestly ask whether you personally, as an outside user, would buy or use the thing you just built.
Whiteboard explanation test — A test for evaluating marketing/landing-page copy by comparing it to how you'd casually explain the feature to a friend, catching when the written version degrades into generic 'marketing speak.'. Apply: Explain the feature out loud first, then check the polished copy against that plain explanation to catch jargon drift.
Small group theory — The contrarian view that the world is effectively run by group chats of eight people or fewer, and that deliberate exclusivity/narrow targeting can be a valid strategy distinct from unjust real-world exclusion. Apply: When designing a product or community, consider explicitly optimizing for a small, well-defined in-group's needs rather than diluting the offering to appeal to everyone.
"Tiny core" theory of product success — The claim that great products succeed via one small, exceptionally executed core feature (e.g., Heroku's `git push heroku master`, GitHub's pull request, Notion's blocks/slash commands) rather than by accumulating more features. Apply: Identify and relentlessly polish the single smallest feature that makes your product feel like a superpower, resisting the urge to add features to compensate for a weak core.
Seeing Like a State / legibility critique — A framing, from the book 'Seeing Like a State,' that executives design reporting systems (dashboards, status reports) for their own legibility in ways that neglect the real on-the-ground reality of how teams work. Apply: When building internal reporting/metrics systems, check whether they capture real signal about how work happens or just create comfortable-but-hollow legibility for leadership.
Claw back agency via self-buildable tools — A personal practice of choosing open, self-assemblable tools — e.g., a split keyboard buildable from schematics and an open-source terminal — specifically to reclaim agency over one's own computing life. Apply: Where possible, choose open, self-buildable, or self-hostable tools over closed defaults as a deliberate way to practice and preserve personal computing agency.
Agent loop as core material to master — The claim that PMs and designers must deeply understand how 'agent loops' work — treating coding harnesses as analogous to 'the operating systems of the '90s' — and that this can only be learned by building in code. Apply: Have non-engineers build small things directly with agent harnesses to internalize how the underlying agent loop works, rather than learning it only conceptually.
80/20 framing for whether an idea 'takes off' — The claim that having the obviously good core idea is about 80% of product success, while the remaining 20% is relentless iteration until it clicks with real users, since a good idea can still fail every user study. Apply: After settling on a good core idea, budget most ongoing effort for repeated user-facing iteration rather than treating the initial idea as the finish line.
The reason Notion built a separate 'playground' codebase instead of prototyping AI chat behavior in Figma is a structural one: static mockups (per Bret Victor's 'dead fish' idea) simply cannot capture dynamic, model-driven interaction.
The source explains why automated code-review bots historically flopped while agentic tools like Claude Code/Codex succeed using the same 'superhero' psychology Kathy Sierra identified: review bots publicly shame the developer's code, while agentic tools brand the output as 'you + Claude,' preserving the human's bragging rights as a good developer.
Notion attributes part of its AI agent's success to a specific, less-obvious engineering choice — unusually rigorous automatic permission handling built into enterprise search — summarized as 'we're just dumb enough to try hard things,' rather than to model quality alone.
The speaker's own history at Heroku (which lost to Kubernetes despite worse UX because Kubernetes preserved customer choice and avoided lock-in) is explicitly used as a template for predicting how the current AI-lab competitive landscape will play out if the current multi-lab race stalls.
The value of multitasking/context-switching often praised in AI-assisted work (queuing a job, walking away, coming back) is floated as possibly just an artifact of currently slow model inference rather than something inherently good for flow or creativity — implying it could vanish once inference becomes instant.
Notion deliberately tolerates roughly six overlapping automation primitives (including multiple agents) inside its product rather than prematurely consolidating them, treating the redundancy as raw material to later fuse into one simplified core — and the speaker makes the same jab at a competitor's unreconciled UI (Claude's desktop app having three separate tabs).
The speaker admits he has personally not replaced roughly 80% of his own job with agentic loops, despite believing others should and envying engineers/designers who have done so — a candid gap between his stated ideal and his own lived practice.
The claim 'we already have universal basic income, it's called knowledge work' implicitly depends on already holding a comfortable, well-paid job — a privilege the source itself notes most people currently worrying about AI-driven job loss and UBI already have.
«We're realizing that even if you have the skills at your fingertips, the thing that matters is agency. I don't think agency is very evenly distributed in the world.»
— 00:06
«Could you drive Notion like it's stolen? One day you wake up and you realize the world is made up by people no smarter than you.»
— 00:20
«The first 10% of every project are now free. It takes almost no effort to now build the first version of a startup.»
— 00:32
«Taste actually means you're able to run a virtual machine in your head where given an idea, you can predict for a certain inroup whether they're going to like it or not. You just have to do reps. It's almost like training a model.»
— 00:40
«All the great products have something tiny that is a superpower. one tiny core that is so exceptionally good. One of the biggest pitfalls is if you get into the loop of if I just add one more thing to the product, it will be finally great. That never works.»
— 00:54
«We already have universal basic income. It's called knowledge work.»
— 01:10
«Malleable software is the idea that software works closer to the interest of the people that use it than the interest of the corporation that makes it.»
— 18:18
«People don't want to go hunting either. They just want to go to Costco and have the steak in styrofoam packaging and pretend that it wasn't hunting or an animal in the first place.»
— 25:24
«the last 10% are still actually 90%»
— 29:37
«You have to be right. Not first.»
— 63:44
«the world is run by group chats of eight people or fewer»
— 71:38
«just carefully look at how everything around you is made up by people that are no smarter than you and realize that probably in the span of 6 to9 months, you can for most things around you figure out how to make it from scratch.»
— 86:33
Reception
Comments are overwhelmingly positive, praising the guest's humility, the host, and the 'tiny core' and agency insights, with only scattered minor criticisms and some spam/promotional comments.
A dense, quotable product-leadership interview that moves fluidly between organizational philosophy (agency, malleable software) and concrete product craft (tiny core, taste, obviously good), making it a strong reference source for a knowledge base despite containing time-bound predictions (e.g., near-term AI capability/ROI timelines) that will age faster than its core frameworks.

87:22