Deconstruct

Turn any everyday object into a safe, validated, interactive 3D science lesson—revealing how its parts work, what they’re made of, and how they’re manufactured.

Comment

Deconstruct

One-line pitch

Deconstruct turns an everyday object into a safe, interactive 3D science lesson inside ChatGPT—from its hidden parts to the raw resources and manufacturing journey behind them.

The idea

There is a particular kind of learning that happens when an object finally opens.

A casing comes off. A motor, spring, circuit board, lens, fan, or gear becomes visible. What looked like a mysterious black box suddenly becomes a system that can be understood.

But real teardowns are not practical for most learners. They cost money, destroy useful products, require tools, and may expose batteries, sharp parts, stored energy, heating elements, capacitors, or other hazards. Repair videos help technicians, but they rarely connect structure, materials, natural resources, and manufacturing in a way designed for a young learner.

Deconstruct connects those missing pieces.

A learner can describe an object—or show ChatGPT a clear photo—and receive an interactive 3D exploration. They can separate its major systems, inspect what each part does, trace its materials back to raw resources, and follow the journey that turns those resources into a finished product.

The physical object stays intact.
The curiosity does not.

What Deconstruct does

Deconstruct is a ChatGPT App for exploring the hidden structure, materials, and manufacturing of everyday objects.

A learner can ask:

What is inside this stapler? Create a safe 3D exploded learning view, trace its materials to raw resources, and show how it is manufactured. Explain it for a 13-year-old learner.

GPT-5.6 interprets the request or image and creates a structured educational specification called an ExplorationSpec. Deconstruct validates that specification and renders it as an interactive Three.js experience directly inside the conversation.

The learner can:

  • move continuously between assembled and exploded views;
  • rotate the object and select numbered components;
  • focus on an individual part and understand its function;
  • trace a part from material form to material and raw resource;
  • follow the manufacturing process from extraction to final testing;
  • see whether information is observed, typical, or estimated;
  • continue asking questions in the same conversation.

There is no CAD workflow to learn and no separate interface for object recognition, visualization, materials research, and follow-up questions.

The conversation is the interface.

More than an exploded view

An exploded view answers one question:

What is inside?

Deconstruct connects four:

  1. What is inside?
  2. What does each part do?
  3. What is it made from?
  4. How did those resources become this object?

For every major component, Deconstruct can create a material chain:

part → material form → material → raw resource

For example:

motor winding → enamelled copper wire → copper → copper ore

It then connects those materials to a chronological manufacturing journey covering extraction, refining, material processing, component fabrication, assembly, finishing, and testing.

The result is not a collection of disconnected facts. Parts, materials, and manufacturing become one continuous learning story.

The learning experience

Interactive 3D structure

  • Live Three.js scenes rather than rendered screenshots
  • Continuous assembled-to-exploded movement
  • Numbered callouts and component selection
  • Focus, reset, camera recovery, and automatic framing
  • Compound shapes, repeated structures, curved connections, radial layouts, and hinged arrangements
  • Assembly-position ghosting that preserves spatial context

Materials and resources

  • Component-level material chains
  • A distinction between material form and base material
  • Links from manufactured materials back to natural resources
  • Explanations adapted to the requested learner level

Manufacturing journey

  • A chronological roadmap from resource extraction to final testing
  • Steps connected to the same parts and materials shown elsewhere
  • A coherent process story rather than a generic list of factory operations

Accessible interaction

  • Responsive desktop and mobile layouts
  • Keyboard navigation
  • Reduced-motion behavior
  • WebGL fallback
  • Onboarding and replayable guidance

The same declarative renderer can represent electronics, optical products, radial assemblies, hinged objects, and other everyday products without relying on a dedicated scene coded for each object.

Honest uncertainty

A useful educational model should not pretend to be an exact engineering reconstruction.

A photo may reveal an object’s exterior while leaving its internal arrangement hidden. Different models within the same product category may also use different components.

