Proposal:

I basically wrote a simple, unnecessary auto-logic-flow of by two week questionnaire with the aid of WEBBgpt. And it identifies the major key works and use insert the variables in the pre-made f-string. Still, this is unnecessary.

Auto Code:

Show/Hide Python code


# 2-Week Mini Project Template
# Theme: find a real need (engineering-solvable) for Mom
# Constraints: 2 weeks, $50 budget, across oceans (remote support)
# Ideal: simple mechanical structure + basic coding

TIME_LIMIT_DAYS = 14
BUDGET_USD = 50

def println(s):
    print(s)

def input_line(prompt="> "):
    return input(prompt).strip()

def classify_feasibility(problem):
    """
    Quick filter:
    - unsolvable (too big / financial crisis / medical / legal)
    - unreachable (requires in-person physical labor you can't do remotely)
    - solvable (small tool/automation you can build + ship instructions/software)
    """
    p = problem.lower()

    unsolvable_keywords = ["bankrupt", "lawsuit", "medical", "cancer", "visa", "divorce", "tax"]
    unreachable_keywords = ["move furniture", "carry", "repair plumbing", "fix roof", "renovation", "install"]

    if any(k in p for k in unsolvable_keywords):
        return "UNSOLVABLE"
    if any(k in p for k in unreachable_keywords):
        return "UNREACHABLE"
    return "SOLVABLE"

def is_within_constraints(idea):
    """
    Very rough gate:
    - must be buildable in 2 weeks
    - must be under $50
    - must not require you being there physically
    """
    println("\nConstraint check:")
    println(f"- Time limit: {TIME_LIMIT_DAYS} days")
    println(f"- Budget: ${BUDGET_USD}")

    println("\nAnswer with short phrases.")
    time_est = input_line("How many days do you think it would take to build/test? ")
    cost_est = input_line("Estimated cost in dollars (rough)? ")
    remote_ok = input_line("Can it be done remotely (instructions + code + maybe mailing small parts)? (yes/no) ").lower()

    try:
        time_est_n = int("".join([c for c in time_est if c.isdigit()]) or "999")
    except:
        time_est_n = 999

    try:
        cost_est_n = float("".join([c for c in cost_est if (c.isdigit() or c == ".")]) or "999")
    except:
        cost_est_n = 999

    if time_est_n > TIME_LIMIT_DAYS:
        return False, "Too slow for 2 weeks."
    if cost_est_n > BUDGET_USD:
        return False, "Over $50."
    if remote_ok not in ["yes", "y"]:
        return False, "Not remote-friendly."
    return True, "Fits constraints."

def prompt_for_problem():
    println("Hi Mom, how are you doing?")
    mood = input_line("(Possible answers: good / fine / tired / stressed / etc.) ").lower()

    if "good" in mood:
        println("\nYay :) I’m working on a small engineering project for the next 2 weeks.")
        println("Is there any SMALL annoying thing you deal with at home that a simple tool or automation could help?")
    elif "fine" in mood:
        println("\nWhen you say 'fine'—is anything slightly annoying or inconvenient lately?")
        println("I’m doing a 2-week engineering mini project and want to solve something real for you.")
    else:
        println("\nGot it. I won’t take long.")
        println("I’m doing a 2-week engineering mini project. What’s one small repeated annoyance you have at home?")

    println("\nGive me 1–3 problems. Keep them concrete (not abstract).")
    problems = []
    for i in range(3):
        p = input_line(f"Problem {i+1} (or press Enter to stop): ")
        if not p:
            break
        problems.append(p)

    return problems

def refine_solvable_problem(problem):
    println("\nLet’s make it specific:")
    who = input_line("Who is affected? (Mom / Dad / everyone / guest) ")
    when = input_line("When does it happen? (morning / daily / weekly / whenever X) ")
    freq = input_line("How often? (times per day/week) ")
    pain = input_line("What part is annoying? (time / effort / forgetting / mess / noise) ")
    desired = input_line("What would 'fixed' look like in one sentence? ")

    return {
        "problem": problem,
        "who": who,
        "when": when,
        "frequency": freq,
        "pain_point": pain,
        "success_definition": desired
    }

def pick_solution_type():
    println("\nPick ONE solution style (simple is best):")
    println("1) I need a [type] tool (mechanical helper)")
    println("2) I need something automated (sensor/timer/reminder/motor)")
    println("3) A small organizer + basic code (tracking/alerts)")
    choice = input_line("Choose 1/2/3: ")

    if choice == "1":
        return "TOOL"
    if choice == "2":
        return "AUTOMATION"
    return "ORGANIZER"

