Prototype-First Engineering Design Process
Build four ugly prototypes and break them before you ever attempt the final version
- Difficulty
- Easy
- Time to result
- ~weeks to results
- Steps
- 6
- Confidence
- 90%
Rober's process, learned building hardware for the Mars rover, inverts how most people build. Instead of attempting a finished object out of the gate, you state the end objective, break it into a few major chunks, and produce several quick, deliberately ugly prototypes whose only job is to teach you something. Crucially, you push those prototypes past their limits — smashing wheels made of different materials and thicknesses — so you know precisely where and why they fail. Each failure is data that feeds the next iteration. Only once the learning is exhausted do you commit to the polished final version, now backed by full knowledge of its capabilities and tolerances. The same objective-to-chunks-to-iterate arc scales from a backyard garden to a rover on Mars.
Origin
Rober spent about seven years as a mechanical engineer at NASA JPL designing hardware for the Mars rover, where senior engineers ('gray beards') stress-tested every young engineer's design. He carried the deliberate-prototyping philosophy into his YouTube builds and business.
Core principles
- 01The final version is the last thing you build, not the first
- 02Prototypes are tests, not products — they are allowed to be ugly
- 03You learn a design's true limits only by intentionally breaking it
- 04Any large build is just a sequence of bite-sized, testable chunks
- 05Confidence in a final design comes from knowing exactly why it fails
How to run it
- 1
State the single objective
Name the concrete end goal in one sentence — get a rover to Mars, build a bait package a thief will take. This anchors everything downstream.
Pro tip Make the objective specific enough that you could recognise success on sight.
- 2
Break it into main chunks
Decompose the objective into its handful of major pieces: research, initial prototype, feedback-and-iterate, final build. This makes an overwhelming project feel like one step at a time.
Watch out People get overwhelmed and quit when they stare at the whole mountain instead of the next step.
- 3
Build several quick, ugly prototypes
Make three or four fast, disposable versions. They are meant to be tests, not showpieces — investing in making them pretty is wasted effort.
Pro tip Do more than one; comparing variants surfaces trade-offs a single build hides.
Watch out If your prototype looks finished, you have spent time on polish instead of learning.
- 4
Break them on purpose to find the limits
Intentionally fail each prototype — smash it, overload it, run it past spec — so you know exactly where and why it breaks.
Pro tip Test the same component in multiple materials and thicknesses to map the full performance envelope.
- 5
Iterate on every learning
Feed each failure back into the design, tweaking and re-testing until the prototypes stop teaching you anything new.
- 6
Build the confident final version
Only now attempt the finished thing. Because you have mapped the limits, you know exactly what it can do and why.
Pro tip Document the tolerances you discovered so the next project starts ahead.
In the wild
Tasked with designing wheels for a rover, Rober built them in three different materials and a range of thicknesses, ran computer analysis, then physically smashed and broke each one. By failing them deliberately he learned the exact point at which each design gave way, so his final wheel came with full knowledge of its limits rather than a hopeful guess.
→ A final design chosen with certainty about its capabilities and failure modes.
Rober's canonical example of the wrong approach: someone who wants a bird feeder tries to build the final, finished bird feeder immediately, out of the gate. The right approach is to build several quick throwaway versions first, learn from them, and only then construct the polished one.
→ Illustrates why final-version-first thinking is the number one mistake makers make.
Common mistakes
Building the final version first
The single most common mistake is trying to make the finished, polished product on the first attempt, before you understand how it behaves.
Making prototypes pretty
Prototypes are disposable tests. Time spent making them look finished is time not spent learning.
Skipping the destruction test
If you never push a design to failure, you never learn its real limits and your final version rests on hope, not data.
Is it for you?
Best for
Anyone building a physical, technical, or creative artifact where the requirements are not yet fully understood.
Not ideal for
Fully specified, well-trodden tasks where the correct solution is already known and iteration adds no information.
From the transcript
“The number one mistake people make when they try and make something is they try to make the final version first.”
“Some of those prototypes, you break, you intentionally fail them to learn the limits. And then once you've done all that learning, now you know…”
“I don't know the answer, but you know what? I could test to find out.”
From the episode
How to Engineer a Life You Love - Mark Rober - #1035
Mark Rober