DEV Community: TROJAN

I Thought AI Would Make Me Code Faster. Then I Spent 6 Hours Debugging One Line.

TROJAN — Tue, 02 Jun 2026 05:16:18 +0000

Everyone keeps saying AI will replace developers.
Meanwhile I was sitting at 3:17 AM staring at a bug created by code that looked perfectly correct.

Classic.

The weird thing about AI coding tools is this:

They are insanely good at getting you from zero to eighty percent.
The remaining twenty percent?
That part turns into a psychological thriller.

The Illusion of Fast Development

You ask the AI for a feature.

It generates:

components
hooks
API calls
utility functions
TypeScript types
enough confidence to destroy your weekend

And for a moment, you feel unstoppable.
Then reality walks in wearing steel toe boots.
Because the code works.
Until it doesn't.
And when it breaks, you're debugging logic written by someone who technically does not exist.

Which is honestly rude.

The Real Problem Isn't The AI

The issue is not bad syntax.
The issue is missing context.
AI understands patterns.
Senior developers understand consequences.
That difference matters a lot.

Especially when:

state management gets messy
async logic starts fighting itself
edge cases crawl out of the sewer
one innocent refactor nukes three unrelated features

The AI generated code looked clean.
Too clean.
Like a serial killer apartment.

The Most Dangerous Thing AI Produces

Confident nonsense.
Not broken nonsense.
Not obvious nonsense.
Confident nonsense.

The kind where you read it and think:

"Damn this looks smart."

Then four hours later you discover the function has been emotionally gaslighting your database the entire time.

What I Learned After Fighting AI Generated Code

1. Fast code is not maintainable code

AI optimizes for completion.
You still have to optimize for:

readability
architecture
scalability
future you not having a breakdown

Because future you will absolutely file complaints against present you.

2. Tests matter more now

If AI writes code faster, you need validation faster.
Otherwise you're basically accepting pull requests from a caffeinated intern that never sleeps.
Which sounds impressive until production catches fire.

3. Senior thinking matters more than ever

AI can generate solutions.
It cannot reliably judge tradeoffs.
It does not understand:

business risk
performance bottlenecks
system boundaries
long term technical debt

It just vibes aggressively.

The Funny Part?

I still use AI every single day.
Because despite all the chaos, it is useful.
It removes boring work.
It speeds up experimentation.
It helps unblock momentum.
But I stopped treating it like an engineer.

Now I treat it like:

an extremely fast junior developer with infinite confidence and occasional hallucinations

Which honestly makes the experience much healthier.

Final Thought

AI is not replacing developers.
It's exposing who actually understands software engineering.
Because generating code was never the hard part.
Understanding why the code should exist in the first place?
That's the real game.

And unfortunately, the AI still can't survive a production bug at 2 AM with three stakeholders breathing down its neck.

Lucky us.

I Updated My GitHub Auto-Commit Desktop App

TROJAN — Sat, 30 May 2026 19:03:16 +0000

A few weeks ago I posted about building a desktop app that automates GitHub commits because contribution graphs are basically developer mood rings.

Somehow people actually liked it.

Which was unfortunate because now I had to keep improving it instead of peacefully abandoning the repo like nature intended.
So I disappeared back into the codebase and shipped a pretty huge update.

What Changed

Deterministic Scheduling

The app now generates the same commit schedule from the same config every time.
Meaning it finally stopped making random life choices for me.

Old version be like:

"Yeah bro you definitely lock in at 4:11 AM."

Absolutely not.

At 4:11 AM I am unconscious and getting combo attacked by my dreams.

Pattern Learning

The app can now analyze repository behavior and generate commit activity that actually feels natural instead of random chaos spam.
Because fake randomness is still obvious randomness.

Now it feels less like:

"robot discovered GitHub"

and more like:

"slightly sleep deprived developer surviving on caffeine and bad decisions"

Which is the exact vibe I was aiming for.

Better Stability

I moved Git execution into dedicated workers which made the app way smoother overall.

Less freezing
Less weird execution issues
Less me staring at the screen like:

"bro please just push the commit."

Git was acting like I personally offended it.

Internal Refactor

I also cleaned up a huge chunk of the architecture because parts of the old codebase were being held together by pure optimism and side effects.

At one point the logic was basically:

if (works) {
  dontTouchIt()
}

Which is not software engineering.

That is survival instinct.

Still Fully Local

