DEV Community: TROJAN

I Let an AI Orb Judge My Facial Expressions While I Code, and Here's What Happened

TROJAN — Mon, 03 Aug 2026 09:21:14 +0000

A deep dive into AURA, the desktop AR companion that watches your face, reads your hand gestures, and — in a previous life — took 35 seconds just to say "hello."

So There's a Glowing Orb on My Desktop Now

Let me introduce you to AURA, a desktop companion whose entire personality can be summarized as: "I will float on top of your windows, stare at your webcam, and silently form opinions about your code and your life choices."

Per its own README, AURA is built to look at your screen, evaluate your facial expressions, and judge your open browser tabs in real time. No notes. No euphemisms. That's just the mission statement, printed in broad daylight, by the people who made it. Bold. Deranged. Kind of iconic.

It's a semi-transparent holographic orb pretending very hard to be a sentient biological interface, the way a Roomba pretends to have feelings when it gets stuck under the couch. It changes color depending on whether you look focused, happy, or the specific flavor of "deeply stressed by my own code" that only a 2am debugging session can produce. It does not, notably, offer to help you fix the bug. It just watches. Like a nature documentary, except you're the nature.

Chapter 1: The Dark Ages (a.k.a. "Please, Just Let Me Open One App")

Before the great rewrite, launching AURA was less "spin up an AI assistant" and more "sit down, we need to talk about your life choices while the computer thinks." It behaved less like software and more like a extremely judgmental houseplant that needed 35 seconds of silent contemplation before it would even acknowledge your existence.

Here's the greatest hits album of suffering, straight from the project's own changelog, presented with the reverence it deserves:

The 35-Second Cold Start Penalty — On launch, the app synchronously imported PyTorch, EasyOCR, MediaPipe, PyAutoGUI, Pygame, and the Windows speech drivers, all before doing anything useful, like a chef who insists on individually greeting every vegetable before starting dinner. You could make coffee. You could floss. You could reconsider your career. You could come back and the window still wouldn't be open.
Webcam Gladiatorial Combat — The emotion engine and the gesture engine both tried to grab webcam index zero independently, like two toddlers diving for the same toy at a birthday party where there is, tragically, only one toy. Windows, a surprisingly reasonable referee in this scenario, refused to let two threads hold the same camera handle, so the app just... crashed. Repeatedly. In the background. Like a ghost that keeps trying to use the bathroom.
Dial-Up Polling Architecture — The frontend polled the backend every 500 milliseconds over a WebSocket, which meant AURA's "empathetic real-time reactions" arrived with the emotional timing of a satellite phone call during a thunderstorm. You'd smile, and half a second later — like a delayed laugh track — the orb would notice. Riveting stuff. Oscar-worthy comedic timing, if the comedy were "grief."
A Syntax Error In The Launch Script — Yes. The very first thing that ran, the .bat file meant to start the whole show, had a stray closing parenthesis on line two. The app failed before the app even had a chance to fail properly. It's the software equivalent of tripping over your own shoelaces before you've left the house.

Somewhere out there, a Task Manager CPU graph from this era is still in therapy, unpacking the trauma with a licensed professional.

Chapter 2: The Enlightenment (a.k.a. Someone Finally Read the Profiler Output)

The maintainers apparently got tired of their own creation taking longer to boot than a small Linux distro compiling itself from source on a calculator, and did an honest-to-goodness performance overhaul. The results are, frankly, a little suspicious in a good way — the kind of glow-up you assume must involve at least one crime:

Metric	Before	After	Vibes
PyTorch / EasyOCR load	~15 seconds	0 seconds (lazy loaded)	🧘
MediaPipe load	7 seconds	0 seconds (background thread)	🧘
Backend init	~24 seconds	~1.2 seconds	🚀
UI render	~10.5 seconds	~0.4 seconds	🚀
Total cold launch	~35 seconds	~1.5 seconds	✨

Translation, for the humans in the room: the heavy ML imports got shoved into background threads instead of blocking the front door like a bouncer who insists on checking everyone's ID twice, the two camera-hungry threads got merged into a single, well-mannered CameraManager that only grabs the webcam once (revolutionary, groundbreaking, someone alert the Nobel committee), and the frontend stopped waiting around for a dev server to compile itself from scratch on every single launch. It now just loads a pre-built static bundle in Electron like a normal, well-adjusted application that has been to therapy.

The telemetry pipeline got a promotion too — from a sad 2Hz polling loop to a snappy 20Hz WebSocket broadcast. Your orb now notices your feelings roughly as fast as your actual friends do, which is either impressive or mildly concerning, depending on how many browser tabs you currently have open and how many of them are, statistically, shopping carts you'll never check out.

