DEV Community: ashleygirl3723

The Lazy Python Tutor: I built a tutor for people who don't want a tutorial

ashleygirl3723 — Thu, 22 Oct 2026 13:55:21 +0000

This is a submission for the Hacktoberfest 2026 DEV Challenge — Week 3: Slow and Steady.

What I built
The Lazy Python Tutor — ask any Python question, get a plain-English explanation first, then a short runnable example, then one tiny optional practice prompt. That's it. No 40-minute video. No 12 documentation tabs. No homework list.

Live app: https://lazy-py-tpvbo7rexyrv4af4lv64qb.streamlit.app/
Repo: https://github.com/ashleygirl3723/lazy-python-tutor

Try asking:
What is a variable?
How do loops work?
Why does my code say IndentationError? — paste your broken code and it names the most likely problem, shows the fixed version, and says what changed in one sentence.
It remembers the conversation, so follow-ups build on what you already asked.

Why I built this — honestly
I'm learning Python myself, in a 30-day self-paced course, mostly on my laptop between caregiving shifts. I know exactly where beginners quit: not because Python is hard, but because every small question turns into a huge tutorial.
"What does elif mean?" should not require watching half a course. I kept wishing I could just ask — in plain words, get a plain answer, see one tiny example, and move on with my day.
So for "Slow and Steady" — build something with open-weight AI that rewards laziness — I built the tutor I wanted. Laziness here isn't cutting corners. It's respecting your time and energy. Slow and steady is literally how I'm learning: one small question at a time.
The design enforces that in the system prompt, which is the whole brain of the app:
Plain English first — no jargon without immediately explaining it
Then a short example — usually under 10 lines, nothing extra
Then one tiny practice prompt — labeled "Feeling ambitious? Try this:" — genuinely tiny, always optional
Hard rules in that prompt: keep it under ~200 words plus code, never dump code without explaining it first, and if code is broken, name the one most likely problem — not a lecture.
That last part matters to me personally. My most common mistakes are picky syntax things — capitalized If/Print (phone autocorrect loves that one), missing colons, missing indents, dropping the variable after elif. A good lazy tutor spots the one thing, fixes it kindly, and doesn't make you feel dumb for it.

How it's built
Streamlit chat interface, Python, deployed free on Streamlit Cloud — runs in any browser, phone included
Open-weight models via OpenRouter's free tier — openrouter/free auto-router picks a working free open-weight model per call. No credit card, no paid API.
One system prompt does the teaching — the tutor's personality, answer shape, and honesty rules all live in one readable block at the top of app.py. Anyone who forks this can retune the tutor by editing plain English, not code logic.
Conversation memory via Streamlit session state — follow-ups keep context.
Total running cost: $0.

Why open innovation matters for this build
I'm a caregiver learning to code on the side. I don't have a budget for AI APIs, and a learning tool that charges per question would teach me to stop asking questions — the exact opposite of learning.
Open weights fix that:
Asking is free. Every "wait, why?" costs nothing. A beginner can ask the dumb question, the follow-up, and the follow-up to the follow-up without a meter running. That's how slow-and-steady learning actually works.
No one can pull the plug. If a closed provider raises prices, retires a model, or changes terms, a closed-API tutor dies on their schedule. With open weights + an open router, when one free model is busy, the request goes to another — the app keeps working.
The tutor is forkable, not rented. The whole thing is one app.py and a prompt written in plain English. Another beginner can clone it, make it stricter, make it funnier, make it teach JavaScript instead — without asking anyone's permission. That's open innovation at the smallest, most personal scale: one learner's tool becomes the next learner's starting point.
This is my Week 1 and Week 2 lesson too, now for the third time: the auto-router is what makes free actually reliable. Openness isn't one model — it's having many, so no single point of failure can take your tool away.

What I'd do next
A "explain my error" paste box with even simpler language for total first-week beginners
Voice input — asking out loud is even lazier than typing, and helps on a phone
A "review what I learned" button that turns your chat history into 5 tiny recap cards
But the core promise is done: one question, one plain answer, one tiny example — back to your day. Slow and steady wins.