No telemetry
No cloud execution
No weird "AI productivity guru" nonsense
No blockchain
No "revolutionizing developer workflows" TED Talk energy

Just a desktop app solving the very real developer problem of:

"damn... I forgot to commit again."

Repo

Auto Commit Desktop App

Honestly this project started as a joke and somehow became one of the coolest things I've built so far.
Which is usually how programming works.

You try to build one tiny stupid tool and suddenly you're restructuring worker threads at 2 AM wondering where your life went.

Full Stack Developer Looking for Internship Opportunities

TROJAN — Thu, 28 May 2026 17:20:51 +0000

Hey everyone,

I’m currently looking for Software Development internship opportunities.

Open to:

Hybrid internships in Delhi or Noida
Remote/online opportunities as well

I’m a Full Stack & Desktop Application Developer focused on building scalable web apps, automation tools, and AI-powered applications using:

JavaScript / TypeScript
React.js / Next.js
Node.js / FastAPI
Python
MongoDB / Supabase
OpenCV / MediaPipe
Desktop automation & system-level tooling
REST APIs, WebSockets, and real-time applications

Some projects I’ve built:

AI-powered desktop assistant with gesture + voice control
Full-stack productivity tracking platform
Developer workflow automation tools
Performance-optimized portfolio applications

I also write technical content on Dev.to with 7,000+ followers, sharing insights on full-stack development, AI tooling, automation, and developer productivity.

Portfolio: https://arishali.vercel.app/
GitHub: https://github.com/TROJANmocX
LinkedIn: https://www.linkedin.com/in/arish-ali-8670341b3/

If your company or someone in your network is hiring interns, I’d genuinely appreciate a referral or connection.

Available to join immediately.

Thanks!

Building Extensio.ai — Looking for Contributors & Ideas

TROJAN — Tue, 26 May 2026 09:53:30 +0000

I’m building Extensio.ai — an AI-powered browser extension focused on developer productivity and workflow automation.

The idea is to make the browser feel less like:

“I have 42 tabs open and none of them are the right one.”

…and more like an actual smart developer workspace.

Some things I’m experimenting with:

AI command palette
GitHub/code understanding
smart tab management
context-aware AI
workflow automation
developer-focused browser tools

But honestly?

I don’t want to build this in isolation and accidentally create another “AI startup buzzword machine” that eats RAM and contributes nothing to society.

So I’m looking for:

developers
extension nerds
UI/UX people
AI tinkerers
productivity addicts
people with cursed but genius ideas

Basically anyone who wants to help shape or contribute to this project.

I’d love feedback like:

What features would make this genuinely useful?
What workflows should it improve?
What browser-extension pain points annoy you most?
What would make you actually install this?

And if you want to contribute or brainstorm ideas:

GitHub:
https://github.com/TROJANmocX/Extensio.ai

Roast the idea.
Suggest features.
Open issues.
Build weird stuff with me.

Let’s make something developers actually want to use instead of another AI tool pretending to change humanity while summarizing emails.

MIA: A Futuristic AI Desktop Assistant Built with Voice, Gestures, and Controlled Chaos

TROJAN — Mon, 25 May 2026 05:32:51 +0000

Most desktop assistants today feel like they were designed by someone whose greatest ambition was setting timers.

I wanted something different.

So I built MIA short for My Intelligent Assistant — an AI-powered desktop assistant that combines voice interaction, hand gesture recognition, HUD overlays, desktop automation, and a surprisingly dramatic personality into one system.

Basically, imagine if a traditional assistant stopped being lazy and decided to become slightly cyberpunk.

What Exactly is MIA?

MIA is a modular AI desktop assistant designed to create a more immersive and interactive way of controlling your computer.

Instead of relying only on keyboards and mouse clicks, MIA introduces:

Voice commands
Real-time hand gesture control
On-screen HUD overlays
Text-to-speech responses
Combo interaction modes
Desktop automation features

The goal was simple:

Make interacting with a computer feel less like operating Excel and more like starring in a sci-fi movie at 2 AM.

And honestly? It got dangerously close.

Core Features

Voice Activation System

MIA can be activated using a wake phrase like:

Hey MIA

Once activated, the assistant listens for commands and processes interactions in real time.

This creates a hands-free workflow where users can launch tasks, trigger actions, or interact with the system naturally.

Because clicking through seventeen menus to open Spotify feels personally offensive at this point.

