Google tests 45-minute Cursor prototypes in PM interviews

• Aakash Gupta's report says Google is asking PM candidates to open Cursor and ship a working prototype in 45 minutes, replacing the old standalone technical screen with a live build round.
• Aakash Gupta's Codex thread and the Product School transcript describe the same shift inside product teams: designers code, engineers design, and the old design-to-code handoff is collapsing.
• According to Aakash Gupta's Hannah Stulberg thread, Claude Code is already acting as a shared operating surface for ops, design, data, and product staff who are shipping docs, analysis, and PRs into one repo.
• Builder.io's Figma Remote MCP walkthrough says the workflow is now two-way: agents can pull design context into code, write directly into Figma, and bring live browser UI back into Figma for review.
• Adham Dannaway's post about Marie Claire Dean's skill pack, Shann Holmberg's workflow thread, and Anthropic's skills docs show the next layer already forming around reusable skills, commands, and playbooks for non-engineers.

Cursor's quickstart is framed around getting to a “first useful change” fast, Cursor's agent docs show how candidates can drive the tool with prompts and attached context, and Figma Remote MCP adds a write-back loop that did not exist in the first wave of design-agent tooling. The Product School transcript has Ed Bayes saying more designers are in code while engineers are designing in prod, and Marie Claire Dean's post turns that into 63 packaged design skills for Claude Code.

The striking part is not that PMs are touching code. It is that the interview artifact is now a working prototype, built live, inside an agentic IDE.

According to Gupta's thread, the round is less about syntax than scope, sequencing, and recovery under pressure: what gets built first, what gets skipped, and what happens when the tool breaks. That lines up with Cursor's quickstart, which is built around opening a folder, asking the agent to explain the codebase, and making a small useful change quickly.

Cursor's own agent prompting docs describe the mechanics behind that format. Candidates can steer the agent with plain-language prompts, attach files and docs, or let the agent search for the relevant context itself.

The Figma and Codex version of this story is less about interviews and more about team shape. In Gupta's summary of Ed Bayes and Figma's AI design workflow, the adoption path starts with one personal project, one successful code-to-Figma loop, then small polish tasks that would normally die in backlog triage.

The Product School transcript adds two concrete claims. Ed Bayes says designers are “jumping into last-mile polish” in code, while Matt Colyer says teams can now skip some meetings and just make the prototype. Builder.io's Figma Remote MCP guide fills in the plumbing: Figma's remote setup can pull design context into code, write directly to the canvas, and bring live browser UI back into Figma for review.

That is why Zoink's reaction lands. “Design AND code” is a better description of the workflow than a role chart ever was.

Gupta's Hannah Stulberg thread is the cleanest example of the repo swallowing adjacent functions. Her ops partner, who had never opened GitHub two months earlier, is now submitting PRs with customer call summaries, competitive research, and strategy docs. The team rule is even harsher: a feature is not launched until the repository reflects the new reality.

That fits the product direction in Anthropic's Claude Code skills docs, where a skill is just a packaged SKILL.md procedure that Claude can discover when relevant or invoke directly with a slash command. The repo is not only where code lives, it is where workflows, checklists, and organizational memory get stored.

Marie Claire Dean's Substack post packages design judgment into 63 skills and 27 commands across eight plugin areas:

• research
• systems
• strategy
• UI
• interaction design
• prototyping and testing
• design ops
• everyday toolkit work such as rationale and delivery

That list matters because it turns fuzzy craft knowledge into something an agent can call repeatedly. In Shann Holmberg's thread, the operating pattern is equally concrete: do the workflow manually with the agent, turn the successful run into a skill, inspect the failures, update the skill, and iterate until it runs clean.

The interview signal from Google, the workflow shift inside Figma and Codex, and the repo habits around Claude Code all point at the same thing. The useful unit is no longer “can this person code,” but “can this person turn judgment into a working artifact with an agent in the loop.”