DEV Community: Ayush Kulshreshtha

SteadyStep: a local AI that refuses to give me a 30-item productivity plan 🦥

Ayush Kulshreshtha — Tue, 20 Oct 2026 10:05:38 +0000

Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady Submission 🦥

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

I built SteadyStep, a tiny local-first CLI with one rule: it is allowed to give me one next step, not a productivity manifesto.

I give it a goal and a time budget. A local Gemma model looks at the goal plus the last few things I actually completed and chooses one concrete action that fits inside that time. I finish it, record what happened, and only then can it generate the next step.

The loop is intentionally simple:

set a goal → get one small step → do it → record outcome → repeat

For example:

python steadystep.py plan \
  --goal "learn binary search trees in C" \
  --minutes 15

The response is constrained to one action, one observable completion condition, and one short explanation of why that step makes sense now.

When I finish:

python steadystep.py done \
  --outcome "Implemented insert() and tested three nodes"

The next planning call sees that result, so it can move forward instead of starting from generic advice again.

The lazy payoff is that I never have to turn “I should work on this” into a giant backlog before I can begin. I only decide once: what goal matters. SteadyStep handles the tiny next decision from there.

Demo

The repository includes demo.gif, an animated recording of actual CLI sample-mode output through plan → done → status. It is explicitly a non-AI interface demonstration; live Gemma inference has not been tested in the publishing environment.

The project has a clearly labelled sample mode that demonstrates the interface without pretending static output came from AI:

python steadystep.py --state demo-state.json plan \
  --goal "ship a tiny CLI" --minutes 10 --sample

It produces a single card like:

🦥 SteadyStep
Goal: ship a tiny CLI
Budget: 10 min  •  SAMPLE (no AI call)

NEXT: Open One File
Open the project README and write three bullets describing what the user should be able to do when the project is finished.

Done when: The README contains three clear outcome bullets.
Why now: A tiny definition of done prevents the next coding session from wandering.

One clear step is enough for today.

No backlog. No ten-step plan. Finish this one thing, then come back.

Code

GitHub: https://github.com/Ayush0612005/steadystep-hf26

How I Built It

SteadyStep is deliberately small.

Python standard library for the CLI, JSON state, and HTTP call.
Ollama on localhost for inference.
Gemma 3 (gemma3:1b) as the default open-weight model.
A strict JSON output contract with five short fields.
A local state file containing the goal, current pending step, and completed history.
Only the latest six completed steps go back into the prompt, so the context stays focused instead of growing forever.

The model is the core of the project. Without the model, there is no adaptive next-step selection: it is what looks at the goal, the time available, and what happened in previous steps and chooses what should happen next.

I also made the CLI refuse to silently replace unfinished work. If a step is still pending, plan shows the same step again unless I explicitly pass --replace. That little constraint turned out to be important to the theme: the tool should encourage steady completion rather than constantly generating exciting new plans.

Local state is written atomically through a temporary file, and the project includes unit tests for persistence, schema validation, context limits, and pending-step reuse.

Why Does Open Innovation Matter?

The most personal part of this tool is not the goal itself; it is the history of what I tried, what I finished, and what I did not finish.

That is exactly the kind of context I do not want to send to a hosted model every time I ask what to do next.

Running an open-weight Gemma model through Ollama means the planning loop can stay on the user's machine. There is no per-step API bill, no required cloud account, and no reason for a private progress journal to leave localhost.

Open weights also make the project genuinely modifiable. The prompt is visible. The model can be swapped. The output constraints can be changed. Someone can fork SteadyStep and tune it for studying, open-source maintenance, writing, or another low-stakes workflow without waiting for a closed service to expose a feature.

For a “slow and steady” tool, that independence matters: set it up once, keep using it, and let the small steps accumulate.

AI Build Disclosure

This project was built with an AI coding agent operating on my behalf. The agent checked the challenge requirements and ran nine automated tests covering local state and mocked model-response handling. The build and write-up use the Fully Autonomous disclosure. The sample demonstration is not evidence of a live Gemma run.

Prize Categories

Best Use of Gemma: Gemma 3 via Ollama is the default local planning model.

What I Learned

The interesting part was not making the model produce a better long-term plan. It was designing the program so the model could not keep expanding the plan.

A few constraints made the idea work:

Exactly one next action.
A requested time budget (a model instruction, not a guaranteed duration).
An observable “done when” condition.
A pending step is reused instead of regenerated by default.
Only completed outcomes become progress context.

That makes the AI less impressive in a single screenshot, but much more useful as a quiet loop I can come back to.

LedgerLocal: sort a freelancer's expenses with an open model that never sees the cloud

Ayush Kulshreshtha — Wed, 14 Oct 2026 17:12:27 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

What I Built

LedgerLocal is a small Node.js CLI for freelancers in India. You give it the CSV export from your bank or UPI app, and it sorts every debit into expense categories (software, internet and phone, hardware, travel, meals, learning, coworking, and personal) and tells you roughly how much of your spending was business.