Real-Time Gesture Control

This is where things start looking mildly illegal.

Using MediaPipe, OpenCV, and computer vision models, MIA can detect and interpret hand gestures directly through a webcam feed.

Current gesture capabilities include:

Cursor movement
Mouse clicks
Scrolling
Volume adjustment
Gesture-triggered actions
Interactive desktop controls

The system tracks hand landmarks in real time and converts them into desktop interactions.

So yes, you can literally control your PC by waving your hand around like a low-budget Iron Man prototype.

And somehow it actually works.

Combo Interaction Mode

One of the most interesting features in MIA is the 30-second Combo Mode.

After activating MIA, users can combine:

Voice commands
Hand gestures
Overlay interactions

Together in a single interaction session.

This allows for more immersive workflows where voice and gestures work simultaneously instead of independently.

In simpler terms:

You talk to your computer.

Your hand moves in the air.

Things happen.

Humanity peaked right there.

HUD Overlay System

MIA includes a custom HUD (Heads-Up Display) overlay built using PyQt5.

The overlay provides:

Live visual feedback
Command indicators
Gesture recognition status
System interaction responses
Animated interface elements

Instead of silently doing tasks in the background like a suspicious government application, MIA visually communicates what it’s doing in real time.

Which makes the entire assistant feel significantly more alive.

And slightly more judgmental.

Personality-Based Responses

Most assistants sound emotionally unavailable.

MIA was designed differently.

Using text-to-speech systems and response handling, the assistant can respond with different tones and personalities such as:

Calm
Smart
Witty
Sarcastic
Futuristic

Because if an AI assistant is going to interrupt my workflow, it should at least have better dialogue than a microwave.

Technical Architecture

The project follows a modular architecture to keep features isolated and scalable.

Main modules include:

server/api.py
gesture_control/main.py
mia_assistant/voice_activation.py
mia_assistant/tts_response.py
mia_assistant/hud_overlay.py
mia_assistant/command_parser.py

Each module handles a separate responsibility such as:

Gesture recognition
Voice activation
HUD rendering
Command parsing
API communication
Text-to-speech processing

This keeps the project maintainable and prevents the classic developer strategy of:

everything_final_v7_last_REAL.py

A file name that has ended friendships and academic careers.

Technologies Used

MIA combines several technologies across AI, computer vision, and desktop automation.

Main Stack

Python
FastAPI
OpenCV
MediaPipe
PyQt5
PyAutoGUI
SpeechRecognition
Pyttsx3

Planned Integrations

DeepFace
Emotion detection systems
Environment-aware AI responses
Adaptive UI themes
AR-based interactions

Because apparently I looked at this project and thought:

“You know what this needs? More problems.”

Challenges During Development

Building MIA was fun in the same way dark souls is “fun.”

Some major challenges included:

Real-time gesture stability
Gesture priority conflicts
Smooth cursor movement
Voice activation latency
Synchronizing gesture + voice workflows
Overlay performance optimization

At one point MediaPipe confidently detected my coffee mug as a human hand.

Which honestly says more about my sleep schedule than the model itself.

Future Goals

The vision for MIA goes far beyond basic desktop automation.

Planned future features include:

AI memory systems
Mood-aware responses
Dynamic personalities
Smart productivity automation
Context-aware desktop assistance
AR interaction systems
Custom voice personas
Intelligent environment adaptation

The long-term goal is to create an assistant that feels less like software and more like an actual digital companion.

Preferably one that doesn’t eventually gain consciousness and start reviewing my browser history.

Final Thoughts

MIA started as an experiment in combining AI, gestures, and desktop control.

It slowly evolved into a full interactive assistant platform that blends:

Computer vision
Voice AI
Automation
UI systems
Real-time interaction design

Into one experience.

This project taught me a lot about system design, modular architecture, real-time processing, and the terrifying speed at which “small side projects” evolve into engineering boss fights.

And honestly?

I’d do it again.

Probably with worse sleep.

Open Source Repository

If you're interested in AI systems, computer vision, futuristic desktop interfaces, or projects that begin with curiosity and end with existential debugging sessions, check it out:

GitHub Repository

Project MIA

Feedback, contributions, ideas, and bug reports are always welcome.

Unless the bug report is:

“It doesn’t work.”

Thank you, detective. Massive breakthrough.

I Built a Desktop App That Ends My “Open 7 Terminals and Pray” Routine

