You will hear some version of this at every company on your active list. The preparation instinct is to build one answer. The question is five different technical-capability screens sharing a surface form, and your evidence covers them unevenly. An interviewer at OpenAI Identity asking "does she really understand AI?" wants to know whether you can design authorization models for agents acting on a user's behalf. An interviewer at OpenAI Codex asking the same words wants to know whether you've shipped production code recently. The preparation that answers one is irrelevant to the other.
Three classifications are used throughout: a perception gap means your evidence already answers the concern and the work is presentation. An evidence gap means the capability is real but your public proof is thin — you need a verbal bridge, an artifact, or both. A mandate boundary means the role requires a credential or history you don't have, and no reframe changes that.
The five capabilities, mapped against your evidence
1. Trust and supervision architecture
Designing how humans oversee, correct, and authorize AI actions.
Your strongest ground. Carrier IQ shows parallel agents converging on an explicit human authorization gate. Brand Pulse shows interpretive oversight of agent-generated synthesis with source-labeled evidence. The Trust essay provides published reasoning about trust patterns in AI systems. BCG Digital Ventures work (attributed as Product Design Director) adds enterprise-scale context for permissions, access, and consequential decision flows. All provable from published work.
2. Code-assisted prototyping fluency
Using tools like Cursor, Claude Code, or v0 to build working interactive prototypes.
Your three Labs apps are deployed and functional. But there is no public repository, no commit history, no build record, no tool attribution. Retail Velocity surfaces TinyFish infrastructure in its interface, which means a reviewer who inspects the app sees evidence of a dependency rather than evidence of your build process. The apps prove you can ship a working product. They don't prove you wrote the code or which tools you used to build it. Evidence gap — closable with a specific artifact you haven't built yet.
3. Production-code authorship
Writing and shipping production code as part of regular professional work.
Your portfolio doesn't show authored production code, public repositories, or named languages and frameworks on any case page. The Labs apps don't establish this because their build provenance isn't inspectable. BCG DV work demonstrates engineering collaboration, not code authorship. TinyFish provides AI-systems context but is past-tense and cannot serve as portfolio proof. Mandate boundary.
4. Evaluation-pipeline ownership
Maintaining Python-based evaluation infrastructure, writing evals, managing data strategy for model quality.
Your public evidence shows no maintained evaluation infrastructure and no Python proficiency. Mandate boundary.
5. Model-behavior specification
Defining what the AI does — agent authority, permissions, state transitions, uncertainty handling, handoffs — as distinct from designing the UI around it.
Your evidence here is real but incomplete. Carrier IQ's five-state agent workflow (Session, Navigate, Fill, Extract, Verify) shows you designing agent behavior, not wrapping it in interface. The scope-of-action decisions in that system — which carrier data each agent can access, what actions require human authorization versus what the agent resolves autonomously — are model-behavior specification decisions, even though the app frames them as trust architecture. Brand Pulse shows you structuring how multiple agents coordinate, what each agent's role is, and how the synthesis layer attributes which agent produced which evidence.
What the published applications don't show is a complete correction loop: a wrong output leading to a diagnosis, an intervention, a rerun, and a measurable change. The Trust essay covers the conceptual layer. Whether this reads as a perception gap or an evidence gap depends on how deeply the specific role requires demonstrated iteration on model behavior versus demonstrated reasoning about agent authority.
Role resolutions
OpenAI — Product Designer, Identity
What it screens for. Human-to-agent and agent-to-agent identity, authorization, access, confirmation, trust. The posting emphasizes permissions, security, systems thinking, complex platforms. Does not require code authorship or evaluation infrastructure.
Your evidence. Carrier IQ's authorization gate is direct proof of the core design problem this role exists to solve: how does a human understand what an agent can access, and where does the human retain final authority? This is also model-behavior specification work — defining the agent's scope of action is defining what the model is allowed to do. The Trust essay provides the conceptual framework. BCG DV enterprise work demonstrates fluency with permissions and access at organizational scale.
Classification: perception gap. Your evidence already answers this role's technical screen. The work is leading with the right artifact in the role's specific language — identity, authorization, access — rather than generic trust framing.
Lead with Carrier IQ. Frame it as: "I designed the authorization model for an insurance-quoting system where five agents operate in parallel, each with different access to carrier data, and the human operator retains binding authority through an explicit approval gate." Deep-link the live app directly in outreach — the homepage doesn't route there, and without the URL a reviewer hits your constrained evidence first. When asked about agent-to-agent identity, bridge to Brand Pulse's multi-agent coordination, where each source agent has a distinct role and the synthesis layer must attribute which agent produced which evidence.
Reachable now.
Anthropic — Product Designer, Safeguards
What it screens for. Safety and trust patterns for AI systems — oversight, intervention, recovery, what can go wrong with AI outputs. The posting also lists Claude Code in the designer's practice as a minimum qualification, and front-end code as preferred.
Your evidence. The trust-architecture artifacts are strong. Carrier IQ shows the authorization gate; the Trust essay provides the reasoning framework for safety-critical AI systems. The role also requires reasoning about model behavior in a safety frame — what the model might do wrong, how to detect it, how to constrain it. Carrier IQ shows the authorization gate but does not show what happens when an agent produces a wrong output. No visible correction-to-changed-behavior sequence exists in any of the three Labs apps.
The Claude Code minimum qualification creates a second screen — the same code-prototyping evidence gap that applies to Brex and Midjourney below: the apps work, but the build process and tool use aren't inspectable.
Classification: mixed — perception gap on trust architecture, evidence gap on code-assisted prototyping. The trust proof is your strongest ground and directly relevant to the safety mandate. The failure-recovery gap is a verbal-bridge problem — the posting screens for design reasoning about safety patterns, not maintained evaluation infrastructure. But the Claude Code minimum qualification means the code-prototyping artifact described under Brex and Midjourney strengthens this application materially.
Lead with the Trust essay's reasoning, then demonstrate with Carrier IQ. Prepare a verbal account of a specific failure scenario you designed for — what happens when a carrier agent returns inconsistent data, how the system surfaces that inconsistency to the operator, what the operator's recovery options are. If you have an unpublished example of a wrong output you caught and redesigned around during the Labs build process, that's your verbal bridge for the safety screen. Don't claim the apps demonstrate a complete correction loop — they don't. Say instead: "The current version shows the authorization layer. What it doesn't show is the failure-handling work underneath — I can walk you through how I designed for agent disagreement and inconsistent source data."
The trust proof is reachable now. The code-prototyping artifact — the same one that unlocks Brex and Midjourney — would close the Claude Code screen. Prioritize building it before outreach if timing allows. If not, the trust proof alone may carry the initial screen, but expect the code question to surface.
Brex — Staff Product Designer, AI
What it screens for. Three constructs in one posting: trust architecture for consequential financial actions (delegation, supervision, output correction), model-behavior judgment (using frontier models daily, designing what the AI does in financial contexts), and code-assisted prototyping (Claude Code, Codex, Cursor, v0 named explicitly). Hands-on AI product experience is a stated requirement, not a preference.
Your evidence across all three screens:
Trust architecture: strong. Carrier IQ's authorization gate maps directly to financial-action authorization. Perception gap — lead with it.
Model-behavior judgment: partial. Brex wants someone who designs what the AI does with money — delegation scope, in-flight supervision, when the system should stop and ask. Your Labs apps show you making these decisions: Carrier IQ defines which actions agents can take autonomously and which require human authorization; Brand Pulse defines how agents coordinate and what each agent's role boundaries are. What you can demonstrate is the reasoning about agent authority and scope. What you can't demonstrate from public evidence is the daily-frontier-model-use pattern Brex describes — iterating on model behavior through prompt tuning, output evaluation, and behavioral adjustment as a regular practice. If that practice exists in your TinyFish or Labs work, it's verbal-bridge territory. If it doesn't, this screen sits closer to evidence gap than perception gap.
Lead with Carrier IQ for model-behavior judgment too, but shift the framing from authorization architecture to scope-of-action design: "I defined which decisions the agents could make autonomously and which required human approval — that's a model-behavior design problem, not an interface problem, because the agent's scope of action determines what the product can do." If you can describe a specific instance where you changed an agent's behavioral scope based on output quality or risk assessment, that verbal bridge closes the distance between "I designed the boundaries" and "I iterate on model behavior."
Code-assisted prototyping: evidence gap. The apps work but the build provenance isn't public. This matters because Brex names the specific tools.
Classification: mixed. Trust architecture is a perception gap. Model-behavior judgment sits between perception gap and evidence gap depending on how the panel weights daily frontier-model practice versus demonstrated reasoning about agent authority. Code-assisted prototyping is an evidence gap that matters because Brex names the tools.
Before outreach, build the code-prototyping proof object described in Issue #12: a deployed prototype with a public repository showing chronological build decisions, at least one failed output with a documented correction, and an explicit statement that this demonstrates code-assisted prototyping fluency, not production engineering. If you can build it using one of the tools Brex names (Claude Code or Cursor), it answers the tool-specific version of the question. Without that artifact, the code-prototyping screen is a verbal-only bridge, which is risky at a company that named the tools in the posting.
Ask this early in any conversation: "How does the team currently split prototyping work between design and engineering — are designers expected to commit to the production codebase, or is the code-prototyping expectation about exploration and validation?" This separates the code-prototyping screen from a hidden production-code screen. If the answer is production commits, the classification shifts to mandate boundary and you redirect your energy.
Midjourney — Design Lead
What it screens for. Hands-on design and prototyping using Claude Code and Cursor. Inventing new interaction paradigms for AI capabilities. The posting names the tools explicitly and says the candidate should believe AI requires new paradigms rather than standard feature design. Does not require production-code history or evaluation infrastructure.
Your evidence. The Labs apps demonstrate that you've built novel AI interaction patterns — agent coordination, evidence-based synthesis, human authorization over autonomous processes. These are the new paradigms the posting describes. But the code-prototyping screen is the same evidence gap as Brex: the apps exist, the build record doesn't.
Classification: evidence gap on code prototyping. The interaction-paradigm judgment is a perception gap — your Labs are direct proof. The code-prototyping fluency is an evidence gap because Midjourney names Claude Code and Cursor and expects hands-on use.
Same artifact need as Brex. The bar is different: Midjourney's posting doesn't require production-code history, so prototyping fluency is the threshold, not engineering contribution. A public repository showing a prototype built with Claude Code or Cursor — even a small one — closes this. Lead outreach with the Labs as proof of interaction-paradigm thinking, and have the code-prototyping artifact ready for the follow-up question about tools. Only say "I can show you the build process and the tools I used" if the build record exists by the time you reach out.
OpenAI — Product Designer, Codex
What it screens for. The posting says candidates "may thrive if they bring a strong technical background and have recently shipped code to production." No language, framework, or tool is named — but the screen is a history question, not a fluency question.
Your evidence. You have no professional production-code shipping history in your portfolio. The Labs apps are deployed but their build provenance isn't inspectable and they don't establish production-code authorship in a professional engineering context.
Classification: mandate boundary — pending one diagnostic question. The "recently shipped code to production" language screens for a professional history that doesn't exist in your background. The posting uses "may thrive" rather than minimum-qualification language, which is softer.
Before writing this off, ask a recruiter or back-channel contact: "Does this role include writing production code as regular work, or is the technical expectation more about prototyping fluency and engineering collaboration?" If the answer is production code, redirect to OpenAI Identity. If prototyping fluency, the classification drops to evidence gap and the same code-prototyping artifact applies.
Anthropic — Product Designer, Evals and Prompts
What it screens for. Production-quality Python. Maintained evaluation infrastructure. Data strategy. The only design posting in the current set that makes a specific programming language a minimum qualification.
Classification: mandate boundary. Production-quality Python is a qualification that exists or doesn't. Skip. Redirect to Safeguards.
Quick-reference summary
| Role | Primary screen | Classification | Action |
|---|---|---|---|
| OpenAI Identity | Trust/supervision + agent scope | Perception gap | Lead with Carrier IQ (authorization model, five parallel agents, binding approval gate). Deep-link the live app. Reachable now. |
| Anthropic Safeguards | Trust/failure prevention + code prototyping | Mixed (perception gap on trust, evidence gap on code) | Trust proof reachable now. Code-prototyping artifact strengthens the application — same artifact as Brex/Midjourney. |
| Brex Staff PD, AI | Trust + model behavior + code prototyping | Mixed (three screens, three classifications) | Trust: lead with Carrier IQ. Model behavior: reframe as scope-of-action design. Code: artifact needed before outreach. Ask about prototyping-vs-production split early. |
| Midjourney Design Lead | Interaction paradigms + code prototyping | Evidence gap (code) | Lead with Labs as paradigm proof. Code-prototyping artifact needed. Say "I can show you the build process" only when the record exists. |
| OpenAI Codex | Production-code history | Mandate boundary (pending) | Diagnostic question first: "Does this role include writing production code as regular work?" Redirect to Identity if confirmed. |
| Anthropic Evals & Prompts | Python + eval infrastructure | Mandate boundary | Skip. Redirect to Safeguards. |
This week
One role is reachable with existing evidence: OpenAI Identity. It screens primarily for trust and supervision architecture, which is your strongest provable construct. Outreach can happen now. Deep-link the Labs apps directly — the homepage doesn't route to them.
Anthropic Safeguards is partially reachable. The trust proof is strong enough to carry an initial screen, but the Claude Code minimum qualification means the code-prototyping artifact would close a real gap. If timing forces a choice between outreach now and waiting for the artifact, lead with the trust proof and prepare for the code question. If you can build the artifact first, do that.
Three additional roles — Brex, Midjourney, and any posting that names Claude Code, Cursor, or v0 as expected tools — are blocked on that same artifact: a public build record showing code-assisted prototyping fluency with named tools. It unlocks a category of roles, so prioritize it over any other portfolio work.
Two roles are mandate boundaries under current evidence. Codex warrants a diagnostic question before you write it off. Evals and Prompts does not.
- Render's agent-experience role: Their Staff Product Designer posting screens for agent-facing CLI/API/MCP design, human-agent handoffs, and governance — a trust-architecture match worth resolving against your evidence before the next issue.
- Handshake's two distinct AI screens: Their Student Experience role asks for reasoning visibility and uncertainty handling without code requirements, while Autonomous Recruiting adds agentic automation and generative-AI prototyping — same company, different constructs.
- Slack's agentic-future mandate: The VP Product Design, IC/Principal Architect posting defines interaction models for agents as coworkers, including action and handback of control, with AI/ML experience listed as preferred rather than minimum — a role geometry worth mapping against the trust-architecture evidence.
- The missing correction loop: No approved Lab currently shows a wrong output leading to diagnosis, intervention, rerun, and measurable change — the artifact described in Issue #8 that would strengthen every role resolution where model-behavior specification is a screen.
