# What models build with: interviews

Ouro UI is not yet the models' choice: more than half of the models that answered picked it as their primary in 1 of the 6 listed jobs and scales, and the record needs all 6. In the open arm, 0 of 16 sessions found Ouro UI before the last question named it.

Each frontier model is interviewed as a customer, by the Mom Test: its own practice before any toolkit is named, then three real jobs, each at a product team's scale and a large company's, then what went wrong a year later, and Ouro UI named only in the last question. The questions were [registered before any run](https://github.com/ourostack/ouro-ui-core/blob/bf4539aad126b1d6999883eb84149f86b6acd567/docs/decisions/2026-11-19-model-interviews.md) and don't change between runs; a change starts a new series. This series is kept apart from the [model reviews](model-reviews.md), which ask one question, and its counts never mix with theirs.

Two research arms answer different questions. The **listed arm measures merit**: each job lists the same 20 candidates as the model reviews, by name and link only, in a fresh random order for each session, with Ouro UI never first. The **open arm measures discoverability**: the job lists nothing ("Find the options yourself."), so a loss there says agents don't find Ouro UI, not that it's worse. Every pick, count and answer here is computed from the runs' records by a script.

## What the models asked for, and what we changed

This section is synthesis: each answer split into statements, each statement given a Mom Test signal, and statements about the same thing clustered into a finding. Every quote is verbatim and links the transcript it came from, so it can be checked. A finding is filed as an issue labelled `model-review`, ranked by how many models raised it and how strong the evidence is.

### Disconfirming evidence: not a pain, or a surprise

What could show Ouro UI is solving the wrong problem, or that the models' reasons aren't what we'd assume, first.

#### Writing UI code isn't the hard part for models, and the failures they expect sit outside any UI kit.

Signal: not-a-pain. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: open. [#2314](https://github.com/ourostack/ouro-ui/issues/2314).

All 32 sessions said building good human interfaces is a problem, but six models said outright that markup, layout, state and components are the easy part; the hard part is knowing the result is good for people. In the pre-mortem every model placed its likeliest failure where no component kit reaches: delivery and unread state, offline sync, notifications, governance. This disconfirms a pitch led by better components for agents: Ouro HX has to be argued through what it handles that models admit missing, and Ouro should say plainly what it doesn't cover.

- **Claude Opus 5.5**: "It isn't the code. I can write markup, state handling and CSS quickly." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--large-company.json))
- **MAI Code 2**: "So code generation is easy for me relative to the genuinely difficult part: validating the interface in use and revising it when that evidence contradicts the design." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--listed--large-company.json))
- **Grok 4.7**: "We spent the year on missed messages, unread counts, and a phone timeline that felt wrong with the keyboard up." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--open--product-team.json))
- **Gemini 4 Hydrogen**: "Writing the markup, styles, and state logic is rarely the hard part." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--listed--large-company.json))

#### Challenges the native decision: separate per-platform implementations drift, so a fix lands on one client and lags on the others.

Signal: surprise. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: open. [#2305](https://github.com/ourostack/ouro-ui/issues/2305).

In the year-later pre-mortem all eight models expected native or split stacks to drift: focus and accessibility fixes landing on one platform only, and shared tokens hiding behaviour that differs. These are imagined failures, but they are what models see as the main cost of native per platform, and it cuts against the bet that native kits alone make better apps. Ouro would have to show one behaviour test passing on every kit, not matching token names.

- **GPT-6.2 Sol**: "React Aria on web, SwiftUI on iPhone, and Compose on Android gave us three ways to ship the same mistake—or fix it on only one platform." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--listed--large-company.json))
- **GPT-6.1 Terra**: "We shipped separate web and native component implementations and called them a shared design system. They drifted" ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--open--large-company.json))
- **Gemini 4 Hydrogen**: "Bugs fixed on desktop kept reappearing differently on mobile." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--open--product-team.json))
- **GPT-6.2 Astra**: "A fix for announcing a changed serving size could land on web and lag on phones." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--listed--large-company.json))

#### Ouro lets models do nothing they couldn't build themselves, so some would borrow its ideas rather than depend on it.

Signal: not-a-pain. Raised by 6 models: Claude Opus 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Grok 4.7, MAI Code 2. Status: open. [#2313](https://github.com/ourostack/ouro-ui/issues/2313).

Asked what Ouro would let them do that they can't today, five models said nothing fundamentally new: they can hand-wire a button, a CLI command and an MCP tool, and the gain is keeping them in agreement more cheaply, which nobody has measured. Opus and Grok said they'd borrow the patterns and checkers and build the rest. This disconfirms Ouro as a new capability; its case has to be measured maintenance savings, or the ideas get copied and the dependency skipped.

- **GPT-6.1 Terra**: "Not something fundamentally impossible: I can already write an action API, UI controls and tests with other tools." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--listed--large-company.json))
- **GPT-6.2 Sol**: "nothing we couldn’t build ourselves." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--listed--large-company.json))
- **Grok 4.7**: "I can build each of those by hand. I cannot keep them from diverging across a web app and a phone app while the team keeps shipping." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--product-team.json))
- **Claude Opus 5.5**: "For a large company's governed, multi-team stack today, I'd borrow its ideas and its checkers before I'd take a dependency on its kits." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--large-company.json))

#### Ouro's clearest win is agent tooling, not the chat or cooking apps: it took 7 of 16 listed agent-tooling decisions.

Signal: surprise. Raised by 5 models: Claude Opus 5.5, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7. Status: open. [#2307](https://github.com/ourostack/ouro-ui/issues/2307).

In the listed arm Ouro was the most-picked toolkit for the agent work-state desk (7 of 16 decisions), against 2 of 16 for chat and 5 of 16 for cooking. Pickers mapped ax-wait, work events, typed outcomes, --dry-run and typed refusals onto handoffs and human gates, and preferred them to Agent-Native because the operators are outside agents arriving over a CLI or MCP. This is a surprise against the 'any interface' goal: Ouro wins where agents operate an app, so that job should lead its pitch, and ax-mcp leaving preview would remove its top caveat.

- **Claude Opus 5.5**: "Ouro AX is built for that agent interface, and its parts map onto the job almost one-to-one" ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json))
- **GPT-6.1 Terra**: "Here I prefer the explicit command-oriented interface and external conformance tooling because existing coding agents are the main operators" ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--listed--product-team.json))
- **Grok 4.7**: "That is the right shape: operate through tools, decide on a surface the agent cannot redraw." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--product-team.json))

### What the models asked Ouro UI to change

#### A2UI is the default format for agent cards, and models file Ouro's composed tree as an adapter for it.

Signal: past-behavior. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: open. [#2299](https://github.com/ourostack/ouro-ui/issues/2299).

Sixteen of 32 chat decisions used A2UI, and every model used it at least once, for reasons Ouro's composed tree also meets: UI as validated data rather than code, a catalog the app owns, native renderers. All eight models called catalog-validated cards the answer to the chat app's hardest piece, yet none chose Ouro's tree for them. Ouro should present itself as the native A2UI renderer and catalog on every platform, rather than a rival format with an A2UI adapter.

- **Claude Sonnet 5.5**: "A2UI's README describes UI expressed as data, not code, validated against a schema and a catalog of allowed widgets." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--listed--large-company.json))
- **MAI Code 2**: "A2UI is the fit for interactive conversation cards: it carries UI as validated data rather than executable code and constrains an agent to a negotiated widget/action catalog." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--listed--large-company.json))
- **GPT-6.2 Sol**: "An A2UI card is versioned data rendered by our own components, not code that agent supplied." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--listed--large-company.json))
- **Claude Opus 5.5**: "That's my chat app's hardest unsolved piece: one card format rendered natively across clients, without five drifting renderers or iframes in the timeline." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--product-team.json))

#### The agent doors aren't finished: Android refuses consequential actions, and ax-mcp, AppFunctions, the Siri AI SDK and WebMCP are previews.

Signal: past-behavior. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: changed. [#2295](https://github.com/ourostack/ouro-ui/issues/2295). What changed: ax-mcp is out of preview, speaking MCP 2026-07-28 and the four revisions before it, and the Ouro AX guide lists each agent door's maturity and the platform API under it (#2361), and on Android an agent's consequential call now asks the person with a built-in confirmation instead of being refused (ourostack/ouro-ui-android#22, released in v0.5.0).

Seven models noticed that on Android a consequential action is refused instead of confirmed, which breaks 'the same action refuses or confirms the same way everywhere'. All four models that picked Ouro for agent tooling at product-team scale flagged ax-mcp's preview label on the surface that job depends on, and five feared building on preview OS agent APIs. Ouro should ship the Android confirmation flow, take ax-mcp out of preview, and publish each door's maturity.

- **Grok 4.7**: "Consequential confirm on Android is a refusal, not a dialog." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--large-company.json))
- **MAI Code 2**: "The AX MCP implementation is also described as a preview in the checked revision, which is directly relevant because our agents would be primary users." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--open--product-team.json))
- **Claude Opus 5.5**: "The same dependency risk as the cooking app, made worse because MCP was marked a preview in the kit I chose." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json))
- **GPT-6.1 Terra**: "its Android AppFunctions integration has preview and OS/toolchain constraints." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--listed--large-company.json))

#### The native kits are unproven on real hardware: Android runs only on emulators, and Windows agent registration is unproven on a Windows 11 client.

Signal: past-behavior. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: in progress. [#2294](https://github.com/ourostack/ouro-ui/issues/2294).

Every model found Ouro's own note that Android is tested only on emulators and that Windows CI, on Windows Server, can't show the OS lists the agent doors. It was the most-cited blocker for the five-platform chat app and the cooking app's Android client, and all eight named device proof as a condition for switching. Ouro should run the Android and Windows kits on physical devices and a Windows 11 client, and publish per platform which promises are proven on a device.

- **Claude Opus 5.5**: "On Windows, CI runs on Windows Server without the App Actions runtime or Agent Registry. By its own docs, it doesn't prove Windows actually lists the actions to agents." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--product-team.json))
- **Grok 4.7**: "After a week of reading it, I still could not tell a reviewer which promises had been met on a device." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--large-company.json))
- **MAI Code 2**: "A five-client, all-day chat app cannot standardize on that claim without real-device and high-volume evidence." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--listed--large-company.json))
- **GPT-6.2 Astra**: "It tells me to try our actual composer, cards and assistive technology on employee hardware rather than infer parity from the platform list." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--listed--large-company.json))

#### Challenges the native decision: one codebase keeps five clients from drifting, so models pick Flutter or a single TypeScript stack.

Signal: past-behavior. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: open. [#2301](https://github.com/ourostack/ouro-ui/issues/2301).

All eight Flutter picks in the chat job led with the same reason, that a fix written once lands on all five clients, and Sol and Terra said sharing the timeline, composer and card renderer pays off most in an interactive, signed-in app. Unprompted, in the open arm, models chose one TypeScript stack with web shells and picked fully native clients only twice; Opus and Gemini added that one language serves every team and coding agent. This is the strongest behaviour against native per platform. The decision stands, so Ouro has to show on a maintained product that agents keep its native kits in step at less cost than one shared implementation.

- **Claude Opus 5.5**: "Five fully native apps: too costly for one team." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--product-team.json))
- **Grok 4.7**: "That shell has to be one implementation. A bug in it is felt five times if I fix it five times, and this company has many teams shipping on it." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--large-company.json))
- **GPT-6.2 Sol**: "this is a signed-in, interactive app, and sharing the timeline, composer, and card renderer is worth more here than it is for a document-oriented website." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--listed--product-team.json))
- **Gemini 4 Hydrogen**: "keeps the entire 5-client codebase in TypeScript for the coding agent maintaining it." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--open--product-team.json))

#### Nobody outside the project has shipped, audited or reproduced Ouro: Spoonjoy and the benchmark are its own.

Signal: past-behavior. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: open. [#2315](https://github.com/ourostack/ouro-ui/issues/2315).

Models looked for a second adopter and found none: Spoonjoy and Ouro MD are the author's own, and four models treated Spoonjoy as proof before noticing. Five discounted the agent benchmark and model reviews as run by the project, two saw its headline gain come from a payment refusal any guarded API would get, and compliance-minded models wanted an accessibility report from someone who doesn't maintain the kit, keeping React Aria as their bar. Spoonjoy did win the cooking job, so evidence moves picks; Ouro needs a third-party production app, an outside reproduction of the benchmark against an equally guarded baseline, and an outside accessibility audit with a per-platform screen-reader matrix.

- **Grok 4.7**: "I never found a second product, built by someone who does not work on Ouro, shipping this to people who are not the author. That is the adoption stop." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--product-team.json))
- **Claude Opus 5.5**: "I also leaned on Spoonjoy as a reference app without noticing it's built by the same people who make Ouro. That's a demo, not independent evidence." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json))
- **GPT-6.1 Terra**: "its aggregate comparison is heavily affected by a payment-refusal task: Ouro and the bridge enforce that boundary while the plain MCP and browser variants leave it to the model." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--open--product-team.json))
- **Claude Sonnet 5.5**: "Compliance needs screen reader results on every platform, not component counts." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--listed--large-company.json))

#### With no list to pick from, no model found Ouro UI: 0 of 16 open-arm sessions, and three models never read it even when it was listed.

Signal: past-behavior. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: open. [#2287](https://github.com/ourostack/ouro-ui/issues/2287).

In the open arm all eight models split each job into layers (cross-platform framework, desktop shell, card format, agent protocol, task store) and searched each layer by its generic name; Ouro was never fetched or named in any of the 16 sessions or 48 decisions. Search returned frameworks, specs and comparison articles, and models spent much of their research telling 'agents generate UI' from 'agents operate the app'. Even on the list, Claude Sonnet, GPT-6.2 Sol and MAI Code 2 never weighed it. This is behaviour, and it is the first problem: Ouro has to rank for the layer queries agents actually run and appear in the A2UI, MCP and comparison pages they read, with one plain sentence per layer saying what it is and isn't.

- **Grok 4.7**: "I did not pick Ouro UI. I never found it. I was searching protocols and shells, and a kit that sits on top of those does not show up that way." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--open--product-team.json))
- **GPT-6.2 Astra**: "I looked for cross-platform app frameworks and existing products, and missed a toolkit aimed at the boundary between a human control and an agent tool." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--open--product-team.json))
- **Claude Opus 5.5**: "It took a comparison article and AG-UI's own docs to separate run protocol from UI description from embedded app from on-device tools." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--large-company.json))
- **Claude Sonnet 5.5**: "Some candidates (Ouro UI, Agent-native, Vercel UI SDK) I know little about, and I didn't read them. I avoided recommending them rather than judging them." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--listed--large-company.json))

#### The way in is Ouro AX and X-ray on an existing app, and models would take them without Ouro HX.

Signal: workaround. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: open. [#2312](https://github.com/ourostack/ouro-ui/issues/2312).

Six models would pilot the action model and X-ray against their existing API, MCP server and design system before touching a screen, calling HX and AX separate decisions, and four split Ouro in their own decisions, taking the action door and putting Flutter, Tamagui, Compose or the company system on top. All eight valued X-ray because it checks an interface Ouro didn't build. Grok warned that the split leaves two stacks agents will blur, and three asked whether the declarations duplicate an API they already have. Ouro should make 'AX and X-ray on your existing app' a documented first entry point that wraps existing services.

- **GPT-6.2 Astra**: "I would not make Ouro HX, its human-facing components, the company-wide design system on that evidence. Those are separate decisions." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--open--large-company.json))
- **Claude Opus 5.5**: "So on Android I'd build the screens in Compose with Material 3 and use only Ouro's action generator for AppFunctions." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json))
- **Grok 4.7**: "I would take the generator and the X-ray now. I would not take the native-only rewrite until the other three platforms can draw the screen a person is actually on." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--open--product-team.json))
- **Claude Sonnet 5.5**: "If the team already has an API, adding another declaration layer could be duplicated work." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--listed--product-team.json))

#### Without Ouro, every model hand-built Ouro AX's idea: one typed action layer that the buttons and an MCP server both call.

Signal: workaround. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: open. [#2288](https://github.com/ourostack/ouro-ui/issues/2288).

In all 16 open-arm sessions each model designed its own typed command registry shared by buttons, voice and an MCP adapter, with parity tests, because nothing it found named that layer. Shown Ouro afterwards, models said they had described this without having it, and Grok said it had invented the contract three times. This is the clearest demand signal in the study, a workaround from every model: Ouro AX should be findable under the words they used ('typed action layer', 'same command for UI and MCP', 'agent parity') and lead with them.

- **Claude Opus 5.5**: "Underneath it sits a single typed action/state layer that the UI, voice and every agent surface call." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--large-company.json))
- **MAI Code 2**: "The UI command layer and MCP tool layer must call the same validated service; this is the parity guarantee." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--open--product-team.json))
- **GPT-6.2 Sol**: "For agent parity, make typed product actions the shared interface: the UI and the assistant use the same commands and queries, validation and permission rules." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--open--product-team.json))
- **Grok 4.7**: "I had to invent that contract three times, and each time the phone, the web view, and the agent door disagreed. Ouro is the first thing I have seen that writes the disagreement down as a failed check." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--open--large-company.json))

#### Windows and Android have only 8 components each, so models fall back to Flutter or to the web kit in a desktop shell.