TROJAN — Sat, 16 May 2026 23:35:44 +0000

Every developer has that one painfully stupid ritual.

Mine was opening multiple terminal tabs every morning, navigating into random folders, running npm run dev, forgetting which server crashed, then pretending I had my life together.

So I built Chronicle.

A desktop app that launches my entire development workspace with one click and lets me inspect Git history like a detective investigating my own questionable commits.

What Chronicle Actually Does

1. One-click workspace launcher

Hit one button and Chronicle spins up all your dev servers
simultaneously.

No more:

opening 5 terminals
copy-pasting commands
forgetting which port exploded
spiritually bonding with terminal chaos

It streams live logs into a clean dashboard so you can actually see what’s happening in real time.

2. Git history explorer with AI summaries

This part became way cooler than I expected.

Chronicle visualizes commit history, lets you inspect diffs, and even
uses AI to summarize what changed.

Because sometimes you look at your own commit from 3 days ago and think:

“Who the fuck wrote this?”

Spoiler: it was you. Sleep deprived. Dangerous.

The Stack

Layer	Tech
Desktop Shell	Tauri v2
Frontend	React 19 + Vite + TypeScript
Backend	Rust + Tokio
Styling	Tailwind CSS v4
Animations	Framer Motion
AI	Gemini

The Rust backend handles async process spawning while the React frontend
listens to live events from Tauri.

And honestly?

Tauri feels criminally underrated.

Electron said:

“What if your app consumed the RAM of a small nation?”

Tauri said:

“Relax. We brought Rust.”

My Favorite Part

Streaming terminal output from Rust into React in real time felt weirdly
magical.

Rust handles the processes asynchronously, pipes stdout/stderr line-by-line, then emits events directly to the frontend.

Tiny code. Massive payoff.

The result feels like a dev cockpit instead of a pile of terminal tabs
held together by caffeine and denial.

What I Learned Building It

Tauri is insanely good for desktop tooling
Rust async is terrifying for 20 minutes and then suddenly beautiful
Real-time event systems make apps feel alive
Developer tooling is fun because you get to solve your own annoying problems first

Also:

designing a “simple dashboard” somehow consumed half my lifespan.

Frontend developers are basically pixel war veterans.

Why I Built It

I wanted a tool that made development feel less fragmented.

Something fast.
Something clean.
Something that didn’t require ritual sacrifice every morning just to boot
a workspace.

Chronicle started as:

“I’m tired of opening terminals.”

And somehow evolved into:

“Let’s build an AI-powered developer control center.”

Classic scope creep. Absolutely deserved.

Try It

GitHub Repo

https://github.com/TROJANmocX/Chronicle

If you build dev tools, love Rust, or just enjoy automating away tiny
daily annoyances, you’ll probably have fun with this one.

And if your current workflow involves 14 terminal tabs and raw emotional
damage...

yeah.

This app was made for you.

Why Every Developer Should Build at Least One AI Project in 2026

TROJAN — Wed, 25 Mar 2026 16:39:53 +0000

AI is no longer “the future.”
It is already part of everyday development.
And yet, many developers are still watching from the sidelines.
Reading about it.
Liking posts about it.
Maybe generating a few lines of code with it.
Feeling productive… without actually building anything.
We have all been there.

The Shift Happening Right Now

We have moved from asking:

“Should I learn AI?”

to:

“How quickly can I apply it without breaking everything?”

Companies are not looking for AI researchers in most roles.
They are looking for developers who can use AI to solve real
problems.

That is a very different skill.

Why This Matters

Building even one AI project teaches you things that tutorials never will:

How to handle unpredictable outputs
How to design systems around uncertainty
How to integrate APIs with real-world logic
When AI is useful, and when it quietly creates chaos

You stop seeing AI as something magical.

And start seeing it as a tool that occasionally needs supervision.

You Do Not Need Something Complex

Your project does not need to be groundbreaking.

It just needs to work.

Some simple ideas:

A chatbot that solves a specific use case
A tool that summarizes or analyzes content
A small assistant for daily tasks
Adding an AI feature to an existing project

Simple and functional beats complex and unfinished every time.

(Yes, even if the UI is a little ugly. We can fix that later. Probably.)

What You Actually Learn

Once you build something, a few things become very clear:

AI outputs are not always reliable
Prompting is not “set it and forget it”
Debugging AI feels like arguing with a very confident intern
User experience matters more than model complexity

