Teardown: The Free Claude Code Skill That Turns Any Machine Into a 3D Simulator You Can Take Apart

What Teardown actually is

Teardown's own README describes it in one line: "A Claude Code skill that turns any machine into a 3D simulator you can take apart." Ask Claude Code how something works in plain words — "Build me a simulator of a 4-stroke motorcycle engine I can take apart" or "How does a mechanical watch keep time? Show me as a simulator" — and it builds one offline HTML page.

On that page, the machine runs in the middle, every panel around it reads the real numbers from the same model that moves the parts, and a button opens the part doing the work. Leave the page alone and it tours itself with a moving cursor; click, drag or press a key and control hands over to you, then the tour resumes after 25 seconds of quiet. The same code then records a film of the tour, frame by frame, with a procedural sound score built on the same timeline.

The repo was created on 30 October 2026. When I checked it on 5 November 2026 it had already passed 2,100 stars and 330 forks, with only 2 commits — this is a brand-new project that spread fast, which is exactly why the viral post around it deserves a check before anyone repeats its claims.

Teardown at a glance

What the viral bird demo showed — and what it did not

The post that set this off shows a robotic bird drone, labelled "Selas TR-9", hovering in a field simulator with wingbeat gauges, power readouts and assembly panels around it. The poster says they gave Claude one picture and one word — the name of the animal — and that this was the third model they ran through the skill, landing on the second generation. Here is each claim from that post, checked against the repo's own SKILL.md:

The honest summary: the workflow in the post is real, and the skill's own documentation backs the mechanics of it. The specific numbers about the bird — 300 parts, 7 feathers, 3 reworks — belong to that one demo, and the "artists should worry" line is the poster's framing, not something the repo claims.

How it works: one input, one timeline

The whole skill rests on three ideas, all spelled out in SKILL.md. First, one input drives everything. A machine is posed from a single value — the crank angle, a stroke from 0 to 1, or the wind — and every gauge, chart and label reads from the same function that poses the parts, so nothing on screen can disagree with the motion. Second, render(t) is a pure function: given a time t, it draws that frame from scratch, with no randomness and no state carried between frames, so the capture step can render any moment in any order. Third, every beat goes into timeline.json in seconds, and the sound reads the same file, so the film, the live page and the score can never drift apart.

Each machine is split into small files by job: the maths (real dimensions in real units), the geometry built from code, the studio stage with lights and shadows, the overlay console of panels and charts, a film script of operator moves, and a live page with buttons, sliders and orbit controls. Frame 0 is the thumbnail, so it must already show the machine.

The 3 machines that ship with it

Teardown comes with three complete machines. Build one first, open the HTML, press the buttons — and copy the closest one when you start a new machine. That is the skill's own advice, and it is good advice: the examples are the documentation.

How to install Teardown

Setup takes a few minutes. The skill itself is free; what you pay for is Claude Code usage while it builds.

Step 1 — Install the skill. This registers it with Claude Code:

npx skills add elvarofficial/teardown -g -a claude-code

Step 2 — One-time setup in the installed folder. This installs the JavaScript dependencies and the Chromium browser that renders the frames:

cd "$SKILL_DIR" && npm install && npx playwright install chromium

Step 3 — Check the other requirements. You need Node.js 20 or newer. For the video you also need ffmpeg on your PATH, and for the sound you need Python 3 (standard library only — no extra packages). You can point the skill at other binaries with the FFMPEG, PYTHON or CHROMIUM settings.

Step 4 — Ask Claude Code in plain words. For example:

Build me a simulator of a 4-stroke motorcycle engine I can take apart.
How does a mechanical watch keep time? Show me as a simulator.
Make a teardown of a hydraulic excavator arm and record a 20-second video of it.

Build your first simulator

Try the included V8 before building your own. This bundles the machine into one offline HTML file:

node sims/build.mjs v8-live          # teardown-out/dist/v8-live.html, offline, ~800 KB
node sims/build.mjs cessna-live
node sims/build.mjs strandbeest-live

Open the HTML file, press the buttons, and watch the auto tour. Then record a film of it:

node "$SKILL_DIR/sims/build.mjs" v8-film
node "$SKILL_DIR/sims/capture.mjs" v8-film --size 1600x900 --dpr 1.2 --out teardown-out/v8-silent.mp4
python "$SKILL_DIR/run_sfx.py" "$SKILL_DIR/sims/v8-shared/score.py"
ffmpeg -y -i teardown-out/v8-silent.mp4 -i teardown-out/v8-score.wav -map 0:v -map 1:a -c:v copy -c:a aac -b:a 256k -shortest -movflags +faststart teardown-out/v8.mp4

Capture prints the GPU it got — if it reports a software renderer, the GPU flags in paths.mjs did not take, and your render will be slow. At 1600 by 900 with a device pixel ratio of 1.2, the output is 1920 by 1080.

The review loop: why the results look so polished

This is the part of the skill that explains the viral demo's quality, and it is the cleverest idea in the repo. Claude cannot watch a video — so it never tries. Instead, the capture step renders a sheet of still frames, one tile per timeline beat, taken 0.3 seconds after each beat and labelled with its time. Claude reads every tile against a checklist: every part that should touch touches, nothing passes through anything, the numbers on the panels match the pose, one focal point per frame, nothing important within 60 px of an edge, labels never cover the part they name, no clipped text, and the key readout still reads at phone width.

