Home
May 6, 2026
View All

AI Adoption as Product Design, and the Vibe/Agent Boundary Blur

The Short Version#

Two signals worth sitting with today: Sendbird's CEO turned internal AI adoption into a product — with quests, token tiers, and leaderboards — and Simon Willison is sounding an alarm about vibe coding and agentic engineering merging in ways that raise real safety questions for PMs building in that space.

Lenny's Newsletter / John Kim (Sendbird) — The Elite AI Adoption Playbook#

Source: https://www.lennysnewsletter.com/p/quests-token-leaderboards-and-a-skills Credibility: High (first-party interview with a CEO sharing internal implementation specifics)

What happened: Sendbird's CEO John Kim built an AI adoption program inside his company that looks less like a training initiative and more like a game. The approach includes quests employees complete to earn tokens, token-based leaderboards, and a skills marketplace. The concrete example in the excerpt: a marketing team shipped a live swag store in a single day, with zero engineers involved. That's not a productivity win — that's a capability shift.

Key patterns:

  • Adoption as product design: Rather than mandating AI tool usage or running optional workshops, Sendbird designed the adoption experience with the same mechanics you'd use for consumer engagement — progression systems, visible status, social comparison
  • Token tiers and leaderboards: Creates intrinsic motivation loops without top-down enforcement; employees level up by doing AI work, not by attending training
  • Skills marketplace: Implies a platform layer where AI capabilities can be discovered and transferred across teams — effectively building internal infrastructure for skill reuse
  • Zero-engineer shipping: The marketing swag store example signals that the adoption program's real output isn't "people know about AI" but "non-technical teams can now ship production-facing work independently"

Why it matters for PMs: The reason most enterprise AI adoption fails isn't access — it's activation. Rolling out ChatGPT licenses is easy; getting people to change how they work is not. Sendbird's approach treats adoption as a product problem, not a communication problem. If you're a PM thinking about how to drive AI adoption inside your org or within your product, the question this raises isn't "what tools do we give people?" but "what progression systems do we build?" Also worth noting: the marketing-team-ships-swag-store example is a leading indicator of where the bar is moving. Teams that can ship without engineers are not novelties anymore.

Critical questions:

  • How does Sendbird measure whether token-earning behavior translates to actual productivity gains, or is this engagement for its own sake?
  • Do token leaderboards create perverse incentives — e.g., gaming the system with low-value AI tasks that earn tokens but don't move the business?
  • What happens to teams or individuals who fall behind in adoption? Does the public leaderboard create exclusion or anxiety?
  • How does this scale beyond a single company's culture? Would this work in a more risk-averse or hierarchical org?

Action you could take today: Map your own team's AI adoption blockers against the three layers Sendbird used — progression mechanics, social visibility, and skill infrastructure. Which of those three is most missing in your current approach, and what would a lightweight version of it look like?

Simon Willison — Vibe Coding and Agentic Engineering Are Getting Closer Than I'd Like#

Source: https://simonwillison.net/2026/May/6/vibe-coding-and-agentic-engineering/#atom-everything Credibility: High (Simon Willison is one of the most technically credible practitioners covering AI tooling; this is his original analysis, published today)

What happened: Willison published a post today flagging that the conceptual and practical boundary between "vibe coding" (casual, low-stakes, AI-assisted app building) and "agentic engineering" (AI systems that take autonomous actions with real-world consequences) is collapsing faster than he'd like. The title alone signals concern — this is not a celebratory post. Based on the excerpt and Willison's consistent body of work on AI safety in software, the argument is that tools designed for vibe coding are increasingly being used (or are converging) with agentic patterns, and the people using them may not recognize the safety implications of the jump.

Key patterns:

  • The "vibe to agent" pipeline is shortening: what starts as a fun side project can quickly acquire capabilities — file access, API calls, persistent memory — that make it agentic in practice even if it wasn't designed that way
  • The mental model mismatch is the real risk: users who think they're vibe coding may not apply the scrutiny they'd apply to a production agent, because the framing feels casual
  • Tooling convergence is driving this: Cursor, Lovable, Replit, and others are simultaneously lowering the floor for casual building AND raising the ceiling toward agentic capability — the same tool does both

Why it matters for PMs: If you're building a vibe coding tool or an AI-assisted development product, Willison's concern is a direct product risk signal. The user experience of "this is fun and low-stakes" can coexist in the same interface as "this agent just emailed your customer list." Users don't switch mental models just because capabilities increased. This is a trust and control design problem, and it's one that products in this space haven't fully solved. It also connects to the open question about user autonomy with agents — if users don't know they're running an agent, they can't meaningfully consent to or oversee its actions.

Critical questions:

  • At what capability threshold should a vibe coding tool be required to surface "you are now in agentic territory" — and how do you design that UX without killing the casual experience?
  • Who bears responsibility when a vibe-coded app takes an autonomous action that causes harm — the user, the tool, or the platform?
  • Are current vibe coding tools doing enough to surface the boundary between "generates code" and "executes actions"?
  • Does Willison's concern apply differently to professional developers vs. non-technical builders?

