DEV Community: Fayaz

Grab $250 in Free Cloud VM Credits from Docker (Before Oct 31, 2026)!

Fayaz — Mon, 19 Oct 2026 13:33:39 +0000

Hey developers! 👋

I stumbled upon this cool promo from Docker yesterday, and thought you'd love it too! Am I late in the party though? 🤣

Anyways, I hope it'll help someone who is building and experimenting with AI Agents, or just trying to save on cloud bills.

Considering that so many people are submitting in Hacktoberfest Challenges, this promo could be really helpful for the DEV community at this very moment! ❤️

So, here it is:

Docker is currently offering $250 in free Cloud Sandbox compute credits for their new Docker Agentic Platform, and you have until October 31, 2026 to claim and activate them!

Yes, $250!

You need just two steps:

You'll have to create a new account from their promo page: https://www.docker.com/c/sbx-promo/ (Docker's own promo page, no affiliation with me 😂).
Then, add an active credit / debit card in the account by October 31, 2026 to receive the FREE Credits.

That's it!

The Catch ‼️

It's cool promo for sure, but there's a few things you need to be aware of:

Deadline: You must sign up and activate the promo before October 31, 2026.
Card Required: A credit / debit card is required for the promo to be applied.
I've noticed that they take $1 from the card account as an authorization hold, and give it back within a few hours. So, if you use a debit card, make sure it at least has $1 balance.
Credit is ONLY applied to new Docker Sandbox accounts. I'm not sure if having an old Docker account (but not a Sandbox account) with the same email address is a deal breaker or not!
Usage Cap: I didn't see any usage alert or usage cap on the platform as of yet. So, make sure to monitor your bill every once in a while, if you don't want to get a surprise bill after your $250 credit runs out. Hope they'll add such options!

What is the Docker Agentic Platform?

Instead of spinning up local containers that need to be shut down or complex cloud infrastructure that requires maintenance, Docker Sandboxes give you isolated microVMs with useful presets running directly in the cloud.

The best part?

You can set your agent to work for a few hours and then stop. Stop means your bill is stopped too, but you still have the VM in it's previous state, saved for you to restart where it left off!

This one thing stood out for me! It's not a limit, but an option, and I can see a lot of use case for this one!

Note: When creating a new sandbox they call this stop, but after creating the sandbox (in sandbox management) they call it pause. Apparently both does the same thing, both stops the bill, so I don't know why they used two names for the same feature!

Other notable features are:

Your agents can keep working even after you close your computer.
You can activate the YOLO mode (or whatever buzz words they use these days when you give your AI Agent unrestricted permissions) without worrying about your privacy or security.
Out of the box, you get pre-configured kits for popular agentic workflows and CLI tools, including (but not limited to):
- claude, codex, copilot, Pi Agent, hermes-agent, antigravity, opencode etc.
- Seamless MCP server integrations and GitHub repo access via GitHub tokens.
- or, just a raw shell environments that you can use to build almost anything you want.

Transparent Pricing: How Far Does $250 Go?

Compute is billed per second while running, and you can choose between linux/amd64 and linux/arm64 architectures across five tier sizes:

Tier	Specs	Cost	Best For
Micro	1 vCPU + 2 GB RAM	`$0.07/hr`	Quick scripts, MCP servers & small experiments
Small	2 vCPU + 4 GB RAM	`$0.14/hr`	Coding tasks
Medium	4 vCPU + 8 GB RAM	`$0.28/hr`	Most standard agentic workflows
Large	8 vCPU + 16 GB RAM	`$0.56/hr`	Bigger code bases and heavier workflows
XL	16 vCPU + 32 GB RAM	`$1.12/hr`	Heavy builds, test suites, big monorepos etc.

Because the promo credits remain valid for 6 months after activation, $250 gives you a good amount of freedom to test out the system. For example:

1 vCPU + 2GB RAM (Micro): Run a lightweight agent or MCP server non-stop 24/7 for ~5 months.
2 vCPU + 4GB RAM (Small): Run continuously for 2.5 months.
4 vCPU + 8GB RAM (Medium): Run 5 agents in parallel for 6 hours a day for a full 30 days.

Wrapping Up

Whether you are stress-testing autonomous customized coding agents like Pi Durable, or just running your regular Claude, Codex, Copilot, Antigravity etc. subscriptions, this is basically free cloud compute for the next half-year.

Why wait! Go claim your $250 Docker Sandbox credits here:
https://www.docker.com/c/sbx-promo/

I'll most likely use this platform even after the $250 promo credits. I guess they are banking on this potential too!

So, what are you planning to spin up with your credits? Let me know in the comments below! 👇

Disclaimer: this is NOT a paid post or anything like that. I just signed up for this and thought the DEV community would love it too! 🥰

There's No AI Agent, Nor Any Harness.

Fayaz — Tue, 13 Oct 2026 16:06:52 +0000

Don't let them make you forget about software.

There's no AI agent, nor any harness. These are just buzz words coined to take the emphasis away from software and software development.

There's just software, machine learning models made using software, and software that makes good use of those models.

If you divide the digital world into:

Software: deterministic programming + non-tensor data e.g. control logic, user inputs, databases, APIs, heuristics etc.
Machine Learning Models

Then, every digital AI system that exists today completely falls in either of those two categories, often both.

There is no mystical third element!

Everything running on servers (CPU / GPU) consists entirely of traditional software, and tensor-based models. Nothing more.

The funny part is: most users never get even close to those models. All they use are software that use those models, and then call it Agent, Harness, etc. etc.

Models don't even do any tool calls either! They only accept input (text, image, audio, video) and return output (text, image, audio, video).

That's all there is to it. It's the software that makes the tool calls based on what the models return.

The models don't have any control over what happens after it returns something.

We do it using the software we developed, software uses those models, then the users do it based on those software.

Once you understand this, use those buzz words when you need to, but every once in a while, remind people of what they are actually using under the hood.

P.S. of course, most developers are already aware of the under the hood architecture of the whole thing. However, what most people are probably not aware of, is the fact that, even switching the word software with terms like "agent" and "harness" devalues our work to people who don't know any better. That's why, saying out loud what it is, at least some of the times, is important. 🥰

FayazFollow