Deconstruct therefore labels important information as:

  • Seen — visible in the image or supplied by the user;
  • Typical — common for this class of object;
  • Estimate — a reasoned educational approximation.

Instead of hiding uncertainty in a general disclaimer, Deconstruct places it next to the part or claim being inspected.

This teaches a second lesson alongside science and engineering: models are representations, evidence has different strengths, and confidence should be visible.

The generated geometry is an educational approximation—not fake CAD.

Safe by architecture

The central technical challenge was generating rich, object-specific 3D lessons without executing arbitrary model-authored code.

GPT-5.6 does not generate HTML, JavaScript, CSS, shaders, executable Three.js code, embedded URLs, or arbitrary assets. It produces only a declarative ExplorationSpec using a closed, allowlisted grammar of shapes, dimensions, transforms, materials, evidence labels, and manufacturing steps.

Deconstruct then validates the specification with a strict Zod contract. Validation errors identify the exact field and constraint so the model can repair its output within a bounded correction loop.

Only a validated specification is rendered.

The responsibilities are deliberately separated:

  • GPT-5.6 handles language understanding, image understanding, educational reasoning, and specification authoring.
  • Deconstruct handles deterministic validation, limited normalization, and rendering.
  • The ChatGPT App provides the conversation and interactive learning surface.

This preserves generative flexibility while keeping execution bounded, testable, and reproducible.

Built through ChatGPT and Codex

Deconstruct was not created from one vague coding prompt. It followed a specification-driven collaboration in which ChatGPT and Codex played different roles.

1. Find the real product

The project began by challenging the idea:

  • Is this more than “generate a 3D model”?
  • Why would a teacher use it instead of a teardown video?
  • What should a learner understand afterward?
  • How can it avoid encouraging unsafe disassembly?
  • What can be inferred from a photo, and what must remain uncertain?
  • Why should materials and manufacturing belong in the same experience?

That discussion produced the core learning journey: structure, function, material, origin, and manufacturing.

2. Turn the idea into a specification

ChatGPT translated the product reasoning into a detailed specification covering:

  • product goals and learning outcomes;
  • safety boundaries and non-goals;
  • the ExplorationSpec data model;
  • validation and correction rules;
  • object-independent 3D composition patterns;
  • material and manufacturing structures;
  • uncertainty labels;
  • accessibility and mobile behavior;
  • testing and deployment requirements.

Codex received a reasoned target with explicit constraints rather than being asked to invent the product while implementing it.

3. Build and verify with Codex

Codex implemented the working system, including:

  • the MCP workflow;
  • the strict validation contract;
  • the bounded correction loop;
  • the generic Three.js interpreter;
  • eight composition archetypes;
  • compound and repeated geometry;
  • curved, radial, hinged, optical, and electronics layouts;
  • exploded-view behavior and callouts;
  • material and manufacturing views;
  • keyboard, mobile, reduced-motion, and fallback behavior;
  • automated browser, unit, and integration testing;
  • containerization and cloud deployment.

Browser review revealed that schema-valid geometry was not always recognizable geometry. The system was therefore refined around silhouette, topology, relative placement, camera framing, and reusable geometry families rather than polishing only one demo object.

Built mostly from a smartphone

Approximately 90% of Deconstruct was built from a smartphone by remotely directing Codex.

After the initial environment setup, implementation, iteration, testing, review, deployment, and most of the hackathon submission workflow were handled from the phone.

This was not a staged mobile demo or a final convenience step. It was the actual development workflow used to build and ship the project.

The project therefore demonstrates two products at once:

  1. Deconstruct as a new way to explore everyday objects.
  2. Codex as a development environment that can make a smartphone a practical control surface for serious software engineering.

An actual Codex development session directed from a smartphone

An actual Codex session showing automated tests, MCP validation, responsive browser checks, and production deployment preparation from a smartphone.

Challenges