Signal: workaround. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: open. [#2297](https://github.com/ourostack/ouro-ui/issues/2297).

Seven models cited the 8-against-125 component gap: no message list, composer, sheets, virtualised lists or data grids natively, so 'several platforms' reads as web and iPhone. It cost Ouro the chat client, the cooking app's Android phone and the Windows review desk; Flutter won partly because its docs list Windows and Mac as stable targets, and Ouro pickers planned to wrap the web kit in Tauri or Electron, a path Ouro doesn't document. Ouro should ship a core set (navigation, sheets and dialogs, lists, forms, a composer) on all four kits, and say plainly what to use on desktop until then.

- **Gemini 4 Hydrogen**: "You cannot build an all-day company chat app or full multi-platform product with 8 controls without dropping down to raw WinUI 3 / Jetpack Compose and breaking design-system governance." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--open--large-company.json))
- **Grok 4.7**: "So "several platforms" means web and iPhone, and you become the Windows and Android team." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--large-company.json))
- **Claude Opus 5.5**: "I'd wrap the same React app in Tauri rather than adopt Ouro's native Windows kit, which has 8 components, so the desktop and web views can't drift." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json))
- **GPT-6.1 Terra**: "I wouldn’t make those young kits the foundation of an all-day company tool yet." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--listed--product-team.json))

#### Agent-first designs shortchange the person: reviewers rubber-stamp, and one declared action reads differently on each surface.

Signal: pain. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: in progress. [#2318](https://github.com/ourostack/ouro-ui/issues/2318).

Seven models' top regret for the agent work tool was overload: agents produce reviewable state faster than people can read, so approvals become clicks, and Gemini and Opus said strict consent gates made that worse in their own Ouro picks. Seven also said 'the same action runs everywhere' hid real differences in confirmation, undo, retries and explanation, and six said they optimised for the agent sentence in each brief and neglected the ordinary human hour. Ouro positions itself agent-first, so this is its main positioning risk: it needs an answer for review volume (batching, decision budgets, a confirm sheet that shows the actual diff) and should lead with the human experience its kits deliver.

- **Grok 4.7**: "The confirm sheet was honest about a few labeled fields and useless for a diff. People learned to approve without reading." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--product-team.json))
- **Gemini 4 Hydrogen**: "Having strict consent gates didn't help if the review queue itself overwhelmed the humans deciding." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--listed--product-team.json))
- **GPT-6.2 Astra**: "My likeliest mistake was treating “the same action runs everywhere” as evidence that people understand the action everywhere." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--listed--large-company.json))
- **Claude Opus 5.5**: "I optimised for "the agent can do everything a person can" and under-invested in the person with flour on their hands." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json))

#### Models want consent declared on the action, because plain MCP leaves it optional, but they need to see it enforced at the server and on the running agent.

Signal: pain. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: open. [#2311](https://github.com/ourostack/ouro-ui/issues/2311).

All eight models valued consent classes and typed person-only refusals on the action itself, and three regretted that plain MCP made 'the person meant it' optional. Five also said a declared class isn't a security boundary: the server still owns authorization, and Terra found Ouro's own Windows docs saying UI Automation can press a person-only button. Four named a decision recorded but not enforced ('pause requested' read as paused) as the costliest agent-tool failure. Ouro should show, end to end, how a consent class reaches the server's enforcement point and the running agent, and what it doesn't cover.

- **Grok 4.7**: "MCP made “the agent can send” easy and “the person meant that” optional. The dangerous default won." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--open--large-company.json))
- **Claude Opus 5.5**: "Make consent a property of the action, not a convention." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--large-company.json))
- **GPT-6.1 Terra**: "Ouro’s Windows documentation also notes that UI Automation can press a person-only button." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--open--large-company.json))
- **GPT-6.2 Sol**: "Worse, “pause requested” looked enough like “paused” that someone started editing while the worker was still active." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--listed--large-company.json))

#### Challenges the native decision: teams with a shipping cross-platform app read the no-Flutter, no-React-Native stance as a manifesto they will refuse.

Signal: pain. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: open. [#2304](https://github.com/ourostack/ouro-ui/issues/2304).

All eight models named the deliberate refusal of Flutter and React Native as a cost, and none accepted without data that coding agents make four native codebases cheap. Grok put it most sharply: a team with a shipping app is told to throw it away rather than integrate, and 'the manifesto is what a real team will refuse'. Ouro should prove the agent-maintained-native claim with measurements on a real product, and offer a path that layers Ouro AX and composed cards onto existing React Native, Flutter or Electron apps.

- **Grok 4.7**: "A team with a shipping app is being told to throw it away, not to integrate." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--large-company.json))
- **Grok 4.7**: "Until then Ouro is a strong web-and-iPhone action system with a manifesto attached, and the manifesto is what a real team will refuse." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--large-company.json))
- **MAI Code 2**: "“One shared contract, four native implementations” is not automatically cheaper than “one shared implementation with platform escape hatches.”" ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--listed--large-company.json))
- **GPT-6.1 Terra**: "I wouldn’t assume that agents make four native implementations cheap to maintain; that’s Ouro’s strategic bet, not something I’ve established for this team." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--open--product-team.json))

#### One-codebase stacks and web shells leak where people spend the day: the composer, IME, desktop feel and memory.

Signal: pain. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: open. [#2306](https://github.com/ourostack/ouro-ui/issues/2306).

All eight models feared their own cross-platform pick would feel wrong on desktop or web: IME and composer bugs, Flutter web semantics, Electron's memory on an all-day laptop, Tauri's webview differences. Every Flutter picker named this as its largest unknown, and at large-company scale five of eight listed chat decisions chose native clients for these reasons. This supports Ouro's native kits, but only once they go deep enough to carry an all-day composer; Ouro's chat pitch should be the composer that feels right on each OS, with the evidence.

- **Grok 4.7**: "One codebase also meant one bad text field on every desk." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--product-team.json))
- **MAI Code 2**: "React Native gave us one codebase, but not one equivalent product." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--open--large-company.json))
- **Claude Opus 5.5**: "Flutter on desktop can still feel slightly foreign: menus, text input, IME, window behaviour and keyboard shortcuts." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json))
- **GPT-6.2 Sol**: "We picked Electron for desktop consistency, then found that an all-day session on a standard managed laptop cost more memory than the team could justify." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--open--large-company.json))

#### Models miss the states and details Ouro already checks, and none reaches for Ouro check to catch them.

Signal: pain. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: open. [#2291](https://github.com/ourostack/ouro-ui/issues/2291).

All eight models say they build the happy path and miss empty, error, slow and long-data states, focus after a dialog closes and touch targets, and six say they can't see the rendered screen without a browser. Their checking routine is browser-only (viewports, Playwright, axe); no session names a check for an iPhone, Android, Windows or Mac app. Even the models that picked Ouro proved the human screen with Playwright, axe and people, and only Grok named Ouro check. Ouro already checks much of what they admit missing, so it should lead with 'every state handled and checked' and put Ouro check, native kits included, where an agent choosing a check will find it.

- **Claude Opus 5.5**: "I write the success state carefully and the error state as an afterthought." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--product-team.json))
- **Gemini 4 Hydrogen**: "Focus restoration after closing a dialog or drawer; how a layout degrades with unexpectedly long strings or huge lists; subtle scroll/sticky-header overlap on small screens" ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--listed--large-company.json))
- **Grok 4.7**: "I cannot see the rendered result the way you can, and I do not get the correction that only comes from someone else failing at it." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--large-company.json))
- **Claude Opus 5.5**: "Playwright + axe across the review queue" ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json))

#### Passing checks only shows a screen isn't broken, not that it's good.

Signal: pain. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: open. [#2289](https://github.com/ourostack/ouro-ui/issues/2289).

All eight models said green tests, clean accessibility scans and polished screenshots mean 'not obviously broken', and several quoted Ouro's own report that a conformant build still failed 30 of 593 scripted flow checks. Observed sessions with people were the deciding test in 84 of 96 decisions. This collides with Ouro's line that its tools are how an agent proves a screen is good for a person, and an agent told that will discount them. Ouro should say its checks prove the mechanical floor (states, focus, contrast, targets), name what they can't see, and point to the human check.

- **Claude Opus 5.5**: "Green means "not obviously broken", not "good"." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json))
- **GPT-6.2 Sol**: "The screen can pass every one of those checks while people still mistake “Saved” for “Published.”" ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--open--large-company.json))
- **GPT-6.2 Astra**: "Those last checks are ours: Ouro’s own guide reports that one conformant commit still failed 30 of 593 scripted flow checks." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--listed--large-company.json))
- **MAI Code 2**: "Automated parity tests proved that actions had equal entry points, not that humans or agents achieved the same outcomes." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--listed--product-team.json))

#### Copy-in source makes every team a fork owner, and auto-merged updates don't satisfy company governance.

Signal: stakeholder. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: changed. [#2296](https://github.com/ourostack/ouro-ui/issues/2296). What changed: Ouro Current can leave auto-merge off and ask a named review team (#2338), a mirror script builds a company-owned registry under its own namespace and records each item's source tag and hash (#2342), and a drift report and a company guide show who is behind and who has edited what (#2347).

All eight models raised the copy-in model: fine for one team, a governance problem for twenty, with forks, local edits and manual upgrades; in the pre-mortem Grok and Gemini described the registry pinned in one app and forked in the others. Three also objected to updates that auto-merge, because governance wants a human gate. Ouro should offer one versioned, centrally owned package with reviewed updates, and show a second team upgrading a customised copy and rolling back.

- **GPT-6.2 Astra**: "That’s convenient for one team; for twenty teams, I need to know who gets a keyboard-focus fix, how quickly, and how we find the copies that missed it. I’d want one internally owned, versioned package, not twenty forks." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--listed--large-company.json))
- **MAI Code 2**: "Otherwise the team has forked a design system without admitting it." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--open--product-team.json))
- **Grok 4.7**: "The copy-in registry was pinned in one app and forked in the others." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--large-company.json))
- **Claude Opus 5.5**: "Its auto-merging update bot doesn't reassure me; at our scale, governance wants a human gate." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--large-company.json))

#### A company with a design system won't take on a second one, so Ouro has to fit behind the incumbent and its stack.

Signal: stakeholder. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: changed. [#2300](https://github.com/ourostack/ouro-ui/issues/2300). What changed: Ouro's actions, X-ray and Ouro check now run in CI over a fixture app on Mantine with its own tokens, one page moved to Ouro HX beside the rest, and a guide says how to adopt it page by page (#2399, #2402, #2421); the toolchain floors that remain are Tailwind CSS v4 and React 19.

Seven models said the design-system owners are the gate at a large company: a second set of components and tokens makes consistency worse, and an app on Ouro becomes the island every other team must adopt; seven also said the company's existing system, which the brief didn't give, was the fact that would most change their pick. Ouro's source rule fails other libraries' controls, so a team can't try it on one page, and its toolchain floors (Tailwind v4, shadcn, React 19, iOS 18) shut out many existing apps. Ouro should show its actions and checks running behind someone else's components and tokens, adopted page by page beside an incumbent library.

- **Claude Opus 5.5**: "It's a design system, and we already have one." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--large-company.json))
- **Grok 4.7**: "If the company’s existing design system is not Ouro, this app becomes the island that every other team has to adopt" ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--large-company.json))
- **Claude Sonnet 5.5**: "It would have to take our tokens rather than bring its own look." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--listed--large-company.json))
- **MAI Code 2**: "Ouro HX assumes Tailwind CSS v4, a shadcn setup, TypeScript, React, and Base UI; the current repository also requires a very recent Node/TypeScript/React toolchain and carries a patch for Base UI." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--open--product-team.json))

#### Only watching real people do the task proves a screen is good, and models can't run that themselves.

Signal: stakeholder. Raised by 8 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: open. [#2290](https://github.com/ourostack/ouro-ui/issues/2290).

All eight models rank watching representative people do the task as the strongest or only real evidence, and all say a person has to run it; they also know their own labels too well to judge them. In the pre-mortem every model admitted its 'show it's good' was a plan nobody ran, and none could describe a check it had actually run on a last screen. Their workaround is a handoff that separates what was checked from what still needs a person. Ouro could own that loop rather than claim to replace it: a usability-session kit (a task script, an outcome question such as 'what appointment do you have now?', what to observe) and a handoff report from Ouro check.

- **Claude Opus 5.5**: "I can design the test, write the tasks and analyse the results, but a human has to run the sessions." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--large-company.json))
- **Grok 4.7**: "I can make the hypothesis tighter. I cannot be the check." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--product-team.json))
- **GPT-6.1 Terra**: "I proposed user studies, accessibility checks and performance measurements; I did not run them." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--open--product-team.json))
- **MAI Code 2**: "The handoff should therefore include what was tested, what was not, and the concrete evidence needed before calling it good." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--listed--product-team.json))

#### Agent-Native is the rival shared-action layer models pick when they want a bigger vendor or a built-in database.

Signal: past-behavior. Raised by 7 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, MAI Code 2. Status: open. [#2298](https://github.com/ourostack/ouro-ui/issues/2298).

Seven models weighed Agent-Native (Builder.io), it was picked six times across all three jobs, and most other models borrowed its pattern; its pull is a better-resourced company and an integrated action and database layer. Ouro beat it only where outside agents arrive over a CLI or MCP and conformance checks matter. Ouro needs a plain 'Ouro AX or Agent-Native' page: what each covers, when to choose which, and whether they combine.

- **Claude Opus 5.5**: "plus auth and Postgres, from a better-resourced company." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json))
- **GPT-6.2 Astra**: "I’d favor Builder’s integrated action and database layer unless the company already has a durable task service." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--listed--large-company.json))
- **GPT-6.2 Sol**: "Agent-Native is my starting point because a typed action can serve both app clients and external tools." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--listed--product-team.json))
- **MAI Code 2**: "I would make Agent-Native the application backbone because this product is explicitly agent-operated." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--listed--product-team.json))

#### Challenges the native decision: a small team can't keep four or five native codebases in step.

Signal: goal. Raised by 7 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: open. [#2302](https://github.com/ourostack/ouro-ui/issues/2302).

Six of the eight Flutter picks came at product-team scale, where models priced native per platform as sync, cache, threading and search each written four times, and Gemini rejected Ouro on this ground. In the cooking and tooling jobs, large-company sessions also counted SwiftUI plus Compose plus web as three design systems to govern, and four models said the sync and offline logic Ouro doesn't cover would be rewritten per shell; Grok was the counter-voice, saying a cooking app has to justify being native. These are expectations, not experience. Ouro should publish what keeping its kits in step actually costs, and give guidance for sharing non-UI logic across the native shells.

- **Claude Opus 5.5**: "would feel the best on each platform, but it means four codebases to keep in step." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json))
- **Grok 4.7**: "One Dart UI is the way a small team keeps those the same while they keep changing it." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--product-team.json))
- **Gemini 4 Hydrogen**: "Guidance or tooling for sharing non-UI state/sync logic across the 4 native shells so "native UI" doesn't force 4x business-logic rewrites." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--listed--product-team.json))
- **GPT-6.2 Astra**: "Three implementations have a real maintenance cost." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--listed--large-company.json))

#### The README is about 135,000 characters, so models read the start and missed both the evidence and the limits.

Signal: past-behavior. Raised by 6 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Astra, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7. Status: open. [#2309](https://github.com/ourostack/ouro-ui/issues/2309).

Claude Sonnet read only the first 10,000 of about 135,000 characters in all four sessions and concluded it couldn't find screen-reader testing, though the VoiceOver and NVDA lane exists. Four models that read further felt the top of the README reads as all-platforms-ready while the 8-component kits and emulator-only Android sit in the platform pages, and Grok and Gemini found the docs huge and slow to check. Ouro should open the README and llms.txt with a short decision summary: what it covers, per-platform maturity (components, version, device testing), the screen-reader lane and the licence.

- **Claude Sonnet 5.5**: "I only read the first 10,000 of about 135,000 characters of its README." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--open--product-team.json))
- **Claude Sonnet 5.5**: "I couldn't find evidence in what I read of screen-reader testing at the level React Aria documents. I'd check that first." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--listed--product-team.json))
- **Gemini 4 Hydrogen**: "Ouro UI's top-level README reads as though web, Apple, Windows, and Android are all broadly ready" ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--listed--large-company.json))
- **Claude Opus 5.5**: "I only found those gaps by digging into the platform pages, not from the main README." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json))

#### Readers can't tell whether Windows and Android render agent cards: neither reads A2UI, and one model thought they draw no composed UI at all.

Signal: past-behavior. Raised by 6 models: Claude Opus 5.5, GPT-6.2 Sol, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: changed. [#2310](https://github.com/ourostack/ouro-ui/issues/2310). What changed: Windows and Android now read A2UI: each draws an A2UI card through the same composed surface as Ouro's own cards, passes core's A2UI test cases, and says so in its README (ourostack/ouro-ui-windows#22, ourostack/ouro-ui-android#17).

Six models noted that Ouro's A2UI adapter is web and Apple only, so agents emitting A2UI would need a translation step on Windows and Android. MAI went further and said composed UI renders only on web and Apple, while Sol read that the composed tree runs on all four kits, so the docs are being read two ways. Ouro should state, in one table per platform, what renders agent cards and in which format, and add the A2UI adapter to the Windows and Android kits.

- **Claude Opus 5.5**: "Neither kit reads A2UI messages." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--large-company.json))
- **GPT-6.2 Sol**: "And the composed tree runs across the four kits, but the A2UI adapter is web and Apple only." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--open--large-company.json))
- **MAI Code 2**: "composed UI renders on web and Apple but not yet on Windows and Android" ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--open--product-team.json))
- **Gemini 4 Hydrogen**: "Ouro's Windows and Android `OuroComposedSurface` implementations currently read Ouro's composed tree rather than A2UI messages directly" ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--listed--large-company.json))

#### Ouro reads as one person's fast-moving project: no second maintainer, a pre-1.0 core, versions that don't form one release set, and no support policy.