Every freelancer I know does this the same way at tax time: scroll through months of transactions in a spreadsheet and guess. The people who could afford a bookkeeper hand their whole bank history to a stranger or an online app. LedgerLocal does the boring first pass on your own laptop, and nothing about your spending leaves it.

Who would pay for it: freelance developers, designers, tutors, and creators who file their own returns. A tool like this could sell as a one-time purchase (no subscription, because there's no server to pay for), or come bundled with a CA's service as a "send me a clean ledger" step.

Demo

Real output from a live run on the included sample file (14 transactions, model running locally):

GITHUB COPILOT MONTHLY             ₹   830.00  → Software & subscriptions (0.38)
JIO FIBER BROADBAND BILL           ₹   999.00  → Internet & phone (0.62)
SWIGGY ORDER 4412                  ₹   342.00  → Needs review (0.24)
UBER TRIP CLIENT MEETING           ₹   418.00  → Travel (0.30)
UDEMY COURSE REACT ADVANCED        ₹   449.00  → Learning (0.44)
AMAZON LOGITECH MOUSE M331         ₹  1299.00  → Hardware & equipment (0.49)
BIGBASKET GROCERIES                ₹  1870.00  → Personal (not deductible) (0.48)
FIGMA PROFESSIONAL PLAN            ₹  1250.00  → Software & subscriptions (0.35)
WEWORK DAY PASS                    ₹   600.00  → Needs review (0.19)
NETFLIX SUBSCRIPTION               ₹   649.00  → Personal (not deductible) (0.46)
IRCTC TRAIN TICKET JAIPUR          ₹   385.00  → Travel (0.33)
AIRTEL PREPAID RECHARGE            ₹   299.00  → Internet & phone (0.62)
STARBUCKS COFFEE                   ₹   310.00  → Meals & coffee (0.44)
GODADDY DOMAIN RENEWAL             ₹   799.00  → Software & subscriptions (0.28)

Totals by category:
  Software & subscriptions     ₹   2879.00
  Personal (not deductible)    ₹   2519.00
  Hardware & equipment         ₹   1299.00
  Internet & phone             ₹   1298.00
  Needs review                 ₹    942.00
  Travel                       ₹    803.00
  Learning                     ₹    449.00
  Meals & coffee               ₹    310.00

Likely business expenses: ₹7038.00  (check with your accountant)

12 of 14 lines landed in a sensible category. The two it wasn't sure about (SWIGGY ORDER 4412 and WEWORK DAY PASS) went to Needs review instead of being guessed. I'd rather it say "I don't know" than quietly put a food order under business expenses.

Code

Ayush0612005 / ledgerlocal

LedgerLocal

Sort a freelancer's bank or UPI export into expense categories with an open-weight model that runs on your own laptop. Your transactions never leave your machine.

Built for the Hacktoberfest 2026 Open-Source AI Challenge, Week 2: Side Hustle.

Run it

Requires Node.js 18+.

npm install
node ledgerlocal.mjs sample_transactions.csv

The first run downloads the Xenova/all-MiniLM-L6-v2 model (~23 MB) into ~/.cache/ledgerlocal. After that you can run fully offline:

node ledgerlocal.mjs my_export.csv --offline --out report.csv

Your CSV needs date, description, and amount columns (any order). Amounts can be negative (debits); they are treated as positive spend.

How it works

Each expense category is described in a few plain words.
The model turns every category description and every transaction description into a sentence embedding.
Each transaction is assigned the closest category by cosine similarity. Anything below 0.25 goes to Needs review instead of being guessed.
You get a per-line CSV…

View on GitHub

Run it:

npm install
node ledgerlocal.mjs sample_transactions.csv
# after the first run, fully offline:
node ledgerlocal.mjs my_export.csv --offline

How I Built It

Model: all-MiniLM-L6-v2, an Apache-2.0 sentence-embedding model, in the quantized ONNX build from Xenova (~23 MB).
Runtime: Transformers.js running the model in Node.js on the CPU. No Python, no GPU, no API key.
Method: each category is a short plain-language description. The model embeds the categories and every transaction description, and each transaction gets the closest category by cosine similarity. Below a 0.25 similarity it goes to Needs review.

There's no generative model here on purpose. Sorting is a matching problem, and a small embedding model is fast, cheap, and predictable: same input, same answer, every time. The whole run on 14 rows takes a few seconds on a regular laptop.

Changing the categories is just editing words in one object, so a photographer can add "camera gear" and a tutor can add "teaching materials" without retraining anything.

Why Does Open Innovation Matter?

For this project, open isn't a nice-to-have. It's the reason the product can exist.

Privacy is the product. A bank statement shows where you live, who you pay, and how much you earn. With an open model running locally, the only network request is the one-time model download. After that, --offline blocks remote loading entirely, and the tool still works.
The business math works. With a hosted API, every user costs money every time they run it, which pushes you toward a subscription. Running locally, the marginal cost per user is zero, so it can be a one-time purchase that freelancers actually like.
No lock-in. If a better small open model comes out, I change one line. No pricing changes or deprecations decided by someone else.

The trade-off: a 23 MB embedding model doesn't understand context the way a large hosted model does. It can't know that one particular Uber ride was a client meeting unless the description says so. That's why the Needs review bucket exists and why the output says "check with your accountant."

What's Next

Learn from corrections: when you move a Needs review line into a category, remember it for next time.
Read PDF bank statements directly, not just CSV.
Get it in front of a real freelancer. I haven't done that yet, so I can't claim a first user this week.

AI Disclosure

I built this with an AI coding agent (Claude Code) at my direction. The agent wrote the code and drafted this post. The demo output above is from a real run of the code on my machine, including the offline run.

OneScreenOut: one screen of local AI, then an outdoor break

Ayush Kulshreshtha — Wed, 07 Oct 2026 18:42:53 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

What I Built

OneScreenOut is a small Python CLI that turns a time budget, nearby surroundings, and energy level into one outdoor micro-expedition. It is designed for students and developers who finish a coding session and need a concrete reason to step outside.

The design constraint is simple: the useful interaction should fit on one screen. A local Gemma 3 model, served through Ollama, generates a mission with three short steps, a sensory cue, and a safety reminder. The program saves a local field card, prints it once, and exits.

Its final line is the product's goal:

📵 Pocket your phone now. The app is done; the outside part starts here.

There is no feed, streak counter, or follow-up chat. The intended flow is: request a plan, read it, close the laptop, and spend the break outdoors.

Demo

This is a local CLI rather than a hosted web application. To run it, download the project folder, start Ollama, and run:

ollama pull gemma3:1b
python app.py --minutes 15 --environment "college campus" --energy medium

For an interface preview without downloading a model:

python app.py --sample

The following is the static sample output, explicitly labeled as such. It is not evidence of a live AI inference:

🌿 OneScreenOut
Quest: Three Textures, Ten Minutes • 15 min • SAMPLE (no AI call)

Walk outside and find three natural textures you can observe without
disturbing anything.

1. Find one rough texture and describe it in three words.
2. Find one smooth texture and notice how light falls across it.
3. Stand still for 30 seconds and listen for the farthest sound.

Notice: Look for one detail you would normally walk past.
Safety: Stay in public, familiar areas and keep clear of roads or hazards.

📵 Pocket your phone now. The app is done; the outside part starts here.

The generated card is also saved to quest_card.txt. This makes it easy to read once before leaving the screen.

Code

OneScreenOut source, README, and MIT license

The project was added during the October 5–11 challenge window. It currently lives in a dedicated folder within my existing repository.

How I Built It

The application uses the Python standard library for argument parsing, HTTP requests, JSON processing, and terminal output. Its default model is gemma3:1b, and its inference request goes to Ollama on localhost:11434.

The model is the core: it adapts the mission to the user's available time, environment, and energy. The Python layer formats the result into a small field card. Ollama's JSON output mode is enabled, and the application checks the expected keys and the three-step list before rendering.

The prompt asks for public, familiar activities and excludes private property, traffic, climbing, swimming, unknown plants, and wildlife handling. These are prompt instructions, not a guarantee that a generated plan is safe; the user still needs to judge local conditions.

The --model option lets users select another locally installed model. The --sample option previews the interface without making an AI call. If Ollama cannot be reached, the app reports an error instead of silently substituting a sample.

An AI agent prepared the implementation and generated this write-up at my direction, with no manual editing of the article by me. During its final review, the agent fixed literal JSON braces in the Python prompt so they were not treated as formatting expressions. Prompt construction and sample rendering were verified. Live Gemma inference and an outdoor field trial have not yet been verified for this submission.

Why Does Open Innovation Matter?

For OneScreenOut, local inference makes the intended interaction private and independent of a hosted AI account. After installing Ollama and downloading the model, the generation path can run without internet access. The app does not send the user's surroundings or energy level to a cloud model API.

An open-weight model also gives the user control over which model runs on their hardware. The application code and prompt can be inspected and changed: someone could localize the missions, adapt the instructions for accessibility, or experiment with another model. Gemma's model terms are separate from the application's MIT license.

A hosted API could generate an outdoor plan too. The concrete advantage here is that the plan can be generated locally, without a hosted-model API key or a per-request API bill. The trade-off is that users need to install a runtime, download model weights, and have hardware capable of running them.

What I Learned

The most interesting constraint was deciding how little the AI should say. A short mission is more useful for this theme than an open-ended conversation. Three steps and one sensory cue give the user something specific to do, while the final instruction makes leaving the screen part of the experience.

The current prototype still relies on the model to follow length and safety instructions. A next improvement would be stricter output validation, followed by measured live-inference tests and a real outdoor trial.

Prize Categories

Best Use of Gemma — the generation path uses Gemma 3 locally through Ollama.