My code runs on intuition, crashes on reality.

CS grad turned PMIT student in Dhaka, professionally employed as a middle manager to a small army of AI agents that occasionally listen to me. I write the vision statement, they write the bugs. Most of what's below is AI-driven experimentation — agents, RAG, code auditors, dashboards, travel products, streaming experiments, and the occasional "why did I build this at 2 AM" side quest that seemed load-bearing at the time.

If you're expecting clean code and pristine docs: bold of you to click a profile called smile-plzz. Lower your expectations to somewhere just above "it ran once on my machine" and you'll have a great time. I mostly build things because I want them to exist, then accidentally learn something useful along the way.

git blame is basically my autobiography at this point. Everything eventually becomes legacy code, including us.

The newer side of the repo pile — where ideas currently go before I have time to reconsider them.

Desktop software for people who still believe files belong on hard drives and local networks shouldn't need an internet connection.

Repurposing old screens, building offline utilities, and making living room TV apps do what I actually wanted.

Where I outsource my thinking to committees of chatbots and call it architecture. Consciousness remains an unresolved dependency.

An honest breakdown of how ideas metastasize into repositories with the help of artificial enablers.

1. The 2 AM Epiphany (Ideation via Impulsive Conviction): An idea strikes — usually solving a problem nobody asked me to solve, or building an entire offline app because an existing service required an email sign-up. A comprehensive PRD is drafted with unwarranted corporate solemnity before common sense can stage an intervention.
2. The Synthetic Committee Debate (Brainstorm.AI & HiveMind): I assemble competing LLM personas into an automated roundtable to stress-test the concept. They argue with each other with supreme, unearned confidence. I moderate this digital circus like an exhausted middle manager who just wanted a clean API spec.
3. Automated Delegation (Outsourced Bug Generation): I supply the high-level architecture; the AI writes the code at 120 tokens per second. I don't hand-craft runtime errors anymore; I outsource their generation to GPU clusters in Oregon with terrifying efficiency.
4. The Forensic Inquest (TCRA Code Auditor & VibeBench): Knowing the agents hallucinated at least three non-existent methods and a deprecated state manager, I deploy another layer of AI auditors to interrogate the first batch. Four iterations of TCRA exist because I refuse to trust AI code without using more AI to judge it.
5. The Free-Tier Scavenger Protocol (Hermes Model Router): When token costs threaten to become actual currency, I route tasks through free tiers — Groq, Gemini, Mistral, OpenRouter — milking context windows like a digital raccoon until the build passes or rate limits enforce bedtime.
6. The Endgame & The Next Repo: The app deploys to Vercel. It runs once. The autonomous agent dutifully logs the victory in its public paperwork (hermes-journal). I notice three catastrophic edge cases, refuse to refactor, and immediately open another repository to start the cycle anew.

Side quests where graphics APIs, canvas rendering, and game loops take precedence over better judgment.

Where gaming obsessions collide with formal academic papers in narrative design, moral philosophy, and culture.

Apparently enjoying something normally is not enough; eventually I want the dataset.

Peak productive procrastination: building the thing instead of watching the thing. Time is finite; apparently this is how I chose to spend some of it.

Building medication tools until I eventually run out of ways to visualize a tablet.

The "there has to be a cleaner way to do this" department. There usually isn't; I build one anyway.

The technical stack, or: how I turn caffeine and mild spite into running software.

• The Polyglot Delusion: TypeScript, Python, C#, and Kotlin — alternating between them based purely on which compiler offended me the least that morning.
• The "Zero-Backend" Religion: If it can run entirely inside client-side MapLibre, WebAssembly, or localStorage, it will. Server bills are an emotional defeat; my preferred monthly cloud spend is strictly $0.00.
• Hardware Recycling as Therapy: Turning eight-year-old Samsung Galaxy phones into offline travel appliances and local TV bridges because letting silicon retire in peace is against my principles.
• Desktop Revivalism: Building native C#/.NET and Avalonia desktop tools because watching modern Electron wrappers consume 2GB of RAM to render three text inputs hurts my soul.
• The Free-Tier Scavenger Routine: Daisy-chaining custom model routers across Groq, Gemini, Mistral, and OpenRouter like a digital raccoon foraging through free-tier context windows.
• Offline Paranoia: Writing offline-first parsers for local SMS, direct iPhone backups, and SHA-256 deduplicators — because trusting third-party cloud sync requires an act of faith I don't possess.
• Academic Coping: Whenever building software fails to resolve an existential question, I write 20-page LaTeX papers dissecting moral trauma and player guilt in video games instead of sleeping.

AI agents · LLM evaluation · Local-first software · Android & TV tools · React / Next.js · Node.js · C# / .NET · Python · data experiments · product prototypes · tools that solve suspiciously specific problems

Most projects here are experiments, prototypes or research artifacts rather than polished commercial products. I build fast, test ideas in public, keep the useful failures, and occasionally remember to write the README.

Some people collect bookmarks for ideas. I appear to collect repositories. Some reach production; others achieve the more peaceful state of abandonment.

Current pattern: research → prototype → deploy → discover three new problems → open another repo → repeat until the heat death of the universe or GitHub changes its pricing, whichever comes first.