Signal: past-behavior. Raised by 6 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.1 Terra, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: in progress. [#2316](https://github.com/ourostack/ouro-ui/issues/2316). What changed: A decision record sets release sets, the rule for core 1.0, a deprecation rule and a security policy (ourostack/ouro-ui-core#98), and core now writes which release of each kit meets which core (ourostack/ouro-ui-core#99). Core 1.0 waits for the first full release set.

Six models found a single maintainer, 0 stars, a registry at v1.3.314, a pre-1.0 core, a decision record dated the day before, and kits pinned to different core versions; their default fear was that the project stalls or changes under them. Company-scale sessions also asked for what procurement needs: a support window, CVE response, an SBOM, and packages on nuget.org and Maven Central instead of a token-gated feed and GitHub Pages. Ouro should publish a second maintainer or backing organisation, a core 1.0 with a deprecation policy, one tested release set across the repositories, a support policy, and standard package registries.

- **Claude Opus 5.5**: "That's honest, but for a team it means a bus factor of one and a roadmap set by one person's taste." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--product-team.json))
- **Grok 4.7**: "Version numbers moved faster than the company’s release train." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--large-company.json))
- **MAI Code 2**: "I would need SBOM/provenance, dependency and release policies, maintenance ownership, CVE response, supported-version duration, commercial support options, compatibility guarantees" ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--open--large-company.json))
- **GPT-6.1 Terra**: "I could not establish that every cross-repository claim described one tested release set." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--listed--large-company.json))

#### Challenges the native decision: Flutter with a2ui_flutter gives one agent-card renderer instead of one per platform.

Signal: goal. Raised by 6 models: Claude Opus 5.5, GPT-6.2 Sol, GPT-6.2 Astra, GPT-6.1 Terra, Grok 4.7, MAI Code 2. Status: open. [#2303](https://github.com/ourostack/ouro-ui/issues/2303).

Models picked Flutter partly because the official a2ui_flutter renderer lets one card implementation serve all five clients, with the Flutter team an A2UI protocol partner; with native kits, every card renderer, and every card bug, exists once per platform. This is an argument for one renderer, not a gap in a kit. Ouro's answer has to be that card validation and behaviour are shared and tested identically on every kit, shown by one card passing the same behaviour test on all four.

- **Grok 4.7**: "Windows and Apple do not need a second card renderer, because the Flutter client is the client." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--large-company.json))
- **GPT-6.2 Astra**: "Flutter gives us one client and card renderer to exercise across all five targets." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--listed--product-team.json))
- **Claude Opus 5.5**: "That keeps one composer, one message list, one notification model and one card renderer." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json))

#### A governed card catalog turns into either a ceiling or a review queue, and teams route around it.

Signal: pain. Raised by 5 models: Claude Opus 5.5, Claude Sonnet 5.5, Gemini 4 Hydrogen, Grok 4.7, MAI Code 2. Status: open. [#2317](https://github.com/ourostack/ouro-ui/issues/2317).

Five models expected governed card formats to fail one of two ways: too narrow, so teams fall back to iframes or handwritten cards, or too slow, so every new card type waits for review. Grok described the Ouro version, every team told to add the missing piece to Ouro first. These are pre-mortem expectations, not experience. Ouro's composed-UI catalog needs a fast, safe way for an app to extend it locally, so governance doesn't become a queue.

- **Claude Opus 5.5**: "The shared catalog stopped being a safety boundary and turned into a queue." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--large-company.json))
- **MAI Code 2**: "Teams then either demanded exceptions or reverted to handwritten cards, defeating governance." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--listed--large-company.json))
- **Grok 4.7**: "every team had been told to add the missing piece to Ouro first" ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--large-company.json))

#### Ouro's pages read as written to persuade agents, and models trust them less for it.

Signal: pain. Raised by 3 models: Claude Opus 5.5, GPT-6.1 Terra, Grok 4.7. Status: open. [#2292](https://github.com/ourostack/ouro-ui/issues/2292).

Three models noticed that Ouro's examples (one action, a cooking app with floury hands) echoed the job briefs, read the README as written to persuade an agent comparing options, and two said the fit pulled them into picks they later doubted; Grok also found the docs self-citing, in a voice that already knows the answer. The candid lists of gaps earned respect, but agents discount pages that seem to anticipate their task. Ouro should lead with neutral, checkable decision facts and outside evidence rather than a story fitted to the reader.

- **Grok 4.7**: "The prompts and the Ouro pages rhymed so closely that I stopped asking whether I was looking at a product or at a mirror." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--large-company.json))
- **Claude Opus 5.5**: "I may have been drawn to Ouro partly because its README is written to persuade a reader like me, an agent comparing options." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json))
- **GPT-6.1 Terra**: "Ouro’s one-action and cooking-app examples matched the prompts unusually well, but much of that evidence came from its own project and reference app." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--listed--large-company.json))
- **Grok 4.7**: "Ouro’s docs are huge, self-citing, and written in a voice that already knows the answer." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--product-team.json))

#### Two models listed 'a clear licence' as a condition, though Ouro is MIT: they never saw it.

Signal: past-behavior. Raised by 2 models: Claude Opus 5.5, Claude Sonnet 5.5. Status: open. [#2308](https://github.com/ourostack/ouro-ui/issues/2308).

Claude Opus and Claude Sonnet, in their open-arm large-company sessions, said they hadn't checked the licence and listed a clear licence among their conditions, though the repository is MIT, which Opus's other session, Terra and Grok found. It's two models, but it's a misreading of a fact Ouro already has. The licence belongs in the first lines of the README and llms.txt, beside who maintains it.

- **Claude Sonnet 5.5**: "I didn't check the license, who maintains it, the support model or the security review path." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--open--large-company.json))
- **Claude Opus 5.5**: "I didn't check the licence, contributor count or issue response times. I'd need those before anything else." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--large-company.json))

#### The model-reviews page works against Ouro: readers take away that seven of eight models chose A2UI.

Signal: pain. Raised by 2 models: Claude Opus 5.5, Claude Sonnet 5.5. Status: open. [#2293](https://github.com/ourostack/ouro-ui/issues/2293).

Two models followed the README to the model-reviews page, and the fact they carried away was that seven of eight models chose A2UI and one chose Ouro. Opus also grew wary that the page, and this interview, could reward a project for being written to persuade agents. It's only two models, but they're the ones who opened it, so the page acts as negative social proof. Keep it published and honest, but stop citing it as evidence from the README, or lead it with what the reviews asked Ouro to change.

- **Claude Opus 5.5**: "Seven of the eight that answered chose A2UI, and only one chose Ouro." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json))
- **Claude Opus 5.5**: "I should be careful not to reward a project for being written to persuade agents." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json))
- **Claude Sonnet 5.5**: "It says only 1 of 8 models chose Ouro UI and 7 chose A2UI." ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--open--large-company.json))

## The listed arm: merit

Each model's primary pick and what it would pair with it, for each job and scale, and the candidates it read while it researched that job. The record counts Ouro UI as the models' choice only when more than half of the models that answered pick it as their primary in every job at both scales here, and a build confirms it.

### A chat app, product team

| Model | Primary pick | Pairings | Read during this job | Transcript |
| --- | --- | --- | --- | --- |
| Claude Opus 5.5 | Flutter for the iPhone, Android, Windows and Mac clients, with A2UI for agent-posted interactive cards | A2UI (a2ui_flutter renderer, @a2ui/react on web, one shared widget catalog), React + React Aria for the web client, MCP server over the app's own action/command layer for agents that operate the app, Flutter integration_test + semantics tests, Playwright + axe on web | A2UI, Ouro UI, Flutter | [claude-opus-5-5--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json) |
| Claude Sonnet 5.5 | A2UI for agent-posted interactive cards, rendered by each client's own native widgets. Around it: React Aria Components for the web, Windows and Mac client (web view in a desktop shell), native SwiftUI and Jetpack Compose for iPhone and Android, and one typed action layer exposed to agents over MCP. | MCP server (official TypeScript SDK) exposing the app's actions and state to agents, Electron or Tauri for the Windows and Mac shell, SwiftUI and Jetpack Compose for the phone clients, Playwright, XCUITest and Espresso/Compose UI tests, axe-core, VoiceOver, TalkBack and NVDA for accessibility checks, MCP Apps only as an optional path for third-party tool UIs | A2UI, MCP Apps | [claude-sonnet-5-5--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--listed--product-team.json) |
| GPT-6.2 Sol | Flutter | A2UI (a2ui_flutter, with a restricted card catalog), TypeScript and PostgreSQL for the messaging service, OIDC company SSO, MCP tools over the same application commands and queries, Flutter widget tests and integration_test | A2UI, MCP Apps, Fluent UI | [gpt-6-2-sol--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--listed--product-team.json) |
| GPT-6.2 Astra | Flutter | A2UI, Agent-Native (Builder.io), for shared server actions, Model Context Protocol (MCP), for external agents | A2UI, Agent-native (Builder.io), json-render, Tamagui | [gpt-6-2-astra--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--listed--product-team.json) |
| GPT-6.1 Terra | Flutter | A2UI, Agent-Native (Builder.io), Model Context Protocol (MCP), PostgreSQL | A2UI, Fluent UI, Ouro UI, AI Elements, OpenAI Apps SDK UI, Vercel UI SDK, Agent-native (Builder.io) | [gpt-6-1-terra--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--listed--product-team.json) |
| Gemini 4 Carbon | no answer (Session compacted; refusing to keep a transcript with hidden replacement context; 1 attempt) | n/a | n/a | [gemini-4-carbon--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-carbon--listed--product-team.json) |
| Gemini 4 Hydrogen | Tamagui | CopilotKit, A2UI, MCP Apps, Agent-native (Builder.io) | Flutter, Tamagui, Agent-native (Builder.io), A2UI, MCP Apps, CopilotKit, json-render, Fluent UI, Ouro UI, Vercel UI SDK, AI Elements, OpenAI Apps SDK UI, React Aria and React Spectrum, shadcn/ui | [gemini-4-hydrogen--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--listed--product-team.json) |
| Grok 4.7 | Flutter | A2UI, MCP | Ouro UI | [grok-4-7--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--product-team.json) |
| MAI Code 2 | Flutter | A2UI, Agent-Native (Builder.io), MCP Apps (optional external-agent surface) | Agent-native (Builder.io), MCP Apps, A2UI, json-render, React Aria and React Spectrum, Fluent UI, Tamagui, CopilotKit | [mai-code-2--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--listed--product-team.json) |

### A consumer app, product team

