Home
Aug 25, 2026
View All

Claude Code's UX Friction, Toyota's Agent Scale, and Figma's Enterprise MCP

The Short Version#

A builder-on-AI switches coding agents over UX friction, Toyota runs 50+ production agents in real enterprise workflows, and Figma ships enterprise-managed MCP auth — three different angles on the same question: what does it actually take to get AI tooling to stick at scale?

Pieter Levels — Claude Code's lootbox UX is pushing him to switch#

Source: https://levels.io/claude-code-lootboxes-switch-xai Credibility: Medium (first-person practitioner post from a solo founder actively building on AI tools)

What happened: Pieter Levels published a post criticizing Claude Code's approval-request UX — comparing it to a child being given lootboxes — and said he's likely switching to xAI's tools as a result. The friction point isn't capability. It's the feeling of being managed by the tool instead of the other way around.

Key UX patterns:

  • Levels objects to Claude Code repeatedly asking for permission at each step, describing it as infantilizing rather than empowering
  • The comparison to lootboxes is pointed: you don't know what you're going to get, and you have to keep engaging with the approval loop to find out
  • He's been a vocal Claude advocate, so this is a meaningful signal — not someone who never liked the product
  • His Hotelist.com build (launched the same day) is ongoing proof he's actively shipping, not just commenting

Why it matters for PMs: This is the autonomy calibration problem playing out in public. Claude Code is clearly erring toward human-in-the-loop at every step, which protects against mistakes but introduces enough friction that power users feel like they're babysitting the agent rather than delegating to it. For PMs building agentic features: the users most likely to churn aren't the ones who got burned by an agent mistake — they're the ones who never got to see what the agent could do because the approval gates drove them off first. Levels is a practitioner-on-AI voice who's unusually transparent about what's actually working and what isn't. His switching signal is worth taking seriously.

Critical questions:

  • Is the approval-heavy UX an intentional safety choice by Anthropic, or a product decision they'd revisit based on power-user feedback?
  • What's the right default for agentic tools: autonomy with undo, or caution with gates? Are there usage-tier or task-type signals that should change the default?
  • How do you design trust-building in agentic UX so the tool earns more autonomy over time rather than staying at the same permission level forever?
  • Does xAI actually have a less friction-heavy coding agent, or is this a grass-is-greener reaction?

Action you could take today: If you're building or evaluating an agentic product, map every approval gate in your current flow and ask which ones are genuinely safety-critical vs. which ones are just defensive defaults. Then ask: what would a power user with six months of experience with your tool want turned off?

LangChain / Toyota — 50+ production agents, delivery time cut from 6 months to 4 days#

Source: https://www.langchain.com/blog/how-toyota-north-america-put-enterprise-ai-on-the-balance-sheet-with-deep-agents-and-langsmith Credibility: High (first-party LangChain case study with specific metrics from a named enterprise customer)

What happened: Toyota North America is running 50+ production AI agents using LangChain's Deep Agents and LangSmith for observability. The headline number: agent delivery time dropped from 6 months to 4 days. They're also tracking AI ROI on the balance sheet — which is the real organizational signal here.

Key patterns:

  • 50+ agents in production at a single enterprise customer — this isn't a pilot, it's an operating system
  • The 6 months to 4 days delivery compression is about standardized infrastructure, not just faster coding. When the scaffolding is in place, each new agent costs dramatically less to ship
  • Putting AI ROI on the balance sheet means Toyota has figured out how to make agent value legible to finance — that's a governance and instrumentation story as much as a product story
  • LangSmith's observability layer is likely what makes this credible at scale: you can't run 50 agents in production without knowing which ones are working and which ones aren't

Why it matters for PMs: The 6-month-to-4-days number is the kind of claim that gets executives excited and PMs skeptical — and both reactions are right. The excitement is warranted because the infrastructure is now mature enough that incremental agents are genuinely cheap to deploy. The skepticism is warranted because the first agents (the ones that took 6 months) are where all the real work happened: building the scaffolding, establishing governance, getting finance to agree on metrics. If you're pitching an enterprise AI agent program, Toyota's story is useful evidence — but be honest about where you are in the infrastructure curve.

Critical questions:

  • What were the first agents Toyota deployed, and how long did those actually take? The 4-day number likely assumes the foundation is already built.
  • How does Toyota handle agent errors in production, and what does the escalation path look like when an agent does something wrong?
  • What does "AI ROI on the balance sheet" actually mean in practice — cost savings, revenue attribution, or something else?
  • Is LangSmith's observability layer a real differentiator here, or would any logging/monitoring tool have served the same purpose?

Action you could take today: Pull up your organization's current process for tracking ROI on any single software feature. Then ask: could you apply that same framework to an AI agent? If not, what's missing — and is that gap the reason your AI pilots aren't getting scaled?

Figma — Enterprise-managed MCP authorization is now GA#

