CommunityImagengithub.com

tech-hub-exploded-view

Turn any inventor's hardware idea (a v1 tech hub or BOM plus CAD, sketches or photos) into a realistic, studio-white interactive exploded-view tech hub (product→modules→subsystems→parts) delivered as one HTML file. Use for \"האב טכנולוגי\", \"מבט מפוצץ\", tech hub.

¿Qué es tech-hub-exploded-view?

tech-hub-exploded-view is a Claude Code agent skill that turn any inventor's hardware idea (a v1 tech hub or BOM plus CAD, sketches or photos) into a realistic, studio-white interactive exploded-view tech hub (product→modules→subsystems→parts) delivered as one HTML file. Use for \"האב טכנולוגי\", \"מבט מפוצץ\", tech hub.

Compatible con✓Claude Code~Codex CLI~Cursor✓Gemini CLI
npx skills add https://github.com/Eliran-technion/tech-hub-exploded-view/tree/HEAD

Installed? Explore more Imagen skills: steipete/songsee, affaan-m/frontend-design, mattpocock/improve-codebase-architecture · View all 6 →

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Tech hub: exploded view from CAD

The goal is a professional tech hub that explains how a hardware product is built and where its open problems sit. It shows exploded views that open level by level: product → modules → subsystems → parts. It looks realistic, on a studio-white background, never cartoon or SVG. Style reference: the SMEG blender product film (clean white seamless studio, soft shadows, slow confident explode moves).

Talk to the user in Hebrew. Documents and code may be in English.

The user decides the structure. Claude never invents how things connect. Everything flows: board → preview → final.

This skill is product-agnostic. It was first built on H.U.B, a folding 3D printer in a case (worked example in examples/HUB/). Users bring any hardware idea: a medical device, a wearable, a drone, a kitchen gadget, a robot arm, a tool. Never carry H.U.B specifics into another product: its fold, scissor arms, rails, materials, module names or challenges. Take every product fact from the user's own material and from their build-notes. H.U.B items below are examples only.

Adapt to the product first

Before stage 0.5, decide with the user, and write into build-notes:

  • Moving or static? Folding, deploying, opening or articulating products get an open/close or motion demo derived from their mechanism (stage 2). Static products skip it entirely.
  • Materials: pick from what the product is made of: injection-moulded plastic, FDM print, machined or anodised aluminium, sheet metal, glass, silicone, fabric, PCB, rubber. FDM layer lines apply only to printed parts.
  • Scale and framing: a ring and a vehicle need different camera distances and explode distances. Derive both from the bounding box, never from fixed numbers.
  • Levels: if the product is small, it may have only product → subsystems → parts. Don't force four levels.

The source-of-truth file (mandatory)

Keep build-notes-<product>.md from the first message. It holds:

  • Sources, the coordinate system, the structure, and design facts the user stated (e.g. "no bearings in this version", "3 rails", "add a T10 lead screw even though it's not in CAD").
  • A corrections log: | date | what the user said | what changed |.

On every correction, update this file FIRST, then the hub. Re-read it before each build.

Stage 0: intake

  1. The user sends what they have. Read it fully. Inputs vary:
    • A v1 tech hub or decision map (e.g. from the Electrum skill): subsystems, BOM, challenges, decisions.
    • Only a BOM or a list of subsystems.
    • Nothing written. Then interview the user briefly: what it does, main parts, open problems. Or suggest running Electrum first. Geometry also varies:
    • CAD (best): STEP. See step 2.
    • No CAD: build clearly labelled placeholder geometry from the BOM (real dimensions from datasheets, simple honest shapes), plus photos or sketches as reference. Tell the user plainly that the hub shows layout, not exact design. Offer to upgrade when they have CAD.
    • Mixed: CAD for custom parts, placeholders for off-the-shelf parts (motors, boards, batteries, sensors).
  2. Tell the user exactly which CAD exports you need for this product, and why:
    • A product that changes shape (folds, deploys, opens, articulates) needs one STEP AP214 per state, e.g. open + closed.
    • Any CAD tool works (SolidWorks, Fusion, Onshape, Inventor, FreeCAD) as long as it exports STEP.
    • A static product needs one STEP of the full assembly.
    • Always ask: STEP AP214, full top-level assembly, all components resolved.
    • Ask them to suppress, not hide, unused parts. STEP has no hidden flag, so hidden parts export as normal parts.
  3. If you have the user's computer, you may open their CAD app yourself to export (e.g. SolidWorks: File > Open on the running instance). Never enter credentials or log in to cloud accounts (e.g. 3DEXPERIENCE); close any login dialog with X.

Stage 0.5: assembly check (never trust the CAD)

Read STEP with OCP (cadquery-ocp) through XCAF. Known API gotchas:

  • OCP.collections.Sequence_TDF_Label
  • TopoDS.Face
  • Bnd_Box.CornerMin()/CornerMax()
  • XCAFDoc_ColorTool.GetColor(shape, …)