Chapter 3: What This Thing Actually Does to You

Once booted (in a very reasonable 1.5 seconds now, thank you), AURA gets to work reading your face and your hands like a mime interpreting your soul for an audience of one, that audience being you, on a Tuesday, in your pajamas.

It Judges Your Mood

Using face-mesh tracking on eyebrow distance and mouth curvature, AURA sorts you into moods and reacts with a whole aesthetic package — color gradient, orb animation, ambient sound, the works, like a mood ring that got a computer science degree and will not stop bringing it up:

Neutral → calm cyan breathing pulse, because you're pretending everything is fine and honestly? Respect.
Happy → bouncy amber shimmer, presumably because your build passed, or someone liked your tweet, same thing really
Sad → slow blue morphing with melancholic piano, presumably because it didn't, and now a robot is playing you a funeral dirge about it
Focused → sharp violet crystalline core, i.e. "do not talk to me, I am in the zone," a zone which will be shattered the instant a Slack notification appears
Angry → jagged red vibrations with a literal warning tone, i.e. "the merge conflict has won and everyone in this office knows it"
Surprised → pink/cyan radial burst, i.e. "wait, that actually worked?" the universal facial expression of every developer, ever, in the history of the craft

It Reads Your Hands Like a Tiny Psychic

Hand gestures via MediaPipe Hands trigger real actions on your desktop, turning your hands into a remote control you didn't know you signed up for:

Open palm wakes it up and expands the dock — the digital equivalent of raising your hand in class, except the teacher is a glowing orb and there are no wrong answers, only vibes
Closed fist puts it to sleep, orb dims to 30% opacity, basically "leave me alone" translated into a universal, pre-verbal gesture that even the orb understands instantly, unlike your coworkers
Index finger to lips (shoosh) mutes the text-to-speech instantly, for when the orb will not stop narrating your life like a nature documentary you never asked to star in
Pointing drops a glowing AR reticle on the UI element you're aiming at, like a laser pointer for people who refuse, as a matter of principle, to read buttons
Thumbs up makes the orb flash gold, presumably as validation that you, a human being, did a thing correctly, which — no shade — some of us really need to hear from a computer sometimes

It Looks Suspiciously Like a Sci-Fi Movie Prop

The frontend, rebuilt in Electron with Framer Motion and Tailwind, delivers a full glassmorphism package: a liquid gradient orb, an ambient mood bar across the top of your screen, AR target reticles with crosshairs, a floating quick-action dock, and a tiny picture-in-picture HUD showing your own webcam feed with a face-mesh overlaid on it — so you, too, can watch yourself being watched, in a delightfully unsettling hall-of-mirrors sort of way that nobody asked for but everybody, deep down, kind of wanted.

The Architecture, For Those Who Like Diagrams

Under the hood, there's a Python/FastAPI backend built around an AuraBrain class (yes, it's really called that, no, I did not name it, I would never) that delegates to a CameraManager (perception), VisionEngine (screen OCR via EasyOCR), VoiceEngine (TTS/STT), and AutomationEngine (PyAutoGUI clicks). All of it streams state to an Electron + React frontend over a WebSocket at 20Hz, where components with names like Bubble.tsx, MoodBar.tsx, Overlay.tsx, QuickDock.tsx, and CameraPreviewHUD.tsx turn "your webcam thinks you look tired" into actual pixels on your screen, twenty times a second, because your existential dread deserves a smooth frame rate.

It is, essentially, a real-time perception pipeline wearing a very stylish holographic costume, like if ps aux went to art school.

Should You Run This?

If you're on Windows, have Python 3.10+ and Node.js 18+, and are emotionally prepared for an orb that watches your face while you write code and occasionally plays melancholic piano at you, the whole thing launches with one double-click of StartAURA.bat. It's MIT licensed, so you're free to fork it, judge its judging code, or build your own emotionally-invested desktop pet that will, unlike your actual pets, never respect your boundaries.

Just maybe don't open it during a live coding interview. The Angry mood's warning tone hitting mid-sentence, right as you're explaining a for loop, is not the vibe you want your interviewer to hear — and "sorry, that's just my sentient orb, it can tell the interview's going badly" has never once saved anyone's callback.

Repo: TROJANmocX/AURA-Desktop-AR-Companion-System