Recognizable 3D without arbitrary code

A closed grammar is safer and more testable than generated Three.js code, but early combinations of valid boxes and cylinders could still look generic.

The solution was to expand the reusable grammar with compound shapes, repeated structures, curved connectors, radial and hinged arrangements, geometry coverage rules, and better camera framing—without introducing object-specific rendering branches.

Validation that enables recovery

Rejecting invalid output is easy. Helping the model repair it is harder.

Deconstruct returns precise validation paths and constraints, allowing GPT-5.6 to correct the specification within a bounded loop instead of failing silently or substituting unrelated demo data.

Usefulness without false precision

The experience needs enough detail to teach, but it must not imply that unseen internals have been verified. The Seen, Typical, and Estimate labels became a core interface element rather than a footnote.

Key accomplishments

  • A text or photo prompt can produce an object-specific, validated 3D learning exploration inside ChatGPT.
  • One declarative grammar drives spatial structure, material provenance, and manufacturing journeys.
  • The renderer is object-independent rather than a collection of hard-coded demo scenes.
  • Model-authored executable code is never run.
  • Invalid specifications return actionable feedback and can be repaired through a bounded loop.
  • The experience supports desktop, mobile, keyboard navigation, reduced motion, and WebGL fallback.
  • Verification passed 17 unit and integration tests.
  • Eight Playwright runs covered desktop, mobile, WebGL behavior, and multiple non-demo composition types.
  • The production dependency audit reported zero vulnerabilities at deployment time.
  • Approximately 90% of the project was built and shipped through Codex from a smartphone after the initial setup.

Why it matters

For learners

Deconstruct connects mechanics, electricity, materials science, earth resources, manufacturing, and evidence literacy through an object already present in the learner’s environment.

For teachers

A familiar classroom object can become a new science lesson without buying teardown kits, preparing exact CAD files, or asking students to follow unsafe repair content.

For generative software

The project shows that rich 3D generation does not require executing arbitrary model-produced code. A bounded declarative system can remain expressive while being safer, testable, reproducible, and correctable.

For AI-assisted development

The project demonstrates an end-to-end workflow in which ChatGPT helps define the product, Codex implements and verifies it, and the final experience returns to ChatGPT as the learner’s interface.

The idea is not simply “3D from a photo.” It combines:

  • multimodal object understanding;
  • constrained declarative 3D generation;
  • spatial exploration;
  • part function;
  • material form and raw-resource provenance;
  • manufacturing sequence;
  • visible uncertainty;
  • deterministic validation;
  • and a ChatGPT-native learning experience.

Most exploded-view tools stop when the parts are separated.

Deconstruct begins there.

What we learned

Recognition depends more on silhouette, topology, relative placement, and camera framing than on surface polish alone.

Strict safety boundaries do not necessarily reduce generation quality. When a schema provides expressive, composable primitives, those boundaries can make the result more stable and easier to repair.

Validation should do more than accept or reject output. It should provide enough structured feedback for the model to recover.

Uncertainty should not be hidden in a disclaimer. It should appear at the point where the learner encounters the claim.

Separating product reasoning from implementation also improved the collaboration with Codex. Defining the audience, learning outcome, trade-offs, and constraints first produced a clearer target than a single build prompt could provide.

Most importantly, the project showed that capable coding agents can change not only how software is developed, but where development can happen.

What is next

Future directions include:

  • standalone photo understanding;
  • additional bounded geometry interpreters;
  • visual-regression and property-based testing;
  • teacher-selectable learning goals and difficulty;
  • side-by-side object comparison;
  • environmental-impact and recycling layers;
  • generated lesson guides and comprehension questions.

These are future roadmap items and are not part of the current submission.

Submission note

Deconstruct is original work planned and built by the entrant. Open-source dependencies are used under their respective licenses. The experience avoids third-party branding, logos, unlicensed music, and unlicensed copyrighted assets.

Built With

Share this project:

Updates