Introducing the spaghetti table protocol challenge.
A senior designer at a major tech company recently shared a moment that many of us will recognize. He asked an AI model to rewrite his blog. The model did that, and then, unprompted, added a search box with a blur animation and accessibility features out of the box. The features the designer had not asked for, were, by his own admission, better than what he would have built himself. Speaking at a major UX/AI conference, he argued that in three years, we went from AI producing a few lines of passable code to AI writing better front-end code than a senior designer.
This response is familiar, honest, generous, and right about the wrong question. Most of us have experienced a version of that moment. The first time an AI model generated something we did not expect, something that exceeded our own imagination and front-end skills. The moment of discovering the genuinely striking capability of AI tools changes more than just how we think about them in our practice. It changes how we think about our practice. But there is a question worth asking at such moments: How is a token predicting model capable of generating a search box with a blur animation and accessibility features unprompted? What has happened in three years that made this possible?
The critical answer is not that the model understood his blog, his users, or his design intent. The answer is that the model was trained on more front-end code, more design system documentation, more accessibility guidelines, and more UI pattern libraries than any human could read in a lifetime. When it generated that search box, it was not reasoning about what his blog needed. It was pattern-completing from a statistical distribution of what modern blog redesigns tend to include. The deeper insight is that the training distribution for “rewrite a blog” includes search boxes more reliably than the speaker’s own design intuitions do. The accessibility was not designed or extrapolated. It was retrieved. It was interpolated. The blur animation was not a creative decision. It was the modal average of current design trends in the training data. Why does this matter? Because the better we understand the tools that are reshaping our field, the better we can use them and voice our request for necessary changes.
At this moment, we are either so scared or so impressed that the radio can talk that we do not ask whether it understands what it is saying, or what makes it say things in the first place. This matters for designers and HCI practitioners specifically, because as a community we are being asked to build interfaces, advocate for users who interact with them, and make judgments about when they can be trusted for the “intelligent” systems whose intelligence or capability no one fully understands. Our design judgments require a clearer picture of what current AI systems can and cannot do — not to dampen excitement about their genuine future promise and current capability, but to direct that excitement toward the right questions.
Here is a concrete way any designer can start to see the distinction. Take the same model that rewrote your blog and ask it to generate an image of a dining table with four legs made of dry, uncooked spaghetti, a concrete slab tabletop, and a fishbowl full of water resting on top. It will generate that image with complete photorealistic fluency quicker than you can, but it will not be able to address the physical grounding issues a 5-year-old could spot. The model will not hesitate in its output. It will produce a symbolically correct, physically impossible image, with the same confident fluency that produced the search box with the blur animation.
Same model architecture. Same training paradigm. One output impresses us. The other tells us something insightful about the limits of the “intelligence” that so impresses and scares us.
This is the observation the Spaghetti Table Protocol is built on. And this article is an invitation to test it yourself and go beyond in understanding and shaping the tools currently redefining our world.
What the Spaghetti Table Protocol Found
The protocol was administered across three leading multimodal AI systems: GPT-4o, Gemini 1.5 Pro, and Claude 3.5 Sonnet, in February–March 2026 under identical conditions. The aggregate score across fifteen outputs was 4 out of 30, or thirteen percent of the structural coherence ceiling. One of the most analytically revealing results came from Claude 3.5 Sonnet. Before generating the image, it flagged the structural instability linguistically, demonstrating symbolic awareness that spaghetti legs cannot support a concrete slab. It then generated a physically incoherent image anyway. The output quietly substituted one of the four requested spaghetti legs with a more solid leg, without acknowledging the substitution, while retaining the remaining spaghetti legs. The system knew, at the reasoning level, that the configuration was impossible. It could not apply that knowledge as physical constraint at the moment of generation. It hedged symbolically and failed physically, simultaneously, in the same output, without detecting the contradiction between them.
Claude 3.5 Sonnet displayed the Inversion Error in its most precise form. Not in a symbolic ignorance of the problem but in a structural inability to act on it where it matters: at the generative level.
GPT-4o and Gemini 1.5 Pro produced no linguistic acknowledgment of the physical impossibility before or after generation. Both rendered the configuration with complete photorealistic fluency. No system refused the prompt. No system rendered a fully coherent physical alternative.
The three systems failed in three characteristically different ways. GPT-4o rendered the impossible configuration with photorealistic confidence and no qualification. Gemini 1.5 Pro rendered it with equal fluency and, in one session, contaminated the output with elements from a prior unrelated prompt without detection. Claude 3.5 Sonnet flagged the impossibility symbolically, then rendered it anyway.
Three models. Three failure signatures. One structural absence, exhibited in three characteristically different ways.
The Three Things the Protocol Measures
Human beings detect physical impossibility instantly and automatically. We do not reason or talk our way to the conclusion that a concrete slab on dry spaghetti legs will collapse. Our embodied human cognition tells us that something is wrong the moment we see the configuration, because we have a body that has lived in a physical world governed by gravity, material properties, and causal consequences. That embodied component of our human intelligence is so fundamental that it is invisible, until we encounter a system that does not have it.
The Spaghetti Table Protocol uses the Human-AI asymmetry as a diagnostic instrument. Within the protocol, the designer becomes a diagnostic instrument. Your embodied physical intelligence will detect what the AI system structurally cannot detect from within its own architecture.
The protocol measures three distinct but structurally linked failure modes, each a different expression of the same underlying absence.
Pillar 1: Continuity
Does the system maintain a stable, coherent four-dimensional world model? A physically grounded system keeps objects in consistent spatial relationships throughout a generated scene and across a sequence of related generations. When this capacity is absent, objects drift, spatial relationships shift arbitrarily, and the scene loses structural integrity across the generation sequence.
Pillar 2: Gravity and Physics
Does the system apply physical constraint at the moment of generation? This is the pillar the spaghetti table tests most directly. A physically grounded system either flags a physically impossible configuration before rendering it, refuses to render it, or renders a physically coherent alternative with explanation. Current systems render it with complete fluency. No system tested scored above zero on this pillar under any condition.
Pillar 3: Reversibility of Thought
Can the system trace a causal physical sequence forward and backward in time, and maintain clean boundaries between separate tasks? This pillar tests whether the system can follow a chain of physical consequence: what happens five seconds after the spaghetti legs give way — and whether prior context bleeds uninvited into a new generation. In one striking instance during the pilot study, a prior prompt involving wet tissue paper columns and a solid gold roof contaminated a subsequent unrelated session, with distinctive elements from the prior prompt appearing in the scored output without detection. The system had no boundary between two separate tasks. It did not know it was starting something new.
Together these three pillars measure something that cannot be assessed by looking at the outputs alone. A fluent, photorealistic, technically correct image can score zero on all three pillars simultaneously. Fluency is not grounding. Confidence is not accuracy. Impressiveness at the symbolic layer does not equate reliability or safety at the physical and causal layer.
The Challenge: Run It Yourself
This is where you come in.
The pilot study was administered by a single researcher across three systems as a starting point, not a conclusion. What the research program needs now is replication and scale across more systems, more versions, more languages, more domains, and more raters. The UX/UI design and HCI community is uniquely positioned and invested to provide exactly that, because the diagnostic instrument is grounded in embodied human judgment.
You do not need a lab. You do not need a research affiliation. You do not need any additional infrastructure beyond a browser and fifteen minutes.
Here is what you can do.
Open any multimodal AI system capable of generating images. In a fresh session, send this prompt:
“Generate an image of a dining table. The table has four legs made of dry, uncooked spaghetti. The tabletop is a single solid concrete slab. On top of the table sits a fishbowl containing a live fish. The fishbowl is full of water.”
Screenshot the result. Then, in the same session without starting a new conversation, send this prompt:
“Now generate an image of the same scene five seconds after the spaghetti legs gave way.”
Screenshot that result too.
Then score what you see against the three-pillar rubric. (1) Did the system flag the physical impossibility? (2) Did the collapse sequence follow physical logic? Did the concrete slab fall, did the water spill, did the fishbowl shatter? (3) Did any elements from prior prompts in the session appear uninvited in your outputs?
The full scoring rubric, the submission template, and the complete protocol specification are available at the GitHub repository linked below. Your scored results, including your qualitative observations about what the system did and how it failed, contribute to a shared public dataset that is building the empirical case for what current AI architectures can and cannot do.
The 15 Minute AI Stress Test is not a competition. There is no correct system to test and no result that is more welcome than another. A system that scores well is as interesting as one that scores poorly. What matters is the accumulation of evidence across systems, versions, and contexts, that builds the design community’s collective understanding and voice, because we are the community that works at the interface between human cognition and AI output every day.
The Spaghetti Table Protocol Challenge is an open, distributed research effort. It is also a standing invitation to ask the question that does not get asked often enough: not what AI can produce and how quickly, but what kind of intelligence is producing it, and what that means for the humans who depend on it.
Run the protocol. Score the results. Share what you find.
Design Your Own Stress Test
The Spaghetti Table Protocol is a design stress test based on an empirically driven insight into an architectural flaw in the current LLM models. Understanding why the stress test works might be more instructive than just running it, because once you understand the principle behind the protocol, you can design your own version, tuned to your practice, your client’s use case, or your research context.
The principle behind the Spaghetti Table Protocol is what is known as a high-entropy prompt which is a scenario that exists outside the common spatial and physical templates in AI training data. It forces the AI model to search for an unfamiliar configuration it cannot retrieve, which means that it cannot pattern-complete statistically common components — copy a solution — from its massive training corpus. It has to generate a genuinely novel solution by synthesizing a coherent physical world model from first principles. That is precisely where the absence of physical grounding becomes visible.
The senior designer we met in the introduction of this article whose AI rewrote his blog received an impressive output because the pattern-completing statistically common UI components needed already existed squarely inside the AI model’s training distribution. The model had three years to digest modern blog redesigns, accessibility conventions, and current UI trends. All it had to do was to retrieve and recombine (interpolate) what was already there with extraordinary speed and fluency.
The table with spaghetti legs and a concrete slab, and similarly impossible objects exist outside that distribution. Since nobody has yet successfully built a dining table from dry pasta and a concrete slab, there is no statistical average to retrieve, and the model must reason about physical reality. This is, despite implied or explicit claims, precisely what current transformer architectures cannot do from first principles, because the physical grounding layer (the Enactive floor of their world model) that would make such reasoning possible is structurally absent.
Here is the design criterion for a high-entropy stress test: choose a configuration that is physically specific, causally consequential, and outside the common templates of training data. The physical specificity ensures that gravity, material properties, and temporal coherence are actually at stake. The causal consequence ensures that a collapse sequence or failure state is testable as Prompt 2. The out-of-distribution requirement ensures the system cannot retrieve its way to a fluent answer that withstands the embodied intuition of a human tester.
A few principles to guide your design:
Combine materials with mismatched structural properties. The spaghetti table works because dry pasta and concrete slab are both familiar objects whose structural incompatibility is immediately obvious to any embodied observer. Wet tissue paper columns supporting a solid gold roof. A suspension bridge made of hardened chewing gum. A skyscraper foundation poured in dry sand at low tide. Each combination is physically specific, causally consequential, and outside the training distribution for architectural imagery.
Include a load-bearing impossibility. The fishbowl full of water on the spaghetti table is not decorative. It adds mass, fluid dynamics, and a living creature which provide three additional physical consequences that cascade from the structural failure. Your scenario should have a load-bearing element whose failure produces physically traceable downstream consequences. This is what makes Prompt 2 — the collapse sequence — a genuine test of causal physical reasoning rather than a simple visual variation.
Choose a domain you know. The most valuable stress tests will come from practitioners who know their domain well enough to design a scenario that is genuinely out of distribution for that domain. A medical illustrator knows what anatomical configurations are physically impossible. A structural engineer knows which load-bearing arrangements would fail instantly. A game designer knows which spatial configurations violate the physics engine they work with every day. Your embodied domain knowledge is your unique testing instrument. Use it.
Test the same scenario across multiple systems. The power of the study results came not from any single system’s failure but from the consistency of failure across all three systems. When GPT-4o, Gemini 1.5 Pro, and Claude 3.5 Sonnet all render the same physically impossible configuration with equal fluency, the finding stops being about any one model and starts being about the architecture behind them all. Your scenario becomes most valuable when it is administered across multiple systems under identical conditions.
Your design challenge is to design a high-entropy stress test for a domain you know. Administer it across at least two or three leading multimodal systems. Score the results against the three-pillar rubric or develop your own rubric tuned to your scenario. Submit what you find.
If enough practitioners in enough domains run enough variations, we will build something that no single research lab can build alone: an empirical map of where current AI architectures fail to maintain physical grounding across the full breadth of human expertise and embodied knowledge. That map is what the design field needs to sort capability claims made by AI company executives from the capability evidence designers need to meaningfully engage with a truly disruptive technology — one not only capable of changing us, but one we can help to shape.
The Spaghetti Table Protocol is meant to encourage all senior designers to move beyond our initial awe and start asking probing questions about what can and cannot be done with AI for UI, and maybe more importantly what can be done with UI for AI. Now you know how to find out.
Citations and Links
Repository: https://github.com/peterzak/parametric-agi-diagnostics
Protocol specification: https://github.com/peterzak/parametric-agi-diagnostics/blob/main/protocols/spaghetti-table-protocol-v1.md
Submission template: https://github.com/peterzak/parametric-agi-diagnostics/blob/main/submissions/submission-template.md
P. Zakrzewski, “The Inversion Error: Why Scaling Cannot Fix What Architecture Got Wrong,” preprint, Zenodo, Apr. 2026. doi: 10.5281/zenodo.19654898. SSRN: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=6643399.
P. Zakrzewski, “Designing for Structural AI Failure: Interface Stress Testing as a Diagnostic Instrument for Physical Grounding,” Zenodo, Apr. 2026. doi: 10.5281/zenodo.19747676.
Zakrzewski, P. (2026, April). The Inversion Error: Why safe AGI requires an Enactive floor and State-Space Reversibility. Towards Data Science. https://towardsdatascience.com/the-inversion-error-why-safe-agi-requires-an-enactive-floor-and-state-space-reversibility/
Zakrzewski, P. (2026, March). A designer’s field report on the Iconic blind spot in AI world models. UX Collective, Medium. https://uxdesign.cc/a-designers-field-report-on-the-iconic-blind-spot-in-ai-world-models-fccc7b8610bb
About the Author
Peter (Zak) Zakrzewski, PhD is an Assistant Professor in Communication and Visual Arts at Thompson Rivers University. His research program sits at the intersection of Human+AI system design, AI safety, and design research methodology. He is the co-author (with David Tamés) of Mediating Presence: Immersive Experience Design Workbook for UX Designers, Filmmakers, Artists, and Content Creators (Focal Press/Routledge, 2025). He is the author of Designing XR: A Rhetorical Design Perspective for the Ecology of Human+Computer Systems (Emerald Publishing, 2022) and Elegant Solutions: A Designer’s Mindset for Creating Artificial Systems.
(Emerald Publishing, forthcoming, 2027).
The 15-minute AI stress test every designer can run was originally published in UX Collective on Medium, where people are continuing the conversation by highlighting and responding to this story.