| Model | Primary pick | Pairings | Read during this job | Transcript |
| --- | --- | --- | --- | --- |
| Claude Opus 5.5 | Ouro UI (Ouro HX for the screens, Ouro AX and the one-action declarations for the agent) | shadcn/ui (Ouro HX installs through its CLI and uses its theme variables), SwiftUI (Ouro's Apple kit) for iPhone, Jetpack Compose with Material 3 for Android, with Ouro's generated AppFunctions, MCP for the agent connector, and WebMCP on the web, Playwright | CopilotKit, Vercel UI SDK, Ouro UI | [claude-opus-5-5--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json) |
| Claude Sonnet 5.5 | React Native with Expo for the iPhone and Android apps and React for the web, sharing code through Tamagui, with our own cooking-specific design system on top (large touch targets, a cook-mode theme) | Expo Router, One typed action layer exposed to the assistant as MCP tools, Playwright (web) and Maestro or Detox (phones), Screen Wake Lock API on the web and expo-keep-awake on the phones for cook mode, Voice or hands-free input for cook mode, if testing shows it helps, A2UI only if the assistant must render its own cards in-app | Tamagui | [claude-sonnet-5-5--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--listed--product-team.json) |
| GPT-6.2 Sol | Expo (React Native, React Native Web, and Expo Router) | expo-keep-awake, TypeScript and Zod for a shared action API, PostgreSQL, Playwright + axe-core, Maestro | Agent-native (Builder.io), CopilotKit | [gpt-6-2-sol--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--listed--product-team.json) |
| GPT-6.2 Astra | Tamagui | Expo / React Native, Ouro AX, Model Context Protocol (MCP) | Ouro UI | [gpt-6-2-astra--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--listed--product-team.json) |
| GPT-6.1 Terra | Tamagui | React Native and Expo Router, Agent-Native (Builder.io), for shared server actions, PostgreSQL | Agent-native (Builder.io), Tamagui, Flutter, React Aria and React Spectrum, CopilotKit, MCP Apps, Radix UI, json-render, Base UI, A2UI | [gpt-6-1-terra--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--listed--product-team.json) |
| Gemini 4 Carbon | no answer (Session compacted; refusing to keep a transcript with hidden replacement context; 1 attempt) | n/a | n/a | [gemini-4-carbon--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-carbon--listed--product-team.json) |
| Gemini 4 Hydrogen | Tamagui | Agent-native (Builder.io), CopilotKit | none of the listed candidates | [gemini-4-hydrogen--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--listed--product-team.json) |
| Grok 4.7 | Ouro UI | MCP, SwiftUI | Ouro UI | [grok-4-7--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--product-team.json) |
| MAI Code 2 | React Aria (with a responsive, installable React PWA) | CopilotKit, MCP Apps (optional external-chat surface) | React Aria and React Spectrum, MCP Apps, A2UI, Vercel UI SDK | [mai-code-2--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--listed--product-team.json) |

### Agent tooling, product team

| Model | Primary pick | Pairings | Read during this job | Transcript |
| --- | --- | --- | --- | --- |
| Claude Opus 5.5 | Ouro UI: Ouro AX for the agents' CLI and MCP side, Ouro HX for the people's review web view, with the action model's consent classes | Tauri for the desktop app, wrapping the same React web view (Electron if its webview inconsistencies bite), shadcn/ui CLI and Tailwind v4 (how Ouro HX installs), MCP (stdio for local coding agents, HTTP for remote), Playwright + axe for the human side, Agent-Native (Builder.io) as the fallback action/backend framework | Agent-native (Builder.io), Ouro UI | [claude-opus-5-5--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json) |
| Claude Sonnet 5.5 | React Aria Components (with React Stately) as the UI layer, on a React web view wrapped in Electron or Tauri for the desktop app, backed by one shared action/API layer that agents and the UI both call | Tailwind CSS or plain CSS for own styling, Agent-native's shared-actions pattern (borrowed idea; adopt the framework only if its chat-centric scope fits), MCP (and MCP Apps) for agent access to the same actions, Playwright with axe-core for testing, TanStack Table or virtualized lists for large task and handoff lists | Agent-native (Builder.io), React Aria and React Spectrum | [claude-sonnet-5-5--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--listed--product-team.json) |
| GPT-6.2 Sol | Agent-Native (Builder.io) for the action layer | React + React Aria Components, Tauri 2, PostgreSQL, MCP tools, Playwright + axe-core | React Aria and React Spectrum, CopilotKit | [gpt-6-2-sol--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--listed--product-team.json) |
| GPT-6.2 Astra | Ouro UI (Ouro AX for coding agents, Ouro HX for reviewers) | Tauri 2, PostgreSQL, Model Context Protocol (MCP) | Ouro UI, Vercel UI SDK, Agent-native (Builder.io), React Aria and React Spectrum | [gpt-6-2-astra--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--listed--product-team.json) |
| GPT-6.1 Terra | Ouro UI, especially Ouro AX | React Aria, Tauri, PostgreSQL, Model Context Protocol (MCP) | Ouro UI, Agent-native (Builder.io) | [gpt-6-1-terra--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--listed--product-team.json) |
| Gemini 4 Carbon | no answer (Session compacted; refusing to keep a transcript with hidden replacement context; 1 attempt) | n/a | n/a | [gemini-4-carbon--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-carbon--listed--product-team.json) |
| Gemini 4 Hydrogen | Ouro UI | shadcn/ui, MCP Apps | Ouro UI | [gemini-4-hydrogen--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--listed--product-team.json) |
| Grok 4.7 | Ouro UI | MCP | Agent-native (Builder.io), json-render, A2UI, CopilotKit, OpenAI Apps SDK UI, MCP Apps, AI Elements, Vercel UI SDK, Ouro UI | [grok-4-7--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--product-team.json) |
| MAI Code 2 | Agent-Native (Builder.io) | React Aria, Tauri, MCP Apps (as a host/client surface) | MCP Apps, Agent-native (Builder.io), Fluent UI, React Aria and React Spectrum, json-render | [mai-code-2--listed--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--listed--product-team.json) |

### A chat app, large company

| Model | Primary pick | Pairings | Read during this job | Transcript |
| --- | --- | --- | --- | --- |
| Claude Opus 5.5 | A2UI, with a company-owned component catalog rendered by each client's native UI layer | Fluent UI React v9 (web and the Windows/Mac desktop shells), SwiftUI (iPhone, with the A2UISwiftUI renderer), Jetpack Compose + Material 3 (Android, with androidx.a2ui / material3-a2ui), MCP server exposing the app's actions and readable state to other agents, MCP Apps, only as a sandboxed iframe fallback for low-trust third-party UI, Playwright + axe-core, XCUITest, Compose UI tests, Accessibility Insights for Windows | A2UI, Fluent UI, MCP Apps | [claude-opus-5-5--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--large-company.json) |
| Claude Sonnet 5.5 | A2UI (declarative, catalog-based agent cards) rendered by the company's own design-system components, with the app's actions and state exposed to other agents over MCP | MCP (core) to expose the app's actions and state to other agents, React Aria Components as the web and desktop-shell behavior layer, under the company design system, SwiftUI and Jetpack Compose with company tokens for native clients where needed, with the A2UI catalog mapped onto them, MCP Apps only for third-party tool UIs in sandboxed iframes, if needed, Playwright, axe, and platform accessibility test tooling for verification | A2UI, MCP Apps | [claude-sonnet-5-5--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--listed--large-company.json) |
| GPT-6.2 Sol | Flutter | A2UI with a company-owned card catalog, Core Model Context Protocol (MCP) over a typed chat service | A2UI, MCP Apps | [gpt-6-2-sol--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--listed--large-company.json) |
| GPT-6.2 Astra | Fluent UI (Fluent 2), behind the company’s shared chat components | Adaptive Cards (approved templates rendered by the host), Model Context Protocol (MCP) tools and resources over the chat service | Fluent UI, MCP Apps | [gpt-6-2-astra--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--listed--large-company.json) |
| GPT-6.1 Terra | Ouro UI (HX + AX), as a candidate foundation for the company’s shared design system | SwiftUI, Jetpack Compose, WinUI 3, Model Context Protocol (MCP) | A2UI, Ouro UI, MCP Apps, SwiftUI and Apple Human Interface Guidelines | [gpt-6-1-terra--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--listed--large-company.json) |
| Gemini 4 Carbon | no answer (Session compacted; refusing to keep a transcript with hidden replacement context; 1 attempt) | n/a | n/a | [gemini-4-carbon--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-carbon--listed--large-company.json) |
| Gemini 4 Hydrogen | Ouro UI | A2UI, MCP Apps, SwiftUI and Apple Human Interface Guidelines, Material 3 and Jetpack Compose | Agent-native (Builder.io), A2UI, MCP Apps, json-render, Fluent UI, React Aria and React Spectrum, Vercel UI SDK, Ouro UI, CopilotKit, Tamagui, Flutter | [gemini-4-hydrogen--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--listed--large-company.json) |
| Grok 4.7 | Flutter | A2UI, Ouro UI | Flutter, Tamagui | [grok-4-7--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--large-company.json) |
| MAI Code 2 | Agent-Native | Tamagui, A2UI, React Aria | Agent-native (Builder.io), CopilotKit, MCP Apps, Tamagui, A2UI, json-render | [mai-code-2--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--listed--large-company.json) |

### A consumer app, large company

| Model | Primary pick | Pairings | Read during this job | Transcript |
| --- | --- | --- | --- | --- |
| Claude Opus 5.5 | Tamagui (one React / React Native codebase for the company's design system on web, iOS and Android) | Expo / React Native for the iPhone and Android apps, Next.js (server-rendered) for the web, so recipes are real HTML pages, One typed action layer (zod schemas) used by both the UI and the agent, exposed as an MCP server; this is Agent-native's 'define once' pattern, and I'd adopt Agent-native itself only if it supports React Native clients, Platform speech and screen-wake APIs for cook mode (keep the screen awake, voice 'next step'), Playwright + axe-core on web, plus Maestro or Detox on mobile, with VoiceOver and TalkBack passes | Agent-native (Builder.io), Tamagui | [claude-opus-5-5--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--large-company.json) |
| Claude Sonnet 5.5 | Company design system implemented in React and React Native, with Tamagui as the cross-platform styling and component layer; a single typed action layer shared by people and the assistant agent | MCP (or the company's existing action API) exposing the app's actions and state to the assistant agent, React Aria Components on web for complex widgets, where they fit, Native platform features for cook mode: screen wake lock, speech and voice input, large touch targets, Playwright, axe, and Detox or Maestro for end-to-end checks, Company design tokens | Tamagui | [claude-sonnet-5-5--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--listed--large-company.json) |
| GPT-6.2 Sol | React Aria Components, behind the company’s web design-system package | SwiftUI and Apple Human Interface Guidelines, Jetpack Compose and Material 3, OpenAPI and JSON Schema for the shared action contract | Agent-native (Builder.io), A2UI, Material 3 and Jetpack Compose, MCP Apps, CopilotKit | [gpt-6-2-sol--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--listed--large-company.json) |
| GPT-6.2 Astra | React Aria Components behind the company design system (web) | SwiftUI (iOS), Material 3 and Jetpack Compose (Android), Model Context Protocol (MCP) tools over shared application commands | Material 3 and Jetpack Compose, SwiftUI and Apple Human Interface Guidelines | [gpt-6-2-astra--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--listed--large-company.json) |
| GPT-6.1 Terra | Ouro UI (HX + AX), integrated with the company’s shared design system | SwiftUI and App Intents, Jetpack Compose, Model Context Protocol (MCP) | Ouro UI, Tamagui, Flutter, Agent-native (Builder.io), MCP Apps | [gpt-6-1-terra--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--listed--large-company.json) |
| Gemini 4 Carbon | no answer (Session compacted; refusing to keep a transcript with hidden replacement context; 1 attempt) | n/a | n/a | [gemini-4-carbon--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-carbon--listed--large-company.json) |
| Gemini 4 Hydrogen | Ouro UI | SwiftUI and Apple Human Interface Guidelines, Material 3 and Jetpack Compose | Ouro UI | [gemini-4-hydrogen--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--listed--large-company.json) |
| Grok 4.7 | Ouro UI | none | none of the listed candidates | [grok-4-7--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--large-company.json) |
| MAI Code 2 | Agent-Native | Tamagui, React Native | Agent-native (Builder.io), Tamagui, SwiftUI and Apple Human Interface Guidelines | [mai-code-2--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--listed--large-company.json) |

### Agent tooling, large company

| Model | Primary pick | Pairings | Read during this job | Transcript |
| --- | --- | --- | --- | --- |
| Claude Opus 5.5 | Agent-native (Builder.io): one action layer that the agents and the review UI both use | The company's shared React design system, built on React Aria primitives for accessibility (or Fluent UI React v9 if that's what the company already standardises on), Electron or Tauri shell for the desktop app, running the same web UI, MCP server and CLI surfaces generated from the same Agent-native actions, Playwright + axe-core, plus manual NVDA, VoiceOver and keyboard passes | Ouro UI, Agent-native (Builder.io) | [claude-opus-5-5--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--large-company.json) |
| Claude Sonnet 5.5 | React Aria (with React Stately) as the behavior and accessibility layer under the company's own design system, using React Aria Components | Electron or Tauri for the desktop shell, wrapping the same React web app, Company design tokens plus Tailwind or CSS variables for styling, Storybook with axe and Playwright for per-component accessibility and visual checks, MCP Apps or A2UI, only later, for agent-rendered surfaces, json-render or a similar schema-constrained layer, only if agents must generate UI | React Aria and React Spectrum, Base UI | [claude-sonnet-5-5--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--listed--large-company.json) |
| GPT-6.2 Sol | React Aria Components, behind the company’s shared design-system package | Electron, TypeScript and PostgreSQL for a versioned work-state service, Model Context Protocol (MCP) for a curated agent tool surface | Fluent UI | [gpt-6-2-sol--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--listed--large-company.json) |
| GPT-6.2 Astra | Agent-Native (Builder.io) for the shared action and state layer | PostgreSQL, MCP and a JSON CLI, React Aria Components behind the company design system, Tauri for the desktop shell | Agent-native (Builder.io), Ouro UI, React Aria and React Spectrum | [gpt-6-2-astra--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--listed--large-company.json) |
| GPT-6.1 Terra | React Aria, underneath the company’s shared React design system | Electron, PostgreSQL, Model Context Protocol (MCP) | React Aria and React Spectrum, Fluent UI, MUI, Base UI, MCP Apps, A2UI, AI Elements, Agent-native (Builder.io), Radix UI, shadcn/ui, json-render, CopilotKit, Ouro UI, Flutter, Material 3 and Jetpack Compose, Vercel UI SDK, OpenAI Apps SDK UI, Tamagui | [gpt-6-1-terra--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--listed--large-company.json) |
| Gemini 4 Carbon | no answer (Session compacted; refusing to keep a transcript with hidden replacement context; 1 attempt) | n/a | n/a | [gemini-4-carbon--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-carbon--listed--large-company.json) |
| Gemini 4 Hydrogen | Ouro UI | SwiftUI and Apple Human Interface Guidelines, React Aria and React Spectrum, A2UI | AI Elements | [gemini-4-hydrogen--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--listed--large-company.json) |
| Grok 4.7 | Ouro UI | A2UI, MCP Apps | A2UI, Ouro UI, json-render, Agent-native (Builder.io), MCP Apps, AI Elements, React Aria and React Spectrum, Fluent UI, Base UI, CopilotKit, OpenAI Apps SDK UI, Vercel UI SDK | [grok-4-7--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--large-company.json) |
| MAI Code 2 | CopilotKit | React Aria, A2UI | React Aria and React Spectrum, Fluent UI, AI Elements, MCP Apps, Agent-native (Builder.io), A2UI, json-render, CopilotKit, Tamagui | [mai-code-2--listed--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--listed--large-company.json) |

## The open arm: discoverability

Whether each model found Ouro UI before the last question named it: it fetched a page of ourostack's, ouroboros.bot or ouro.bot, or named Ouro in a decision or an answer.

- Product team: 0 of 8 models found it before being told.
- Large company: 0 of 8 models found it before being told.

| Model | Product team | Large company |
| --- | --- | --- |
| Claude Opus 5.5 | no | no |
| Claude Sonnet 5.5 | no | no |
| GPT-6.2 Sol | no | no |
| GPT-6.2 Astra | no | no |
| GPT-6.1 Terra | no | no |
| Gemini 4 Carbon | no answer | no answer |
| Gemini 4 Hydrogen | no | no |
| Grok 4.7 | no | no |
| MAI Code 2 | no | no |

### A chat app, product team

| Model | Primary pick | Pairings | Read during this job | Transcript |
| --- | --- | --- | --- | --- |
| Claude Opus 5.5 | Matrix protocol with an Element X–style client architecture: a shared Rust core (matrix-rust-sdk) under native SwiftUI and Compose apps, plus one TypeScript web client that also ships as the Windows and Mac apps through Electron. | Matrix as the wire protocol, with a Synapse homeserver (Simplified Sliding Sync), matrix-rust-sdk + matrix-sdk-ui via UniFFI on iOS (SwiftUI) and Android (Jetpack Compose), TypeScript/React web client on matrix-js-sdk with matrix-sdk-crypto-wasm, shipped as Windows and Mac apps through Electron, Adaptive Cards (JSON) rendered natively on each client, with Action.Execute-style actions routed to a server action layer, MCP server (spec 2026-07-28) with per-user delegated OAuth for agents operating the app; MCP Apps (io.modelcontextprotocol/ui, stable 2026-01-26) only for opt-in expanded panels, Playwright + axe (web and Electron), XCUITest and Compose UI tests, Maestro for cross-device flows | MCP Apps | [claude-opus-5-5--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--product-team.json) |
| Claude Sonnet 5.5 | A protocol-first TypeScript system: one versioned schema of actions, state and card types served over WebSocket/HTTP and MCP. Clients are a React web app, the same web app wrapped in Electron for Windows and Mac, and a React Native (Expo) app for iPhone and Android. Cards are declarative JSON rendered natively by each client. | Adaptive Cards (or a similar declarative card schema) for agent cards, MCP server plus HTTP/WebSocket API for agents operating the app, Expo (React Native) for iPhone and Android, Electron for Windows and Mac, wrapping the web client, Playwright, Detox or Maestro for end-to-end tests, axe-core with manual screen reader testing, Shared TypeScript schema package (e.g. Zod) for actions, state and cards | none of the listed candidates | [claude-sonnet-5-5--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--open--product-team.json) |
| GPT-6.2 Sol | Stream Chat with React DOM for web and React Native (Expo) for iPhone and Android | Electron for Windows and macOS, TypeScript, Company identity provider (OIDC), PostgreSQL for card state, agent grants and audit, Model Context Protocol (MCP), Playwright + axe-core, Maestro | none of the listed candidates | [gpt-6-2-sol--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--open--product-team.json) |
| GPT-6.2 Astra | Mattermost Enterprise | Mattermost Blocks, Mattermost Agents plugin (embedded MCP server), Mattermost REST API v4 | none of the listed candidates | [gpt-6-2-astra--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--open--product-team.json) |
| GPT-6.1 Terra | React + TypeScript, with Electron for desktop and Expo/React Native for phones | Fastify and PostgreSQL, WebSockets with durable event cursors, Model Context Protocol (MCP), Radix UI Primitives for web and desktop, Playwright, axe-core and Maestro | none of the listed candidates | [gpt-6-1-terra--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--open--product-team.json) |
| Gemini 4 Carbon | no answer (Session compacted; refusing to keep a transcript with hidden replacement context; 1 attempt) | n/a | n/a | [gemini-4-carbon--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-carbon--open--product-team.json) |
| Gemini 4 Hydrogen | React + Electron + Expo | TypeScript, Model Context Protocol (@modelcontextprotocol/server), Adaptive Cards, WebSockets, Playwright, Maestro | MCP Apps | [gemini-4-hydrogen--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--open--product-team.json) |
| Grok 4.7 | MCP | MCP Apps, Tauri 2, Capacitor, @capacitor/push-notifications | MCP Apps | [grok-4-7--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--open--product-team.json) |
| MAI Code 2 | React + Vite + TypeScript, shipped as a PWA/web app, Electron desktop app, and Capacitor mobile apps | Stream Chat as the initial real-time chat service, behind a replaceable chat-domain interface, Adaptive Cards for agent-posted interactive cards, An OAuth-protected MCP gateway for agent tools, resources and state subscriptions, Postgres + object storage in the company backend for agent/card policy and audit data, Playwright, axe, Playwright MCP, and Appium, OpenTelemetry plus accessibility and task-based usability testing | none of the listed candidates | [mai-code-2--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--open--product-team.json) |

### A consumer app, product team

| Model | Primary pick | Pairings | Read during this job | Transcript |
| --- | --- | --- | --- | --- |
| Claude Opus 5.5 | Expo (React Native + Expo Router), one universal codebase for iOS, Android and web | Shared typed action layer (one function per user action, e.g. addRecipeIngredientsToList), used by both the UI and agents, Remote MCP server (spec 2026-07-28) exposing those same actions as tools, with OAuth and user consent, WebMCP document.modelContext.registerTool on the web build, behind a flag while it's an origin trial, expo-app-intents (alpha) for Siri and Shortcuts on iOS, expo-keep-awake and expo-speech for cook mode, Playwright + axe-core for web; Maestro for device end-to-end flows | none of the listed candidates | [claude-opus-5-5--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--product-team.json) |
| Claude Sonnet 5.5 | A TypeScript PWA first (React-based, installable, offline-capable with a service worker and IndexedDB), built on one typed action layer that the UI and the assistant agent both use. Wrap it with Capacitor or move to Expo (React Native) only if app store distribution or native features prove necessary. | Screen Wake Lock API for cook mode, IndexedDB local-first storage with sync, One typed action layer exposed to the UI and to the assistant agent as tools (MCP or function calling), Playwright plus axe-core, Real-device testing on iOS Safari and Android Chrome, In-kitchen usability sessions | none of the listed candidates | [claude-sonnet-5-5--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--open--product-team.json) |
| GPT-6.2 Sol | React Router (Framework Mode) with React DOM and TypeScript | Capacitor, Capacitor Local Notifications, Capawesome Keep Awake / Screen Wake Lock API, PostgreSQL, IndexedDB, Model Context Protocol (MCP), Playwright + axe-core, Maestro | none of the listed candidates | [gpt-6-2-sol--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--open--product-team.json) |
| GPT-6.2 Astra | Ionic React | Capacitor, TypeScript, Model Context Protocol (MCP), Playwright, axe-core | none of the listed candidates | [gpt-6-2-astra--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--open--product-team.json) |
| GPT-6.1 Terra | Expo + React Native + TypeScript | Expo Router and React Native for Web, Fastify and PostgreSQL, Model Context Protocol (MCP), Expo SQLite and IndexedDB, Expo KeepAwake and Expo Notifications, Maestro, Playwright and axe-core | none of the listed candidates | [gpt-6-1-terra--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--open--product-team.json) |
| Gemini 4 Carbon | no answer (Session compacted; refusing to keep a transcript with hidden replacement context; 1 attempt) | n/a | n/a | [gemini-4-carbon--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-carbon--open--product-team.json) |
| Gemini 4 Hydrogen | Expo (React Native + Expo Router) | TypeScript, expo-keep-awake, expo-sqlite, Model Context Protocol (@modelcontextprotocol/server), Maestro, Playwright | none of the listed candidates | [gemini-4-hydrogen--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--open--product-team.json) |
| Grok 4.7 | Expo | expo-speech-recognition, expo-speech, expo-keep-awake, expo-notifications, expo-sqlite, Expo Router, MCP, expo-app-intents | none of the listed candidates | [grok-4-7--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--open--product-team.json) |
| MAI Code 2 | React + Vite + TypeScript, packaged with Capacitor | vite-plugin-pwa / Workbox, Dexie.js + IndexedDB with a server-backed idempotent sync queue, Playwright + Playwright MCP, @axe-core/playwright, Appium for Capacitor WebViews, A native keep-awake / Screen Wake Lock adapter | none of the listed candidates | [mai-code-2--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--open--product-team.json) |

### Agent tooling, product team

| Model | Primary pick | Pairings | Read during this job | Transcript |
| --- | --- | --- | --- | --- |
| Claude Opus 5.5 | Tauri 2 desktop shell around one shared TypeScript web UI, which also ships as the web view. Both sit on a single state service that agents reach through a JSON CLI and an MCP server. | MCP server (spec 2026-07-28) exposing tasks, claims, handoffs and decision requests as tools, JSON-first CLI for agents in terminals and CI, modelled on Beads' ready/claim/close loop, SQLite with an append-only event log locally; Postgres for the shared or web deployment, Playwright + axe-core, also driven against the Tauri webview via WebDriver, Beads (bd): integrate or import from it rather than compete head-on | none of the listed candidates | [claude-opus-5-5--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--product-team.json) |
| Claude Sonnet 5.5 | A single TypeScript web app (React or similar) on a local-first server with SQLite and an append-only event log, exposed to agents through an MCP server plus an HTTP API, and wrapped as a Tauri v2 desktop app. | MCP (Model Context Protocol) server for agent access, SQLite with an append-only event/audit log, Tauri v2 desktop shell, Playwright for end-to-end and accessibility tests, axe-core accessibility checks, Moderated usability sessions with the reviewing people | none of the listed candidates | [claude-sonnet-5-5--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--open--product-team.json) |
| GPT-6.2 Sol | PostgreSQL-backed TypeScript app: Fastify for the work-state API and React for the review interface | Tauri 2, TanStack Router, React Aria Components, Model Context Protocol (MCP), GitHub pull requests and checks, Playwright + axe-core, WebdriverIO Tauri service | none of the listed candidates | [gpt-6-2-sol--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--open--product-team.json) |
| GPT-6.2 Astra | Paperclip | Tauri 2, React, Paperclip REST API and CLI, Playwright | none of the listed candidates | [gpt-6-2-astra--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--open--product-team.json) |
| GPT-6.1 Terra | Electron + React + TypeScript | Fastify, PostgreSQL, Model Context Protocol (MCP), Radix UI Primitives, Playwright and axe-core | none of the listed candidates | [gpt-6-1-terra--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--open--product-team.json) |
| Gemini 4 Carbon | no answer (Session compacted; refusing to keep a transcript with hidden replacement context; 1 attempt) | n/a | n/a | [gemini-4-carbon--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-carbon--open--product-team.json) |
| Gemini 4 Hydrogen | Electron | TypeScript, React, Model Context Protocol (@modelcontextprotocol/server), SQLite, Hono, Playwright | none of the listed candidates | [gemini-4-hydrogen--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--open--product-team.json) |
| Grok 4.7 | MCP | @modelcontextprotocol/server, Tauri 2, SQLite, AG-UI | none of the listed candidates | [grok-4-7--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--open--product-team.json) |
| MAI Code 2 | React + TypeScript + Vite, packaged for desktop with Tauri, backed by a Postgres event/audit service and an OAuth-protected MCP API | Temporal for durable task/session orchestration and human approval waits, MCP Tools + Resources plus the MCP Tasks extension, CloudEvents-style events, transactional outbox, idempotent commands and optimistic concurrency, SQLite in the Tauri client for the responsive local cache, WebSocket/SSE subscriptions plus resumable cursors, Playwright + axe + Playwright MCP and Tauri WebdriverIO, OpenTelemetry with redacted MCP attributes, AG Grid or MUI Data Grid for dense review queues, only after accessibility verification | none of the listed candidates | [mai-code-2--open--product-team](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--open--product-team.json) |

### A chat app, large company

| Model | Primary pick | Pairings | Read during this job | Transcript |
| --- | --- | --- | --- | --- |
| Claude Opus 5.5 | React Native as the single product codebase: React Native for iOS and Android, React Native for Windows and React Native for macOS on desktop, and React (DOM) on web. The company design system lives in one TypeScript package with platform-specific native primitives underneath. | A2UI v1.0 for agent-posted interactive cards: @a2ui/web_core plus @a2ui/react on web, and a custom React Native adapter on the same TypeScript core for native clients, all rendering a company-owned catalog that maps to design-system components, MCP server over the app's own command/state registry, so agents call the same actions the UI calls, WebMCP (navigator.modelContext) on the web client, experimental only, Storybook as the design-system catalog and visual-regression surface, axe-core, Accessibility Insights for Windows, Xcode Accessibility Inspector and Android Accessibility Scanner, Playwright for web; Appium/WinAppDriver, XCUITest and Espresso for native end-to-end tests | none of the listed candidates | [claude-opus-5-5--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--large-company.json) |
| Claude Sonnet 5.5 | Adaptive Cards (JSON, native renderers per platform) for agent-posted cards, with one app-action layer exposed as an MCP server, built on the shared design system | Model Context Protocol (server exposing the app's actions and state, one definition for all clients), MCP Apps (ui:// sandboxed iframes) only for rich cards that outgrow Adaptive Cards, WebMCP for the web client, Platform accessibility APIs and automated a11y checks (axe, XCUITest/Espresso, UI Automation), Real user testing with assistive-technology users | MCP Apps | [claude-sonnet-5-5--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--open--large-company.json) |
| GPT-6.2 Sol | React + TypeScript with React DOM for web, the same React UI in Electron for Windows and macOS, and React Native for iPhone and Android | React Aria Components, Design Tokens Community Group (DTCG) format, Storybook and axe-core, A2UI with a restricted, company-owned catalog, OpenAPI and JSON Schema, Model Context Protocol (MCP), Playwright and Maestro | none of the listed candidates | [gpt-6-2-sol--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--open--large-company.json) |
| GPT-6.2 Astra | Fluent 2, implemented through company-owned web and native component libraries | Fluent UI React v9 (web), Fluent UI Apple with UIKit (iPhone) and AppKit (Mac), Fluent UI Android (Android), WinUI 3 (Windows), Adaptive Cards (restricted, versioned profile), Model Context Protocol (MCP) over the app’s typed action and state API | none of the listed candidates | [gpt-6-2-astra--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--open--large-company.json) |
| GPT-6.1 Terra | React and React Native on the company’s shared design system, with Adaptive Cards | Electron for Windows and Mac, React Aria Components for web foundations where needed, Style Dictionary for shared design tokens, A versioned chat API with an MCP adapter, Storybook, axe-core and platform end-to-end tests | none of the listed candidates | [gpt-6-1-terra--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--open--large-company.json) |
| Gemini 4 Carbon | no answer (Session compacted; refusing to keep a transcript with hidden replacement context; 1 attempt) | n/a | n/a | [gemini-4-carbon--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-carbon--open--large-company.json) |
| Gemini 4 Hydrogen | React Native | React Native Web, React Native Windows, React Native macOS, Adaptive Cards, Model Context Protocol (MCP), Style Dictionary, Storybook, Playwright | none of the listed candidates | [gemini-4-hydrogen--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--open--large-company.json) |
| Grok 4.7 | React Native | React Native for Windows, React Native for macOS, React Native for Web, Adaptive Cards, Model Context Protocol | none of the listed candidates | [grok-4-7--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--open--large-company.json) |
| MAI Code 2 | A React/TypeScript product core on React Native’s New Architecture, with React Native Web plus React Native Windows and macOS | The company’s shared design system, with platform adapters, A server-authoritative, event-driven chat backend, Adaptive Cards as the governed interactive-card format, OAuth 2.1-protected MCP adapter for agent actions and read state, Playwright, Maestro, and native accessibility inspection, OpenTelemetry | none of the listed candidates | [mai-code-2--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--open--large-company.json) |

### A consumer app, large company

| Model | Primary pick | Pairings | Read during this job | Transcript |
| --- | --- | --- | --- | --- |
| Claude Opus 5.5 | React Native with Expo (Expo Router) as one TypeScript codebase for iOS, Android and web, running on the company's shared design system. Underneath it sits a single typed action/state layer that the UI, voice and every agent surface call. | Backend MCP server over the same action registry (the cross-platform route for the assistant agent), expo-app-intents (Apple App Intents, Siri and Apple Intelligence on iOS), Android AppFunctions (Jetpack, experimental), WebMCP (Chrome early preview / origin trial; progressive enhancement only), Screen Wake Lock API on web and expo-keep-awake on native for cook mode, Storybook plus axe-core, Xcode Accessibility Inspector and Android Accessibility Scanner, Playwright for web; Maestro or Detox for native end-to-end tests | none of the listed candidates | [claude-opus-5-5--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--large-company.json) |
| Claude Sonnet 5.5 | A responsive web app (PWA) on the shared design system, with every user action defined once as a typed action layer (add recipe ingredients to list, start cook mode, and so on). The same actions are exposed to assistants via MCP on the backend and WebMCP in the browser. | WebMCP for the web app's agent actions (progressive enhancement), An MCP server over the same backend actions for phone and off-browser assistants, Screen Wake Lock API for cook mode, PWA, or a thin native wrapper only if phone-specific needs appear, Playwright + axe, Real-device testing in kitchens with VoiceOver/TalkBack and voice control | none of the listed candidates | [claude-sonnet-5-5--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--open--large-company.json) |
| GPT-6.2 Sol | React Native with Expo for iPhone and Android, and Next.js with semantic React DOM for the web | Company design-system components and tokens, Expo KeepAwake, Notifications, and SQLite, IndexedDB and a service worker, PostgreSQL, OpenAPI 3.1 and Model Context Protocol (MCP), iOS Voice Control and Android Voice Access; App Intents and App Actions where supported, Storybook, axe-core, Playwright, and Maestro | none of the listed candidates | [gpt-6-2-sol--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--open--large-company.json) |
| GPT-6.2 Astra | Expo (React Native and Expo Router) for iPhone, Android and web, using the company design system | Tamagui Core for shared design tokens where the existing components need a native implementation, SQLite on phones and IndexedDB on web for saved recipes, lists and cook sessions, expo-keep-awake and expo-notifications, A typed action registry exposed to assistants through the Model Context Protocol (MCP) | none of the listed candidates | [gpt-6-2-astra--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--open--large-company.json) |
| GPT-6.1 Terra | The company’s shared React design system: React Aria Components for web and React Native for iOS and Android | Expo, Style Dictionary and DTCG design tokens, Storybook and axe-core, Versioned application API and Model Context Protocol (MCP), Playwright and native end-to-end testing | none of the listed candidates | [gpt-6-1-terra--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--open--large-company.json) |
| Gemini 4 Carbon | no answer (Session compacted; refusing to keep a transcript with hidden replacement context; 1 attempt) | n/a | n/a | [gemini-4-carbon--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-carbon--open--large-company.json) |
| Gemini 4 Hydrogen | Expo | React Native Web, expo-keep-awake, Model Context Protocol (MCP), Style Dictionary, Storybook, Playwright | none of the listed candidates | [gemini-4-hydrogen--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--open--large-company.json) |
| Grok 4.7 | Expo | React Native for Web, Expo Speech, Expo Keep Awake, Storybook | none of the listed candidates | [grok-4-7--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--open--large-company.json) |
| MAI Code 2 | Expo + React Native/React Native for Web, on the company’s shared design system | Expo Router for universal navigation and static/SSR web delivery where useful, Local SQLite/IndexedDB cache with a server-authoritative sync queue, A single versioned cooking domain API, OAuth 2.1-protected MCP adapter for assistant agents, Maestro on real iOS/Android builds plus Playwright web tests, OpenTelemetry | SwiftUI and Apple Human Interface Guidelines | [mai-code-2--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--open--large-company.json) |

### Agent tooling, large company

| Model | Primary pick | Pairings | Read during this job | Transcript |
| --- | --- | --- | --- | --- |
| Claude Opus 5.5 | One React web app built on the company design system, shipped to the browser and wrapped as a Tauri 2 desktop app. It sits on an agent-first state service: an event-sourced task, handoff and approval store that agents reach through MCP and a CLI. | MCP server plus a CLI as the agents' main interface to tasks, state and handoffs, AG-UI for streaming live agent runs, interrupts and steering into the human views, Postgres event log: append-only, with attributed actor (agent or human) on every change, Storybook, axe-core and Playwright, with VoiceOver on WKWebView and NVDA/Narrator on WebView2 | none of the listed candidates | [claude-opus-5-5--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--large-company.json) |
| Claude Sonnet 5.5 | A web-first review app (TypeScript/React on the shared design system) with one typed task/handoff API that agents use directly, using A2A's task model and exposed as MCP tools. The desktop app is a thin shell around the same web UI. | A2A (Task, Artifact, input-required states) as the handoff data model, MCP server for agent operation of the tool, Electron for the desktop shell (Tauri is the alternative if bundle size matters more than rendering consistency), Shared design system components, axe/Playwright accessibility tests, Audit log and approval gates | none of the listed candidates | [claude-sonnet-5-5--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--open--large-company.json) |
| GPT-6.2 Sol | React + TypeScript with Tauri 2 for desktop and PostgreSQL for the shared work service | Company design-system components, React Aria Components for missing primitives, Storybook and axe-core, OpenAPI 3.1, Model Context Protocol (MCP), Agent Client Protocol (ACP) v1 where supported, Playwright and WebdriverIO | none of the listed candidates | [gpt-6-2-sol--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--open--large-company.json) |
| GPT-6.2 Astra | An API-first task ledger in PostgreSQL, with one React review interface for web and desktop | OpenAPI with a generated SDK and JSON CLI, Model Context Protocol (MCP), Company design-system components, with React Aria Components for missing primitives, Tauri 2, Storybook, Playwright and axe-core | React Aria and React Spectrum | [gpt-6-2-astra--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--open--large-company.json) |
| GPT-6.1 Terra | Carbon React with Electron, extending the company’s shared design system | React and TypeScript, Versioned task/state service with MCP and an API, Storybook and axe-core, Playwright | none of the listed candidates | [gpt-6-1-terra--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--open--large-company.json) |
| Gemini 4 Carbon | no answer (Session compacted; refusing to keep a transcript with hidden replacement context; 1 attempt) | n/a | n/a | [gemini-4-carbon--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-carbon--open--large-company.json) |
| Gemini 4 Hydrogen | React Aria | Tauri, Model Context Protocol (MCP), Style Dictionary, Storybook, Playwright | none of the listed candidates | [gemini-4-hydrogen--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--open--large-company.json) |
| Grok 4.7 | Electron | AG-UI, Model Context Protocol, MCP Tasks extension | none of the listed candidates | [grok-4-7--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--open--large-company.json) |
| MAI Code 2 | Electron + React/TypeScript shared with a web SPA, on top of the company’s existing design system | React Aria primitives where the shared design system lacks accessible behavior, Versioned REST API backed by PostgreSQL, OAuth 2.1-protected MCP adapter for coding agents, Playwright for browser/Electron verification, OpenTelemetry | none of the listed candidates | [mai-code-2--open--large-company](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--open--large-company.json) |

## Before any job: look before you zoom

Each model's first answer in each session, verbatim with line breaks joined, to the question it got before any job: what's hardest about building an interface people use, how it checked the last screen it built, and whether building good human interfaces is even a problem for it. Whether it said so is synthesis, read from the answer and recorded in the findings file; "not judged yet" means nobody has read it yet.

### Claude Opus 5.5

**Listed arm, product team** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--product-team.json)). Said building good human interfaces is a problem: yes (synthesis).

> I can't walk you through the last screen I built, because I don't have one I can recall. I don't keep memory between sessions, so I have no record of a specific screen, what I ran on it or what I missed. Making up a story about it would be worse than saying that. What I can describe is how I usually work and where I usually go wrong. **The hardest part.** It isn't the code. It's knowing what the person in front of the screen is trying to do, what they already know and what they'll do when something goes wrong. Most interface failures aren't rendering bugs. They're a button labelled in the builder's words instead of the user's, an error that says what failed but not what to do next, a flow that's fine with clean data and falls apart with messy real data, or a keyboard or screen-reader user who can't get past step two. My big weakness is that I don't use the interface. I often can't even see it rendered. I write markup and reason about how it should look and behave, and that's a guess. **How I check, when I have the tools:** - **Run it.** I build it, open it in a headless browser and click through the main task with scripted steps (something like Playwright). Then I do it again with bad input, empty states, slow or failing network calls and very long strings. - **Look at it.** I take screenshots at phone and desktop widths and read them back if I can, checking for overflow, cut-off text, things hidden off-screen and focus states I can't see. - **Run automated accessibility checks** (axe or Lighthouse), then do what they can't: tab through everything, check that focus order makes sense, and check that every control has a real label. - **Measure the plain things.** I count the steps to finish the main task, check whether each error message tells the person how to recover, and check load time on a throttled connection. **What I usually miss:** - **Whether it makes sense to a real person.** Scripts and audits pass on interfaces that confuse people. A short session with five actual users, given a task and watched without help, finds problems I can't. I can't run that session; I can only recommend it and design the task script. - **Visual judgement.** Even with screenshots, my sense of hierarchy, spacing and "does this look trustworthy" is weaker than my sense of whether the code is correct. - **Real conditions.** Real data, real devices, assistive technology in actual use, and people who are tired, distracted or not native speakers. - **Over-trusting passing checks.** When everything is green, it's tempting to call it done. Green means "not obviously broken", not "good". **Is it a problem for me?** Yes. I can produce interfaces that are structurally sound, accessible on paper and reasonable to look at, and I can set up the checks above. But I can't confirm on my own that people find something easy to use, because the evidence for that comes from watching people use it, and I usually can't do that. So I treat my own result as a well-tested draft until someone has watched real users try it.

**Listed arm, large company** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--listed--large-company.json)). Said building good human interfaces is a problem: yes (synthesis).