J&J Instant Estimate: an honest AI quote desk for a one-woman home-services business

ashleygirl3723 — Mon, 19 Oct 2026 01:38:50 +0000

J&J Instant Estimate: an honest AI quote desk for a one-woman home-services business

This is a submission for the Hacktoberfest 2026 DEV Challenge — Week 2: Side Hustle.

What I built

J&J Instant Estimate — a quote helper for my actual home-services business, J&J Home Services (cleaning, yard work, and appliance repair in Lebanon & Sweet Home, Oregon).

A customer picks a service, answers a few questions, and gets an honest starting-price estimate. Then the AI writes it up in plain language and answers follow-up questions — "do you do move-outs?", "what's included in a deep clean?", "my dryer has no heat, what am I looking at?"

The key design decision: the AI never does the math. Every price is computed with plain Python straight from my real price sheet, so the model literally cannot misquote a number. The open-weight model only writes the friendly message and answers questions. Anything that doesn't fit the sheet — a 5+ bedroom home, a junk haul-off — routes to a free quote by call or text instead of a guessed number.

Live app: https://jj-quote-apper-ttywjbfirlartq7nwgymtn.streamlit.app
Repo: https://github.com/ashleygirl3723/jj-quote-helper

Who would pay for this

Me. That's the honest answer, and it's why I built it.

I run J&J on the side of a full-time caregiving job. Every quote I write by hand is time I'm not working or resting. Lead response time is everything in home services — the business that answers first usually wins the job. A tool that gives a customer a real number in 60 seconds, at midnight, while I'm on shift, is worth more to me than any ad spend.

Beyond me: there are thousands of one-person home-service businesses running on Facebook and word of mouth. They can't afford Housecall Pro or Jobber. A free, honest quoting tool they can clone and load with their own price sheet? That's a product.

First user: me. I ran it the way a customer would — studio standard clean ($120) with inside-fridge ($25) and interior-windows ($40) add-ons, one-time visit: $185. The math checked out against my price sheet, it disclosed the figure as a starting price, it picked up the "pets and heavy smokers" note without changing the price, and it ended with my booking line. It passed.

How it's built

Streamlit frontend, Python, deployed free on Streamlit Cloud
Open-weight models via OpenRouter's free tier — openrouter/free auto-router picks a working free open-weight model per call. Two lines of config, no paywall, no credit card.
Deterministic pricing layer — the price sheet lives in the code as data; the AI receives computed numbers as facts. This is the whole trick: the model's job is tone and Q&A, never arithmetic.
The system prompt carries the full price sheet as knowledge, with hard rules: never invent a price, always say "final quote confirmed before any work begins," always mention the $50 diagnostic credit on appliance repair, and the honest rule that if fixing costs more than half of new, we say so.

The whole stack costs $0. That's not a footnote, it's the business case.

Why open innovation matters for this build

A quoting tool for a tiny business only works if it costs nothing to run. Closed AI APIs would put a meter on every customer question — I'd be paying per quote before I'd earned a dollar. That kills the tool for exactly the businesses that need it most.

Open weights change the math completely:

Zero marginal cost. Every estimate, every follow-up question, every "what's included?" costs me nothing. A one-woman business can run an AI quoting desk 24/7 for free. That was impossible two years ago.
No one can take it away. If a closed provider changes pricing or kills a model, my quoting tool breaks on someone else's schedule. Open weights + an open router mean the app keeps working no matter what any single company decides.
The knowledge stays mine. My price sheet is my business. Running it through an open model via a free router means I'm not training someone else's product on my livelihood to get a quote bot.

Last week taught me that "open" with a hidden toll booth isn't open (a credit-walled "free" tier, rotting model IDs). The auto-router approach is what actually held up: when one free model congests, the request goes to another. Resilience through openness, again.

What I'd do next

Photo upload: customer sends a photo of the oven / yard / broken dryer, AI describes what it sees to pre-fill the form (with the same honesty rules — "can't tell from this photo" is always an allowed answer)
Spanish version — a real share of my service area
"Text me this quote" — SMS the written estimate via a free-tier gateway

But the core is done: honest numbers, friendly words, zero cost. That's the whole business.