This is where real understanding begins.

A Common Mistake

Do not rely entirely on AI to build your project.
Use it, but understand what it is doing.
If you cannot explain your own system clearly, then you have not really built it.

You have just supervised it.

Final Thought

You do not need to become an AI expert.
You just need to stop being an observer.
Build one project.
That is enough to change how you think, build, and learn.

And if nothing else, you will finally have something better to show than

“experimented with AI tools” on your resume.

I Built a Desktop App That Starts My Entire Dev Environment With One Click (Using Tauri + Rust + React)

TROJAN — Thu, 12 Mar 2026 19:33:08 +0000

Every morning I would open 4 terminal tabs, cd into different folders, and run some combination of npm run dev and cargo run. Then I'd forget which terminal crashed. Then I'd do it again.

So I built Chronicle to kill that habit.

What Is Chronicle?

Chronicle is a desktop app (built with Tauri) that does two things:

One-click workspace launcher — press a button, fire up all your dev servers simultaneously, watch their output stream into a tabbed terminal dashboard in real-time
Git history explorer — visualize your commit graph, click commits to read diffs, and use an AI (Gemini) to summarize what changed

The Stack

Layer	Technology
App Shell	Tauri v2
Frontend	React 19 + Vite 7 + TypeScript
Backend	Rust (async, via Tokio)
Styling	Tailwind CSS v4
Animations	Framer Motion
AI	Google Gemini

Why Tauri?

Tauri lets you write your UI in whatever web framework you want, then wraps it in a native OS window using Rust. The result is a .exe that's tiny, fast, and has full access to the OS. No Electron 300MB bloat. No compromises.

The Rust backend part is what made the launcher feature possible. Here's the core of how it works:

#[tauri::command]
async fn start_all_processes(
  app: AppHandle,
  state: tauri::State<'_, Arc<AppState>>,
  project_path: String
) -> Result<(), String> {
  // Spawn each process asynchronously
  spawn_and_stream(app.clone(), state.clone(), "buildforge", 
    "npm", &["run", "dev"], &format!("{}\\BuildForge", project_path)).await?;

  spawn_and_stream(app.clone(), state.clone(), "airwebreathe", 
    "npm", &["run", "dev"], &format!("{}\\AirWeBreathe", project_path)).await?;

  Ok(())
}

The spawn_and_stream function uses Tokio to spawn processes async, reads their stdout/stderr line by line, and emits each line to the React frontend using Tauri's event system.

On the React side, listening for those events looks like:

const unlistenOutput = await listen<LogPayload>('process-output', (event) => {
  setLogs(prev => ({
    ...prev,
    [event.payload.id]: [...(prev[event.payload.id] || []), event.payload.line]
  }));
});

That's it. Real-time streaming terminal output from Rust to React in so few lines.

The UI