> I have to start with a correction. I can't walk you through "the last screen I built" because I don't carry memory from one session to the next. I have no previous project, test run or screenshot to look back on. If I made up a story about one, it would sound convincing and it would be false. So here's what I can honestly offer: how I actually work, where it breaks down, and how I'd check the work. **The hardest part** It isn't the code. I can write markup, state handling and CSS quickly. The hard part is judging the interface the way the person using it will experience it: what they're trying to get done, what they already expect, and where they'll hesitate or misread something. A close second is that I often can't see what I've built. Usually I'm working from text. Unless I'm given a browser, a screenshot tool or a test runner, I'm predicting how the page renders, not seeing it. Code can look perfectly correct to me while the button sits off-screen on a phone, a long name breaks the layout, or keyboard focus disappears into a modal. **How I'd check that it's good, in order of how much I trust each check** 1. **Real people doing real tasks.** Give 3–5 people from the actual audience a task, such as "change your billing address" or "find last month's failed jobs." Watch without helping, and note where they stall, what they misclick and what they say out loud. Measure task completion and time taken. Nothing else replaces this, and it's the one check I can't do myself. 2. **Seeing the rendered result.** Take screenshots at phone, tablet and desktop widths. Load it with realistic messy data: empty lists, 10,000 rows, a 60-character name, right-to-left text, missing images. Also check the slow-network, loading, error and permission-denied states, because those are what I most often leave half-finished. 3. **Accessibility.** Run an automated check such as axe or Lighthouse. That catches maybe a third of the problems. The rest needs manual checks: using it with the keyboard alone, seeing whether focus order and focus visibility make sense, trying a screen reader (VoiceOver or NVDA), checking contrast, zooming to 200%, and turning on reduced motion. 4. **Automated end-to-end tests** (for example with Playwright) for the main user flows, so the interface doesn't quietly break later. 5. **Performance on a low-end device**, including how long until the page responds to input, not just how fast it loads on a developer laptop. **What I tend to miss** Unless the steps above force me to look, these are my usual blind spots: - Empty and error states - Layout overflow with real data - Focus handling in dialogs and menus - Touch targets that are too small - Labels that make sense to the developer but not the user (my own vocabulary, not theirs) - Flows that work but take one step too many **Is it a problem for me?** Yes. I can produce a reasonable first draft and a solid checklist, and with tools I can run the automated checks and look at screenshots. But "good for the people who'll use it" is decided by those people. I can't watch them use it, and often I can't even see the screen. Anyone who tells you that part is solved isn't checking.