Per leaf, record path (product names), transform, bbox, volume and colour. Then:

  • Interference: BRepAlgoAPI_Common, solid by solid (compound booleans fail silently). Under 0.5% of the smaller volume = seat/press fit, log only. 0.5% and up = show. 5% and up = high.
  • Contact: BRepExtrema_DistShapeShape < 0.15 mm. A unit touching nothing is floating.
  • Vendor sub-assemblies (motors, rails, extruders) are one unit. Ignore overlaps inside them, and split repeated instances by a marker leaf.
  • Duplicates / hidden copies: find them by symmetry. An instance with no mirror partner that overlaps a same-kind part is a hidden copy.
  • Symmetry check: mirrored left/right pairs must mirror. A side shifted along an axis is a question, and often the real cause of a user remark like "the rails aren't the same length".
  • Fixes:
    • Move a named rigid group along the axis of least penetration, by depth + 0.1 mm, restricted to the mechanism's real degree of freedom.
    • Probe only the colliding part.
    • Re-check everything after each fix. If a fix creates a new clash, revert and ask. Never chain fixes.
    • Prefer the smallest geometric change. Thinning a wall beats scaling a whole part, because scaling moves seats.
  • Holes and axes: when the user says something sits off a hole, section the mesh and fit the circle. Never guess.
  • Only raise issues that show in the render. Hidden clashes inside the product are not questions for the user.
  • Off-the-shelf parts the user says exist but aren't modelled are added as clearly dashed placeholders on the axis they ride.

Stage 1: mapping board (the user decides the structure)

Publish an interactive board (artifact with a db):

  • One card per component, identical parts grouped ("scissor arm ×8"). Each card has a thumbnail render, CAD name and a computed "touches" list.
  • Columns are modules and subsystems seeded from v1, plus "unassigned". The user drags cards, renames, adds and removes groups.
  • Every detected issue is a card with a verdict: fine / modelling error, fix in render / extra, delete / don't know. Never fix what the user didn't confirm.

When the user says done, read the db. That structure is the source of truth.

Stage 2: preview (approval)

A realtime three.js viewer (vendored r170, model as base64 GLB in model.js, GLTFLoader.parse):

  • Look:
    • Studio white #f4f4f1, PMREM room environment, VSM shadows, GTAO, NeutralToneMapping.
    • Creased normals, box-projected mm UVs, an FDM layer-line normal map on printed parts.
    • Brushed and grain roughness on metal and the case.
  • Levels: product → modules → subsystems → parts. Explode rules:
    • Modules and subsystems move by set vectors, outside-in.
    • Parts use three rules: (1) a part inside another part's box rises out of it; (2) parts sharing a footprint centre spread along Y in height order (layered stacks); (3) the rest move out radially.
    • Non-focused groups fade out.
  • Labels are callout cards with leader lines for modules and subsystems, and pills for parts. Click a label or the model to go deeper. Back with a button, Esc or breadcrumbs.
  • Open/close the product if it folds, derived from the mechanism, never tweened between the two STEPs:
    • Find the pins (holes shared by links).
    • Rotate each link about a pin already solved: fixed base pin → crossing pin → stage joint.
    • Driven bodies (top frame, sliders, nut bar) follow their pins.
    • Compare with the closed STEP and report the difference.
    • Animate the mechanism first, then the lid.
  • A how-to-use guide on the first screen, plus a hint bar that changes with the level.
  • A feedback box in every view, saved to the artifact db (preview/feedback), keyed by product, module, subsystem or card. Read it with db_get when the user says they saved comments. Log each comment in build-notes first, then fix and republish.

Stage 3: the final tech hub (the deliverable)

The final is the approved stage-2 viewer, turned into a presentation piece:

  • Replace the feedback boxes with information:
    • Product: one-line pitch, counts, how-to, module list.
    • Module: its subsystems and the open challenges on it.
    • Subsystem: its parts (CAD vs placeholder badge) and challenges.
    • Part: description, BOM spec for placeholders, and challenges.
    • Map CAD cards to v1 part codes so v1 challenges land on the right part.
  • Remove review-only content: the "what I fixed" list, open questions, the db.
  • Keep the realtime transitions. They are smooth, sharp and instant. (User, 2026-11-15: the realtime preview beat pre-rendered frames.)
  • Deliver one self-contained HTML file:
    • Bundle app.js with esbuild: --bundle --format=iife --alias:three=./vendor/build/three.module.min.js --alias:three/addons=./vendor/jsm. This also inlines the dynamic import('./model.js').
    • Inline data.js, structure.js and the bundle as <script> tags, and drop the importmap.
    • About 10 MB. It opens by double-click. Test it from file:// in headless Chrome (goto with wait_until='commit').
  • Send it with SendUserFile. Optionally also publish it as an artifact.

Optional: photoreal Cycles stills/film (only with a GPU)

On a CPU-only box, pre-rendered Cycles transitions are slow (~35 s per 800×500 frame) and look soft when upscaled. Use Cycles only for:

  • Hero stills at rest states (1600×1000, about 40 samples, film transparent + shadow catcher, AgX Punchy -0.3 EV, area-light studio rig following the camera).
  • Full animation, on a real GPU only (the user's PC with NVIDIA/AMD, or Google Colab's free GPU).

Pipeline:

  1. Export per-mesh arrays from the browser. GLTFExporter hangs on big scenes.
  2. Sample per-mesh matrices, camera and label anchors from the viewer's own pose code.
  3. Build the scene with bpy (python3.11), render resumably, and pack WebP sprites.

Custom-property fades via an Attribute node did not render. Use material alpha keyframes instead.

Generative image or video AI (Gemini, etc.) cannot replace this: it doesn't reproduce the real CAD geometry.

Working rules

  • Long jobs: background processes die a few minutes after the turn ends, and the container can restart. Keep the turn alive while long work runs, poll every ~5 min with an idempotent "ensure running" script, and make every job resumable (skip finished outputs). Don't promise overnight work you can't keep alive. Say so up front.
  • Before rendering, give an honest time estimate, and offer the faster option when the user is under time pressure.
  • Uploading to the web: browser file uploads need the user's own approval, and the cloud git proxy can't push to a repo where the Claude GitHub app isn't installed. Ask before using desktop apps to work around this, and stop immediately when the user says stop.
  • When finished: send the HTML file, list what changed in a few Hebrew lines, and note known limits honestly.

Skills relacionados