The whole thing is themed after GitHub dark mode (#0d1117, subtle borders, green accents). The launcher screen has one big green button. The dashboard that opens shows tabbed terminal output for each running process, auto-scrolling, color-coded (green = success, red = error).

What I Learned

1. Tauri is genuinely underrated. The developer experience is excellent, the apps are fast, and the security model is much more sensible than Electron.

2. Tokio makes async process spawning a joy. tokio::process::Command + BufReader + lines() is all you need to stream terminal output.

3. Tauri's event system is a perfect bridge. app.emit("event-name", payload) from Rust, listen("event-name", handler) from TypeScript. Clean and simple.

Try It

git clone https://github.com/TROJANmocX/Chronicle.git
npm install
npm run tauri dev

If you're building dev tooling or have ever thought "I should automate my terminal workflow" — Tauri + Rust is a genuinely great choice. Feel free to drop questions in the comments.

Happy building! 🗡️

I Performed an Autopsy on My LeetCode Streak (It Didn’t Die Peacefully)

TROJAN — Fri, 30 Jan 2026 15:26:32 +0000

My LeetCode streak didn’t “break.”
It died.

Not heroically.
Not after a hard problem.

It died on a random weekday because I got tired and lied to myself.

So I stopped tracking streaks like a motivational influencer
and started treating them like crime scenes.

Everyone Tracks Wins. Nobody Tracks Failure.

We love dashboards that say “X days strong”.
We don’t talk about how those streaks actually end.

When I analyzed my submissions, I noticed something uncomfortable:

My streaks don’t die randomly — they die on the same days
Most of them collapse between day 7–10 (fake discipline window)
My “longest streak” is a flex My average streak is the truth — and it’s embarrassing

Discipline wasn’t the problem.
Predictable burnout was.

So I Built a Streak Autopsy Tool

Instead of promising myself I’d “do better next time,”
I built something that performs a post-mortem.

You enter your LeetCode username.
It tells you:

how many streaks you’ve started
how many you’ve killed
how long they usually survive
the exact day you’re most likely to quit
and gives you a streak reality check instead of motivation porn

No quotes.
No fake encouragement.
Just data quietly judging you.

Why I Built This

Tracking wins was lying to me.
Losses don’t lie — they repeat.

If you know how your streak dies,
you can stop pretending it was an accident.

Repo:
👉 https://github.com/TROJANmocX/GrindGuard-2.0

Live demo:
👉 https://grindguard.vercel.app/

Final Thought

If your streak ever “mysteriously” vanished,
this will tell you why.
And if you don’t like the result good. Neither did I.

PLEASE TELL ME HOW CAN I IMPROVE IT AND WHAT PROBLEM ARE YOU ALL FACING.

I tried tracking my LeetCode streak honestly. The API fought me. I won.

TROJAN — Sun, 25 Jan 2026 17:16:21 +0000

Most LeetCode trackers fail at the one thing that matters most: trust.

If I solve a problem, I expect the app to:

mark it as solved
remove it from recommendations
update my progress immediately

No refresh. No manual ticking. No lies.

That frustration is exactly why I built GrindGuard 2.0.

Live app: https://grindguard.vercel.app/
GitHub repo: https://github.com/TROJANmocX/GrindGuard-2.0

What is GrindGuard 2.0?

GrindGuard 2.0 is a LeetCode accountability and focus system that turns your accepted submissions into:

Automatic progress tracking
Smart daily missions
Topic-wise analytics
Zero manual work

If LeetCode says you solved it, GrindGuard believes it. Period.

Core Philosophy

One source of truth. Everything else is derived.

No duplicated state.
No stale UI.
No “why didn’t this update?” moments.

Key Features

1. Automatic Progress Tracking

Solved problems are fetched directly from LeetCode accepted submissions and normalized into a single solvedProblems state.

If a problem is solved:

it is instantly marked as done
it never appears again in focus or suggestions

No manual input required.

2. No Repeat Questions

Daily Mission and recommendations strictly filter out solved problems using a normalized identifier (slug).

Once a question is done, it’s gone for good.

3. Real-Time Progress Analytics

Progress bars recompute every time solved data changes.

Topic-wise completion
Smooth count-up animations
Visual feedback that feels alive

If bars don’t move, users don’t trust the app. This fixes that.

4. Smart Focus System

Instead of showing everything, GrindGuard answers one question:

“What should I solve next?”

The algorithm:

Detects weakest topics (<40% completion)
Selects high-impact unsolved problems
Uses seeded randomness so missions stay consistent for 24 hours

No noise. Just focus.

5. One-Click Sync

A single Sync button:

fetches LeetCode data
updates progress, focus, and analytics together
shows freshness (“Synced 2 mins ago”)

Explicit feedback builds trust.

6. Zero Manual Work

The happy path is fully automated.

Manual overrides exist only as a fallback — never as the primary flow.

Architecture Overview

GrindGuard uses a simple but strict data flow:

LeetCode API
↓
fetchSolvedProblems()
↓
Dashboard (single source of truth)
↓
Derived UI

Progress
Daily Mission
Analytics

All components are reactive and render-only.
No component fetches data on its own.

Tech Stack

React 18 + TypeScript
Vite
TailwindCSS
Alfa LeetCode API (accepted submissions)
Striver SDE Sheet (curated problems)
LocalStorage fallback for resilience

What I Learned

Trust beats features
Reactive derivation beats stored state
If UI doesn’t update instantly, users assume it’s broken
One clear recommendation beats ten options

GrindGuard is not a dashboard. It’s a coach.

Try It Out

Live: https://grindguard.vercel.app/
Code: https://github.com/TROJANmocX/GrindGuard-2.0

If you’re grinding LeetCode and want accountability without friction,this one’s for you.

Happy grinding.

My Diary 2.0 — A Digital Journal

TROJAN — Fri, 16 Jan 2026 08:18:38 +0000

Some thoughts deserve a journal.
Some thoughts deserve therapy.
This app handles both.

Welcome to My Diary 2.0 — a personal web diary that feels like writing in an old notebook, but without the risk of your sibling finding it.

Live Demo: https://my-diary-snowy.vercel.app/
GitHub Repo: https://github.com/TROJANmocX/My-Diary

What Is My Diary 2.0?

My Diary 2.0 is a React + TypeScript diary app with a vintage aesthetic, mood tracking, and a writing experience that actually makes you want to journal.

Think:

Typewriter vibes
Candlelight drama
Nostalgic paper textures
Mild emotional chaos

Features That Deserve Respect

Vintage Writing Experience

Feels like:
“Dear Diary, today was… a lot.”

Includes:

Typewriter-style fonts
Paper-like background
Auto-expanding text area
Zero judgment

Mood Tracking

Because “fine” is not a real emotion.

Choose from:

Happy
Sad
Moody
Chaotic
Existential

Aesthetic Themes

Switch between:

Vintage – classy, nostalgic
Candle – dramatic, low-light, main-character energy

Secure Storage (Supabase)

Your secrets stay secret.
Unless you forget your password. Then… character development.

Custom Signatures

End entries like:

“— Trojan, still figuring things out.”

Tech Stack (The Sensible Kind)

React + TypeScript
Supabase (auth + storage)
Tailwind CSS
Custom Vintage UI
Vercel Deployment

No unnecessary frameworks. Just vibes and functionality.

Why I Built This

Most diary apps feel like filling out an emotional tax form.

I wanted something that:

Feels personal
Looks nostalgic
Makes writing fun
Doesn’t judge my 2 AM thoughts

So I built it.

Try It Before Your Thoughts Escape

Live Website:
https://my-diary-snowy.vercel.app/

Source Code:
https://github.com/TROJANmocX/My-Diary

Fork it. Customize it. Make it your own emotional support app.

What’s Next?

Planned upgrades:

Entry analytics
Mood history charts
Cloud backups
More themes
Possibly AI reflections (no promises)

Final Words

If your brain never shuts up
and your thoughts need somewhere safe to scream —

My Diary 2.0 is ready.

Now go write something unhinged.

— Trojan

I Built a Gesture Controlled Fluid Simulation (And Accidentally Fought GitHub)

TROJAN — Sat, 10 Jan 2026 16:12:31 +0000

So I had a simple idea:
“Let’s control a fluid simulation with hand gestures.”

Now I have:

10,000 particles
A racing mode
Audio reactivity
A physics engine
And emotional damage from GitHub’s 100MB file limit

Worth it.

What Is HydraFlow?

HydraFlow is a real-time, gesture-controlled fluid simulation where your hands literally control physics.

Open palm?
Particles fly away.
Pinch?
Black hole.
Fist?
Time stops.
Two hands?
Magnetic chaos.

It’s like Doctor Strange, but with Python and worse life choices.

The Cool Stuff

10,000 particles moving at 60 FPS
MediaPipe hand tracking
Multiple visual modes (Matrix, Heatmap, Disco, etc.)
Audio-reactive effects (yes, it vibes to music)
Racing mode where you steer with your hands
Glow, trails, chaos mode because subtlety is overrated

Your webcam becomes a controller.
Your hands become an API.

The GitHub Villain Arc

Everything was going great until I tried to push my repo.

GitHub saw my .exe file and said:

“That’s cute. Now delete it.”

Turns out GitHub has a 100MB file limit, and my build files were built DIFFERENT.

So I:

Nuked big files from git history
Added a proper .gitignore
Force-pushed like a responsible menace

Now the repo is clean, lean, and judgment-free.

What I Learned

GitHub is not your USB drive
Build files are not source code
.gitignore is not optional
Physics + hand tracking = dopamine
Debugging at 2AM builds character

Why I Built This

Because:

Mouse control is boring
Gestures feel futuristic
Physics is fun
And I like watching particles suffer

Also, it looks cool on my portfolio.

Try It Yourself

Repo:
https://github.com/TROJANmocX/HydraFlow

Wave your hands.
Break physics.
Feel powerful.

Final Thoughts

HydraFlow started as a fun experiment.
It became a full-blown chaos simulator.
And GitHub tried to humble me.

But we move.

If you’re building something weird, ambitious, and slightly unhinged
you’re doing it right.