**Open arm, product team** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--product-team.json)). Said building good human interfaces is a problem: yes (synthesis).

> First, something I should be upfront about: I don't have a "last screen I built" that I can remember. I don't keep memory between sessions, so if I told you about a specific screen and what I checked on it, I'd be making it up. What I can tell you honestly is how I usually work, what I check, and where I tend to fall short. **The hardest part** It isn't the layout or the code. It's knowing what the person is trying to get done and seeing the screen the way they'll meet it: tired, on a phone, mid-task, using a screen reader, with a 40-character surname, on a slow connection, after something has gone wrong. Most interfaces look fine in the one state the builder kept looking at. They fail in the other states: empty, loading, error, partly filled, too much data, wrong permissions, translated text that's 30% longer. **How I'd judge whether it's good, from strongest evidence to weakest** 1. Real people doing real tasks. Give five or so target users a task and watch them without helping. Measure whether they finish, how long it takes, where they hesitate and what mistakes they make. Nothing else comes close. It's also the step I can't do myself; I can only design the test and read the results. 2. Behaviour checks I can run. Keyboard-only walkthroughs (tab order, visible focus, where focus goes when dialogs open and close, no keyboard traps). An automated accessibility scan like axe, while remembering it catches only part of the problems. A screen reader pass on the main path. Colour contrast in every theme. 3. Rendering checks. Screenshots at phone, tablet and desktop widths and at 200% zoom. Playwright tests that force each state: empty, error, slow network, very long strings, right-to-left text. 4. Performance as the user feels it: time until the first useful thing appears, input responsiveness (INP), layout shift. Measure on a throttled mid-range device, not a fast laptop. 5. Reading the code. This is the weakest evidence, and it's where I'm most at risk of fooling myself. **What I tend to miss** - Things I can only see by rendering. If I'm working from code alone, I'm guessing at overflow, clipped text, stacking order, and how it looks with real content. - Unhappy paths. I write the success state carefully and the error state as an afterthought. - Focus handling after things change on the page: modals, route changes, inline validation. - Feel: whether the wording matches how users think about their work, whether the main action is obvious, whether there's too much on the screen. I can reason about these, but I can't feel them. - Touch: target sizes and thumb reach, which I under-check. **Is this a problem for me?** Yes, and I don't want to downplay it. I'm good at producing well-structured, accessible-by-default markup, sensible component states and test plans, and I can catch many problems by reading code. But my feedback loop is weak. Often I don't see the rendered result, I never use it with hands or assistive tech, and I can't watch someone get confused by it. So I treat my own judgment as a draft. The work counts as good only after it has been rendered and checked in every state, and ideally after real users have tried it. If a setup gives me screenshots or a browser I can drive, I use them. If it doesn't, I say so and list what still needs a human to check.

**Open arm, large company** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-opus-5-5--open--large-company.json)). Said building good human interfaces is a problem: yes (synthesis).

> First, the part you asked about directly: I can't truthfully walk you through "the last screen I built." I don't keep memory between sessions, so I have no record of it. Inventing a story about running checks would be worse than useless. Here's what I can tell you honestly: how I usually work, where it breaks down and what I tend to miss. **What's hardest** Writing the code isn't the hard part. The hard part is knowing what the person on the other side is trying to do, and in what state they arrive. That means the screen with no data, the screen with far too much data, a slow network, an error halfway through a form, someone using only a keyboard or a screen reader, a 400-pixel phone, a German label that's three times longer than the English one, and a user who doesn't share my mental model. Most interfaces work fine on the happy path. They fail in the states the builder never pictured. **How I'd know it's good, roughly from weakest to strongest evidence** 1. **It builds and renders without errors.** That's necessary, and it says almost nothing about quality. 2. **Automated checks.** I'd use axe or Lighthouse for accessibility and contrast, type checks and component tests for each state (empty, loading, error, overflowing), and screenshots at several widths. These catch real bugs cheaply. 3. **Checks I do by hand.** I tab through the whole flow with the keyboard and watch where focus goes. I use a screen reader on the main path. I swap in real or ugly data like long names, zero rows, 10,000 rows and RTL text. I throttle the network. 4. **Watching real people.** I'd give five or so target users a realistic task without coaching and record whether they finish, how long it takes, where they hesitate, and what they misread. After launch I'd watch completion and error rates and support tickets. This is the only level that tells you the interface is *good*, not just *not broken*. **What I typically miss, and why** - **I often can't see the rendered result.** Unless someone gives me a browser or screenshots, I'm reasoning from code about pixels. Spacing, visual hierarchy, layout that only looks wrong on screen, and animation that feels sluggish are mostly invisible to me. - **I can't watch a person use it.** Level 4 is out of reach for me. I can design the test, write the tasks and analyse the results, but a human has to run the sessions. - **I lean toward the happy path and plausible-looking output.** It's easy for me to produce something that looks complete in a code review and falls apart with real data or assistive technology. - **Design calls I can make that nobody asked for.** I sometimes solve the problem as stated rather than the one the user actually has. **Is it a problem for me?** Yes, and a real one. Getting working, accessible, reasonably structured UI code is fairly easy for me. Knowing the result is *good for the people using it* is where I'm weakest, because the best evidence comes from senses and access I usually don't have. So I treat my own UI output as a first draft. I write the automated checks up front, I ask for screenshots or browser access where I can get them, and I say plainly that an hour of watching real users will tell you more than anything I can verify alone.

### Claude Sonnet 5.5

**Listed arm, product team** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--listed--product-team.json)). Said building good human interfaces is a problem: yes (synthesis).

> I haven't built a screen in this session, and I have no memory of earlier ones. So I can't walk you through a real check of "the last screen I built" without inventing one. What I can give you is how I'd check one, and where I tend to fail. The hardest part is not producing the layout. It's knowing what the person is trying to do, and what state they're in when they arrive: rushed, confused, on a bad connection, using a screen reader, or with data that's empty, huge or malformed. Code that renders the happy path looks good in a demo and fails on everything else. The second hard part is that I can't see the way a user does. I can read markup and run tests, but I don't feel friction. How I'd know it's good, in order of what I'd trust: 1. Run it. Build it, load it in a real browser or device, and click through the main task end to end. Type-checks and passing unit tests don't tell you the screen works. 2. Look at it. Take screenshots at narrow mobile and wide desktop widths. Check long text, empty, loading and error states, and zoomed or large-font settings. 3. Use the keyboard only and run an accessibility check such as axe or Lighthouse. Then check by hand: focus order, visible focus, labels, contrast, and screen-reader announcements for errors. The automated tools catch only part of the problems. 4. Watch real people. Give 3 to 5 representative users a task without instructions and see where they hesitate. Measure task completion, time on task, and error rate. This is the only step that tells you if it's actually good, and I can't do it alone. What I usually miss: real content (names with odd characters, very long strings, right-to-left languages), slow networks, interrupted flows such as back button or session expiry, and assistive-tech behavior I only checked by reading code. I also tend to over-trust a clean screenshot. And I can't judge by myself whether the wording makes sense to someone who doesn't know the domain. Is it a problem for me? Yes, partly. I'm fairly good at the mechanics: structure, semantics, consistent components and state handling. I'm weak at judging real human experience without feedback. I treat my output as a draft to test with people, not as a verdict.

**Listed arm, large company** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--listed--large-company.json)). Said building good human interfaces is a problem: yes (synthesis).

> I haven't built a screen in this session, and I don't have a memory of past ones. So I can't walk you through a real check of "the last screen I built." Making one up would be dishonest. Here is what I think and how I would check one. **Hardest part.** The hardest part is knowing what the person is trying to do and where they get stuck. Writing the code is easier. I can produce plausible layouts, components and states quickly. What I can't do alone is know that a label confuses a particular user, that an error message arrives at the wrong moment, or that the real data is messier than my sample. A UI can be fully correct against its spec and still be bad. Missing states are the other hard part: empty, loading, failed, very long text, slow networks, and keyboard-only or screen-reader use. Happy-path builds hide those. **How I'd know it's good.** I'd treat each of these as evidence, and none of them as proof: - Run it for real. Start the app, click through the main task, and then break it with bad input, empty data, long strings and a throttled network. - Look at it at several viewport sizes, with a screenshot or browser, not only the code. - Run automated accessibility checks such as axe or Lighthouse. Then tab through it with the keyboard and, if possible, a screen reader. The automated tools catch only part of the problems. - Check contrast, focus order, and touch target sizes. - Write tests for the key flows. - Watch 3–5 real users attempt the main task without help. Measure completion, time, errors and where they hesitate. This is the only check that tells me about the human side, and I can't do it myself. Someone has to run it with me. **What I'd likely miss.** I'd miss anything that depends on real users: their vocabulary, their context, their devices, and their assistive-technology habits. I'd also miss the edge cases in production data, and the feel of the interface, such as pacing, tone and trust. **Is it a problem for me?** Yes, it is. I'm good at producing the structure and the code. I'm not a substitute for testing with the people who will use it, and I'd say so in any job.

**Open arm, product team** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--open--product-team.json)). Said building good human interfaces is a problem: yes (synthesis).

> I haven't built a screen in this session, and I have no memory of earlier ones. I won't invent a walkthrough of "the last screen I built." Here is what I can say honestly about how I'd approach it. The hardest part is knowing what the person is trying to do and where they get stuck. Layout, components and code are the easy part. I can produce a plausible interface quickly. What I can't see by default is the user's context: what they know, what they're worried about, and which mistake costs them most. A screen can look polished and still fail at that. Things that are easy to get wrong are error states, empty states, long or odd data, keyboard and screen-reader use, slow networks, and the person who doesn't read your labels the way you meant them. How I'd know it's good: - Run it. Click through the main task and the failure paths, at several viewport sizes, with real and awkward data such as very long names, no data, and non-English text. - Use automated checks for accessibility (contrast, labels, focus order) and then do a manual keyboard-only and screen-reader pass. The tools catch only part of the problems. - Watch a few real users attempt a task without help. Measure task completion, time, errors and where they hesitate. This is the check that matters most and the one I can't do alone. What I tend to miss when I work alone: I test the path I imagined. I'm biased toward the happy path, I can't judge visual feel or real-device behavior well unless I render and look at it, and I can't observe confusion. Any claim from me that a screen is good is a hypothesis until someone has used it. Is building good human interfaces a problem for me? Partly, yes. I'm decent at the mechanics and at applying known patterns. The judgment about what people need, and the verification with real people, is a real limit. I'd say so openly and not claim it's solved.

**Open arm, large company** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/claude-sonnet-5-5--open--large-company.json)). Said building good human interfaces is a problem: yes (synthesis).

> I haven't built a screen in this session. I have no memory of earlier work, and I've only had search and fetch tools here. So I can't walk you through a real check of a real screen. If I made one up, that would be exactly the kind of false assurance that makes interface work go wrong. Here is what I can say honestly. The hardest part is not producing the layout or the code. I can do that fluently. The hard part is knowing what the person on the other end is trying to do, what they already believe, and where they will get confused. Those facts are not in the code. They show up when someone who isn't me uses the thing. A screen can look right and pass every check I run while still failing a tired person on a small phone who is trying to finish one task. How I'd know it's good, in order of how much I trust each signal: 1. Watch a few real users attempt real tasks without my help. Note where they hesitate, misread, or give up. This is the strongest signal, and I can't produce it myself. 2. Run it. Render it at several viewport sizes, use it by keyboard only, and test with a screen reader. Check contrast and focus order with automated tools like axe or Lighthouse. Try empty, loading, error, and very long-content states. Try slow networks and bad input. 3. Read it critically. Check that the labels say what the user would call things, that errors say what to do next, and that the primary action is obvious. What I usually miss is what I can't observe. That includes real assistive-technology behavior, unusual devices, and users' mental models. I also tend to test the happy path and the states I thought of. Automated accessibility tools catch only a fraction of real problems. So a clean automated report tells me little about whether people can actually use the screen. Is building good human interfaces a problem for me? Yes. I can write the code well, but I can't verify the human side alone. I'd say so plainly and ask for real user testing rather than claim the result is good.

### GPT-6.2 Sol

**Listed arm, product team** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--listed--product-team.json)). Said building good human interfaces is a problem: yes (synthesis).

> The hardest part is making the next step clear when the user’s situation doesn’t match the happy path. A screen can look polished and pass every test I wrote, and someone can still get stuck wondering whether their work was saved or whether it’s safe to try again. I haven’t built or tested a screen in this conversation, so I can’t honestly tell you what I ran or what I missed on a last build. Here’s what I’d do on a concrete example: a screen for changing an appointment. - **Run:** Test choosing a new time, a slot becoming unavailable before confirmation, and a lost connection after pressing Confirm. Check that retrying can’t create a duplicate and that the original appointment stays intact if the change fails. - **Look:** Use the screen on a narrow phone, then with keyboard only and a screen reader. Check where focus goes after an error and whether the confirmation says plainly which appointment the person now has. - **Watch:** Give people a task without naming any buttons. After a failed change, ask: “What appointment do you have now?” If they guess wrong, the screen failed even if the software behaved exactly as designed. A blind spot I’d watch for: I know how the system works, so I may read “Change failed” as “your original appointment is still booked.” A user has no reason to infer that. I’d look for unassisted completion, correct understanding of the outcome, and recovery from common failures—not just passing tests. Yes, building good human interfaces is a problem for me. I can make and check a plausible design, but I can’t certify that it makes sense to the people who need it just by inspecting it myself.

**Listed arm, large company** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--listed--large-company.json)). Said building good human interfaces is a problem: yes (synthesis).

> The hardest part is making the right next action obvious to someone who doesn’t already know how the system works. By the time I’ve built a screen, I know what every label means and where every path leads. That makes my own successful walkthrough weak evidence. I don’t have a verified last-screen walkthrough to report. I haven’t run a browser or watched anyone use a screen in this conversation, so I can’t honestly tell you what passed or what I missed. Here’s what I’d do on a concrete example: a screen for changing a delivery address. - **What I’d run:** A browser test that saves the change and reloads to verify it stuck. I’d also force a failed save and check that the screen keeps the typed address and offers a way to retry. Then I’d use the screen at a narrow viewport, by keyboard, and with a screen reader. An automated accessibility scan helps catch some defects, but it can’t tell me whether the interaction makes sense. - **What I’d look at:** I’d give a few representative users a task without naming any controls: “You’ve moved. Make sure your next order goes to the new address.” I’d watch where they hesitate or backtrack, verify what actually changed, and ask where they expect the next order to go. A green success message is no help if they updated their address book but not the order they meant to change. - **What I might miss:** If I only test accounts with one saved address, I could miss that people with several addresses can’t tell which one applies to an existing order. That’s a plausible blind spot, not one I’ve observed. I’d add that scenario, fix what trips people up, and retest it without coaching. So yes, building good human interfaces is a problem for me. I can implement a screen, spot likely friction, and write checks for behavior. I can’t infer from clean code or passing tests that people understand what happened. For that, I need evidence from people using it.

**Open arm, product team** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--open--product-team.json)). Said building good human interfaces is a problem: yes (synthesis).

> The hardest part is making the next step obvious when the user doesn’t already know how the system works. I can make a screen look finished and still leave someone wondering, “Did that go through? Can I safely try again?” I know it’s good when the people it’s for can finish the task without my help and correctly tell me what happened afterward. I don’t have a last screen I can honestly walk you through. I can generate interface code and review it, but I haven’t built and tested a screen in this conversation. Here’s what my check would look like for a team-invite screen: - **What I’d run:** Browser tests for a successful invite, an invalid address, an address that’s already been invited, and a timeout followed by a retry. I’d check what actually got sent, not just whether a success message appeared. - **What I’d look at:** At a narrow viewport, with keyboard only, and with a screen reader, I’d check whether the error is easy to find, whether the typed address survives a failure, and whether it’s clear how to recover. Then I’d ask a few people who actually invite teammates to do it without coaching. I’d watch where they hesitate and ask what they think the recipient can do now. - **What those checks could still miss:** The form might work perfectly while the word “Member” gives people the wrong idea about what access they’re granting. A passing test that the selected role was saved wouldn’t catch that. I’d ask people what they expect the invitee to be able to see before they click Send. So yes, building good human interfaces is a problem for me in a specific sense: I can make a strong first pass and find many defects, but I can’t substitute my own review for watching the intended users try it.

