Nate's position on AI and product/engineering practice has moved through four distinct phases. In late 2023 and early 2024 he was a skeptic on judgment grounds: LLMs are language mirrors, not reasoning engines, and their fluency tricks people into assuming competence (code quality, PM judgment, customer bereavement policy) that isn't there. His fix wasn't "use AI less," it was "don't let AI chase its own agenda" — teams need complementary non-AI domain expertise, because good business judgment and precise, structured engineering are exactly what LLMs are bad at.
By fall 2024 the tone shifts to pragmatic acceleration. AI collapses coordination cost (the PM's core job), prototype cycles drop to minutes, and a real deployment-tooling landscape (Val Town, Bolt, v0, Cursor) forces a "pick your tool by goal, not hype" discipline. But the load-bearing insight of this phase is that AI amplifies whatever clarity (or fuzziness) you feed it — messy thinking in, messy product out, regardless of how fast the tool is.
Early 2025 is a systematization phase: Nate codifies process (user/problem discovery before any prompt asks for code, AI as thought-partner not shortcut) and catalogs failure modes (oversized builds, fix-and-fail loops, skipped deployment/security, overconfident delegation to agents like Devin). This is where "vibe coding" gets disciplined into a repeatable loop.
Spring 2025 elevates the frame to teams and design systems. High-performing AI teams are defined by explicit context management, workflow ownership, and async/trust rituals — AI adoption is a team-sport problem, not an individual-tool problem. In parallel, design itself is reframed from interface design to "Relationship Design" across five pairings (human-software through agent-agent), and Nate's own build (PromptKit) becomes a live case study applying six product principles (trust loops, state as UX, deterministic recovery, second-use litmus) drawn from the Klarna AI-support failure.
By August 2025 these threads converge into his most mature thesis: documents are being replaced by executable "instruments" — typed inputs, visible logic, tests-as-gates, built-in audit trails — that make decisions rather than describe them. This directly extends his May 2025 "docs-first" idea (translation is now free, so the durable artifact is customer-facing truth, not the internal memo) into a full operating-system claim for how orgs should run meetings and approvals.
Key moves
Don't chase AI as an end in itself — pair it with durable non-AI domain expertise; complementary teams beat all-in AI teams.
LLM fluency is not judgment: treat model output as a fast draft requiring human strategic review, never a finished decision.
Start every AI build with user/problem discovery (who, what pain, what's actually broken) before writing a single prompt for code.
Use AI as a thought partner in problem-framing, not just a code/content generator — ask it to surface unexpected user insights first.
Build lean: constrain AI-generated scope explicitly ("only the login flow") to avoid oversized, unmaintainable builds.
Write test cases before asking AI to fix bugs, or you enter a fix-and-fail death spiral as context windows blow out.
Plan deployment, security, and compliance from day one — AI tools bias toward prototype polish and skip productionization.
Get a second AI opinion on risky output; ping-pong between models rather than trusting one agent's confidence.
Manage AI adoption at the team level: explicit shared context, defined roles/workflows, and async-first rituals outperform ad hoc individual tool use.
Design for "Relationship Design," not chatbot UX: each human/AI/agent pairing (human-LLM, human-agent, agent-agent, agent-software) needs its own trust, memory, and repair patterns.
Instrument products with visible trust loops: show sources, allow instant rollback, measure and surface the "invisible delta" (time saved, errors prevented).
Judge AI products by the second-use litmus, not launch-day fireworks — retention after novelty wears off is the real signal.
Replace decision-bottleneck documents (WBRs, launch gates, deal desks) with executable instruments carrying typed inputs, test gates, and audit trails.
Speed is no longer the constraint on desirability or feasibility — reliability and clear thinking are now the bottleneck.
2025-05-16 — How to do Voice of Customer in the Age of AI — Case study using o3 to tag 158 PromptKit signup comments into themes in minutes, then map findings directly to a five-feature MVP.
2025-05-13 — Six AI Product Principles No One Tells You — Dissects Klarna's AI-support reversal into six principles (trust loops, state as UX, emotional moat, deterministic recovery, show the delta, second-use litmus) and applies them to his own PromptKit build.
2025-04-11 — Your Team is Using AI Wrong — AI adoption succeeds or fails at the team level; lays out eight high-performing behaviors (shared context, workflow ownership, async-first) against eight low-performing pitfalls.
2025-01-17 — Dodging the AI Potholes — Catalogs five recurring AI-build failure modes: oversized scope, fix-and-fail loops, skipped deployment, security blind spots, and overconfidence in coding agents.
2024-11-08 — You get a deploy, we all get a deploy! — Compares Val Town, Bolt, v0, and Cursor's deployment philosophies to help builders pick tools by goal, not hype.
2024-10-13 — PM in an AI World: Where We've Been — Opens a series arguing AI's core PM value is cutting coordination cost, not replacing the judgment that drives alignment.
2024-10-02 — Moving the prototype cycle to minutes — Builds and ships a shareable AI-narrated podcast prototype in 15 minutes, illustrating how far idea-to-execution time has compressed.
2024-02-28 — LLM's are bad at code and product — Founding skeptic's take: LLM fluency is a proxy for intelligence that misleads builders and users alike; judgment still requires humans.
2023-09-06 — We're all AI PM's now (and that is sub-optimal) — Warns against chasing AI as an end in itself; complementary, non-AI domain expertise is becoming the scarce, valuable commodity.