Outsider

~/projects/edi $ glow README.md

Why I built it

Two years as an analyst meant two years in Excel, the worst software known to mankind. A billion dollar company, by the way. I lost work countless times because autosave was on holiday, stared at the screen while simple macros ran, and watched big datasets lock the whole thing up.

I couldn't just throw the file at an AI tool either. Company policy: you don't paste client data into a website. Fair enough. So I went all local and built something for myself. It started as EDIMA, Excel Doesn't Interest Me Anymore. The idea: my data, my model, my machine.

I thought it was my magnum opus. Things have changed since, so it's open source now. Go nuts.

What it does

• Ask a CSV or Excel file things in plain English: filter it, clean it, chart it, write formulas for it.
• No sign-up and no API key. Clone it, point it at a model, and the whole thing runs on localhost.
• You pick the model: Ollama by default, or LM Studio, vLLM, OpenRouter, Claude, OpenAI, Gemini or Groq.

How it's built

• Two modes. A simple question compiles to one SQL query; a complex one goes to a LangChain ReAct agent that queries and refines over several turns.
• The FastAPI backend is stateless: every request rebuilds an in-memory SQLite database from the stored sheet, cached on a hash of the rows.
• Charts come back as data (type, axes, series) and render in the browser with Recharts, not as images.

Decisions worth noting

• With a hosted model, it says exactly what leaves the machine: the question, recent messages, column names and at most 200 rows.
• Keys are never sent back to the browser. There is only an endpoint that reports whether one exists.

"dependencies": ["Next.js", "FastAPI", "LangChain", "SQLite", "Univer", "Recharts"]

github.com/illeniall239/EDI

~/projects/resumewesume $ glow README.md

Why I built it

I went to update my resume and found I'd lost the template. I could rebuild it from scratch or hand it to Claude, but the Bob the Builder part of my brain itched. So I built my own: it runs on my Claude subscription with no API key, or on local models when I'm in my "I hate these multi billion dollar corps" phase.

The name is the reply you get when you ask someone for help with a job: "resume wesume bhejo, dekhte hain". The day never comes.

Now I can get back to the real work: applying to 60 places and hearing back from two.

What it does

• Import a PDF or Word resume and see the parse beside it before anything is saved.
• Paste a job posting and ask for changes. The assistant makes discrete, validated edits one at a time, and the page re-renders as each lands.
• Export a clean, ATS-safe PDF. Local first: Ollama by default, with Claude, OpenAI, Gemini and others optional.

How it's built

• The model calls typed tools that change a structured document. It never writes free text into the page.
• Import reads each section against its own small schema. A section it can't read is shown with its source text rather than dropped.
• PDF export runs backwards through the stack: the API drives headless Chromium to the web app's print route.

Decisions worth noting

• Safety lives in the engine, not the prompt. A posting with a hidden instruction to add "Board Certified Neurosurgeon" got the model to try, and the server refused it as not grounded in anything the user said.
• Property tests assert that no sequence of edits can corrupt a document. They found a real bug on their first run.
• Turning off qwen3's reasoning for extraction took one section from 35.2 seconds and a failure to 4.0 seconds.

"dependencies": ["Python", "FastAPI", "Next.js", "SQLite", "LiteLLM", "headless Chromium"]

github.com/illeniall239/ResumeWesume

~/projects/bandsy $ glow README.md

Why I built it

I had to take IELTS and had no idea where to start. The practice tests were all over the place, spread across 24 Cambridge books, and I was honestly overwhelmed.

So I built one place to take me through it end to end, with AI doing the parts that usually need a tutor: marking my Writing and examining my Speaking.

What it does

• Reading and Listening look like the computer-delivered exam, with the real book audio, played once in a mock.
• Explain on any answer quotes where it is in the passage or transcript, why the key is right and why yours didn't fit.
• Writing is graded on the four criteria with errors marked inline. Speaking is a three-part test with a spoken examiner.
• One suggested session a day, weighted to your weakest module.

How it's built

• A pipeline turned the book PDFs and audio into tests: OCR, answer keys, transcripts repaired against the recordings with local Whisper, and validators for every 40 of 40 answers.
• Speech-to-text and the examiner's voice run locally, with faster-whisper and Kokoro.
• Answers are marked the IELTS way: alternatives, optional words, pairs in either order.

Decisions worth noting

• A model is used in the pipeline only where OCR can't do the job.
• Explanations are cached per question and answer, so a second click costs nothing.
• A job without a chosen model refuses to run rather than picking one for you.

"dependencies": ["React", "Vite", "Node", "SQLite", "Supabase", "faster-whisper", "Kokoro"]

github.com/illeniall239/Bandsy

~/projects/mentora $ glow README.md

Why I built it

AI fatigue. So much of my thinking had been handed to a model that I wanted to start from scratch and build myself back up. No more third party thinking.

So I used AI to beat AI: a tutor on a fixed path from TypeScript to agents, where I write the code and it notices what I keep getting wrong.

What it does

• A thirteen phase curriculum, about 976 hours at eighteen a week, from TypeScript and algorithms through full stack, machine learning and agents to interview practice.
• The tutor adapts the pacing, never the content.
• Exercises run in the browser in TypeScript, JavaScript, Python or Java, with daily spaced reviews and mistakes tracked so a weak spot gets drilled.

How it's built

• The tutor runs on Claude through a Claude Code login, with Ollama as the fallback.
• Every exercise's tests pass on its reference solution and fail on its starter, checked in every language it has.
• Progress lives in one SQLite file on your machine, with a backup export.

Decisions worth noting

• The curriculum is a fixed map, changed only as a deliberate, versioned decision.
• The machine learning phases were planned against real syllabi: Stanford CS229, CS231n and CS224n, MIT 6.S191 and fast.ai.

"dependencies": ["Next.js", "TypeScript", "SQLite", "Claude Code", "Ollama"]

github.com/illeniall239/Mentora

~/projects/naqsha $ glow README.md

Why I built it

I was tired of being the outsider on my own projects. The AI made the calls, quietly cutting corners to save tokens, and I found out later, then spent my time on workarounds and band-aid fixes.

I wanted control back. So I built my own skill: one that won't let the AI decide anything without me, not even in auto mode, and makes it plan and research properly before it touches the editor. Something like 80% planning, 20% execution.

Now it tells me everything. It's a team: a PM agent running the others, each in its own worktree, and every step is tracked, reviewed and tested, with me in on every decision. I guess I can call myself a 10x engineer now. Finally done slopmaxxing.

Btw, Naqsha is Urdu for map, plan or blueprint.

What it does

• /naqsha:plan has Claude interview you, study the codebase and research the standard approach, then write a plan you steer decision by decision, on a local page.
• Project files stay locked until you approve the plan, with a command only you can type.
• Then it builds step by step, test-first and security-first, every step reviewed, and asks before it changes the plan. It can also design every screen in every state first, audit an existing codebase, teach you what was built, and make a demo video of it.

How it's built

• A Claude Code plugin: skills for each command, and hooks that lock the project's files until the plan is approved.
• System design is derived, not assumed: quality scenarios ranked with you, load estimates with the arithmetic shown, each decision recorded with its trade-offs.
• Crew mode is a team: the session runs it like a PM, handing each step to a fresh worker agent in its own git worktree, up to four at once when they share no files.

Decisions worth noting

• What it cost is measured, not guessed: it reads Claude Code's own session logs and splits the tokens by step, agent and model.
• The context stays lean: one step at a time, references loaded only when a step needs them, research sent to subagents.
• The demo above was planned, recorded and rendered by its own /naqsha:demo.

"dependencies": ["Claude Code", "Node.js", "Playwright", "FFmpeg", "Mermaid"]

github.com/illeniall239/naqsha