A Software Engineer who strongly believes you can add immense value by knowingly implementing Software Engineering best practices even at the age of AI, and puts human life and dignity above all else.

Birds.Quest - My Effortless Bird Watching Auto Blogging Buddy that Inspires Me to Go Back to Nature

Fayaz — Mon, 12 Oct 2026 06:53:09 +0000

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

What I Built and Why

I love watching birds with my Bushnell ENGAGE 8x42 Binoculars. I like to track some of my experiences, but I'm too lazy to write them down. I used to enter every walk into eBird APP by hand at the very beginning of my bird watching journey. It was fun for a while, but then it became like homework, and homework is the opposite of having fun while touching grass.

Birds.Quest is my attempt to remove the homework. I switch on a GPS tracker, walk, and put my phone in the pocket. Later, a post about the walk shows up on my blog, written for me. That's the idea of Birds Quest.

The auto generated post is not a claim that I saw these birds. Rather it's an inspiration to take the walk again, a reminder that says what's waiting for me in the nature. And since the posts will be in public, perhaps a few other people will feel the same as well!

The system predicts which species anyone could plausibly have met along my exact route at that time of year, then writes it up as "what you might see if you took this path". I open the draft, tick the birds I really saw (if I get time), and hit regenerate. If I don't like the words, I edit the Markdown in a side-by-side editor. For now, posts are drafts until I publish them. Eventually after I test the system enough, I plan to auto publish them to with minimum or no effort from my part.

Two rules shaped the whole build:

Location never leaves the server. The blog and the LLM prompt contain no coordinates and no place names. The post describes birds and seasons, never where I was.
Predictions are not sightings. Everything is a draft until I approve it, and the species list is editable.

It's a tool for my own walks, but it's open source. Anyone can point it at their own Traccar server and get the same effortless blog.

Demo

Note: I didn't complete the server deployment while writing this post. Site will become live once I complete tests on the live server. Until then, the domain redirects to my DEV profile.

FayazFollow

Code

SweaDev / birds.quest

birds.quest

Auto-blogging from bird watching sessions. GPS tracks recorded with the Traccar Client are turned into a blog post about the birds anyone might see on that route. See specs/ for the spec, plan and task list.

Privacy rule: no location data (coordinates, place names) may reach the LLM prompt or the public blog.

Local development

Requirements: Node 22+, pnpm, MariaDB, and Ollama with gemma4:e2b.

pnpm install
cp .env.example .env        # then fill it in, see the comments inside

Create the databases and users (once, as the MariaDB admin):

CREATE DATABASE birdsquest CHARACTER SET utf8mb4
CREATE DATABASE birdsquest_test CHARACTER SET utf8mb4;
CREATE DATABASE traccar CHARACTER SET utf8mb4;
CREATE USER 'birdsquest'@'127.0.0.1' IDENTIFIED BY '...';      -- app, read/write
CREATE USER 'birdsquest_ro'@'127.0.0.1' IDENTIFIED BY '...';   -- Traccar DB, read-only
CREATE USER 'traccar_dev'@'127.0.0.1

…

View on GitHub

Using the project

I couldn't finish the project before taking the first bird watching journey for it. However, I designed it such that even a previous run with Traccar can be uploaded and published later.

Here's a real run on a real track. I exported a GPS track from my Traccar server as a KML file: 82 positions, about 10.4 km, around 10–11 October 2026. I'm not publishing the coordinates, for the same reason the blog doesn't.

The pipeline processed it like this:

Step	What happened
Discover	Traccar positions became one finished trip (more than 30 minutes, then idle).
Sample	The 82 positions were thinned to 24 route points, about one every 300 m.
Week	10–11 October is week 38 of BirdNET's 48-week year.
Predict	The GeoModel ran once, as a single batch of 24 `[lat, lon, week]` inputs, on a plain CPU. Each species keeps its best score along the route.
Filter	A threshold of 0.15 and a top 20 cap kept the likeliest birds.

The top 20 for that route and week:

Likelihood	Species	Scientific name
99.7%	Spotted Dove	Spilopelia chinensis
99.4%	Common Tailorbird	Orthotomus sutorius
99.3%	Black Drongo	Dicrurus macrocercus
99.3%	Red-vented Bulbul	Pycnonotus cafer
99.0%	White-throated Kingfisher	Halcyon smyrnensis
99.0%	Common Kingfisher	Alcedo atthis
98.8%	Little Cormorant	Microcarbo niger
98.8%	Little Egret	Egretta garzetta
98.7%	House Crow	Corvus splendens
98.7%	Barn Swallow	Hirundo rustica
98.6%	Oriental Magpie-Robin	Copsychus saularis
98.5%	Indian Pond Heron	Ardeola grayii
98.1%	Common Myna	Acridotheres tristis
98.1%	Eastern Cattle Egret	Ardea coromanda
98.0%	Rufous Treepie	Dendrocitta vagabunda
98.0%	Black Kite	Milvus migrans
97.9%	Asian Palm Swift	Cypsiurus balasiensis
97.7%	Rock Dove	Columba livia
97.6%	Common Iora	Aegithina tiphia
97.3%	Brown Shrike	Lanius cristatus

A few things I like about this list. The kingfishers, egrets and herons suggest water nearby. The Barn Swallow and the Brown Shrike are the kind of autumn migrants you'd expect in mid-October. That's the point of feeding the model the week as well as the position: the same route in June gives a different list.

From here the worker pulls each species' summary and a licensed photo from Wikipedia. Then Gemma writes the post from only the species names, those Wikipedia facts and the season ("mid October, autumn"). The photo credits and licences are added by my code, not by the model. Finally I open /admin, untick the birds I didn't actually see, and regenerate.

How I Built It

Traccar Client ──HTTPS──> Caddy ──> Traccar ──> MariaDB
                                                  │ read-only
              hourly worker ──────────────────────┘
                discover → predict → enrich → generate ──> MariaDB
                              │         │          └─ Gemma 4 (Ollama / DigitalOcean)
                              │         └─ Wikipedia
                              └─ BirdNET GeoModel (ONNX, on the droplet)
Next.js (public blog + /admin) <──────── MariaDB

Recording: the Traccar Client app on my phone sends positions over HTTPS to a self-hosted Traccar server.
Trips: the worker reads Traccar's tc_positions table with a read-only DB user and splits it into trips. A gap or standstill of 10 minutes ends a trip, trips under 10 minutes are ignored, and an ongoing trip is never processed.
Prediction: BirdNET GeoModel (ONNX, FP16) runs through onnxruntime-node on the CPU. It takes [lat, lon, week] and returns a probability for each species. I sample the route and take the maximum per species, because "could be seen anywhere along the route" is what I actually want.
Facts: Wikipedia's REST API gives a summary and an image for each bird. Images with no licence info are skipped, and the licence and credit are stored with every image.
Writing: Gemma 4 turns species, facts and season into a post.
App: Next.js 16 (App Router), TypeScript, Drizzle on MariaDB, a job queue that is just a table (FOR UPDATE SKIP LOCKED), and an admin area with an argon2 login, CSRF tokens, a nonce-based CSP and a live-preview Markdown editor.
Tests: unit tests for trip splitting (9 minutes ignored, 11 accepted), week maths, the queue, sanitising and, most importantly, that no coordinates or place names reach the prompt.

DigitalOcean: the whole production stack

Everything runs on one DigitalOcean Droplet running Ubuntu 26.04. There's no managed zoo to wire up. One idempotent deploy/install.sh sets up:

MariaDB, native Traccar (bound to localhost, open registration switched off after my account is created), Node 22 and pnpm
Caddy as the reverse proxy and automatic HTTPS for two domains: the blog, and the Traccar endpoint the phone talks to
UFW with only ports 22, 80 and 443 open
systemd units for the web app and an hourly worker timer
a bare git repo with a post-receive hook, so shipping is git push production main. The hook checks out the tree, installs, migrates, builds and restarts the app

The model is the other half. The droplet doesn't need a GPU, because it calls DigitalOcean Serverless Inference for Gemma. Serverless Inference exposes an OpenAI-compatible endpoint (https://inference.do-ai.run/v1/chat/completions) with a model access key, so the app has one small fetch-based LLM client. The same client talks to Ollama in development, and only environment variables change:

LLM_PROVIDER=digitalocean   # or "ollama" locally
LLM_MODEL=gemma-4-31B-it    # or "gemma4:e2b" locally
LLM_API_KEY=...             # DO model access key

The droplet, the database, the ONNX model and the inference call all sit in one provider. For a hobby project that I want to run for years, that's one bill, one dashboard and very few moving parts.

Gemma 4: small at home, big in production

Development: Gemma 4 E2B through Ollama on my laptop. It's small enough to iterate quickly with no API key and no network, and the pipeline test runs entirely offline. A 20-species post took about three minutes there.
Production: Gemma 4 31B on DigitalOcean Serverless Inference, for noticeably better prose.

Some things I learned about using Gemma for this:

Gemma 4 is a thinking model. With a small token limit, the Ollama response had an empty content and only a reasoning field. The dev client now sends reasoning_effort: "none" so the answer lands where it should.
The prompt is deliberately starved. The model only sees species names, up to three Wikipedia sentences per bird and the season. It never sees a coordinate, even to "set the scene".
I don't trust the reply. Wikipedia sentences that name countries, cities and so on are dropped before prompting and again from the output. A reply containing coordinates, map names or URLs is thrown away completely. The model can't add images or links either, because my code adds those.
There's always a fallback. If the LLM times out or fails the checks, a plain template writes the post, so a flaky call never means a missing entry.

Building It with GitHub Copilot

Birds.Quest was built almost entirely by GitHub Copilot, and I tried to be deliberate about how. I stayed in the role of the person who decides what to build and checks the result, and let Copilot do the typing. The workflow had four stages, and every stage leaves a file in the repo you can read:

I wrote the spec by hand. specs/SPEC-01.md is 45 lines of my own words: the goal, the big picture, the security rule (no location data to the LLM or the blog), the tech stack and some references. Nothing in it was generated, so the intent stayed mine.
Copilot /plan mode turned the spec into a plan. specs/PLAN-01.md is the approach it proposed. I read it before any code was written. Planning before coding saved me from the "agent runs off in the wrong direction for an hour" problem.
Agent mode turned the plan into a checklist. specs/TODO-01.md is a 36-task execution tracker. It also contains the rules for the agent itself, which I think is the most useful part:
- Work top to bottom, one task at a time, and mark it [~] while in progress and [x] when verified.
- Make one commit per task (git add -A && git commit -m "<task id>: <summary>") and never push. That is why the history reads like a build log, and why I could review or revert any single step.
- If a task turns out to be wrong or too big, edit the TODO and note why in a changelog instead of silently improvising.
- Install the relevant agent skills before the work they apply to. My spec required it, so Copilot installed six project-level skills for React/Next.js, TypeScript, web security and Drizzle/MySQL (npx skills add -a github-copilot).
- Never commit secrets, keep README.md and .env.example up to date, and never let coordinates or place names reach the prompt or the blog.
Agent mode implemented the checklist, step by step. I pointed it at TODO-01.md and let it work through the tasks. The security rule in the spec became a test that checks no coordinates or place names reach the prompt, so Copilot couldn't quietly break the one promise the project makes. It finished with lint, typecheck, 208 passing tests and a clean production build.

Working in parallel with a git worktree

Agent runs take a while, and I didn't want to sit and watch. I created a git worktree so Copilot kept building in one working directory while I wrote the first draft of this post (POST.md) in another, on a separate branch. We never touched the same files, so there were no conflicts and no stashing. When the app was finished, I asked Copilot to read the generated README.md and use it to enrich the draft, so the architecture and setup details in this post match what the code actually does.

Setup and honest notes

Model: Claude Sonnet 5.5 with the default High thinking setting, used for planning, task breakdown and implementation.
Tools used: /plan mode and Agent mode, plus project skills for Next.js, Drizzle, MySQL, TypeScript and security best practices.
What worked: a hand-written spec, a plan I reviewed, and a TODO with strict rules. The agent had a clear definition of "done" for every task, and I got a reviewable commit at every step.
What it cost: this was a lot of agent work, and I used up almost all of my monthly Copilot quota doing it. 😅 Worth it, though.
What I still did myself: the idea, the spec, reviewing the plan, and the privacy decisions. I also ran a real GPS track through the pipeline and read the species list to check it made sense.