The 2026 Dev Tools Tier List (Or : Everyone's Nen Ability Just Got an Upgrade)

TROJAN — Fri, 31 Jul 2026 13:57:40 +0000

The tools are your equipment. You're still the one leveling up.

If you've been napping since 2024 and you wake up right now, you could be forgiven to believe that the whole industry has gotten hit with Ten Thousand Hands maneuver. All the tools in your stack—writing, reviewing, testing, shipping the code—all got a silent AI-powered upgrade without you even noticing.

This article is not a "40 tools for you, good luck" listicle. It is actually a tier list that describes what tools people are currently using in 2026 and why, so let's go.

S-Tier: The Coding Agents (Your Main Character Energy)

The one truly game-changing aspect: AI assistants aren't simple autocompleters anymore. They've graduated from being "that Pikachu who knows Thunder Shock" into fully fledged collaborators, who read through your codebase, help you write tests, and open pull requests.

GitHub Copilot – still the most widely adopted solution, particularly within larger organizations. Your most reliable Naruto here, no frills but definitely the same side as everyone else down the line.
Cursor – AI-native editor, built around the idea of doing away with tabs between your IDE and your chat window. Strong contextual awareness of your codebase, rapid iterations.
Claude Code – an agent, meant to be used directly from your terminal or an integrated development environment (IDE). Not just suggestions but actual implementation of a new feature.
Windsurf – another AI-native editor, similar to Cursor, in the same league when it comes to agentic, multi-file editing.

The real takeaway: developers aren't settling for one tool anymore. Multi-tool solutions – one chat assistant, one IDE agent, and one terminal-based are increasingly becoming a standard.

A-Tier: The Vibe Coding Platforms (Broken-Nen speed prototype version)

One area that has really taken off is platforms meant to turn ideas into prototypes quickly.

Replit – Cloud-based IDE and agent which are good at building something usable fast without worrying about local set up.
Bolt – Codeless platform that turns prompts into applications. Specializes in front-end development.
Lovable – Competes with Bolt. Also a codeless front-end platform but focuses on UI generation.
Base44 and Emergent – New players in the same space as "description-to-app."

Not a replacement for actual coding but solves the "starting from a blank sheet of paper" issue. Useful for hackathons, MVPs and client demos.

A-Tier: AI Code Review (The Sensei Who Actually Reads Your Scroll)

Speeding up the coding process just shifts the problem of review. So now there's an entire category of tools whose sole purpose is to spot something the rush job human reviewer missed:

Greptile - codebase-aware PR review, made to understand the true quirks of your codebase, not just diffs
CodeRabbit - lightweight and fast AI review, a favorite of smaller dev shops without a separate review workflow

The important thing here is the trend: combining a tool to write code (Copilot, Cursor) with a separate one to review it is rapidly becoming a necessity, not a perk.

On the B-Tier List but Gaining Momentum: Testing

Playwright is secretly beating out the competition in the cross-browser testing wars. It scales better to handle bigger, more complex applications than Cypress does, and its TypeScript-first approach is attracting more QA engineers every single quarter. Your tests aren't using Playwright? This is the time to change that.

Infrastructure Tools People Don't Talk About Nearly Enough

Vercel – deployment tool constantly growing beyond "just" front-end hosting
Supabase – backend-as-a-service with Postgres under the hood that comes with vector search and authentication capabilities out of the box; very important if you're building anything involving AI
Linear vs. Jira – Linear shines in speed and UI design for small, fast-paced teams; Jira has the edge on integrations and scalability in the enterprise environment

The Part That Everyone Skips: Security

This is the surprise twist to everyone’s "AI writes half your code" story that nobody saw coming: security technologies would need to play catch-up, big time. Get ready to see much more talk in 2026 about software bill of materials adoption and threat detection by AI — basically, scanners that treat AI-written code like it’s any other piece of code produced from a black box, which is what it is until proven otherwise. If you’re releasing AI-written code without a review step and security scan along the way, consider yourself taking “living dangerously” to the next level.

TL;DR

The tools are different, but the basics remain the same. Nobody will be hiring you because you can give commands to the AI for creating a to-do app, that's why all these vibe coding tools exist. What really helps in getting hired is the comprehension of why the code generated by the AI does what it does, being the one who picks up the stuff the AI may have overlooked in the review, and knowing which particular tool in this array serves which particular purpose.

The tools are the equipment. You are the one who levels up.

And which ones have you tried? Which of them is a scam arc? Mention it in the comment section below. I'm going to do a deeper dive into the AI code review section, as it's the one that gets most people snoozing.

Did you find it helpful? A follow-up would get you more content. Yes , I'm open to positions that consider "reads the entire diff prior to approval" to be a trait of character.

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.