Outsider

~/Outsider Gallery $ glow README.md

Outsider Gallery

A curated digital exhibition space for fine art and aesthetic transformations.

Why I built it

As someone who bridges the gap between analytical thinking and art, I needed a dedicated platform to showcase my creative projects. Standard platforms often ruin carefully crafted details—like classic cinematic lighting, 90s vintage aesthetics, and specific fabric textures—through aggressive compression. I built Outsider Gallery to have complete control over how my art, from Ghibli-inspired portraits to traditional paintings, is presented to the world, free from the constraints of social media algorithms.

What it does

• Showcases high-resolution digital and traditional artworks in an immersive, minimalist interface.
• Organizes collections by specific aesthetics, including vintage cinematic themes and detailed digital transformations.
• Offers a seamless, fast-loading viewing experience across all devices without losing visual quality.

How it's built

• Hosted and deployed via Cloudflare Pages for fast, secure, and reliable global performance.
• Designed with a clean, responsive frontend to ensure the artwork takes center stage on any screen size.
• Optimized media delivery to maintain strict visual consistency and preserve the intricate details of each piece.

Decisions worth noting

• The UI is kept intentionally minimal to prevent distractions from the core visual content.
• Prioritized high-fidelity image rendering to maintain exact color balances and lighting direction, mirroring a meticulous editing process.

"dependencies": ["Tailwind", "Next.js", "JavaScript", "React"]

https://outsidergallery.pages.dev

~/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