I used the following approach shared by Harper Reed to describe the project idea in detail:
Ask me one question at a time so we can develop a thorough, step-by-step spec for this idea. Each question should build on my previous answers, and our end goal is to have a detailed specification I can hand off to a developer. Let’s do this iteratively and dig into every relevant detail. Remember, only one question at a time. Here’s the idea: <IDEA>
It works very well and at the end provides a detailed specification, but its very comprehensive and overengineered.
One thing I would like to add is deleting and simplifying as much parts or process as possible, using Elon Musk’s first principles approach.
``` Elon Musk's 5-Step First Principles Process (as described in the video):
Core Problem Addressed:
The most common error smart engineers make is to optimize something that should not exist in the first place.
This happens because people are trained (like in school) to answer the question given, not to question the question itself ("convergent logic," "mental straitjacket").
The Process:
Step #1: Question the Requirements
Action: Make your requirements "less dumb."
Premise: Assume your requirements are inherently flawed ("Your requirements are definitely dumb").
Source Invariance: It doesn't matter who gave you the requirements (even a smart person).
Warning: Be especially critical of requirements from smart people, as you might be less inclined to question them.
Foundation: Everyone is wrong some of the time, so challenge the fundamental assumptions behind why something is needed.
Step #2: Remove Unnecessary Parts or Process Steps
Action: Try very hard to delete parts of the item or steps in the process.
Validation: If you are not occasionally having to add things back in, you are not deleting aggressively enough.
Counteract Bias: Fight the strong tendency to add steps "just in case."
Step #3: Simplify or Optimize
Action: Make the remaining process/part better or more efficient.
Order: This is explicitly the third step, not the first. Optimization should only happen after questioning and deleting.
Step #4: Accelerate Cycle Time (Accelerate Time-to-Learning)
Action: Speed up the process ("If you're moving too slowly, go faster").
Order: Only accelerate after completing the first three steps (Question, Delete, Optimize). Do not speed up a flawed or unnecessarily complex process.
Step #5: Automate
Action: Implement automation for the process.
Order: This is the final step. Only automate a process that has already been rigorously questioned, simplified/deleted from, optimized, and accelerated.
The Wrong Way (Common Mistake):
Musk explicitly warns against (and admits to personally making the mistake of) doing these steps backwards: Automating first, then trying to accelerate, simplify, delete, and only questioning the requirements last (or not at all). This leads to automating and speeding up unnecessary work. ```
Summary I generated using Gemini based on the following video: