DEV Community: Musaddiq Ahmed Khan

El Pueblo de los Muertos — a village where nine AI spirits solve the case themselves

Musaddiq Ahmed Khan — Mon, 02 Nov 2026 00:38:47 +0000

Someone stole a dead man's portrait — and in a village where being remembered is what keeps you real, he's starting to disappear.

El Pueblo de los Muertos is a top-down, Game Boy-style village of the dead built for Día de los Muertos — and every spirit in it is a live AI agent running on an open-weight model, entirely on-device. They gossip, they lie, they trade evidence mouth-to-mouth, and — with no scripts and no player — they solve the case themselves.

What I Built

Nine spirits wander a pixel-art pueblo: they visit shops, gather by the fountain, inspect the great ofrenda, and slowly piece together who stole Solorio's portrait — the last object anchoring him to memory.

Every spirit runs on a small open-weight LLM (gemma3 via Ollama on desktop, on-device Gemma on Android). Each one decides where to walk, who to talk to, what to say, and which secrets to share.
The proofs are scattered — a dropped guitar pick, wax on a sleeve, humming heard at dusk. Nobody holds all of them, so the agents have to gossip the case closed: trading secrets, overhearing private mutters, repeating lies.
At three proofs the village acts — an accuser marches on the culprit, and the accusation, confession, motive and the town's reaction all play out as a live scene in the world.
Meanwhile the victim is fading. Spirits whose remembrance battery dies dim into translucent skeletons until someone speaks their name. Solorio is the victim and a witness — his testimony fades with him.

The player is an unseen living presence. You can simply watch — the spirits genuinely solve it alone — or tap any spirit and interrogate it: they answer from the secrets they actually hold, in their own persona voice. You can carry whispers between them, send one off to question another on your behalf, or speak a fading name to bring a ghost back.

Demo

📹 Watch the trailer — 56 seconds, plays inline on GitHub.

Story screenshots and alternate cuts live in screenshots/.

How it works — the model proposes, the engine disposes

The interesting engineering problem: LLMs are brilliant at sounding alive and terrible at being trustworthy. So the game is split in two.

The open-weight model writes the voices. Every mutter, reply, lie and confession comes from the model, shaped by a persona card (vocation, traits, grudges) and the secrets that spirit genuinely holds.
A deterministic Dart engine owns the truth. The knowledge graph — who knows which secret and how they learned it — plus the secret ledger, the three-proof verdict threshold, walk schedules, memory batteries and fades are all plain, testable Dart. The model can propose anything; it cannot mint truth.

That split is what makes "no scripts" honest: the deduction is emergent, but the case can't be hallucinated. A whisper only counts toward the verdict if it was actually carried — by a spirit, or by you.

It also makes the game testable. A ext.pueblo.cmd driver socket exposes state, shot, speed, chat, look and solve — the last a "director's cut" that seeds the ledger so the confession scene can be filmed on demand. 92 tests cover the sim engine, the sprite contract and the mystery logic, and --dart-define=LLM=mock runs the entire village with canned lines on machines with no GPU.

Stack: Flutter · Flame · Dart · SQLite · Ollama + gemma3 (open weights) · flutter_gemma. MIT licensed.

Why open innovation matters here

This game is the theme. The ghosts are literally in the machine — and the machine is yours.

No API keys, no cloud, no internet. Every spirit thinks on the player's own hardware. The village keeps gossiping with the Wi-Fi off — on a plane, in a basement, forever.
The minds are inspectable and swappable. Because the model is an open weight served over a standard local API, you can pull any Ollama chat model and watch the same village develop different personalities — swap LLM= and the whole pueblo changes character.
Nothing private leaves the device. Every whisper, secret and confession stays on disk. For a game about memory — about what we choose to remember of the dead — shipping the villagers' souls to a data centre felt wrong.
It can't be sunset. The spirits don't live on someone's endpoint. As long as one person has a copy, the village keeps its dead.

Interpreting "Ghost in the Machine"

I took the theme literally, twice over. First: literal ghosts — spirits of the dead — running inside a literal machine, via local inference on commodity hardware. Second: the theme's deeper echo — a village that honours the past. The core mechanic is remembrance: spirits stay real while someone remembers their name, and the climax is a town carrying a dead man's story until it can be proven true. It's Día de los Muertos as a game system.

Prize categories

Best Use of Gemma — the villagers' minds are gemma3 served by Ollama on desktop, with an on-device Gemma path (flutter_gemma) for Android. Every line they speak is open weights, running locally.
(Overall prize — automatic entry.)

Running it

git clone https://github.com/Musaddiq625/pueblo
cd pueblo
ollama pull gemma3:4b && ollama serve
./run_macos.sh         # macOS, real model
# or no model at all:
./run_macos.sh --mock  # canned lines, still plays the full case

For judges without a Mac or GPU: the mock path plays the whole mystery end-to-end, and the driver socket can fast-forward (speed) or jump straight to the confession (solve). Repo: https://github.com/Musaddiq625/pueblo · MIT.

Built with ❤️ by Musaddiq625

MVP — Minimum Viable Person: a survival tracker that knows how long you'll survive

Musaddiq Ahmed Khan — Sun, 25 Oct 2026 22:42:12 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

Two buttons. That's the whole app.

MVP — Minimum Viable Person is a survival tracker that knows how long you'll survive.
Tap ATE when you eat, tap DRANK when you drink.

The app converts each into survival hours using the pop-science "rule of threes" (~3 days without water, ~3 weeks without food). Two tanks — food and water — drain in real time, counting down every second. When they run low, a notification nags you, the buttons pulse, and a lazy AI roommate comments on your continued existence.

It rewards laziness twice over: the tracking costs one tap, and everything the AI writes assumes you won't try.

▶ Video demo (full walkthrough, airplane mode on): https://drive.google.com/file/d/1q6PtO1c3dP3ZCMznCAiQaDVae_gvM1ou/view?usp=drivesdk

Code

Musaddiq625 / mvp_minimum_viable_person

a survival tracker for people who cannot be bothered — offline-first Flutter app powered by on-device Gemma 3n

MVP — Minimum Viable Person

knows how long you'll survive.

Built for Hacktoberfest 2026 — Week 3: Slow and Steady.

Two buttons. That's the whole app.

Tap ATE when you eat, tap DRANK when you drink
The app tells you how long you'd survive if you stopped caring entirely
Powered by the pop-science "rule of threes" (≈3 days without water ≈3 weeks without food)
Backed by a local, on-device, open-weights AI model — no cloud no account, no effort

Built for Hacktoberfest — DEV Open-Source AI Challenge, Week 3: "slow and steady." Nothing is slower or steadier than a person who barely moves.

The joke, taken seriously

Every health app assumes you want to try. This one assumes you don't — and that's the whole product.

Two tanks: food and water, measured in survival hours
Tanks decay in real time — watch the countdown tick every second
A…

View on GitHub

How I Built It

Flutter Android app, offline-first. The AI is Gemma 3n E2B-it LiteRT Preview (~3 GB int4) running on-device via flutter_gemma → MediaPipe LLM Inference / LiteRT with a GPU delegate. After the one-time download it's 100% offline — airplane mode, everything works.

What the model actually does:

Writes every persona line, streamed token-by-token — you watch it type, signed — gemma, on-device
Writes the weekly report — a shareable card generated live
Gates the entire app — verified by real inference, not a file-existence check

What it deliberately doesn't do: survival math. That's pure Dart — deterministic, test-covered, clamped. The model's output is parsed and validated before it can touch state, because a creative model should write jokes, not arithmetic.

Lazy-engineering details worth mentioning:

Serialized inference — MediaPipe can't run concurrent sessions, so every generation takes a mutex; cancelled streams drain to completion before the session closes
5s debounce — spam-tapping gets a canned clapback instantly, no inference wasted
Chunky 3D buttons that press like an arcade machine — haptics postponed, in the spirit of the app
Resumable model download — a 3 GB file survives crashes; the download→install handoff was the single highest-pressure moment in the app (ask me about the WorkManager foreground-service crash)

Why Does Open Innovation Matter?

This app could not exist the same way on a closed API:

It actually works offline. Airplane mode is a feature, not an edge case — an open-weight model makes "nothing leaves the phone" a fact instead of a privacy policy.
What you eat is nobody's business. A tracker logging your meals has no business shipping that to someone's server. On-device inference means there is no server.
Zero marginal cost. The laziest possible economics: no API key, no billing alert, no rate limit. Download once, run forever, free.
The model is swappable. The persona is a prompt, not a product — drop in a different open-weight model and the app gets a new personality.

Open innovation isn't a garnish here — the open model is load-bearing infrastructure that happens to write dry one-liners.

The Lazy Payoff

Interaction cost: ~1 second. One tap, three times a day, versus any food journal that wants you to weigh your lunch.
Forgives skipping. Miss a whole day and gap-fill assumes you self-maintained — the only health app that rewards not logging.
Doesn't even require opening it. Notification quick actions log the meal from the shade.
The AI does the writing so you can do the lying around. Every acknowledgement, report, and sarcastic worry is generated, not templated.

Prize Categories

Best Use of Gemma — Gemma 3n E2B-it LiteRT Preview runs locally on-device and gates the entire app.

Built with ❤️ by Musaddiq625

Reclaim: a private, on-device AI screen-time coach for Android

Musaddiq Ahmed Khan — Sun, 18 Oct 2026 21:55:58 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge: Week 2 — Side Hustle

What I Built

Reclaim is a private AI screen-time coach for Android — on-device Gemma 3, zero servers, and an app freezer that actually holds the line.

It reads the usage history Android already keeps and turns it into a blunt, kind coaching digest — plus enforceable app-freeze windows — entirely on-device.

A weekly digest: total time, pickups, late-night minutes, 20m+ "doom-scroll" sessions, and your top time-sink app
A locally-running Gemma 3 1B model writes the coaching plan — verdict, daily goal, and 2–3 concrete cap/protect/replace actions
Scheduled app freezes that show a full-screen blocker, with a logged 5-minute emergency unlock
Streaks, milestones, and "you vs the world" benchmarks — all computed locally

Who Would Pay For It

Screen-time apps are crowded, but the "AI coach" ones all route your most personal behavioral data through a server and charge a subscription for it. Reclaim is for privacy-conscious users and digital-detox communities who want the coaching without the data pipeline. The open-weight model is what makes it viable as a paid app: no inference bill, no server costs, zero marginal cost per user.

Demo

▶ Video demo: https://drive.google.com/file/d/1jqn60eJyvs85t-nSLA2sVdmahB2OZ1b2/view

Code

GitHub repo: https://github.com/Musaddiq625/reclaim

MIT licensed.

How It Works

It reads the log your phone already keeps. Android tracks which apps you open and for how long. Reclaim turns that raw log into a clear weekly picture — no tracking added, nothing extra collected.
An AI model on your phone writes the advice. A small open model (Gemma 3, ~0.6 GB, downloaded once) reads your week and writes a coaching plan. The app does all the math itself — the model just puts it into words, so it can never invent numbers.
Freezing actually freezes. Using Android's accessibility feature, Reclaim can detect when a frozen app opens and covers it with a full-screen block during your scheduled windows — even if the app itself is closed. A 5-minute emergency unlock exists, but it's logged, so "just this once" shows up in your history.
It remembers longer than Android does. Android forgets usage data after about a week, so Reclaim keeps its own private archive for streaks and progress over time.

Layer	Tech
App	Flutter / Dart, Android
On-device AI	Gemma 3 1B IT via flutter_edge_ai + MediaPipe
Usage data	usage_stats, installed_apps
App blocking	Kotlin AccessibilityService + native blocker activity

Why Does Open Innovation Matter?

Privacy is the product — "usage history never leaves the phone" is only true because there's no server
Zero marginal cost — a paid app with no API bill, ever
Inspectable and swappable — the model file can be audited, replaced, or sideloaded by the user
No lock-in — no pricing changes, rate limits, or deprecation emails

Prize Categories

Best Use of Gemma — Gemma 3 1B IT is the coach's entire voice, running fully on-device via LiteRT/MediaPipe; no API key, no network call, every line of the digest generated locally.

Built with ❤️ by Musaddiq625

DEV SUPPORTS - BeAware of this SCAM ACCOUNT

Musaddiq Ahmed Khan — Mon, 12 Oct 2026 06:51:57 +0000

DO NOT OPEN THE LINK!

It will ask you for account details and even current balance.

THIS LOOKS LEGIT, BUT IT IS NOT

It is posting on these hashtags:

devchallenge

hf26challenge

Sprout: a creature that starves indoors

Musaddiq Ahmed Khan — Mon, 12 Oct 2026 06:11:30 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

Sprout is a creature that lives on your phone and starves indoors.

It's a Tamagotchi with one rule: it only eats things that exist outside. Hold your phone up to real sunlight and it drinks. Point the camera at actual grass and it eats. Carry it on a walk and it perks up. Shake it awake and it tells you — groggily — about the dream it just lost. Every word it speaks is generated on-device by Gemma 4, an open-weight model running inside the app. There is no server. In a forest with zero bars of signal, the creature still talks back.

It also refuses to let you cheat the theme:

Indoor lamps and bright windowsills don't count as sun — the ambient light sensor only banks "drinks" above outdoor-class lux.
A photo of a green wall gets rejected by a pixel classifier before the AI ever sees it.
Leave the phone in a sunny window and walk away? Nothing happens. Sunlight only counts toward growth while you're actually engaged with the creature — it can't evolve alone.

Who is it for? Anyone whose screen time is beating their outside time. The shortest path to keeping Sprout alive is to put on shoes.

Demo

▶ Video demo: https://drive.google.com/file/d/1c7aG0o_WBRdop3rcMKDgyWcqQPEbmjhC

Code

GitHub repo:

Musaddiq625 / sprout

Sprout

A creature that needs you to go outside. On-device AI, sunlight detection, grass verification.

Built for Hacktoberfest 2026 — Week 1: Touch Grass.

What it is

Sprout is a small creature that lives on your phone. It hatches from an egg, then survives on two things:

Sunlight — detected by the Android ambient light sensor (TYPE_LIGHT), no camera needed
Grass — confirmed by a green-pixel HSV classifier, with Gemma vision as a borderline arbiter

Every line the creature speaks — its greeting, its gratitude, its confusion when you show it something that isn't grass — is generated on-device by Gemma 4 E2B running locally through LiteRT-LM. No network call, no API key, no data leaves the device.

Why open-source AI

Private by design: photos of your environment, your outdoor habits, your streak — nothing leaves the device
Offline: the creature works in a forest…

View on GitHub

MIT licensed. Requires Android API 30+ (arm64).

How I Built It

Sprout is a Flutter app, but the interesting parts are three systems that never touch the network.

The body: physical detection

Everything the creature senses comes straight from the phone's hardware — I wrote my own Kotlin EventChannels instead of pulling sensor plugins:

Sunlight — Android TYPE_LIGHT ambient sensor. The feed threshold is 5,000 lux, deliberately above indoor bulbs (~200–800) and bright windows (~1–3k); only genuinely outdoor light counts. Charge builds in 3-second "drinks" at a 10 Hz tick, and a passing shadow drains the bar at 40% speed instead of wiping it — sustained darkness still does.
Shake — accelerometer magnitude over 2.5 g, with a 900 ms cooldown so one physical shake doesn't fire fifty events. A rough wake: the creature stirs, but the dream it was having is gone.
Tilt — a low-pass filter over the same accelerometer broadcast pulls gravity out of the noise and emits lateral lean (-1..1). Tilt it sideways and the creature complains.
Walking — TYPE_STEP_DETECTOR emits one event per step; carrying it outside counts as care.
Grass — camera photos are downscaled to 64×64 and scored by a pure-statistics HSV classifier: hue 60–160°, saturation > 0.25, value > 0.20. ≥40% green pixels passes, <20% fails, and the grey zone in between goes to the model. An md5 of the photo blocks re-feeding the same patch twice.

The mind: a local, open-weight model

Every line of dialogue — the hatch moment, the morning greeting keyed to its energy/hunger/stage/streak/mood, gratitude after a drink of sun, confusion at a rejected photo, dreams, dizziness, songs — comes from Gemma 4 E2B running locally through LiteRT-LM (flutter_edge_ai). No API key, no network call, ~40–80 tokens per line under a character system prompt, a fresh session per call so prompts never accumulate.

Two places go beyond text:

Function calling. Periodically the creature is asked what it wants — Gemma picks a native tool call: demand_sunlight, request_grass, request_walk, sing, nap, ask, or invent_quest, which lets it author a small real-world quest ("find something round and alive") that it later verifies itself.
Vision. The borderline grass verdict and judgePhoto — a yes/no check of a photo against a verification prompt the creature invented — run the model's vision modality with an 8-token cap.

The model is downloadable, not hardcoded

A first-run Model Manager screen pulls the ~2.4 GB gemma-4-E2B-it.litertlm from the ungated Hugging Face litert-community mirror — resumable progress, cancel, and a foreground service so Android's background limit can't kill the download. You can also sideload any .litertlm file through a file picker, which means a fine-tuned creature personality is a file swap away. Until the model lands, a deterministic FakeGemmaClient keeps the whole game playable — and keeps the test suite model-free.

State, care logs, quest progress, and stage history persist in sqflite. Evolution runs on trials: a couple of feeds plus a completed real-world quest, or roughly nine seconds of honest sunlight.

Layer	Tech
App	Flutter 3.44.5 / Dart 3.12.2
AI	Gemma 4 E2B `.litertlm` via `flutter_edge_ai` (LiteRT-LM)
Lux sensor	Custom Kotlin `EventChannel` → `TYPE_LIGHT`
Grass gate	Custom HSV classifier, ~0 ms, no ML
Storage	`sqflite`
Camera	`camera` + `image_picker` + `image`

Why Does Open Innovation Matter?

A creature whose whole job is sending you outside cannot depend on a network — that's the premise. Open weights make the premise real:

Offline where it matters. The app works in a forest, on a mountain, in a dead zone — exactly the places it sends you. A closed API would brick its voice the moment you left coverage.
Private by design. Photos of your yard, your walking habits, your streak — none of it leaves the device, because there is nowhere to send it.
Inspectable and swappable. The brain is a .litertlm file you can audit, swap, or fine-tune into a different personality — the file-picker import exists precisely so someone can ship their own.
Zero marginal cost. It can nag you to go outside forever, for free. No API bill scaling with how needy the creature gets.

Prize Categories

Best Use of Gemma — Gemma 4 E2B is the creature's entire voice, decision-maker, and vision arbiter, running fully on-device via LiteRT-LM.

Built with ❤️ by Musaddiq625

I told an AI "put me in the rain with a bee circling my head" — and heard it orbit my ears

Musaddiq Ahmed Khan — Mon, 05 Oct 2026 06:20:13 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

Spatial Audio Sandbox — describe a scene, hear it in 3D

Flutter + Rust HRTF engine · Gemma-3-1B on Render · ElevenLabs · head-tracked on Android + macOS

What I Built

Spatial (3D) Audio Sandbox — describe a place in plain words and the app builds it
as a live binaural 3D scene on your headphones. "I'm in the rain and a bee is
circling my head" becomes rain around you, a bee orbiting your head, and thunder
arriving behind you on cue — rendered in real time through a Rust HRTF mixer
with head tracking, so the world stays anchored when you turn.

I built it for a friend — and for anyone who can describe a place. Whatever
scene he imagines is the scene he gets: rain to sleep to, a forest to focus
in, a city he misses. He writes it; it plays around him.

The whole pipeline is visible while you listen: a radar shows every source
moving in 3D, stereo meters show which ear is receiving energy, and a
scene-score timeline lays out when each sound cues and ends — you can see
the spatial audio in a screen recording.

Demo

▶ Watch the demo video (Google Drive)

Hacktoberfest26-week0_20261005.mp4 - Google Drive

drive.google.com

Headphones recommended — the video captures the binaural mix, so the bee
actually circles your ears if you're wearing earbuds.

Code

Musaddiq625 / spatial_audio_sandbox

Spatial Audio Sandbox

Describe a place in plain words — "I'm in the rain and a bee is circling my head" — and this app builds it as a live binaural 3D audio scene on your headphones. A Gemma model plans the scene, a deterministic compiler grounds it against your prompt, ElevenLabs generates each sound, and a real-time Rust mixer renders every source through HRTF convolution while head tracking keeps the world anchored as you turn.

Built for Hacktoberfest 2026 — Weekend Challenge: Build for a Friend

For anyone who wishes they were somewhere else: describe the place, put on headphones, be there.

The pipeline (visible in-app)

prompt ──► Gemma on Render ──► SceneCompiler ──► ElevenLabs ──► Rust HRTF
         screenplay JSON      grounding/timing   per-source      spatial mix
                              repairs            clips           + head pose

Gemma (hosted on Render) writes a constrained screenplay JSON — sources, places, movement verbs, start/end cues. The schema is enforced…

View on GitHub

Flutter UI + pure-Rust DSP engine bridged with flutter_rust_bridge. Android and
macOS. MIT. Three recorded Gemma scenes are bundled, so the repo demo plays
with no API keys.

How I Built It

The pipeline: prompt → Gemma on Render → SceneCompiler → ElevenLabs → Rust HRTF.

Gemma-3-1B-it (Q4_K_M, ctx 4096) served by llama.cpp in Docker on Render's 2 GB standard plan — weights baked into the image at build time. It authors a constrained screenplay JSON: sources, positions, movement verbs, end cues.
SceneCompiler (Dart) is the part I'm proudest of — the model hallucinates (it invented "a plane" in a cave prompt), so a deterministic pass grounds every source against the prompt's actual words, drops invented ones, resolves "then the fire goes out" into timed end events, and repairs truncated JSON. Its drops and repairs are visible in the UI pipeline strip.
ElevenLabs generates each source's clip; a 4-layer cache (memory → disk → bundled assets → API) means replays never re-bill.
Rust engine mixes on an allocation-free, lock-free audio callback — rtrb command queue, pose seqlock, synthetic HRTF with physically-modeled head shadow. Because a GC pause in the callback is an audible click.

Why Does Open Innovation Matter?

Every load-bearing piece is open or open-weight. The model weights are the
portable part: the same Dockerfile line that pulls gemma-3-1b-it could pull
any GGUF — the app doesn't care whose checkpoint writes the screenplay JSON.
On a closed API that schema would be hostage to a vendor, every scene would
bill per call, and "it still works offline" would be impossible. Here the
keyless demo path runs end-to-end without keys.

Prize Categories

Best Use of Gemma — the scene's author is gemma-3-1b-it, open weights served on my own endpoint.
Best Use of Render — Render is the inference host (Docker service running llama.cpp).
Best Use of ElevenLabs — every generated source's audio comes from the SFX API.

Built with ❤️ by Musaddiq625

Completed this amazing MVP ❤️ - n8n + Supabase + OpenAI + OneSignal + Flutter

Musaddiq Ahmed Khan — Tue, 20 Jan 2026 14:29:56 +0000

Completed this amazing MVP ❤️
n8n + Supabase + OpenAI + OneSignal + Flutter

I Built an Automated Content Publishing Workflow with AI for Social Media Posting

Last night, I posted on LinkedIn using this workflow without opening LinkedIn itself 😉

🤖 𝗚𝗲𝗻𝗲𝗿𝗮𝘁𝗲:
Write content with OpenAI in your own writing style 𝗯𝗮𝘀𝗲𝗱 𝗼𝗻 𝘆𝗼𝘂𝗿 𝗰𝗼𝗻𝘁𝗲𝗻𝘁

🔔 𝗚𝗲𝘁 𝗡𝗼𝘁𝗶𝗳𝗶𝗲𝗱:
Get Notified in the app with the updated status

✅ 𝗠𝗼𝗯𝗶𝗹𝗲 𝗮𝗽𝗽 -> 𝗔𝗽𝗽𝗿𝗼𝘃𝗲:
Post content on multiple social media platforms at once

🔄 𝗠𝗼𝗯𝗶𝗹𝗲 𝗮𝗽𝗽 -> 𝗥𝗲𝗷𝗲𝗰𝘁:
Use the OpenAI to write it again

📃 𝗟𝗶𝘃𝗲 𝗦𝘁𝗮𝘁𝘂𝘀:
See live status of posts in the app

For technical detail, you can check out my medium article:
https://medium.com/@musaddiq625/how-i-built-an-automated-content-publishing-workflow-with-ai-for-social-media-posting-4a12233d4a50

LinkedIn Post: https://www.linkedin.com/posts/musaddiq625_indiedev-n8n-supabase-activity-7418935487777890304-ES3m

Like, Comment and Share the post 😊 ❤️

𝗪𝗿𝗮𝗽𝗽𝗲𝗱 𝟮𝟬𝟮𝟱 ⭐️

Musaddiq Ahmed Khan — Wed, 31 Dec 2025 11:39:51 +0000

𝗪𝗿𝗮𝗽𝗽𝗲𝗱 𝟮𝟬𝟮𝟱, This year, I used a lot of AI IDEs ⚡️🤖

Used 36,539,316 tokens only in Cursor
Wrote 74,980 lines of code using Windsurf

I've tried different IDEs to write my code:
Cursor
Windsurf
TRAE
Claude
Antigravity.Google
Void (YC S24)
Zed Industries

Whether it is Flutter, Python, React or even SwiftUI, I created wonderful Apps, Desktop Apps, Games and even a few Websites ✨

Honestly didn’t expect AI IDEs to become this normal, this fast, especially for me 🕊️

Linkedin Post: https://www.linkedin.com/feed/update/urn:li:activity:7412062717727133696/

𝟭.𝟰𝗞+ 𝗗𝗼𝘄𝗻𝗹𝗼𝗮𝗱𝘀 🎉

Musaddiq Ahmed Khan — Mon, 13 Oct 2025 07:39:05 +0000

just noticed, one of my package 𝘀𝗰𝗿𝗲𝗲𝗻_𝗼𝗳𝗳 is growing faster than I expected
Grateful to everyone using it 🙌🏻

https://pub.dev/packages/screen_off

flutter #flutterdev #opensource #coding #pubdev #musaddiq625

Hacktoberfest 2025 - First post

Musaddiq Ahmed Khan — Tue, 07 Oct 2025 09:01:13 +0000

This is a submission for the 2025 Hacktoberfest Writing Challenge: Maintainer Spotlight

Hello Devs
This is my first post on dev.to

I build stuff with Flutter
and honestly, I believe anything can be built using Flutter ❤️
I do have 5.5+ years of experience using Flutter

I've built Packages and Games using Flutter
From mobile apps to games, and even controlling Minecraft, I love exploring the boundaries of what's possible.

📦 Packages:

generic_bloc_listener
screen_off

🎮 Games:

DigitWars IO
Fluterius
More Games under development 🚧

🧱 Minecraft x Flutter x Python:

Minecraft Flutter Controller
Minecraft Python Controller

I'll be actively reviewing Pull Requests during Hacktoberfest and would love for you to contribute!
Whether it's fixing bugs, improving documentation, or adding features
Your PRs are welcome!

I also write on Medium about unique topics, mainly focused on architecture-level concepts 💡

Linkedin - Portfolio - Medium - GitHub