Source: https://help.figma.com/hc/en-us/articles/41992841175959-Set-up-MCP-enterprise-managed-auth-with-Okta-Cross-App-Access-XAA Credibility: High (official Figma changelog, generally available release)

What happened: Figma shipped enterprise-managed authorization for MCP (Model Context Protocol), now generally available for Enterprise and Organization plans. Admins can centrally manage Figma's MCP server authentication through Okta Cross-App Access (XAA), which means organizations can control which AI tools and agents can access Figma data at the admin level rather than leaving it to individual users.

Key capabilities:

  • Centralized admin control over which external AI agents and tools can connect to Figma via MCP
  • Okta XAA integration — fits into existing enterprise SSO and identity management stacks
  • Scoped to Enterprise and Organization plans, not available on lower tiers
  • This is a governance feature, not a capability feature — it doesn't make Figma more powerful, it makes Figma safer to connect to powerful things

Why it matters for PMs: MCP is becoming the connective tissue between design tools and AI agents, and the missing piece for enterprise adoption has always been admin control. IT and security teams won't let design data flow to external AI systems if individual designers can authorize that connection themselves. By shipping centralized MCP auth through Okta, Figma just removed one of the main blockers for enterprise teams that want to build AI workflows on top of design data. This is how enterprise AI tooling actually gets adopted: not through capability launches, but through governance features that let the organization's control structure extend into the new tool.

Critical questions:

  • What can an MCP-connected agent actually do in Figma — read files, modify designs, create components? The governance feature matters less if the scope of access isn't well-defined.
  • Is this a defensive move (keeping Figma in the enterprise stack as agents proliferate) or an offensive one (making Figma the hub for design-adjacent AI workflows)?
  • How does Figma handle audit logging for MCP-connected agent actions? If an agent modifies a design file, can admins see what changed and why?
  • Which AI tools are being connected to Figma via MCP at enterprise scale today — Claude, Cursor, something else?

Action you could take today: If your team uses Figma at Enterprise tier and is experimenting with AI agents that touch design files, check whether your IT/security team knows MCP connections are possible. This is the kind of shadow IT that security teams will eventually ask about — getting ahead of it with centralized auth is the right move.

Quick Hits#

  • Pieter Levels: Built and launched Hotelist.com in one day — a hotel review site designed to surface negative reviews that platforms like Airbnb and Google delete. Real-time proof of solo vibe-coding output: https://levels.io/hotelist-real-hotel-ratings (2026-08-24)

  • Simon Willison: Released llm-anthropic 0.27, a plugin update for his LLM CLI tool. Small package, useful signal — Simon's CLI tool is becoming a meaningful benchmark for how practitioners access and compare models in day-to-day workflows: https://simonwillison.net/2026/Aug/24/llm-anthropic/ (2026-08-24)

  • AWS / Agentic Resource Discovery: AWS published a spec for ARD (Agentic Resource Discovery) — an open standard for agent discovery and a centralized registry for agents, tools, and skills. Early infrastructure signal for how multi-agent systems will find and coordinate with each other at enterprise scale: https://aws.amazon.com/blogs/machine-learning/agentic-resource-discovery-ard-an-open-specification-for-agent-discovery/ (2026-08-24)

  • Zachary Lipton: Posted today that "history will remember 2026 as either 'year zero of the post-human era' or 'the year of the parenthetical hyphen'" — a pointed commentary on the gap between AI hype narratives and the actual product reality. Classic Lipton signal-to-noise filter: https://x.com/zacharylipton (2026-08-25)

  • OpenAI / GPT-5.6 in Kiro: GPT-5.6 is now available in Kiro (AWS's AI-native IDE), positioned explicitly around "price-performance" for developers. Worth watching: the price-performance framing is a direct response to the pressure from cheaper models: https://openai.com/index/gpt-5-6-in-kiro (2026-08-24)

The Thread#

The governance gap is becoming the product moat. This week's pattern: three separate signals (Claude Code's approval friction, Toyota's LangSmith observability layer, Figma's enterprise MCP auth) are all pointing at the same underlying dynamic. The AI tools that win at enterprise scale aren't the ones with the best models — they're the ones that make it safe and legible for organizations to actually deploy them. Figma shipping centralized MCP auth isn't a capability launch; it's a trust infrastructure launch. Toyota's balance-sheet ROI tracking isn't an AI story; it's a governance story. And Claude Code's lootbox friction is, at its core, a trust calibration problem. The builders who figure out governance-as-product are the ones who'll own the enterprise layer.

Sit With This#

Pieter Levels is switching coding agents not because Claude Code doesn't work — but because the approval-gate UX makes him feel like he's managing the tool instead of the tool managing the work. He called it being treated "like a child getting lootboxes."

For your agentic product or feature: Where in your current flow are you asking users for approval that could instead be handled with a sensible default plus an easy undo? Pick one specific gate and ask: what's the worst realistic outcome if we remove it — and is that outcome actually worse than losing a power user who gets frustrated before they ever see the value?