Oracle Fusion · Proto Runner

A system for product teams to prototype in the platform and deliver new patterns and solutions

When

2026

Duration

3 months

Role

Design Engineer, strategy lead

Team

Two design engineers

Agentic prototyping
Agentic app prototyper
Agentic app prototyper loaded
  1. Loading the Agentic app prototyper plugin
  2. Using the gather-platform-context skill
  3. Using the resolve-product-rules skill
  4. Using the inspect-component-library skill

The plugin is ready. Please upload or share any context about the use case and we'll create an agentic app environment for you to prototype within.

Generate a prototype

What we built

A Codex plugin that turns a prompt, a PRD or a Confluence page into a working, on-system prototype. Product teams prototype inside validated platform patterns, and designers bring coded, responsive proposals that are easier to ship.

Impact

100+ internal users within two weeks of release.

The problem

Everyone was prototyping with AI. Nothing looked like the product.

Off-platform

Vibe-coded prototypes ignored what the platform can actually do and how it behaves.

No visual parity

None of them looked like the product, and designers were left to clean up.

Design sidelined

Design got reduced to visuals, not the problem, the solution, or how the product works for a person.

The goal

One place the whole product team can prototype in, true to the platform, fully wired, and built from the components shipping in that release.

How it works

What you get in the browser

Proto Runner builds it in Codex from your PRD. Everything after that happens in the browser.

  1. 01

    Ask in Codex

    Point the plugin at a PRD, a Confluence page or a prompt. It reads the platform's context, resolves the product rules and inspects the component library before it writes anything — then builds the environment.

  2. 02

    Open it in the browser

    A working prototype, not a picture of one: real content, approved components, responsive, and every click path already wired — because the runtime was built before the agent ever ran.

    localhost:3000
    The generated prototype served on localhost: a greeting, the Ask Oracle composer with its Work, Research and Full Auto modes, and three suggested work cards.
  3. 03

    Author it, then share it

    Turn on the pencil and every editable region outlines. Change one in the panel and each save is a new revision. Write the agent's replies to build a flow for the demo, then publish a viewer-only copy for colleagues to review.

Impact

Show the behavior, not the screen

Product teams can rapidly prototype and iterate within the validated platform capabilities and patterns, and designers can bring coded, responsive proposals about how the product works, not just how it looks. Because they're built in-system, they're meant to be easier to ship.

100+ internal users within 2 weeks of release.

Proto Runner featured on Oracle Design's Experiment Hub

The foundation

Reference the platform, don't regenerate it

Before any agent work, we built the foundation the agent stands on: a coded component library and a runtime. Instead of pages of rules describing how components look and how the platform behaves, both already exist as code. The agent writes content, and the real foundation renders it. Below is one page from that library, running — take it apart.

Why a coded component library?

Generating UI on every ask drifts from the design, burns tokens and varies run to run. Referencing real components keeps every prototype on-system, for less.

Generate on every ask (.md file)Reference the foundation
ParityComponents re-invented on every prompt, drifting from Figma.1:1 with the design team's toolkit: the same code engineering consumes.
CostMarkdown describes each component; the agent rewrites it every run.The agent pulls only the source it needs. Fewer tokens, faster runs.
ConsistencyResults vary run to run.Every screen composed from the same pre-QA'd components.
BehaviorRules explain how pages link and APIs respond; the agent re-implements them every run.The runtime already wires the pages, APIs and touch points. The agent fills in content.

A coded runtime we can reference

Rather than write rules for how the platform works, we built it, so each prototype starts as a working piece of the platform, not a mockup of one. That saves compute for generating content and selecting the right components.

The runtime rendering a generated Hiring Center page: a summary of why pipeline coverage is below target, a screening section listing three requisitions with their risks, and an action panel of priority actions down the right.

hiring-center.page.tsx

<AppPage app="Hiring Center">
  <PageSummary
    headline="Hiring pipeline coverage is below target"
    sources={["Requisitions", "Screening"]}
  />

  <Section name="Screening" widget="list">
    <Record title="#12938 Food Prep Support" risk="Critical" />
    <Record title="#18372 Grocery Stock Lead" risk="High" />
  </Section>

  {/* Action panel, follow-ups */}
</AppPage>

Architecture

A plugin of focused skills

Seven skills, each with one job, running in order. Five of them reach into the foundation — the library for what exists, the runtime for how the platform behaves.

  1. 01
    gather-platform-context

    Reads the runtime's schema: what the platform already is.

    Touches the runtime.
  2. 02
    resolve-product-rules

    Loads design.md and the component rules before anything is chosen.

  3. 03
    inspect-component-library

    Indexes what Storybook has marked approved and available.

    Touches the component library.
  4. 04
    match-components-to-intent

    Picks the template and components the use case calls for.

    Touches the component library.
  5. 05
    generate-content

    Writes product content into a validated JSON model. No UI code.

  6. 06
    scaffold-prototype

    Hands the model to the runtime and wires the project.

    Touches the runtime.
  7. 07
    open-local-preview

    Serves it locally; the runtime renders the real components.

    Touches the runtime.
A running prototype, rendered by the real runtime.

The context it reads

Before choosing anything, the skills read design.md for how a prototype should look and behave, and the component rules for which part of the library fits each use case.

Context

design.md

Principles

  • Compose from the library. Never write new UI.
  • Start from the page template closest to the task.
  • One primary action per view.
  • Wire every touch point. No dead ends in a demo.

Content

  • Plain, specific language, in the product's voice.
  • Realistic data from the use case, never lorem ipsum.

Layout

  • Spacing and color come from tokens only.
  • Responsive by default: check narrow widths before preview.

Iteration

What we learned in the process

  1. 01

    Split the big skill

    One skill worked, but when something broke there was no telling where. Focused skills mean every fix lands in exactly one place.

  2. 02

    The library drifted

    The first version went stale fast. The library became versioned and pinned.

  3. 03

    “I can't share this”

    Users wanted colleagues to see their work, so hosting and share-out were added.

  4. 04

    Stricter templates ✓

    Tighter page controls and templates in Storybook made generation far more consistent.

Next steps

From using the system to growing it

The same tokens and foundations that keep prototypes on-system can generate what the system doesn't have yet: new components and new patterns, proposed back to the platform.

  1. 01

    Generate from tokens

    When a use case needs something the library doesn't have, the agent builds it from the same tokens and foundations, so it's on-system from the first render.

  2. 02

    Prove it in the platform

    The new component runs in the runtime next to approved ones, responsive and wired, and is flagged as proposed rather than approved.

  3. 03

    Propose it back

    Design brings a coded, working proposal to review. Once approved, it joins the library for every team, and engineering starts from code instead of a picture.