Then it zooms in on transitions frame by frame, fixes what is wrong, rebuilds, and goes back to the start. It stops only when a full pass finds nothing. As a final check it renders a sheet from the finished mp4 itself, to see what the encoder actually wrote — not what the live page showed. That loop, not any single clever prompt, is why a second-generation bird could already look finished.

The same discipline shows up in the taste rules: one accent colour, and it means something (the part working right now); the machine fills 60 to 70 percent of its viewport; labels never under 34 px on a 1080 canvas; nothing dead-still — one element always alive. And the skill is honest about three.js traps it already hit, from a smoothstep call that returns 0 on Windows to a single NaN pixel blacking out a whole frame through bloom.

Honest limitations

• It needs a real reference and real dimensions. Invented machines come out generic — the skill says so itself. If you cannot find the bore, stroke, tooth count or link lengths, the result will look plausible and be wrong.
• Everything is code-drawn three.js geometry. It cannot match a photo-real render or a hand-modelled asset. The skill's own checklist warns that bloom eats detail, near-white surfaces blow out, and glossy metal streaks under low light.
• The reviewer never watches motion. It reads still frames, so a timing glitch between beats can slip through, and each state must hold long enough to read (the rule is 1 second for a short phrase, plus 0.25 seconds per word beyond three).
• Capture wants a real GPU. A page that runs at 60 fps on a desktop card can drop to 15 fps on a laptop's built-in graphics, which is why the examples carry quality tiers. Check the GPU the capture step reports.
• It is a simulator and explainer, not a production 3D pipeline. There is no rigging export or asset pipeline here — the output is a web page and a film, not a model you drop into Blender or a game engine.
• The sound is procedural. Python synthesises every sound from the timeline, mastered to −14 LUFS. There is no voiceover and no narration track.
• It is days old. Two commits at the time of writing, no releases, no tags. Expect rough edges and breaking changes while it grows.

Security and privacy

• The finished page is a single offline HTML file. Once built, it makes no server calls and carries no tracking — you can host it anywhere or send it to a client as a file.
• Install runs third-party code on your machine. npm install in the skill folder and a Playwright Chromium download are normal for this kind of tool, but skim SKILL.md and package.json first, and keep the skill updated — a repo with 2 commits can change fast.
• Your prompts go to Claude. Reference photos and dimensions are sent to Anthropic as part of Claude Code, so do not feed it proprietary CAD files or unreleased product designs you cannot share.
• Licences are clean. The skill is MIT, the kit it builds on is MIT, and the recorded sound samples are CC0 from Freesound. Your own builds are yours to use.
• Rendering is local. ffmpeg and Python run on your machine; nothing is uploaded to render the film.

Real use cases

• Teaching: an interactive lesson where students pull a machine apart beats a static diagram in a textbook.
• Engineering teams: explain a mechanism to non-engineers, sales staff or management without a CAD licence.
• Product explainers: a take-apart page for a machine you sell, embedded next to the manual.
• YouTube explainers: record the auto-tour as B-roll, then add your own voiceover on top.
• Documentation: a living diagram that stays correct because the gauges read from the same model as the motion.

Should 3D artists and motion designers worry?

Short answer: no — but the floor for "good enough" explainers just moved. Teardown produces correct, code-driven mechanism explainers. It does not produce art direction, characters, environments, lighting design, or the taste that makes a film memorable. A robotic bird that flaps correctly is not a story.

What it does threaten is the low end of explainer work. A simple "how it works" animation that used to take days in Blender can now be drafted in an afternoon, and the frame-sheet review loop is exactly the kind of iteration clients pay for. The designers who should pay attention are the ones selling generic mechanism animations — and the opportunity is for the ones who use Teardown as a drafting tool and add direction, story and polish on top. The skill writes the machine; it does not direct the film.

Frequently asked questions

Is Teardown really free?

Yes. The repo is public under the MIT licence, so the skill itself costs nothing to download, use or modify. You still pay for Claude Code usage while it builds, and you need your own machine for rendering.

Do I need a GPU?

For smooth live pages and fast capture, yes — a real GPU. The examples include quality tiers for integrated graphics, and the capture step prints which GPU it got, so you can check before a long render.

Can it build anything, or only machines?

It is built for machines and mechanisms with one driving input — an engine, a gearbox, a linkage, a pump. Characters and organic shapes are outside its design, and the bird in the viral demo worked because it is a mechanical bird with a wingbeat cycle, not a living animal.

Does it work without Claude Code?

The skill is written for Claude Code — that is what the install command targets. The HTML pages it produces run anywhere, offline, in any modern browser.

Where does the sound come from?

Procedural Python synthesis on the film's timeline (48 kHz, reproducible), mastered automatically to −14 LUFS with true peak at or under −2 dBFS. Recorded bits are CC0 Freesound samples. There is no voiceover.

What should I build first?

Build the included V8, Cessna landing gear or Strandbeest before your own machine. The skill's own advice is to copy the closest example — the examples are the documentation, and they teach the file layout faster than reading about it.

Sources

• elvarofficial/teardown — README and SKILL.md (accessed 5 November 2026; stars, forks and creation date as listed on the repo page)
• whaleyxbt/claude-motion — the MIT-licensed kit Teardown builds on
• The viral bird-demo post shared with Asad Webs — its bird-specific numbers are labelled as the poster's own claims in the table above

Related reading: Kimi K3.1 Pro: open weights, 2.8 trillion parameters · 10 GitHub repos to build your own overnight system · Chrome's new features for 2026: vertical tabs and PDF annotations