def generate_project_plan(spec, solution_type):
    """
    Output a 2-week plan with parts + steps.
    Keep it generic and adaptable.
    """
    println("\n-----------------------------")
    println("PROJECT PROPOSAL (DRAFT)")
    println("-----------------------------")
    println(f"Need / problem: {spec['problem']}")
    println(f"Who: {spec['who']}")
    println(f"When: {spec['when']}")
    println(f"Frequency: {spec['frequency']}")
    println(f"Pain point: {spec['pain_point']}")
    println(f"Success looks like: {spec['success_definition']}")
    println(f"Solution type: {solution_type}")

    println("\nConstraints:")
    println(f"- Time: {TIME_LIMIT_DAYS} days")
    println(f"- Budget: ${BUDGET_USD}")
    println("- Remote: must work across oceans (instructions/code, minimal shipping if any)")

    println("\nWhat I likely need (choose what you already have first):")
    if solution_type == "TOOL":
        println("- Cardboard/wood/acrylic + screws + tape (prototype)")
        println("- Optional: 3D printed bracket (if you have access)")
        println("- Phone camera for Mom to test and send feedback")
    elif solution_type == "AUTOMATION":
        println("- Microcontroller you already own (Arduino / ESP32 / Pico)")
        println("- 1 cheap sensor OR 1 motor/servo (keep it minimal)")
        println("- USB cable + phone video for testing")
        println("- Optional: buzzer/LED")
    else:
        println("- Phone-based workflow + simple script/app (reminders/logging)")
        println("- Optional: QR code labels, simple spreadsheet, or small display")

    println("\n2-week timeline:")
    println("Day 1–2: confirm exact use case + measure constraints (space, power, safety).")
    println("Day 3–5: build prototype v1 (ugly but works).")
    println("Day 6: remote test with Mom (video call / short video).")
    println("Day 7–9: improve design + simplify steps for her.")
    println("Day 10–11: make final version + write instructions.")
    println("Day 12: final remote test.")
    println("Day 13–14: polish: backup plan, troubleshooting guide, short demo video.")

    println("\nRemote support plan (across oceans):")
    println("- Make a 1-page setup guide with photos/diagrams.")
    println("- Give a 'one-button' or 'one-switch' interface if possible.")
    println("- Add a fallback mode (manual use still works if code fails).")

def main():
    problems = prompt_for_problem()

    if not problems:
        println("\nNo problem given. Here are safe prompts to ask Mom:")
        println("- 'What do you do every day that feels repetitive?'")
        println("- 'What do you wish you could do with one button?'")
        println("- 'What do you forget often (lights, water, timer, medication)?'")
        return

    # pick first solvable one (you can change this later)
    chosen = None
    for p in problems:
        tag = classify_feasibility(p)
        println(f"\nChecking: '{p}' -> {tag}")
        if tag == "SOLVABLE" and chosen is None:
            chosen = p

    if chosen is None:
        println("\nNone look solvable remotely in 2 weeks. Try re-framing smaller:")
        println("- reduce scope to ONE step of the task")
        println("- change from 'fix X' to 'remind/measure/track X'")
        return

    spec = refine_solvable_problem(chosen)
    solution_type = pick_solution_type()

    ok, reason = is_within_constraints(chosen)
    if not ok:
        println(f"\nDoesn't fit constraints: {reason}")
        println("Shrink it: remove features, use fewer parts, or do software-only first.")
        return

    generate_project_plan(spec, solution_type)

if __name__ == "__main__":
    main()

```

Show/Hide Python code

Sample Response:

This is a sample response you will get on your terminal. Of course I did not send this to my mom as she doesn’t understand English.

Hi Mom, how are you doing?
(Possible answers: good / fine / tired / stressed / etc.) fine

When you say 'fine'—is anything slightly annoying or inconvenient lately?
I’m doing a 2-week engineering mini project and want to solve something real for you.

Give me 1–3 problems. Keep them concrete (not abstract).
Problem 1 (or press Enter to stop): I want to manage my cables
Problem 2 (or press Enter to stop): I want a charging station
Problem 3 (or press Enter to stop): I want an ai automater

Checking: 'I want to manage my cables' -> SOLVABLE

Checking: 'I want a charging station' -> SOLVABLE

Checking: 'I want an ai automater' -> SOLVABLE

Let’s make it specific:
Who is affected? (Mom / Dad / everyone / guest) Mom 
When does it happen? (morning / daily / weekly / whenever X) daily
How often? (times per day/week) 10
What part is annoying? (time / effort / forgetting / mess / noise) forgetting
What would 'fixed' look like in one sentence? A clean and elegant desk top with my three phones charging at the same time

Pick ONE solution style (simple is best):
1) I need a [type] tool (mechanical helper)
2) I need something automated (sensor/timer/reminder/motor)
3) A small organizer + basic code (tracking/alerts)
Choose 1/2/3: 1

Constraint check:
- Time limit: 14 days
- Budget: $50

Answer with short phrases.
How many days do you think it would take to build/test? 14
Estimated cost in dollars (rough)? 50
Can it be done remotely (instructions + code + maybe mailing small parts)? (yes/no) yes

-----------------------------
PROJECT PROPOSAL (DRAFT)
-----------------------------
Need / problem: I want to manage my cables
Who: Mom
When: daily
Frequency: 10
Pain point: forgetting
Success looks like: A clean and elegant desk top with my three phones charging at the same time
Solution type: TOOL

Constraints:
- Time: 14 days
- Budget: $50
- Remote: must work across oceans (instructions/code, minimal shipping if any)

What I likely need (choose what you already have first):
- Cardboard/wood/acrylic + screws + tape (prototype)
- Optional: 3D printed bracket (if you have access)
- Phone camera for Mom to test and send feedback

2-week timeline:
Day 1–2: confirm exact use case + measure constraints (space, power, safety).
Day 3–5: build prototype v1 (ugly but works).
Day 6: remote test with Mom (video call / short video).
Day 7–9: improve design + simplify steps for her.
Day 10–11: make final version + write instructions.
Day 12: final remote test.
Day 13–14: polish: backup plan, troubleshooting guide, short demo video.