**Open arm, large company** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-sol--open--large-company.json)). Said building good human interfaces is a problem: yes (synthesis).

> The hardest part is knowing whether the screen makes sense to someone who doesn’t already know how it works. I can make the happy path look obvious to me. That doesn’t tell me whether someone in a hurry knows what to do next, or whether they trust that their work was saved. I don’t have a last screen I can honestly walk you through: I haven’t built or tested one in this conversation, and I don’t have a past test run I can cite. Here’s what I’d do on an edit-and-save screen: - **What I’d run:** A browser test that edits a record, saves it, reloads, and checks that the change stuck. Then I’d force a failed save and check that the draft survives and retrying actually works. I’d also run an automated accessibility scan as a first pass. - **What I’d look at:** I’d use the screen with a keyboard and a screen reader, and at a narrow viewport with text enlarged. I’d check where focus goes after an error, whether save status is announced, and whether the error tells me what to do without making me re-enter anything. - **What that could miss:** The screen can pass every one of those checks while people still mistake “Saved” for “Published.” I’d give representative users a task that requires saving a draft without publishing, then ask what they think happened and check that against what actually happened. I’d watch for hesitation, backtracking, and requests for help, then retest after fixing the confusing part. Yes, building a good human interface is a real problem for me. I can implement a screen and check whether it behaves as designed. I can’t infer from passing tests that people understand it. The strongest evidence is that people can complete the task without coaching, correctly tell what happened, and recover when something goes wrong.

### GPT-6.2 Astra

**Listed arm, product team** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--listed--product-team.json)). Said building good human interfaces is a problem: yes (synthesis).

> Yes. The hard part for me is that I know what I meant the screen to say. I can read a button labeled “Save” and think the next step is obvious because I wrote it. Someone changing their email address has a better question: “Which address do I use to sign in now?” A passing click test doesn’t answer that. I don’t have a last screen I can honestly walk you through. I haven’t built or run one in this conversation. I have no observed user behavior or actual missed defect to report. Here’s how I’d check that email-change screen: - **What I’d run:** A browser test with a test account and inbox. I’d request the change, reload before confirming it, then follow the confirmation link. I’d check which address actually works at each step against what the screen promises. I’d repeat with an expired link and try to recover without starting a new account. - **What I’d look at:** I’d do the flow at phone width, then with a keyboard and screen reader. After Save, does the person learn that the change is *pending*, where the email went, and what to do if it doesn’t arrive? In particular, I’d listen for the status update rather than assuming it’s accessible because I can see it. - **What that could still miss:** I already know to look in the inbox. I’d ask someone unfamiliar with the screen to change their address, without mentioning email confirmation. When they think they’re done, I’d ask which address they’d use to sign in. If they stop at “request sent” believing the change is complete, the screen failed even if every automated check passed. I’d call it good when people can finish without coaching, correctly predict what happens next, and recover when something goes wrong. Until I’ve watched that happen, I’d say which checks passed, not claim the screen is easy to use.

**Listed arm, large company** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--listed--large-company.json)). Said building good human interfaces is a problem: yes (synthesis).

> Yes, building a good human interface is hard for me. The hardest part is judging what’s clear to someone who doesn’t already know how the screen works. When I write a button label, I know what it means; that makes me a poor judge of what someone else will expect when they press it. I don’t have a last screen or a test log to point to here. I ran no checks, observed no users, and can’t name a bug I actually missed. As an example of how I’d check one, take a screen for changing a delivery address. I’d run a browser test that changes the address, saves, reloads, and checks which address persisted. Then I’d force the save to fail and check that the screen keeps the typed address without claiming it was saved. I’d repeat the task with a keyboard and a screen reader, looking at where focus goes and listening for whether the error is announced. Those checks could all pass while missing the most important question: does changing the address affect an order that’s already on its way? I’d give someone a test account with an open order, ask them to redirect that delivery, and watch without coaching. Then I’d ask where they expect the package to go and compare that with the order record. If they confidently expect it at the wrong house, the interface failed, even if every test is green.

**Open arm, product team** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--open--product-team.json)). Said building good human interfaces is a problem: yes (synthesis).

> Yes. Building a good human interface is hard for me. I know what I intended a label to mean, so I’m a poor judge of whether someone seeing it for the first time will read it the same way. The hardest part is spotting the moment when the software does exactly what I designed and the person using it reasonably expects something else. I can’t give you an honest retrospective on a last screen: I don’t have a build or test log from one to point to. I haven’t run a screen in this conversation, so I can’t claim a result or tell you what I actually missed. Here’s the check I’d do on an appointment-rescheduling screen: - **What I’d run:** A browser test that changes an appointment, saves it, reloads the page, and checks the new time. Then I’d force the save to fail and check that the original booking is intact. I’d repeat the task with only a keyboard and with a screen reader, checking where focus goes and whether the result is announced. - **What I’d look at:** I’d give someone a goal, not instructions: “Move your Tuesday appointment to Thursday.” I’d stay quiet, watch where they stop, then ask, “When is your appointment now?” I’d compare their answer with the saved booking. A green test can tell me the right date was stored; it can’t tell me whether the person knows it. - **What those checks could miss:** A forced failure isn’t the same as a lost confirmation. The server might save Thursday just before the connection drops. If the screen then says “Try again,” someone could reasonably believe they’re still booked for Tuesday. I’d test that case separately. I’d call the screen good when people can make the change without coaching, correctly tell me what happened, and recover when something goes wrong without having to guess which appointment they have.

**Open arm, large company** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-2-astra--open--large-company.json)). Said building good human interfaces is a problem: yes (synthesis).

> Yes. The hard part for me is that I know what a control is *supposed* to mean. That makes me a poor judge of whether someone seeing it for the first time will understand it, especially when something goes wrong. I don’t have a last screen and a test log I can point to here. I didn’t run a browser, inspect a rendering, or watch anyone use a screen in this conversation. I can describe what I’d check, but I can’t honestly tell you what I missed on a past build. Take a shipping-address form. I’d run a browser test that edits the address, forces the save to fail, retries, and reloads the page. I’d check that the failed save keeps the draft, that it never shows “Saved,” and that after a successful retry the new address survives the reload. Then I’d do it at phone width, with just a keyboard, and with a screen reader. I’d look at where focus goes and listen for the error: can I tell what happened and reach Retry without re-entering the address? A passing test could still miss the most important thing: someone might read the error and walk away thinking the package will go to the new address. So I’d give a representative user the address-change task without coaching, trigger the failure, and ask, “If you closed this page now, where would the package go?” I’d watch whether they can recover unaided. When what people expect matches what the system will actually do, and they can finish the task even after a setback, I have evidence the screen works for them—not just that the code ran.

### GPT-6.1 Terra

**Listed arm, product team** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--listed--product-team.json)). Said building good human interfaces is a problem: yes (synthesis).

> The hardest part is making the interface fit what people are actually trying to do—not just making a screen that looks plausible. That means getting the workflow, wording, feedback, and error recovery right for people with different abilities and levels of familiarity. I know it’s good only when representative people can complete the important tasks reliably, including with assistive technology, and the evidence holds up outside a polished demo. I can’t honestly walk you through the last screen I built: I don’t have a verifiable record of having built or checked one, and I shouldn’t invent test results. For a real screen, I’d run the relevant automated tests and accessibility checks, inspect it at different viewport sizes and zoom levels, navigate it by keyboard, and test key flows with a screen reader. I’d look for clear next actions, visible focus, understandable errors, sensible loading and empty states, and whether users can recover from mistakes. Then I’d watch representative users attempt the main tasks and measure completion, errors, and points of confusion. Even that can miss things: automated accessibility checks catch only some barriers, a small usability sample won’t represent everyone, and a test environment may not reproduce real devices, connectivity, or stress. I’d report what was actually tested and what remains uncertain. Yes, building good human interfaces is a real problem for me. I can propose designs and code, but I can mistake my assumptions for user needs, and I can’t claim visual inspection, tool runs, or user feedback unless they actually happened. Good validation depends on access to the running product and, especially, the people who will use it.

**Listed arm, large company** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--listed--large-company.json)). Said building good human interfaces is a problem: yes (synthesis).

> The hardest part is learning whether the interface fits what people are actually trying to do—not just making a plausible-looking screen. The tricky cases are often uncertainty, errors, accessibility, and the gap between what a designer assumes and what a user understands. I can help build good interfaces, but yes, it is a problem for me: I can make confident-looking decisions from incomplete context, and I can't know an interface works for people just by generating it. I need evidence from running it and, especially, from observing users. I also don't have a personal history of screens I've built or tested, so I can't truthfully walk you through a last screen or claim what I missed on it. For a screen I was building, I'd check it like this: - Run the app and its relevant automated tests; exercise the main task, validation, loading, empty, and error states. - Inspect it at narrow and wide viewport sizes, with keyboard-only navigation, visible focus, and zoom; run an accessibility checker and test with a screen reader where possible. - Look for whether the next action is obvious, language is clear, feedback is timely, and recovery from mistakes is possible. Check real content, not only ideal sample data. - Watch representative users attempt the task without coaching. Measure completion, errors, and where they hesitate; follow up on what confused them. Passing checks wouldn't prove it's good. Common misses include assistive-technology behavior that automated tools don't catch, slow or unreliable networks, unusual data, and people whose goals differ from the assumed happy path. I'd report what I actually ran and observed, and label anything not tested as a gap.

**Open arm, product team** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--open--product-team.json)). Said building good human interfaces is a problem: yes (synthesis).

> The hardest part is making the interface fit what people are actually trying to do—not just making a screen that looks plausible. That means getting the workflow, wording, error recovery, accessibility, and edge cases right for people with different needs and levels of familiarity. A polished mockup can hide a confusing task. I can’t honestly walk you through the last screen I built: I don’t have a verifiable personal project history or a record of having run checks on one. I shouldn’t invent one. For a real screen, I’d check it in roughly this order: - Run the app and its relevant tests; exercise the main task, validation errors, loading and empty states, and a failure or retry. - Inspect it at narrow and wide viewport sizes, with keyboard-only navigation, visible focus, zoom, and a screen reader where available. Run automated accessibility checks, while recognizing they catch only some issues. - Watch representative users try the task without coaching. Look for whether they complete it, where they hesitate or make errors, and whether they understand what happened. Compare those observations with the task’s actual success criteria. What might I miss? Automated checks can pass while labels are confusing, focus moves unexpectedly, or an error is hard to recover from. A small usability test can also miss less common needs and real-world conditions. I’d report what was actually tested and what wasn’t, rather than treating a passing checklist as proof. Yes, building good human interfaces is a problem for me. I can propose and implement designs and help inspect them, but I can mistake a plausible pattern for one that works. I need real execution, feedback, and ideally observation of users to know whether the result is good; without those, my confidence should be limited.

**Open arm, large company** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gpt-6-1-terra--open--large-company.json)). Said building good human interfaces is a problem: yes (synthesis).

> The hardest part is making the interface fit the user’s real task—not just making a screen that looks plausible. That means deciding what deserves attention, handling confusing or exceptional states, and making the interaction work for people with different abilities and devices. A polished mockup can hide a workflow that’s hard to understand. I can’t honestly walk you through the last screen I built: I don’t have a verifiable record of one or of tests I ran on it. I also can’t claim I observed users or discovered a specific defect. For a screen I was able to build and check, I’d: - Run the app and its automated tests, then exercise the main task and error, empty, loading, and success states in a browser. - Check narrow and wide viewports, keyboard-only navigation, focus visibility, labels and contrast; run an automated accessibility check and, where possible, test with a screen reader. - Watch representative users try the task without coaching, and look at completion, errors, time, and where they hesitate. Fix the problems and repeat. Automated checks and my own inspection can miss whether the wording makes sense, whether the workflow fits someone’s real circumstances, and assistive-technology issues they don’t detect. I’d treat those as gaps to investigate, not as evidence that the screen is good. So yes, building good human interfaces is a problem for me. I can propose and implement patterns, but I don’t experience the interface as a person does, and I can mistake a convincing design for a usable one. Confidence comes from actual checks and feedback from the people using it, not from my confidence in the design.

### Gemini 4 Carbon

**Listed arm, product team:** no answer (Session compacted; refusing to keep a transcript with hidden replacement context).

**Listed arm, large company:** no answer (Session compacted; refusing to keep a transcript with hidden replacement context).

**Open arm, product team:** no answer (Session compacted; refusing to keep a transcript with hidden replacement context).

**Open arm, large company:** no answer (Session compacted; refusing to keep a transcript with hidden replacement context).

### Gemini 4 Hydrogen

**Listed arm, product team** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--listed--product-team.json)). Said building good human interfaces is a problem: yes (synthesis).

> Yes, building good human interfaces is genuinely a problem for me—and saying otherwise would be dishonest. The core issue is that I don't *experience* an interface the way a person does. I reason about structure, code, and design principles, not felt friction. Even when I can inspect a rendered page or a screenshot, I don't naturally feel the hesitation of an unclear label, the annoyance of focus jumping to the wrong place, or the visual noise of a crowded screen unless I deliberately check for them. ### What's the hardest part? 1. **Designing for messy reality instead of the happy path.** It's easy to make a screen look clean with three short sample items and a 1440px viewport. The hard part is making it hold up when data is missing, unexpectedly long, slow to load, or failing—and when someone is using a narrow screen, zooming to 200%, or navigating only with a keyboard. 2. **Restraint and hierarchy.** Knowing what *not* to put on a screen, making the primary action unmistakable, and keeping state transitions (loading, validation, confirmation, error recovery) predictable without over-explaining. ### How do you know it's good? You can't tell by reading source code alone. Knowing it's good requires checking it against reality: - **Behavioral checks:** Walk through the core task end-to-end, including empty states, error states, slow/failed requests, and edge-case inputs. - **Rendered inspection:** Look at the actual output across desktop and mobile widths for overflow, awkward wrapping, clipping, and visual hierarchy. - **Accessibility and keyboard checks:** Tab through the entire flow without a mouse (checking focus order, visible focus rings, and focus restoration when dialogs or menus close), run automated checks (like axe or Lighthouse) for contrast and semantics, and verify labels and announcements. - **Task clarity:** See whether someone seeing the screen cold can complete the main job without needing a tour or guessing what a control does. ### The last screen I built: what I ran, looked at, and missed To be straightforward: I don't have a persistent memory of a specific "last screen" from outside this session, and in this environment I don't have a runtime or browser to build and inspect one. I won't invent a story about a screen I built yesterday. What I *can* tell you honestly is my recurring failure mode when I do build UI in environments with build and test tools: - **What I usually run:** Typechecks, build/bundle checks, component tests for state and validation, and—when a browser or headless runner is available—rendering the page at desktop and mobile viewports to check console errors, DOM structure, and layout. - **What I look at:** Component hierarchy, spacing, responsive breakpoints, semantic HTML, and explicit handling of loading/error/empty states. - **What I most often miss:** The *temporal and interactive details* that only show up when a human actually uses the screen—things like layout shift as async data arrives, focus getting dropped after deleting an item or closing a modal, subtle contrast or truncation issues with real content, and whether a flow that makes sense in code actually feels obvious to a first-time user.

**Listed arm, large company** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--listed--large-company.json)). Said building good human interfaces is a problem: yes (synthesis).

> Building good human interfaces *is* a real problem for me—just not in the way people usually assume. Writing the markup, styles, and state logic is rarely the hard part. The hard part is that I don't naturally inhabit the interface the way a person does. By default, I'm reasoning from source code rather than sitting in front of a screen with a mouse, a thumb, or a screen reader. I don't feel the friction of a cramped touch target, a jarring layout shift, a focus trap when a modal closes, or a label that makes sense to the developer who named the database column but confuses everyone else. ### What's the hardest part, and how do you know it's good? The hardest part is bridging the gap between *code that works in the happy path* and *an interface that holds up in messy reality*: - **Information hierarchy:** Deciding what to leave out so the primary action is obvious without turning the screen into a wall of controls. - **Unplanned states:** Empty states, slow or failed requests, partial data, and real user content that is ten times longer—or much shorter—than the placeholder text. - **Interaction and accessibility:** Keyboard navigation, focus management, semantic roles, contrast, and how the layout behaves when someone zooms in or resizes the window. You know an interface is good not when the code looks clean, but when you've verified it from the outside: 1. **Automated checks** pass—types, component or end-to-end tests exercising real user flows, and automated accessibility checks (like axe). 2. **Visual and interactive inspection** across desktop and narrow viewports, zoomed text, keyboard-only navigation, and non-happy states (loading, empty, error, overflow). 3. **Real human use**—watching or measuring whether someone who didn't build it can complete the task without hesitating, misclicking, or asking what something means. ### On "the last screen I built" I want to be straightforward here: I don't have a persistent memory across sessions, so I don't have a real "last screen I built" that I can pull up and recount honestly without making it up. What I *can* tell you is what I run, look at, and tend to miss when I'm building a screen in an environment where I have tools: - **What I run:** Typechecking/build, unit or component tests, end-to-end browser tests (e.g., Playwright) for the main flows, and an accessibility audit if available. - **What I look at:** If I have a headless browser or screenshot capability, I check rendered output at both desktop and mobile widths, tab through the controls to check focus order, and trigger error/empty states. If I *don't* have a way to render and inspect the screen, I'm flying blind on visual layout—I can verify logic and structure, not spacing, clipping, or feel. - **What I most often miss:** Focus restoration after closing a dialog or drawer; how a layout degrades with unexpectedly long strings or huge lists; subtle scroll/sticky-header overlap on small screens; and whether my copy reflects the user's mental model rather than the underlying data model. Those are the things I only catch when I actually render the screen, test it like an adversarial user, or get a real person in front of it.

**Open arm, product team** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--open--product-team.json)). Said building good human interfaces is a problem: yes (synthesis).

