Home
Jul 11, 2026
View All

Cursor's Side Chats, Figma Gets GPT-5.6, and Dan Shipper on Tending Your Loop

The Short Version#

Three signals worth paying attention to today: Cursor shipped a meaningful UX update that changes how developers stay in flow during agentic work, Figma quietly added the newest OpenAI model to Make (which is now the design-to-prototype layer most PMs interact with daily), and Dan Shipper wrote something worth reading slowly about how AI changes what it means to actually do your job.

Cursor — Side Chats and Conversation Search (v3.11)#

Source: https://cursor.com/changelog/side-chat Credibility: High (first-party changelog, shipped July 10)

What happened: Cursor's 3.11 release adds side chats — parallel conversations you can run alongside your main agent thread — plus the ability to search through past agent transcripts. There's also a simplified project and repo picker. This is a small-sounding release that addresses a real friction point: if you're in the middle of an agentic session and you want to ask a clarifying question or explore a side idea without interrupting your main task, you previously had to break context or start over. Now you don't.

Key capabilities:

  • Side chats run in parallel with the main chat window — you can explore ideas, ask questions, or test hypotheses without touching the main agent session
  • Agent transcript search means you can go back and find what the agent did in a previous session without scrolling forever
  • Simplified project and repo pickers reduce friction when switching contexts

Why it matters for PMs: This is a UX decision that reveals something real about how people actually use agentic coding tools. The original assumption was linear: you give the agent a task, it does it, you review. But in practice, people want to branch — run a check, try something else, ask a question — while the main task is running. Side chats are essentially Cursor acknowledging that agentic work is non-linear and the interface needs to match that. If you're building any kind of AI assistant or agent product, the interaction model question isn't just "what can it do" — it's "what happens when users want to do two things at once, or change their mind mid-task." Cursor just gave you a concrete design answer to that.

Critical questions:

  • Does the side chat share context with the main chat, or is it fully isolated? That architectural choice has big implications for whether it's actually useful during debugging vs. just exploration.
  • How does transcript search handle sessions across multiple days or repos? The value here depends heavily on how far back it can actually search.
  • Is this a feature that new users will discover on their own, or will it stay a power-user thing? The discoverability problem is real for parallel-thread UX.

Action you could take today: If you're shipping any kind of AI assistant, write down the three most common moments where users probably want to "branch" mid-conversation without losing their main thread. That list is your case for (or against) a side chat equivalent.

Figma — GPT-5.6 Now in Figma Make#

Source: https://www.figma.com/blog/gpt-5-6-is-now-available-in-figma-make/ Credibility: High (first-party changelog, shipped July 9)

What happened: Figma Make now has GPT-5.6, OpenAI's latest model family, available as an option. Figma Make is the design-to-prototype layer — you describe what you want, and it builds a working interactive prototype. This is an incremental update, but it's coming right on the heels of Lenny's benchmark showing GPT-5.6 Sol beating Claude Fable on prototype generation specifically. That's probably not a coincidence.

Key capabilities:

  • GPT-5.6 is available in Figma Make for generating prototypes and interactive designs
  • Users can switch to it from the model picker in Make
  • No change to Figma's credit pricing or access model mentioned

Why it matters for PMs: Figma Make is now the layer where a lot of product managers first touch AI-generated prototypes — not in a coding tool, not in ChatGPT, but in the design environment they already live in. As models improve at prototype generation specifically (and the Lenny benchmark suggests they are improving fast), the quality bar for "AI-generated prototype" gets higher. That changes the conversation with engineers: if the PM can generate something that looks and feels closer to a real product, the gap between "design spec" and "thing we're building" gets smaller. Worth watching whether that accelerates feedback cycles or creates new kinds of misalignment.

Critical questions:

  • Does model choice in Figma Make actually matter to most users, or do they just use whatever the default is? If it's power-user only, the impact is limited.
  • How does GPT-5.6 in Make compare on multi-screen flows versus single-screen prototypes? That's where Make either becomes genuinely useful or stays a demo tool.
  • Is Figma planning to gate newer models behind higher tiers, or is this the same access model?

Action you could take today: If you have access to Figma Make, try generating a prototype for a feature your team is currently speccing. Switch between models if you can and see if the output quality difference is noticeable for your use case — that's real signal for whether model selection matters to your workflow.

Dan Shipper — Don't Do Your Work. Tend Your Loop.#

Source: https://every.to/chain-of-thought/don-t-do-your-work-tend-your-loop Credibility: Medium-High (Dan Shipper is CEO of Every, a credible practitioner voice on AI and work)

What happened: Shipper published a piece arguing that the fundamental shift AI creates isn't in the tasks you do — it's in how you relate to the work itself. The core idea: with AI handling execution, the human role becomes more about setting up, monitoring, and steering a system (a "loop") than about doing individual tasks directly. "Tending your loop" rather than doing your work.

Key patterns:

  • The shift from execution to orchestration: AI handles task-level execution; the human role becomes setting up the right conditions for good output
  • "Tending" involves three things: feeding inputs (context, direction), monitoring outputs (is it going where I want?), and adjusting the loop (changing prompts, adding constraints, redirecting)
  • The emotional experience of tending is different from doing — it can feel passive or like you're not contributing, even when you're making the decisions that matter most
  • The trap: optimizing for busyness (doing more tasks) instead of optimizing the loop itself

Why it matters for PMs: This one lands differently if you're already using AI heavily. The PMs who are struggling most right now aren't the ones who can't figure out the tools — they're the ones who feel vaguely guilty that they're "not doing enough" because they're not typing the words themselves. Shipper is naming something real: the job is changing from execution to orchestration, and the metrics we use to evaluate whether we're working hard (output volume, time on task) don't map to the new role. If you're managing a team, this is also relevant to how you evaluate what "productive" looks like for your AI-assisted reports.

Critical questions:

  • Is "tending the loop" actually a sustainable mental model for knowledge work, or does it eventually lead to skill atrophy in the areas you've delegated?
  • How do you know if the loop is producing good outputs if you're no longer doing the work yourself — and what does that mean for PM judgment that was built through direct execution?
  • Is this pattern specific to individual contributors, or does it apply differently when you're a PM whose job was already partly about orchestration?

Action you could take today: Pick one recurring task you've been doing manually (a weekly summary, a competitive brief, a meeting prep doc) and intentionally set it up as a loop — prompt, review, adjust — instead of doing it directly. Notice what it feels like, and what you actually spend your judgment on.

Quick Hits#

The Thread#

Agentic work is forcing a UX reckoning. Cursor's side chats, Shipper's "tend the loop" framing, and even OpenWiki Brains all point at the same thing: the mental model of "give AI a task, get a result" is breaking down in practice. Real agentic workflows are non-linear, context-dependent, and require active steering — and the tools and mental frameworks are just now catching up. If you're building any kind of AI assistant this month, the question isn't "what can it do" but "what does the human do while it's doing it."

Sit With This#

Cursor's side chats solve for a specific moment: you're in the middle of an agentic task and you want to branch without losing context. The design answer they landed on is a parallel conversation window.

For your AI product: What's the equivalent moment in your product — where a user wants to do two things at once, or change direction mid-task, without starting over? And what does your current design assume about whether that ever happens?