Why Does Open Innovation Matter?

I want the same model on my laptop and on my server.

With an open-weight model I can develop offline on a 2B-class Gemma, then ship the exact same model family to production on a 31B version. I can also pin a specific model ID, so my blog's voice doesn't shift under me because someone upstream quietly retrained a hosted model. For a journal I want to keep for years, that consistency matters.

The same goes for the rest of the stack. BirdNET's GeoModel is open, so I can run it myself, and Traccar is open, so my GPS history sits on my own droplet and not in someone else's cloud. That is what makes the privacy rule realistic: my location data is only used on a machine I control, and only the species list ever goes to the inference endpoint. Because every piece is open, you can fork the repo, point it at your own Traccar and run the same thing.

Prize Categories

Best Use of DigitalOcean: the whole production deployment runs on a DigitalOcean Droplet (Traccar, MariaDB, Caddy, the Next.js app, the worker timer and git-push deploys), and post generation goes through DigitalOcean Serverless Inference.
Best Use of Gemma: Gemma 4 E2B for local development and Gemma 4 31B in production write every post, behind a prompt and output filter designed so that no location data ever reaches the model.
Best Use of GitHub Copilot: I wrote the spec by hand, then Copilot generated the project: /plan mode produced the plan, Agent mode produced a 36-task TODO with rules for the agent (one commit per task, no pushing, never leak location data), and Agent mode then implemented it task by task. I used a git worktree to write this post while Copilot kept building, then had Copilot enrich the draft from the generated README. All of it used Claude Sonnet 5.5, and it ate almost my whole monthly quota 😂. The evidence is stored in the specs directory of the source code.

Excessive Use of AI Does Not Take Away Your Ability of Writing Code, but ...

Fayaz — Thu, 08 Oct 2026 17:40:29 +0000

I've said this before: if you keep using AI, and don't write code yourself, you'll lose that particular skill.

But I think I was not entirely correct in that conclusion! 🤔

What you really lose if you keep using AI for everything, is not your skills, but your ability to focus.

Being able to focus, being able to use your brain deeply, i.e. being able to enter the flow state, is the true high level skill that empowers human ingenuity in every knowledge base field.

If you lose that, what do you actually have?

I hope you'll give it a thought! 🥰

Does Your Favorite AI Tool's Cache Hit Mean Your Project's Uniqueness Miss?

Fayaz — Mon, 05 Oct 2026 07:53:32 +0000

This is NOT a Challenge Submission Post 🥰

I was checking out Hacktoberfest Weekend Challenge Submissions. I do this from time to time on DEV Challenges, even when I myself don't have time to submit my own projects.

This time was no different. I didn't have time to submit my own project, but had a couple of hours to checkout other submissions.

Then I was wondering, what would be my project if I had time! 🤔

Before I go forward, I just want to spit something out! Yeah, I could just ask Claude, Antigravity, or GitHub Co-pilot to generate the idea, build the implementation, write the submission post and submit — all by themselves! But that's not me. I would've revealed that fact within my submission post, even if I had done that. Otherwise, it wouldn't be fair to other contestants!

On the other hand, I wouldn't submit something, if at least some important parts of it wasn't my own. In other words, I'm not in favor of submitting completely AI generated works, even with the revealing! That's just my choice. I don't intend to pass judgement on others. If you want to do that, it's 100% up to you!

Now that it's out of the way, let me go back to the original story. Where was I? Oh, I was wondering, what my own project would've been, if I had enough time for this Challenge.

So I was thinking that, and just to do a bit of brainstorming, I opened Gemini. I know, most people prefer Claude these days. But for these sort of brainstorming, Gemini works well for me, especially Gemini Notebook, A.K.A NotebookLM.

So I asked Gemini specifically to go to the challenge description page, and cook 10 unique ideas for me.

To my surprise, well, may be not a total shock, but at least I raised one of my eyebrows, when I saw Gemini's suggestions mostly matching many of the submissions! Some even almost verbatim.

Then I thought, well, it's Google. So, perhaps Gemini already indexed those posts, right?

Then I extracted all the submission entries URLs myself, and then asked Gemini again to check those posts, and suggest 5 unique project ideas that are different enough from those submissions.

This worked. I'm pretty sure these 5 ideas were unique up until that point! I was already sleepy at that point, so I went to sleep without going further down the rabbit hole.

The next morning, which is the date of posting this, after some routine works, being only few hours away from submission deadline, I checked for new submissions again.

And this time I got the shock! This time I noticed quite a few posts, very close to what Gemini suggested me, which were unique up to last night!

How did that happen?