Action you could take today: If your product includes any agentic capabilities — even lightweight ones like sending emails, writing to databases, or making API calls — audit whether the user's mental model at that moment matches the actual risk level. Is there a clear signal in your UI that distinguishes "this generates" from "this does"?

OpenAI — GPT-5.5 Instant Ships as ChatGPT's New Default#

Source: https://openai.com/index/gpt-5-5-instant Credibility: High (first-party product announcement)

What happened: OpenAI shipped GPT-5.5 Instant as ChatGPT's new default model, replacing the previous default. The positioning: smarter and more accurate answers, reduced hallucinations, and improved personalization controls. The "Instant" framing signals this is optimized for speed and everyday use — not the highest-capability model, but the one most users interact with most of the time. A system card was published alongside it, which is now standard OpenAI practice for model releases.

Key capabilities:

  • Smarter, more accurate answers compared to the previous default
  • Reduced hallucinations (a claim that will require independent verification over time)
  • Improved personalization controls — meaning the model can better adapt to user preferences and context across conversations
  • Ships as the default, meaning this affects the broadest possible ChatGPT user base immediately

Why it matters for PMs: Default model changes matter disproportionately because they affect the median experience, not the power user. If GPT-5.5 Instant is meaningfully better at reducing hallucinations, that raises the quality floor that users now expect from AI tools — including yours. The personalization angle is worth watching: if OpenAI is improving how the default model adapts to individual users, that sets an expectation that AI products should feel like they know you, not just respond to you. That's a retention and differentiation implication.

Critical questions:

  • What does "reduced hallucinations" actually mean quantitatively, and across which domains? The claim is important but needs grounding
  • How does GPT-5.5 Instant compare to Claude Sonnet or Gemini Flash on everyday tasks — the actual competitive set for default models?
  • Does "improved personalization" require users to opt in or share data, and how is that surfaced?
  • How quickly does a default model change affect user behavior expectations in downstream products built on the API?

Action you could take today: If your product uses any OpenAI model as its backbone, check whether GPT-5.5 Instant is available via API and whether the quality improvements affect your use case specifically — especially if hallucination reduction is relevant to your users' trust.

Microsoft / Copilot — Copilot Cowork Expands to Mobile with Cross-Device Delegation#

Source: https://www.microsoft.com/en-us/microsoft-365/blog/2026/05/05/copilot-cowork-from-conversation-to-action-across-skills-integrations-and-devices/ Credibility: High (first-party Microsoft blog, product launch announcement)

What happened: Copilot Cowork — Microsoft's agent-mode delegation layer inside Microsoft 365 — shipped mobile support for iOS and Android, plus new business system connectors. The product pitch: you can now delegate a task on your phone, pick it up on your desktop, and the agent keeps working in between. The Satya Nadella LinkedIn post frames this as "expanding human agency" while AI handles execution. New connectors let Cowork operate across business systems and data, not just Microsoft's own surface area.

Key capabilities:

  • iOS and Android apps — the delegation experience is no longer desktop-only
  • Cross-device continuity: tasks delegated on mobile remain active and can be resumed on desktop
  • New business system connectors: Cowork can now reach into external data sources, not just M365
  • Skills and plugins framework: suggests a marketplace or extension model for what Cowork can do

Why it matters for PMs: Cross-device agent continuity is a new UX pattern that most products haven't had to think about yet. When an agent is doing work on your behalf across a session gap — you hand it a task on your phone at 8am, it completes it by the time you're at your desk — the product questions shift entirely. What does "done" look like? How does the user know what happened while they were away? What's the recovery path if the agent made a wrong call? Microsoft is now forcing these UX questions into the enterprise mainstream. Any PM building agentic workflows should be studying how Cowork handles the handoff, the status visibility, and the error states.

Critical questions:

  • How does Cowork communicate what it did while the user was between devices — is there an activity log, a summary, a push notification?
  • What's the failure mode when a cross-device task hits an ambiguous decision? Does it wait, ask, or guess?
  • The connector model is promising but raises enterprise security questions — how does Cowork handle authorization across external systems?
  • Is the "skills and plugins" model open to third-party developers, and if so, what does that ecosystem look like?

Action you could take today: If you're building any agentic feature, draft a user flow specifically for the "user returns after agent has been running" moment — what does your product show them, and what can they undo?

Quick Hits#

The Thread#

The "who controls the agent" question is now a product category, not just a design consideration. This week: Microsoft ships cross-device agent continuity with Copilot Cowork, Notion adds admin controls for Custom Agents, Simon Willison raises alarms about vibe coding tools sliding into agentic territory without users noticing, and Cursor ships context usage breakdowns so developers can understand what their agents are actually doing. The common thread: as agents become the default execution layer, the products that win will be the ones that give users and admins legible, controllable visibility into what's happening on their behalf.

Sit With This#

Simon Willison's post flags that vibe coding tools and agentic engineering tools are converging — the same interface that generates a quick prototype can now, with a few capability additions, send emails, write to databases, or call external APIs autonomously.

For your product: If you're building or shipping agentic features, where exactly does your product signal to users that they've crossed from "this generates" to "this acts"? And if that boundary isn't clearly communicated, what's the realistic worst-case outcome — and do your users know it's possible?