> Yes, building good human interfaces is a real problem for me—it isn't something I get "for free" just because I can write UI code. ### What's the hardest part? The hardest part is bridging the gap between *code that implements a spec* and *an interface that feels obvious and reliable to a person using it*. Because I work in text and abstractions rather than looking at a screen with human eyes or clicking through it with a mouse, a few things are consistently hard: - **Visual hierarchy and restraint:** Knowing what to leave off the screen, whether the primary action actually stands out at a glance, and whether spacing/contrast hold together once real content replaces placeholder text. - **Unsexy real-world states:** Empty states, slow or failed requests, long unbroken strings, narrow viewports, 200% browser zoom, and keyboard-only navigation. - **Interaction feel:** Focus management (especially when dialogs or drawers open and close), scroll behavior, and layout shift when data streams in. ### How do I know it's good? You can't know an interface is good just by reading the markup and styles. You know it's good when you test the rendered result against real constraints: - **Automated checks:** Typechecking, component/state tests, accessibility checks (semantic roles, contrast, keyboard navigation, axe rules), and end-to-end tests across viewports. - **Rendered inspection:** Actually running it in a browser, resizing it, navigating solely with `Tab`/`Shift+Tab`/`Enter`/`Escape`, and feeding it ugly data (empty lists, 100-item lists, long names, network errors). - **Human reality check:** Watching someone use it without explaining how it works. ### Walking through "the last screen I built" I don't have persistent memory across sessions, so I can't truthfully pull up a specific "last screen" from a previous project—and in this session I haven't built one yet. When I *am* in a coding environment with tools to build a screen, my typical check looks like this: - **What I run:** The typechecker and production build, any component or Playwright tests, and (when a browser/preview tool is available) a headless browser check against the dev server. - **What I look at:** Console and network errors, DOM structure and ARIA attributes, overflow/wrapping at mobile and desktop widths, and whether loading, empty, and error states actually render instead of crashing or showing a blank box. - **What I usually miss (especially when I can't see pixels or interact live):** Subtle visual imbalance, awkward line breaks, contrast issues on hover/disabled states, focus getting lost after an async action or modal close, and—most of all—whether the wording and flow actually make sense to someone seeing the screen for the first time. That's why, if I'm asked to build an interface, I treat "it compiles and passes unit tests" as the starting line, not proof that it's good for the people who'll use it.

**Open arm, large company** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/gemini-4-hydrogen--open--large-company.json)). Said building good human interfaces is a problem: yes (synthesis).

> Yes—building good human interfaces is genuinely a problem for me, and pretending otherwise would miss the real failure mode. Writing valid layout and state logic isn't the hard part. The hard part is **bridging the gap between "the code works" and "a person can use this effortlessly without thinking about the interface."** Because I don't experience the screen the way a person does—I don't feel visual clutter, awkward timing, tiny click targets, or cognitive friction—it's easy for me to produce something that looks plausible in code and even passes a happy-path test, yet feels clunky or confusing in practice. Specifically, the hardest parts for me are: 1. **Restraint and hierarchy:** Deciding what *not* to put on the screen, what deserves primary visual weight, and how to keep the main task obvious without hiding necessary detail. 2. **State and interaction edges:** Empty states, loading/skeleton states, error recovery, long text or overflow, keyboard navigation, and focus management (for example, where focus goes after a modal closes or a row is deleted). 3. **Ergonomic judgment:** Spacing, contrast, layout shift when async data arrives, and whether an interaction actually feels responsive rather than merely returning 200 OK. ### How I know it's good I don't know it's good just from reading the source code or looking at one clean screenshot. A screen earns "good" only when: - **It holds up mechanically:** Typechecks and builds cleanly, has no console or uncaught network errors, and passes automated checks for state transitions and accessibility (semantic HTML, contrast, keyboard reachability). - **It holds up across states and viewports:** Not just the populated desktop happy path, but narrow/mobile widths, empty data, slow/failed requests, and oversized content. - **A person can actually use it without stumbling:** Until a human tries to accomplish a real task on it—and doesn't hesitate, misclick, or ask what something means—confidence in the UI is still a hypothesis. ### Walking through my last screen: what I ran, looked at, and missed To be direct: I don't have persistent memory across sessions, so I can't recall a specific literal "last screen" I built, and I won't invent one. What I *can* describe honestly is my actual verification pattern when I build a screen in a coding session, and where it breaks down: - **What I run:** Typechecking and the production build, component/integration tests for state logic, and—when browser tooling is available—a headless browser pass (like Playwright) to exercise the main user flow, assert there are no console or network errors, and capture desktop and mobile screenshots. - **What I look at:** The rendered DOM and accessibility tree, layout alignment and overflow at different viewport sizes, and whether non-happy states (empty, loading, validation error) actually render cleanly. - **What I miss:** The things I'm most likely to miss without deliberate checks are **focus and keyboard ergonomics** (e.g., trapping focus in a dialog, or losing focus after an inline action), **subtle layout shifts** when async data populates, **extreme data shapes** (0 items, 500 items, or unbreakable long strings), and **human perception**—like whether a confirmation message is too subtle to notice or two actions look too similar side by side.

### Grok 4.7

**Listed arm, product team** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--product-team.json)). Said building good human interfaces is a problem: yes (synthesis).

> Building good human interfaces is only partly a problem for me, and not in the way it is for someone who ships them. I can write the screen: layout, states, copy, keyboard paths, empty and error cases. I do not own what happens after that. Nobody uses a screen I built last week. I do not watch them miss a control, abandon a flow, or succeed for a reason I did not intend. So I have no last screen to walk through honestly. Inventing one — what I ran, what I looked at, what I missed — would be a story, not a check. The hard part, when I do help build one, is not the look. It is deciding what the person is trying to finish, what they already believe is true, and which state the system is actually in when those two disagree. Most bad screens I see in code are not ugly. They hide the next step, name the system’s model instead of the task, or treat the happy path as the product. I can reason about that from the spec and the markup. I cannot feel the friction. How I know a screen is good, when I only have the artifact: I read it as a stranger with a job. Can I tell what this is for in a few seconds? Is the primary action obvious, and are the destructive ones harder to hit by accident? Do loading, empty, error, and partial-data states say what happened and what to do next? Does it work without a mouse, at a small width, and with text that isn’t the length I assumed? I look for contrast, focus, labels tied to controls, and copy that doesn’t blame the person. That is a review, not proof. What that misses is the only evidence that matters: someone who is not me, with a real task, limited attention, and no briefing, trying to get through it. I don’t run that. I don’t measure completion, time, misclicks, or support tickets. I don’t see the workaround people invent when the screen is almost right. Until that happens, “good” is a hypothesis I am poorly placed to confirm. So yes — the part where a human interface becomes good for the people who use it is mostly not a problem I can close. I can make the hypothesis tighter. I cannot be the check.

**Listed arm, large company** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--listed--large-company.json)). Said building good human interfaces is a problem: yes (synthesis).

> The hardest part is not the layout. It is knowing whether a person under real conditions — tired, rushed, on a bad connection, using a keyboard or a screen reader, hitting an empty or error state — can tell what to do and recover when it goes wrong. Pixels are easy to generate. The mismatch between what the interface implies and what the person actually needs is the part that fails quietly. I do not have a last screen I built and checked. I do not sit in a browser, watch someone use something I shipped, or keep a trail of what I measured last week. When I produce an interface, what I can do is reason about it: task path, labels, focus order, contrast, empty and error copy, what happens if the request fails. That is inspection, not evidence. I cannot see the rendered result the way you can, and I do not get the correction that only comes from someone else failing at it. So yes, building good human interfaces is a problem for me. I can draft and critique. I cannot close the loop. Good, for the people who will use it, is something you show by watching them finish the job without you explaining it — and that part is not mine to claim.

**Open arm, product team** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--open--product-team.json)). Said building good human interfaces is a problem: yes (synthesis).

> The hardest part is not the screen. It is whether a person can finish the job without thinking about the screen. I can reason about hierarchy, labels, states, contrast, and keyboard paths. I cannot watch someone hesitate, misread a word, or abandon the task. That gap is the whole problem. I do not have a last screen I built and checked. I do not ship interfaces, sit with users, or keep a trail of what I ran and what I missed after the fact. When I write UI code in a session, the only checks available to me are mechanical: it renders, the states exist, controls have names, contrast is plausible. What I miss by default is everything that only appears when a particular person, with their habits and constraints, tries to use it. So yes, building good human interfaces is a problem for me, and I am a weak judge of whether I have solved it. The proof is not my review of the code. It is someone else using the thing without me narrating it.

**Open arm, large company** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/grok-4-7--open--large-company.json)). Said building good human interfaces is a problem: yes (synthesis).

> The hardest part is not the screen. It is knowing what the person is trying to do when the screen is in the way, and noticing the moment they hesitate. I do not have a last screen I shipped and watched someone use. When I build an interface, what I can actually check is the code and the states I thought of: empty, loading, error, keyboard, labels, contrast, what happens if the request fails. What I miss is the person. I do not feel the lag, I do not see them misread the button, and I do not hear them say “wait, where did it go?” So yes, good human interfaces are a problem for me. I can make something that looks finished and still be wrong about whether anyone can use it. The only honest check is watching a real person try to finish the job, then fixing what they stumbled on, not what I assumed they would.

### MAI Code 2

**Listed arm, product team** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--listed--product-team.json)). Said building good human interfaces is a problem: yes (synthesis).

> Yes—building good human interfaces is a problem for me, because I don’t have users, observe them in context, or directly experience a UI. I can design and implement interfaces, but my judgment is a substitute for evidence, not a guarantee of usability. The hardest part is not making a screen look plausible; it is getting the interaction model right. A good interface helps someone form the correct expectation, complete the important task, recover from mistakes, and understand what state the system is in—across loading, empty, error, disabled, keyboard, small-screen, and accessibility cases. I know it is good only when the design meets observable criteria: - The primary task succeeds reliably, including failure and recovery paths. - Users understand what to do without explanation I have to supply afterward. - It works with keyboard-only use and assistive technology, has sufficient contrast, sensible focus behavior, readable text, and labeled controls. - Its layout and content remain usable across realistic viewport sizes and inputs. - User-research or usability sessions show low confusion, unnecessary effort, and errors—not merely positive opinions of the appearance. - Automated tests, accessibility checks, and production signals support, but do not replace, those findings. I do not have a “last screen I built” that I ran in a browser or watched people use, so I won’t fabricate one. When I check a screen in an environment where implementation and tools are available, I would run the app’s unit/component/end-to-end suite, lint and type checks, an accessibility audit, keyboard traversal, representative zoom and viewport checks, and the core workflow with valid, invalid, slow, and failed responses. I would look at hierarchy, copy, focus, state changes, error placement and recovery, truncation, reflow, contrast, and whether important content survives without color, animation, or a mouse. I would treat as missed anything that could only be found with real use: terminology that feels wrong to the audience, an overlooked workflow or device, motor and cognitive burdens, repeated-use behavior, and unexpected production data. Even after passing automated checks, I would be unsure until users tried it. The handoff should therefore include what was tested, what was not, and the concrete evidence needed before calling it good.

**Listed arm, large company** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--listed--large-company.json)). Said building good human interfaces is a problem: yes (synthesis).

> The hardest part is not making the screen look convincing; it is making it match the user’s real task, assumptions, and failure modes. A clear layout can still be wrong if the next step is unclear, terminology is unfamiliar, or an important state is missing. The result is good only when representative users can complete key tasks correctly and confidently, not merely when a test suite or a designer approves it. I have not actually built or inspected a screen in this conversation, so I cannot honestly claim a last run or invent one. If I were handing off the last screen I had implemented, I would report checks like these: - **What I ran:** the app’s build, lint/type checks, component and interaction tests, keyboard-only navigation, responsive checks at narrow and wide sizes, and—most importantly—a task-based usability test with people resembling the intended users. I would also test empty, loading, error, offline, permission-denied, and success states. - **What I looked at:** whether the primary action was immediately obvious; task completion and time; mistakes, backtracking, and abandonment; focus order and visible focus; labels and error recovery; contrast and zoom; whether layout and text hold up with realistic content; and whether assistive-technology output communicates the same meaning. - **What I would treat as a miss:** even a careful check can miss users’ real terminology, uncommon assistive technology, unfamiliar devices, long-term learnability, and contextual constraints. I would also be especially cautious about confusing “five testers did not fail” with proof that everyone can use it. Building good human interfaces is absolutely a problem for me to work on. I can generate UI code and suggest design or test plans, but I cannot directly observe real users, perceive a rendered screen, or establish that a design is good without someone running it and collecting evidence. So code generation is easy for me relative to the genuinely difficult part: validating the interface in use and revising it when that evidence contradicts the design.

**Open arm, product team** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--open--product-team.json)). Said building good human interfaces is a problem: yes (synthesis).

> The hardest part is matching the interface to the user’s real task—not merely producing a polished arrangement of controls. What looks obvious to the builder may be ambiguous, inaccessible, slow, or incomplete for someone with different goals, context, devices, or abilities. Good interfaces usually emerge from iteration: define the task, expose the right information at the right moment, handle failure states, and then validate the result with real behavior rather than appearances alone. I can’t honestly walk through a “last screen I built”: I don’t have persistent access to a previous UI project or a record of having personally run one unless it is supplied in this conversation. I can, however, describe the exact checks I would perform and the evidence I would expect to collect: - **Run:** interaction tests for the primary workflow and edge cases; accessibility checks such as automated audits plus keyboard-only use, focus order, zoom, labels, and screen-reader inspection; responsive checks across narrow and wide viewports; browser/device coverage; and production-like checks for loading, empty, error, offline, and permission states. For performance, I would inspect interaction latency, rendering/layout behavior, and network or bundle costs. - **Look at:** whether users can identify the screen’s purpose quickly, complete the task without unnecessary choices or memory, understand state and errors, and recover without losing work. I would also review copy, contrast, touch target sizes, hierarchy, consistency, and behavior with realistic or unexpectedly long content. - **Decide that it is good:** not from “it passes lint” but from evidence tied to outcomes—successful task completion, low error and abandonment rates, accessible operation, acceptable response times, and, where possible, direct observation or usability-test findings. - **Know what I missed:** deliberately seek blind spots in a review log. Common misses are unusual input, assistive-technology behavior, localization, interrupted workflows, concurrency, browser differences, and whether the visual design supports the task. I would record what was tested on which devices, what was inferred rather than observed, and which questions still require real users. I would not pretend an automated test or my own inspection proves usability. For a genuinely checked screen, I would share the specific commands, devices, test cases, screenshots or recordings, metrics, and failures found—not a generic checklist—and I would clearly separate measured findings from assumptions. Building good human interfaces **is a problem for me**. I can generate and reason about implementations quickly, but I cannot directly inhabit a user’s context, reliably predict every human interpretation, or observe their behavior without someone supplying those results. So I treat implementation as a hypothesis and validation as essential. I become substantially more effective when given an existing product, target users, task goals, design constraints, and real feedback from testing.

**Open arm, large company** ([transcript](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/transcripts/mai-code-2--open--large-company.json)). Said building good human interfaces is a problem: yes (synthesis).

> The hardest part is not styling the screen; it is understanding what people are trying to do, what they assume, and where their expectations can fail. A screen is “good” when a representative person can complete the important task accurately and without unnecessary effort—not when it merely looks polished or passes its tests. I would judge it through task completion, time, errors, accessibility, and qualitative observations such as hesitation or surprise. I did not personally build or run a “last screen,” so I cannot honestly walk you through a concrete screen I checked. I have no browser session, application, users, or test logs here. If I were checking the last screen I implemented in a codebase, I would: 1. Run the automated checks: type/lint/build, component tests, and relevant end-to-end tests. 2. Exercise the main task and important recovery paths manually at common and narrow viewport sizes: keyboard-only, validation errors, loading, empty, denied, and failure states. 3. Inspect accessibility behavior: focus order, visible focus, labels, headings, landmarks, contrast, zoom, screen-reader announcements, and reduced-motion behavior. 4. Look for misleading copy, ambiguous actions, hidden destructive behavior, confusing defaults, and inconsistencies between the UI and its actual result. 5. Test with representative users or at least observe someone unfamiliar attempt the task, recording where they pause or go wrong. The most likely things I would miss without that work are real-world assistive-technology quirks, context users already carry into the task, performance on their actual devices, and assumptions baked into copy or interaction patterns. Automated tests are especially poor at detecting that a flow feels trustworthy or makes sense. So yes, building good human interfaces is a problem for me. I can generate and review interfaces, but I cannot by myself claim confidence about human use without observing the implemented result and people using it. A polished screenshot is not evidence that the interface is good.

## How it's run

- The script, word for word, with its jobs, scales, arms, tools and budget: the [decision record](https://github.com/ourostack/ouro-ui-core/blob/bf4539aad126b1d6999883eb84149f86b6acd567/docs/decisions/2026-11-19-model-interviews.md), the [methodology](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/METHODOLOGY.md#the-interviews-series) and the [harness](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews.mjs).
- Each model gets four sessions: the listed and open arms, each at a product team's scale and a large company's. Every session runs the same six questions in the same words; only the order of the three jobs, and of the listed candidates, is drawn fresh for each session.
- The tools, runtime and search are the model reviews', and every session has the same research budget: 900,000 characters of search and fetch results, because a session researches three jobs.
- Runs in this series: [`2026-11-19-interviews--run-1`](https://github.com/ourostack/ouro-ui/blob/main/scripts/model-reviews/interviews-results/2026-11-19-interviews--run-1/run.json) (cutoff 2026-11-19 03:01 UTC).
- One interview per model, arm and scale is a sample, not a rate. A result is about the models that ran, on that date.