Did Gemini suggest me the same thing some other people were working on, or brainstorming with it (but didn't yet submit)?
Did they come up with those ideas all by themselves, and it was just a coincidence that AI suggested me the same before they made those posts public?
Did the frontier labs share user data among themselves, and hence people keep getting LLM cache hit, when they work with AI tools with similar things?

I have no idea. But it's too much of a coincidence to just let go!

I remember the incident that happened a while ago, between a mathematician and OpenAI, about OpenAI's frontier model solving Navier-Stokes Millennium Prize Problem.

To summarize the incident somewhat, the mathematician claimed he was using ChatGPT with his work. So the LLM just used his research data, and regurgitated with some of it's own variations, and OpenAI just took it as the LLM's own invention.

If I consider that everyone is being honest in such incidents, then this is the only logical conclusion I can think of: when we are using AI, AI is using our prompts, works, conclusions, and spreading them around as either cache hit or part of it's training data, killing our own intellectual human uniqueness in the process.

What does that mean if my conclusion is correct?

I don't know. I leave the decision up to you. But I know exactly what I'm going to do from now on. But that's a post for another day. 🥰

Note: If you find a lot of spelling and grammar mistakes in this post, that's because I just typed it all in one go, without bothering to check with any AI tool. So, if something is unclear in the post, please just quote it and ask me in the comment. 🙏🏼

So, We Don't Need to Learn or Use Basic Math / Arithmetic Anymore? 😜

Fayaz — Thu, 01 Oct 2026 13:41:23 +0000

Have you heard about calculators?

Do you know that calculators can do addition, subtraction, multiplication, division, and some other basic math fast and without any errors?

The frontier calculators, a.k.a. scientific calculators, can do even more complex math, super fast and error-free! You won't even have to review them anymore. You'll just have to know how to "prompt them" properly!

And then there's something called computers! The government just put a ban on them, so only a specific set of people can use them. Those are the next level. They can do all sorts of calculations super fast, using some skill files called programming.

Seriously, why do people bother to learn math anymore? 😜

Sounds familiar? 🤣

If so, then:

Do not stop learning the fundamentals of programming.
Do not stop writing code by hand.
Use AI if it is useful, but not as a replacement for programming.

Feeling Burnt Out? May Be You Should Read This! ❤️‍🩹

Fayaz — Mon, 28 Sep 2026 08:24:59 +0000

Note: I started writing this as a comment to one of @embernoglow's posts, but it became too long.

So I'm posting it as an article instead.
Hope it'll help someone in need. ❤️

Hey You! Whoever you are!

Know that you are not alone.
Know that you are important.

If you are feeling burnt out again and again, and nothing you try seems to help, then perhaps you need to find the true meaning of life, your reason for being.

Perhaps you need to take a spiritual journey, a journey within.

Until you find the true meaning of your life, and align your work with that meaning, no matter what you try, you'll keep burning out.

The true meaning of life will give you a kind of motivation that will never run out.

But I can't help you with this, I wish I could, but I can't.
Only you can help yourself.

I can only share what helps me when I feel down.

First, I try to become comfortable, as much as I can, depending on the situation. Eat something sweet, lie down, take a walk in the woods — whatever helps.

Sometimes even crying helps!
Yes, even grown men cry. There's no shame in that.

But that is only the beginning.
Most people stop there. They think the job is done, but that's where they are wrong.

Because the next step is the most important step.

Once I'm comfortable enough from the first step, I dive deep into my inner self.

Then I contemplate about:

Who I am, really!
The reality of this life: we are born, we live for a while, then we die.
I try to feel all of it.
Then I try to find the meaning in it.

What is the point, if it all ends in a short while!

Then, I remind myself of what I've already found in this short journey of mine, called life:

I found meaning in taking care of my mother, who is a cancer survivor.
I found meaning in helping others.
I found meaning in Sufi poetry. Poetry of Rumi.
I found meaning in prayer.
I found meaning in one true God who created everything.
I found meaning in trying to connect to God, through which connection our essence lives on.
And yes, I found meaning in continuing what I do: programming, writing, reading, connecting with people. Because it activates my mind, it helps me sustain this life, my family, and others too. However little, in whatever way!

If finding meaning is too difficult because of a tough situation, I try to find a little inner peace, but not instant enjoyment or instant gratification.

Instant gratification burns further. On the other hand, inner peace is a kind of happiness that gives spiritual energy.

I find inner peace in:

looking at my loved ones with deep care.
helping other people, even a little bit.
looking at the innocence of a child who is laughing, playing and passing a worry free time.
taking a deep breath and feeling alive!
thinking and deeply believing that this universe, my life and everything in between must be connected somehow, and all these must not be in vein, even if I don't feel the connection at times.

Once I find a little inner peace, even for a moment, the next step is gratitude.

I'm grateful for this momentary inner peace. I'm grateful for this experience called life.

I thank my creator — the creator of everything that exists. I thank my parents, my wife, my siblings, my friends ... I thank everyone from the bottom of my heart, for being there for me.

Of course, I don't just go and tell them that in that instant. That's for another time. This gratitude is in my heart, for what I feel deep within.

In your case, you need to thank whoever you feel this gratitude to, deep within yourself, from the bottom of your heart — to God, to the Universe, to your parents, or whoever fills your heart at that moment.

Feel it. Really feel it.

Gratitude is the beginning of a spiritual journey that'll help you find the true meaning of your life. That meaning of life will provide you the energy that'll never burn out, or at least, it'll continue to fill you up whenever there is a need for it.

But as I said before, I can't really help you with this.
Because mere words are never enough.

You'll have to take this journey yourself.

I can't promise you that the journey will be easy.

In fact, spiritual journeys are often difficult, painful even. Leaving those bad habits, instant gratifications, wasting of time — are going to take their toll.

I can promise you one thing though: if you take this journey, it'll be fulfilling.

If you read this far, perhaps it helped you a little, perhaps it didn't, but I deeply hope and pray that you'll find your path soon! ❤️‍🩹

I wish you all the best! 🥰

BoonFest: The Anti-Sloth Game Where Generosity Means Survival!

Fayaz — Mon, 07 Sep 2026 06:37:45 +0000

This is a submission for Weekend Challenge: Generosity Edition

What I Built

I built BoonFest: a web game designed to awaken your inner generosity.

Most games reward you for conquest, killing, speeding, hoarding, stacking power, and looking out only for yourself. In BoonFest, that exact mindset is a death sentence. Here, to survive, you'll have to be generous, productive, and mindful.

Most games are designed to be addictive—promoting endless sloth. BoonFest is built to create balance between healthy entertainment and your real life, with built-in playtime restrictions.

Demo

boonfest.ai.studio

Code

SweaDev / BoonFestDemo

BoonFest Demo

BoonFest

An anti-sloth, pro-social web game balancing capital accumulation, self-cultivation, and societal welfare through generative altruism.

🌟 Overview

BoonFest challenges players to resist deceptive short-cuts and predatory economic traps while navigating the delicate tri-fold balance between personal capital, self-mastery, and civic altruism.

As you navigate real-time economic turns, entropy steadily degrades your societal environment—visualized dynamically by your world's Ecosystem Hue (shifting from verdant green towards catastrophic crimson red). Only by cultivating your core attributes and funneling personal wealth into pro-social Boon projects can you stabilize the world, conquer entropy, and achieve enduring legacy.

🎮 Gameplay Details & Mechanics

1. The Three Pillars of Self-Cultivation

Your attributes dictate your capacity for honest productivity, physical resilience, and altruistic impact:

Pillar	Symbol	Primary Function	Strategic Value
Mind	🧠	Labor Efficiency	Multiplies net Credit yields from honest Earn cards. Higher Mind unlocks high-tier intellectual and architectural contracts.
Body	⚡	Entropy Dampening	Bolsters physical and

…

View on GitHub

A Little Background

This Weekend Challenge is specifically interesting for me!

DEV did something unique for this one: @heyitsjem, on behalf of The DEV Team, asked the DEV community what the next Weekend Challenge theme should be.

Some cool suggestions came up from the community, but to my pleasant surprise, DEV decided to run with generosity, which was inspired by my own world peace suggestion!

Since the theme this time was inspired by my suggestion, I thought I must participate in this one, as an appreciation for The DEV Team's kind consideration! 🙏🏼

Initially I wanted to develop a donation organization finding web app for this Challenge, but @sizzlebop beat me to it with her Sprinkle Project.

Well, this is generosity challenge, so I'm just grateful that someone already did what I wanted to do! 🥰

How I Built It

As I've already mentioned, the idea generation took too long. So I didn't have enough time to manually develop the game. I had multiple options to develop the game using AI. I chose AI Studio.

I've used AI Studio before, but only for checking out, never for a complete app with deployment. So, I thought, why don't I try it out and see how it goes!

Turned out, it was an excellent decision. Without AI Studio, I wouldn't be able to complete this demo.

Suffice it to say, with my existing Google AI subscription ($19.99/mo), I ran out of my daily limit fast. I had to use some prepaid Gemini API Credits. But I'm glad I could complete the demo in less than $10 API expense. Thanks goes to the Google AI Team! 🥰

The Game Idea

Almost immediately after replying to @sizzlebop's comment, I thought, hey, why don't I develop a generosity game, where giving means winning!

That idea stuck to my brain, but forming the actual game logic where generosity wins, proved to be more difficult than I initially thought. That's normal though, most games we play these days translates taking to winning, not the other way round. On the other hand, endlessly giving without an "End Game" is not really fun!

So, I had to take the healthier alternative to taking, which is apparently not fun, and make generosity interesting in game play.

I accepted my inner challenge, and started brainstorming with literally pen and paper.

So, yeah, the entire game logic is 100% original. This demo is only a partial implementation, as the idea generation phase took too long to actually implement the entire game within this short challenge window.

Naming BoonFest

As I was working with the game play logic, multiple name idea came to my mind. BoonFest was one of the first few names, but I didn't really expect the .com version of the domain name to be available. So I was really glad to be able to secure BoonFest.com for the future of the game!

Game Development with AI Studio

After the idea generation, I used AI Studio for game development and Publishing.

My development experience with AI Studio was surprisingly good. The whole process from start to publish was very smooth.

I've implemented Gemini API to generate some in-game content, and with AI Studio it was just a single prompt and then securely adding my Gemini API Key from the Settings panel.

All the in game AI content can be changed from Admin panel, so it's not a simple AI generation implementation. AI Studio did it without any issues at all.

Prize Categories

Along with contesting for the overall challenge winner, I'm also applying for the Best Use of Google AI prize category.

Hope you'll like this brand new game.

Please stay tuned for future updates once the Challenge judges finalize their decisions.

Stay blessed! 😇

I Won a Writing Challenge That I Almost Didn't Publish!

Fayaz — Mon, 24 Aug 2026 17:24:53 +0000

All praise to almighty God, and thanks to Google and the DEV Team, a while back, I won the Google Cloud NEXT '26 Writing Challenge!

Google Cloud NEXT '26 Winners

Jess Lee for The DEV Team

May 7

Congrats to the Google Cloud NEXT '26 Writing Challenge Winners!

#devchallenge #cloudnextchallenge #googlecloud

2 min read

A big congrats to all the other winners of this challenge. 🥳

The "interesting" thing is, I almost didn't even publish the post! 😬

I was running behind schedule and I still had too many things to say. I wanted the post to be perfect! But then I remembered the saying:

Perfection is the enemy of good enough.

So I focused on a specific topic, and completed writing right around 20 minutes before the deadline.

And just when I wanted to press the Publish button, I thought, why don't I check the Challenge page and see how much time I have left.

To my utter shock, the DEV Challenge page was showing the status: ENDED!

For a minute there, I thought I must have miscalculated the deadline based on my time zone, but then I got my confidence back after double-checking the deadline and timezone conversion.

At that point, there was no time to confirm with the DEV Team, so I just published the post first, and then wrote a comment on the Challenge announcement post.

Long story short: it was showing me the ENDED status because of a bug.

Thanks @jess for those quick responses! 🥰

Phew! Man, was I ever glad that I went through with publishing the post!

Obviously, after becoming one of the winners, I was totally thrilled, and in a way, gained a few pleasant lifelong lessons:

Never give up!

Ship, even if it's not perfect.

Hope my story will motivate others to publish more.

If you liked the post, here's another real-life story where I learned a few more lifelong lessons - and this time, the hard way!

Summer Bug Smash: Smash Stories 🐛🛹

Fayaz

Aug 24

Why my biggest embarrassment was also one of my greatest learning experiences in Programming!

#devchallenge #bugsmash #programming #performance

10 min read

FayazFollow

Why my biggest embarrassment was also one of my greatest learning experiences in Programming!

Fayaz — Mon, 24 Aug 2026 06:29:53 +0000

This is a submission for DEV's Summer Bug Smash: Smash Stories powered by Sentry.

The background

This happened almost twenty years ago, in the year 2006, back in my undergraduate days, when I was still studying CSE - I participated in my first and only International Collegiate Programming Contest (ICPC), which was then known as ACM-ICPC.

I was, and still am, one of those programmers who like to take it slow, with full clarity, and try to completely grasp the concepts all by myself before jumping into implementation. As a result, I never was competitive programming contest material!

So then, why did I participate in that contest?

Well, one fine morning, I was working on a project in our university's computer lab, and two of my friends came to me and said, "We want to participate in the upcoming ICPC that our university is hosting, and we want you to join us!"

They even wanted to make me the team lead! I was hesitant at first, but then I thought, "Why not? It will be a good learning experience!" So I agreed to join them. Except for the team lead part, of course, that would have been a bit too much for me, given my lack of interest in competitive programming.

A bit more about my own background

I've never publicly shared this story before, especially because of the embarrassing part of it, but I think it's way past time to share it now, as I feel that it can be a good learning experience for others.

To make sure readers understand the context of my embarrassment, I need to give a bit more background about my programming experiences up until that point.

I started my Bachelor in Computer Science and Engineering (CSE) in 2002, at North South University and I was introduced to programming only in the first semester. Before that, I had no idea what programming was, but I found it interesting from the very first day!

C was my first programming language, but it was only part of a single credit lab course, which ended merely in three lab sessions, one and a half hours long each! So my real taste in programming began in the second semester, with the course named "Introduction to Object Oriented Programming in Java" - if my memory serves me right.

Around the middle of that second semester, there was an intra-university solo programming contest, and I participated in it. I was able to solve three out of six problems, which landed me third place in that contest! I was very happy about that, and it gave me a lot of confidence in my programming skills. But after that, outside my regular course curriculum, I became more interested in math, robotics and software development in general. For some reason, competitive programming never really attracted me that much.

That said, since I was attending that ICPC team contest anyway, I did try to prepare for it for a while. Part of that preparation was going through some problem sets from previous contests. As a CSE student, I was already familiar with most of the algorithms that were needed to solve those problems, so all I needed to do was to practice enough problems to be able to solve them quickly during the contest. We didn't get much time to prepare, so we thought it would be best if we participated in an actual contest before the main event.

Fortunately for us, there was an online programming contest hosted by Topcoder that was happening around that time. That was a solo contest also known as SRM (Single Round Match). All three of us participated in that contest, and all of us were able to solve two out of three problems individually, which was a good result for us.

So, from that preparation, we were expecting to solve at least 50-60% of the problems in the main contest! We weren't expecting to win, but we were hoping to do well enough to be recognized!

As a straight-A student, that was a very basic expectation for me, and I was very confident that I would be able to achieve that. But as it turned out, I was in for a big surprise!

The embarrassment

Now that all the background is out of the way, let me get to the embarrassing part of this story:

We ended up solving ZERO problems in the main contest!

Yes, you read that right - ZERO problems! We were not able to solve a single problem in that contest, and we ended up at the very bottom of the scoreboard!

Doomsday!

Every religion has a doomsday, and if programming were a religion, then that contest was our doomsday!

As I said before, I thought it would be a good learning experience, and I was right about that eventually, but none of us were expecting this sort of devastating learning experience!

Out of ten problems, we were able to solve none! We were not even able to solve the easiest problem in that contest, which was a very basic math problem. I still remember that problem somewhat, and I can still solve it in my head without much difficulty. But during that contest, we were not able to solve any of them!

I clearly remember, the moment I finished reading problem A (the very first problem), I knew that was the easiest problem in the contest.

In every ICPC, usually there's one problem that is very easy, as far as programming contests go, and it's expected that most teams will be able to solve that problem. The first one is not always the easiest, but in most cases, it is.

So I started solving it and probably within the first 5-6 minutes, I submitted my solution. But to my surprise, it was rejected! And the reason was given: "Memory Limit Exceeded". I was shocked! I had never encountered that error before, not in the practice problems we solved, and not in the past two contests I participated in!

It's not that I didn't know what that error meant, but for that particular problem, the input was really straightforward, and there was no way that my solution could have exceeded the memory limit, or so I thought! I was very confused, and I tried to figure out what went wrong, but I couldn't find any issue with my solution. So I submitted it again with some improvement in the algorithm, and it was rejected again for the same reason!

No matter what I did, I was not able to solve that problem, and I was not able to solve any of the other problems either! All three of us kept getting the same error, for all the problems we attempted to solve! We were completely baffled, and we had no idea what was going on!

The contest was four and a half hours long, and we gave up after trying for almost three hours! We were completely demoralized, and kept thinking there must be something wrong with the contest system, or maybe it was about solving those problems more efficiently. But no matter what we tried, we could not figure it out!

After we gave up, we spent the rest of the time gossiping among the three of us, trying to have some fun, as our last unsuccessful attempt to salvage some dignity from that contest.

And right when there were only a few minutes left in the contest, suddenly something clicked in my mind! OMG! I realized what the problem was!

The Aha moment!

Along with the computer, the contestants were allowed to bring some programming or algorithm books, and a pen-drive with some code snippets in it.

To solve the problems faster, the night before the contest, we wrote some code snippets for some common input and output handling - like taking inputs from the console (Standard Input), taking inputs from a file, printing outputs to the console (Standard Output), printing outputs to a file, etc. following common programming contest input output patterns. We wrote those snippets in C, and we were using those snippets in our solutions.

But the problem was: we were taking all the input lines into an array all at once, and then processing the array to get the result based on the problem statement, and then concatenating the result into a single string, and then printing that string as the output. That was a very inefficient way of handling input and output, and it was causing our solutions to exceed the memory limit!

However, since we were only focusing on solving the problems, we didn't realize that our prewritten input and output handling snippets were causing the problem! We were so focused on solving the problems that we didn't even think about the input and output handling part of our solutions!

Sample Code

As it happened long ago, I don't have the exact code snippets we used back then, but I can give you a rough idea of what they looked like.

1. The Flawed Code (Memory Limit Exceeded)

For example, in this version, we preallocated giant arrays to read all input numbers into memory before processing. Then we processed all formatted output strings in another huge array before printing anything to standard output.

With 100,000 per test case across up to 110 test cases, this instantly exceeded the judge's memory limit.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_NUMBERS 100000
#define MAX_LEN 25

/* 
 * Flawed approach: Pre-allocating giant arrays to store all 
 * inputs and outputs in memory before printing.
 */
char input_numbers[MAX_NUMBERS][MAX_LEN];
char output_buffer[MAX_NUMBERS][MAX_LEN * 2];

void print_differing_suffix(const char *start, const char *end, char *out) {
    int i = 0;
    while (start[i] && start[i] == end[i]) {
        i++;
    }
    sprintf(out, "%s-%s", start, end + i);
}

int main() {
    int N;
    int case_num = 1;

    // Buffer inputs and outputs across test cases
    while (scanf("%d", &N) == 1 && N != 0) {
        int input_count = 0;
        int output_count = 0;

        // Store ALL input phone numbers into memory first
        for (int i = 0; i < N; i++) {
            scanf("%s", input_numbers[input_count++]);
        }

        // Process stored inputs into output buffer array
        int i = 0;
        while (i < N) {
            int j = i;
            // Check for consecutive phone numbers
            while (j + 1 < N && atoll(input_numbers[j + 1]) == atoll(input_numbers[j]) + 1) {
                j++;
            }

            if (j > i) {
                // Consecutive sequence range found
                print_differing_suffix(input_numbers[i], input_numbers[j], output_buffer[output_count++]);
            } else {
                // Single standalone phone number
                strcpy(output_buffer[output_count++], input_numbers[i]);
            }
            i = j + 1;
        }

        // Print header and buffered outputs all at once
        printf("Case %d:\n", case_num++);
        for (int k = 0; k < output_count; k++) {
            printf("%s\n", output_buffer[k]);
        }
        printf("\n"); // Blank line after each case output
    }
    return 0;
}

2. The Corrected Code

The proper approach should've been to read, process, and print one line at a time, rather than keeping the complete input and output in memory. In other words, we should've never built a giant concatenated output buffer before flushing it to stdout.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_LEN 25

/* 
 * Corrected approach: Helper function to print range directly 
 * to stdout without allocating output buffers.
 */
void print_range(const char *start, const char *end) {
    int i = 0;
    while (start[i] && start[i] == end[i]) {
        i++;
    }
    printf("%s-%s\n", start, end + i);
}

int main() {
    int N;
    int case_num = 1;

    // Process case by case using streaming I/O
    while (scanf("%d", &N) == 1 && N != 0) {
        printf("Case %d:\n", case_num++);

        char start_num[MAX_LEN], prev_num[MAX_LEN], curr_num[MAX_LEN];
        long long prev_val = 0, curr_val = 0;
        int in_range = 0;

        for (int i = 0; i < N; i++) {
            scanf("%s", curr_num);
            curr_val = atoll(curr_num);

            if (i == 0) {
                // First phone number of the test case
                strcpy(start_num, curr_num);
            } else if (curr_val == prev_val + 1) {
                // Phone number is consecutive, extend current range
                in_range = 1;
            } else {
                // Consecutive sequence ended; output range or single number immediately
                if (in_range) {
                    print_range(start_num, prev_num);
                } else {
                    printf("%s\n", start_num);
                }
                // Start tracking new sequence
                strcpy(start_num, curr_num);
                in_range = 0;
            }

            strcpy(prev_num, curr_num);
            prev_val = curr_val;
        }

        // Output the final range or single number for the current test case
        if (N > 0) {
            if (in_range) {
                print_range(start_num, prev_num);
            } else {
                printf("%s\n", start_num);
            }
        }

        printf("\n"); // Blank line after each case as required by problem specification
    }
    return 0;
}

Lessons learnt

We thought that programming contests, and programming in general, were all about solving problems very efficiently, but we learned that, in real life, user input and output handling is also a very important part of programming, and it can make or break your solution! We learned that we should always be careful about how we handle input and output, and that we should never assume that the input will always be small enough to fit in memory, or that it will always be in a format that we expect.
We learned that we should always test our code against realistic input and output scenarios, with edge cases.
We learned that, sometimes, in programming, taking breaks and looking at the problem with a fresh set of eyes is essential to find trivial mistakes that we might have otherwise overlooked, while being too focused on the problem, the solution and the efficiency of it.
We learned that, in real life, failure doesn't mean the end of the world, and that we should always be ready to learn from our mistakes, and that we should never give up when it gets tough! As the proverb says:

When the going gets tough, the tough get going!

While trying to solve the problem after the AHA moment, we realized that we should've used a version control system like Git to keep track of our solutions, so that we could easily go back to a previous simpler version of our code and fix the input/output handling part without having to rewrite the entire solution from scratch, out of all the jumbled code we had written at the later part of the contest to make them unusually efficient! Had we used git, we probably would have been able to solve at least one problem in those last few minutes of the contest, and we would have been able to salvage some dignity from that contest!

The happy ending

After that embarrassing event, we three attended another programming contest, the last one in our life, as a team.

It was not an ICPC, but it was a prestigious inter-university programming contest nonetheless.

We secured 2nd place in that one. 🏆

And last but not least, I started my first job as a Software Engineer a week before my last programming contest. It was a students' contest, but since I was still a student when I registered for it, they allowed me to participate! 😇

Conclusion

I sincerely hope that this story will help others avoid making the same mistakes we made, but more importantly, I hope that you'll learn to rise up from failures - own them, learn from them, and use them as stepping stones to future success!

Disclaimer

I used AI to help with grammar and spelling corrections, but the story is genuine, and the main write-up is entirely my own.
Code snippets above are not the exact code snippets we used back then. They are AI (Gemini) generated rough approximations of what they would look like. So please take the story as the lesson, not the code snippets.
The cover image is AI (Gemini) generated.
I wrote the entire thing from memory. So, although the overall story is real, a few minor details here and there may not be!

References

The Actual Problem Set. I found it after deeply looking for it in the Wayback Machine. Salute to the Wayback Machine for preserving this problem set for so long! 🫡
My Topcoder Profile after attending the only online programming contest (SRM) before the main contest. Thanks to Topcoder for keeping my profile for twenty years! 😍

I need a new kind of Open Source Software License: "AGPL Pro Max"

Fayaz — Mon, 15 Jun 2026 20:05:48 +0000

As far as I know, AGPL doesn't cover Large Language Models.

I think it should, but it doesn't.

Going forward, we need a new kind of Copy Left License for Open Source Software - something that covers LLMs as well.

I mean, your LLM can be trained with my Open Source Software, but only if it's made Open Source as well!

I'm calling it AGPL Pro Max! 😎

Someone please give it a better name, and make it popular among developers. 🙏🏼

Question: Does something like this exist already?

If so, then what is it?
If not, then why not! 🤷

FayazFollow

New AI Model Quality Check Flowchart.

Fayaz — Sun, 14 Jun 2026 18:36:38 +0000

Is it banned by any Government?

Yes = Good Quality
No = Bad Quality

😁🤷🙏