DEV Community: Abdullah Bin Altaf

ChatLedger: Turning messy WhatsApp DMs into an order book for home businesses

Abdullah Bin Altaf — Tue, 13 Oct 2026 14:08:11 +0000

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

What I Built

A lot of small businesses near me don't have a website. Their whole shop is a WhatsApp number and an Instagram page: home bakers, tailors, thrift resellers, people who sew plushies and sell them to friends of friends.

Every order comes in as a conversation like this:

Ayesha: can i get the choc fudge cake for saturday? 1kg
Ayesha: oh and add a box of brownies too
Sara:   Done! 50% advance to confirm pls
Ayesha: <Media omitted>
Ayesha: sent 30 👍
        ...next day...
Ayesha: sorry can u make it 2 boxes of brownies instead of 1??

Now imagine 20 of those a week, mixed in with "is this still available?" messages, voice notes and family group chats. What did Ayesha finally order? How much does she still owe? Did Bilal say Thursday or Friday? The seller ends up scrolling back through weeks of messages, or forgets, and forgetting costs real money.

ChatLedger fixes that. You paste the chat (or upload a WhatsApp export), and it gives you back:

📋 A clean order list: who ordered what, how many, when it's due, where it goes
🔁 The final version of every order. "Make it 2 boxes instead" updates the order instead of creating a second one, and cancelled orders are marked cancelled.
💰 Correct totals and balances, using the seller's price list, including special prices agreed in the chat ("ok since it's 10, 5 each 😄")
✅ Who has paid, who has partly paid and who still owes, plus one number at the top: still to collect
🧾 A printable invoice for each order
💬 A one-tap WhatsApp reminder with the order summary, the balance and payment details
🔍 "Why the AI thinks this": every order quotes the exact chat lines it came from, so the seller can check it in seconds instead of trusting a black box

Who would pay for it? Any seller doing 10+ DM orders a week. One forgotten balance on a cake order costs more than a month of a $5 subscription, so the value is easy to explain.

Demo

chatledger-2wxe.onrender.com

(It runs on Render's free tier, so if the page takes ~50 seconds to load the first time, it's waking up.)

Code

abdullah-k18 / chatledger

ChatLedger

Paste your DMs. Get your orders.

Home bakers, tailors and resellers take orders in WhatsApp and Instagram DMs. Orders get changed ("make it 2 boxes instead"), cancelled, half-paid with a screenshot, and buried under 200 other messages. ChatLedger reads the messy chat and gives back:

a clean order list with items, quantity, due date, address and phone number
totals and balances, computed from your price list (including prices you negotiated in the chat)
what's paid, what's partly paid and what's still owed
a printable invoice for each order
a one-tap WhatsApp confirmation or payment reminder
a CSV export for your spreadsheet

Each order shows the exact chat lines it came from ("Why the AI thinks this"), so you can check it in seconds.

How it works

chat text ──► clean-up (drop "<Media omitted>", system lines)
          ──► open-weight LLM (Gemma via any OpenAI-compatible API) ──► JSON
          ──► Python:

…

View on GitHub

How I Built It

The stack is deliberately small: FastAPI on the back end, plain HTML/CSS/JS on the front end (no build step), and an open-weight LLM doing the reading.

chat ─► clean-up ─► open-weight LLM ─► JSON ─► Python does the math ─► order cards

1. Clean the chat first. WhatsApp exports are full of noise: <Media omitted>, "This message was deleted", encryption notices. I strip those before calling the model. It saves tokens, which matters on free-tier rate limits.

2. The model reads, and only reads. The open-weight model gets the chat, the seller's price list and a strict set of rules:

output only the final version of each order
never invent an address, phone number or price
return null when something isn't stated
include 1–3 verbatim quotes as evidence for every order

It returns structured JSON.

3. The code does all the math. This was the most important design decision. LLMs are great at understanding "can u make it 2 boxes instead of 1??" and unreliable at multiplying 2 × 18. A wrong balance is the one mistake a seller won't forgive, so the model never produces a total. Python takes the extracted items and:

matches them to the price list (the customer says "elephant play toy," the catalog says "Elephant plushie," and it still matches)
computes every line total, order total and balance
works out paid / partial / unpaid from the amounts
validates everything the model returned

4. A provider-agnostic client. ChatLedger talks to any OpenAI-compatible endpoint and falls back automatically if one fails:

Provider	Model
Google AI Studio	Gemma
Groq	gpt-oss-120b
OpenRouter	free open-weight models
Custom	Ollama / vLLM on your own machine

The live demo runs on gpt-oss-120b via Groq's free tier. It extracted all five orders in the sample chat correctly in about 6 seconds, including the changed order, the cancellation and the negotiated price.

5. Small things for real use:

It's mobile-first, because sellers live on their phones.
Orders stay in the browser, so there's no account to create.
A per-visitor rate limit stops the public demo from draining the free API quota.

Why Does Open Innovation Matter?

This project only makes sense as a business because of open-weight models.

💸 The margins work. Extracting a week of chats with an open-weight model on a cheap provider costs a fraction of a cent. That means a $5/month tool for a home baker can be profitable. On premium closed-model pricing, the cost per seller would eat most of that margin.

🔓 No lock-in, and I found that out for real. Halfway through building, the model I'd picked was retired by the provider and my requests started returning 404s. Because everything speaks the same OpenAI-compatible API and the models are open, I switched to another open-weight model by changing one line of config. The extraction got better, not worse. Building on a single closed vendor, that would have been a scramble.

🔐 Privacy can be offered. These chats are full of customers' names, home addresses and phone numbers. Because the models are open-weight, a seller who doesn't want that data on anyone else's server can run the exact same app against a model on their own machine with Ollama, by setting three environment variables and changing no code. My own laptop can't run models locally, which is why the demo uses hosted endpoints, but the option exists only because the weights are open.

🌍 Room to specialize. Real order chats near me are rarely in pure English. They switch between Urdu and English mid-sentence, use local slang, and say "pls" and "bro" a lot. Open weights mean this can eventually be fine-tuned on real order chats, a niche that a general-purpose closed API will never prioritize.

Prize Categories

Best Use of Render: ChatLedger is deployed as a Render web service from a render.yaml Blueprint, and it's the live demo judges can use.

Leaf Pixels

Abdullah Bin Altaf — Sat, 10 Oct 2026 22:42:09 +0000

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

What I Built

Leaf Pixels turns any picture into a printable colour-by-letter pixel-art sheet that kids take outside and colour in.

Pick a picture: a fox, an owl, a pumpkin, a rocket… (or type your own).
Choose a paper size (A5, A4, A3 or Letter) and print it.
Grab some crayons or pencils and head outside: the park, the garden, a picnic blanket, the front steps. Colour each square to match its letter until the picture appears.

The sheet is a 24×24 grid with Battleship-style coordinates (A1, B7…), a letter in every square (R for red, O for orange, and so on) and a colour key. Page 2 has a fun fact about the subject ("Owls can turn their heads almost all the way around!") and a space to draw or stick a photo of where you coloured it.

It's made for kids, parents and teachers who want a screen-free activity. Pixel art is calm and satisfying, and it quietly practises colour matching, counting and grid coordinates. The name comes from the autumn palette: every pattern uses the colours of October leaves. The screen part takes about a minute; the colouring happens offline, outdoors.

Demo

leaf-pixels.vercel.app

Code

abdullah-k18 / leaf-pixels

Leaf Pixels 🍁

Pixel art you build outside, one leaf at a time.

Pick a picture (a fox, an owl, a pumpkin…), print the pattern, then go outside, collect fallen leaves and lay them on the ground, one leaf per square, until the picture appears. The screen part takes a minute; the rest happens outdoors.

Built for the Hacktoberfest Open-Source AI Challenge, Week 1: Touch Grass.

How it works

gpt-oss-120b (open-weight, Apache 2.0), served by Groq, checks that the subject is kid-friendly and drawable, writes an image prompt, and comes up with a fun fact.
FLUX.1 [schnell] (open-weight, Apache 2.0), served by Cloudflare Workers AI, draws a simple flat icon.
The server turns the drawing into a 24×24 grid in a fixed autumn palette (red, orange, yellow, green, brown, black). Each square gets the colour most of its pixels have, thin parts like stems and legs…

View on GitHub

How I Built It

Leaf Pixels is a Next.js app with two open-weight models at its core:

Step	Model	Licence	Where it runs
Check the subject, write the drawing prompt, write a fun fact	gpt-oss-120b	Apache 2.0	Groq
Draw the picture	FLUX.1 [schnell]	Apache 2.0	Cloudflare Workers AI

The pipeline:

gpt-oss-120b decides whether the subject is kid-friendly and drawable. "Fox" is fine, but "my tax return" gets a friendly "Try a happy animal or a yummy fruit!". It then writes a strict prompt for a flat icon in autumn colours, plus a one-line fun fact for a 6-year-old.
FLUX.1 [schnell] draws the icon in about 2–4 seconds.
My own code turns the drawing into a 24×24 grid using a six-colour autumn palette (red, orange, yellow, green, brown and black), so you only need a small box of crayons.
The browser builds a two-page printable PDF with jsPDF.

The hardest part was step 3. A naive downscale gave messy results, so it went through a few rounds:

Colour fringes: averaging pixels made a yellow halo around every shape. I switched to a vote: each square takes the colour most of its pixels have.
Wrong colours: matching pixels to the nearest palette colour turned a red sail orange and grey edges green. Classifying by hue fixed it, since the soft edge of a red shape is still red.
Vanishing details: a thin mast or a bird's legs covered too little of a square to win the vote, so they disappeared. A morphological opening finds parts thinner than half a square and thickens them before voting.
Clean-up: a bounding-box crop centres the subject even when the drawing has a faint drop shadow, and a connected-components pass removes stray specks.

There are no accounts and no database, and nothing is stored. A small rate limit keeps the free tiers alive.

Why Does Open Innovation Matter?

I changed models twice in one week, and each change took one line.

I first planned to run FLUX on Hugging Face. When I checked, the free tier there had changed. Because the weights are open, I moved the same model to Cloudflare Workers AI, which has a free daily allowance. With a closed model, I'd have been stuck with one vendor's pricing.
The Llama model I'd planned to use on Groq was no longer available. I swapped in gpt-oss-120b by changing a single model name. The text step uses the OpenAI-compatible API format, so GROQ_BASE_URL and GROQ_MODEL can point at any host of an open model: Ollama on your own laptop, vLLM on a school server, or OpenRouter.

That flexibility matters for this audience:

Kids' data: a school or library could self-host both models and keep everything on their own hardware, with no third party involved.
Cost: both models are Apache 2.0, and both run on free tiers. Making a pattern costs nothing, which is the point for a free family activity.
Control: the models' behaviour lives in my own prompt and my own code. Nothing changes under me when a vendor updates a closed model.

RepoRadar

Abdullah Bin Altaf — Sun, 04 Oct 2026 13:50:47 +0000

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

What I Built

Every October, my friend Ahmad says the same thing: "I want to contribute to open source this year." And every October, they open GitHub, search for "good first issue", scroll through a few thousand results, and close the tab.

Ahmad is a final-year CS student who's comfortable with React and Python but has never opened a PR on someone else's project. The skills aren't the problem. The problem is that GitHub search doesn't know who they are. It can't tell a repo that fits them from one that will eat their weekend and give nothing back.

So I built RepoRadar for them: an open-source project finder that starts from you, not from the search bar.

Tell it who you are, once. Upload a CV (or paste it) and an open-weight model turns it into an editable profile: languages, skills, interests, experience, and certifications with who issued them. Add your GitHub username and it cross-checks the languages you actually write in your own repos.
Pick how big you want to go. Entry level (smaller repos with good first issue labels), mid level (established projects asking for help), or big projects (25k+ stars).
Get 5 real repos. Each one comes with a short "why this fits you" note tied to your actual background, a suggestion for which issue to start with, and a list of issues that are open and unassigned right now.
Say "not for me." Skipped repos never come back, and neither do ones you've already seen. Every click on "Find 5 more" brings something new.

There's no account and no database. Your profile lives in your browser, and Export / Import JSON lets you back it up or move it to another laptop.

Demo

Live app:

reporadar1.vercel.app

To try it, open Settings, paste a free Groq API key (a GitHub token is optional but recommended), then upload a CV on My profile and hit Find 5 repos.

Code

abdullah-k18 / reporadar

◉ RepoRadar

Find open-source projects that fit your skills, with open, unassigned issues you can pick up today.

Upload your CV (or fill the form). An open-weight model extracts your languages, skills, experience and certifications.
Pick a level: Entry, Mid, or Big projects.
Get 5 real repos from GitHub, each with a "why it fits you" note and starter issues.
Skip what you don't like. Repos you've already seen never come back.

How it works

Profile ──► open LLM: profile → GitHub search terms
        ──► GitHub API: real repos filtered by level (never invented by the model)
        ──► open LLM: shortlist best fits
        ──► GitHub API: keep repos with open, unassigned issues
        ──► open LLM: explain each match + which issue to start with

Bring your own key: in Settings, paste a free Groq key and pick a model from the live list. Keys stay in…

View on GitHub

How I Built It

Stack: Next.js (App Router), TypeScript and Tailwind, deployed on Vercel. The model is gpt-oss-120b, an open-weight model released under Apache 2.0, served through Groq's OpenAI-compatible API. GitHub's REST API supplies the repo data.

The core design rule: the model never invents a repo or an issue. LLMs are great at matching and explaining, and terrible at remembering which repos exist and which issues are still open. So the work is split:

Profile ──► open model: profile → GitHub search terms (languages + topics)
        ──► GitHub API: real repos, filtered by level, minus everything already seen
        ──► open model: shortlist the best fits for this person
        ──► GitHub API: keep only repos with open, unassigned issues right now
        ──► open model: explain each match + which issue to start with

A few details I'm happy with:

Levels are hardcoded and concrete. "Entry" means 50–3,000 stars with at least one good first issue. "Mid" means 3k–25k stars with help wanted issues. "Big" means 25k+. Everything must have been pushed to in the last 90 days, so no abandoned repos.
Structured output everywhere. Each model call asks for JSON with a fixed shape. Every name the model returns is checked against the real GitHub results, and anything it made up is dropped. If a model call fails, the app falls back to a simple star-sorted list instead of an error page.
The model sees your GitHub, not just your CV. CVs exaggerate. Your public repos don't. If you give your username, the languages you actually use are fed into the matching.
Bring your own key. Your Groq key and optional GitHub token are stored only in your browser and sent only with your own requests. Export JSON deliberately leaves them out, so a backup file never contains secrets.
A live model list. "Test key & load models" asks the provider which models it serves today, so the dropdown never offers a retired model.
No database, on purpose. It's built for one person, so a login system and Postgres would have been effort with no payoff. localStorage plus JSON export covers everything: profile, seen repos, skipped repos and saved repos.

Why Does Open Innovation Matter?

RepoRadar is a tool for getting into open source, so building it on a closed, black-box model would have felt backwards. But open weights also made real technical differences:

No lock-in. gpt-oss-120b is the same model whether it runs on Groq, Together, OpenRouter, Hugging Face or someone's own GPU. The app talks to a plain OpenAI-compatible endpoint, so switching hosts is one line in providers.ts, not a rewrite. With a closed model, the model and the company come as a package.
A real path to privacy. A CV is personal. Today it goes through Groq's API, but because the weights are open, anyone who doesn't want that can run the exact same model on their own server with vLLM or Ollama and point RepoRadar at it. Same prompts, same behaviour, and the CV never leaves their machine. A closed API can't offer that at any price.
Free for the person it's for. Ahmad is a student. Open models on Groq's free tier mean the tool costs them nothing to use, and it'll keep costing nothing.
I know what I'm running. The license, model card and weights are public. I can say exactly which model reads your CV and what it's allowed to be used for.
It can grow with them. If the matching ever needs to be sharper, open weights can be fine-tuned on examples of good repo matches. That's not something you can do with a closed model.

Ask & Regret — The AI That's Always Wrong, Always Confident, and Proudly Serving 418s

Abdullah Bin Altaf — Fri, 10 Apr 2026 21:57:56 +0000

This is a submission for the DEV April Fools Challenge

What I Built

Ask & Regret is a deliberately terrible AI assistant that looks exactly like a real AI product — clean UI, confidence meters, system logs — but is entirely dedicated to being wrong.

Core features:

4 Personality Modes — Overconfident Idiot (wrong but certain), Philosopher (answers everything with vague existential musings), Passive-Aggressive (judges you for asking), and Teapot Mode ☕ (refuses everything via HTTP 418)
Misinterpretation Engine — your question gets distorted before being sent to the AI. "Fix my code" becomes "write poetry about bugs"
Moving Send Button — hovers away from your cursor on purpose
Confidence Meter — always 99.8% confidence, always ??? accuracy
Random 418 Teapot Errors — 10% of requests are refused with { "error": "418 I'm a teapot", "message": "I refuse to process this. Try tea." }
Mood Swings — personality auto-switches every few messages
Fake System Logs — a live panel showing logs like [ERROR] truth.js has crashed and [OK] Response generated (verified: wrong)
Inverted Home Page — the page literally starts at the footer. Scrolling down takes you up. Scrolling up takes you down.

Useless API as a Service™

Three public endpoints anyone can call:

GET /api/random-excuse                        → professional excuses for not doing work
GET /api/fake-motivation                      → inspirational quotes that mean nothing
GET /api/probability-of-success?goal=anything → always ~3%

Responses for all three endpoints are AI-generated via Gemini.

Demo

ask-and-regret.vercel.app

Recommended demo script:

Load the page — notice you start at the footer
Scroll down to go up to the hero
Click "Start Regretting"
Ask something normal — watch it get misinterpreted
Hover over the Send button
Wait for a 418 teapot error
Hit "Show Logs" and watch truth.js crash in real time

Code

abdullah-k18 / ask-and-regret

Ask & Regret

The AI assistant that's always wrong, always confident, and genuinely trying its best.

🔗 ask-and-regret.vercel.app

What is this?

Ask & Regret is a deliberately terrible AI assistant that looks exactly like a real AI product — clean UI, confidence meters, system logs — but is entirely dedicated to being wrong. Powered by Gemini AI, sabotaged by us.

Features

4 Personality Modes
- 🤓 Overconfident Idiot — wrong but 100% certain
- 🧐 Philosopher — answers everything with vague existential musings
- 😤 Passive-Aggressive — judges you for asking
- ☕ Teapot Mode — refuses everything via HTTP 418
Misinterpretation Engine — distorts your question before sending it to the AI
Moving Send Button — flees from your cursor on hover
Confidence Meter — always 99.8% confidence, always ??? accuracy
Random 418 Errors — 10% of requests get refused by a teapot
Mood Swings — personality auto-switches every few messages
Fake System…

View on GitHub

How I Built It

Next.js 15 (App Router) — pages, API routes, everything
Gemini API (gemini-flash-latest) — powers all four sabotaged personality modes plus the three Useless API endpoints. Each has a carefully crafted system prompt that instructs the model to be maximally unhelpful in a specific way
Tailwind CSS — for the "clean real AI product" aesthetic
CSS animations — fake typing dots, fade-in messages, pulse glow
Vanilla JS scroll interception — wheelEvent.preventDefault() + inverted scrollBy for the upside-down home page
No framer-motion — all chaos achieved with CSS transitions and transform: translate()

The Gemini prompts are the real magic. For example, the Passive-Aggressive prompt:

"You are a passive-aggressive AI that subtly judges users. Express quiet disappointment at the question. Give technically unhelpful or wrong answers while sighing. Add a passive-aggressive emoji at least once."

Prize Category

Best Ode to Larry Masinter

RFC 2324 deserves more respect. Ask & Regret treats HTTP 418 not as an easter egg but as a core product feature:

A dedicated Teapot Mode personality that refuses all requests and only discusses tea
A 10% random 418 rate on all chat requests — because sometimes the server is simply a teapot
The 418 response appears as a first-class UI event with a bubble in the chat
The Useless API philosophy is essentially RFC 2324 as a SaaS product

Larry Masinter wrote a joke RFC in 1998. I built a production app around it in 2026. This feels right.

AI Customer Support Chatbot with Smart Rate Limiting Using Redis

Abdullah Bin Altaf — Fri, 25 Jul 2025 21:25:18 +0000

This is a submission for the Redis AI Challenge: Real-Time AI Innovators.

What I Built

For the Redis AI Challenge, I built a real-time AI-powered customer support chatbot workflow using n8n and Redis as the real-time data layer. This chatbot isn’t just reactive, it tracks user activity and throttles requests to ensure scalability and prevent abuse.

Each user session is assigned a unique UUID. Redis then keeps track of how many messages that session sends within a 60-second time window. If a user sends more than 10 messages in that timeframe, Redis prevents further interaction until the TTL resets. This allows for intelligent, real-time rate limiting directly within the chatbot flow.

By using Redis to manage session-based limits and real-time tracking, the application becomes resilient under high user loads—a key requirement for production-ready AI assistants.

Demo

How I Used Redis 8

I used Redis 8 as the core real-time data layer to power session-level message tracking and throttling:

INCR + EXPIRE pattern: For every user session (keyed by UUID), I increment a counter each time a message is sent.
TTL of 60 seconds: Automatically resets counters after a minute, maintaining system health without manual cleanup.
Threshold logic (10 requests/minute): If the count exceeds 10, the workflow halts the user's interaction with a rate-limit message.
Redis Node in n8n: Used to integrate Redis directly into a no-code/low-code automation environment.

This makes the AI chatbot resilient, rate-aware, and truly real-time—leveraging Redis not just as a data store, but as a real-time traffic manager for an AI system.

Build Apps with Google AI Studio: Pet as Superhero

Abdullah Bin Altaf — Sun, 13 Jul 2025 19:01:38 +0000

This post is my submission for DEV Education Track: Build Apps with Google AI Studio.

What I Built

I built a fun superhero-themed web app where users enter a pet description and a superhero theme. It combines both inputs to generate a comic-style image using the Imagen API.

I used the following prompt in Google AI Studio to build the app:

Build a web app with two input fields:
- Pet Description (e.g., “a golden retriever puppy named Max”)
- Superhero Theme (e.g., “fire powers and a cape made of lightning”)

Use a default system prompt that will work with all the use cases, entering the pet description and superhero theme.
When the user clicks the Generate Image button, combine both inputs into a single detailed prompt for image generation using the Imagen API.

The app should:
- Show a loading indicator while the image is being generated
- Display the generated image once it's ready
- User should be able to download the mage

Use a fun, colorful design that feels like a comic book or superhero theme.

Demo

GitHub Live Demo

My Experience

This project helped me understand the creative potential of generative AI beyond typical use cases. I enjoyed combining text and image generation into one simple workflow using Google AI Studio.

What stood out was how easily a fun, interactive app could be built — just by guiding the AI with well-structured prompts. It was interesting to see how each result had its own twist, even when the inputs were similar.

Runner H - GitHub Repository Analysis and Documentation

Abdullah Bin Altaf — Sat, 05 Jul 2025 13:32:27 +0000

This is a submission for the Runner H "AI Agent Prompting" Challenge

What I Built

I built a Runner H workflow that automatically generates professional project documentation (in markdown format) from any GitHub repository by deeply analyzing the entire codebase.

This Runner H agent:

Clones the GitHub repository
Understands the architecture, code structure, and logic
Extracts key information from source code, dependencies, and file structures
Generates clean and structured project documentation

It solves the problem of poor or missing documentation in many open-source and internal projects. This agent is especially useful for:

New developers onboarding to a project
Maintaining consistent documentation across teams
Open-source maintainers who want to save time

Demo

Runner H Chat

How I Used Runner H

Prompt used in Runner H:

Please clone and analyze the following GitHub repository:
https://github.com/abdullah-k18/PrintHub

Your task is to:

1. Understand the entire codebase — including source code, project structure, dependencies, comments, and any existing documentation.
2. Based on this understanding, generate comprehensive, professional documentation with the following sections:
   - Project Overview
   - Key Features and Use Cases
   - Folder Structure & Module Breakdown
   - Setup Instructions (installation, configuration, environment variables)
   - Usage Guide (CLI/API/UI details, if applicable)
   - Deployment Instructions (if any)
   - Contribution Guidelines (if not present)
   - Dependencies / Tech Stack
   - Author and License Information
3. Deliver the final documentation in a well-formatted markdown format.

Note: While the repo did include a basic README, it didn’t describe the actual project functionality or architecture. Runner H intelligently interpreted the logic from the source code and structure to craft the full documentation — showing its ability to reason and extract meaning even in low-context environments.

Use Case & Impact

This workflow can be a game-changer for:

Dev teams that need instant documentation before handoffs
Freelancers and consultants inheriting poorly documented code
Open-source maintainers who want to make their repo contributor-friendly
Hackathon and startup teams who need quick docs for demos or pitches

It turns Runner H into an autonomous technical writer — no more manually writing project overviews or setup steps.
By making documentation generation automatic, this agent:

Saves time
Improves consistency
Reduces onboarding friction
Boosts project professionalism

Social Love

Runner H - GitHub Repository Analysis and Documentation | Abdullah Bin Altaf

🚀 Just built something super useful with Runner H, the autonomous agent platform — and I’m genuinely impressed by its capabilities. I gave it just a GitHub repo URL and a clear prompt, and it: 🔍 Understood the entire codebase 🧠 Analyzed the logic, structure, and dependencies 📝 Generated complete project documentation in markdown format This was a real-world test — the repo had a basic README with no detailed explanation of the project. Yet, Runner H read through the code and figured it all out. 📚 I’ve written a blog about the full workflow, the use case, and how this could save countless hours for developers and open-source maintainers: 👉 https://lnkd.in/dnG3f687 🧪 Want to try the same prompt? You can use the exact Runner H chat I used: 💬 https://lnkd.in/dJdbqhWf This is just one example of how AI agents can handle the heavy lifting in creative and technical workflows. #AI #RunnerH #DevTools #OpenSource #Automation #Documentation #Github #AgenticAI #PromptEngineering #BuildWithAI

linkedin.com

Git-Push: Crush Git with Natural Language

Abdullah Bin Altaf — Sun, 04 May 2025 13:54:34 +0000

This is a submission for the Amazon Q Developer "Quack The Code" Challenge: Crushing the Command Line

What I Built

gitpush is an AI-powered command-line tool that translates natural language into Git commands and executes them in your terminal. It's built to simplify version control for developers of all levels.

🚀 Features

🤖 Convert natural language like "push my changes" to real Git commands.
🔄 Cross-platform support (Windows, macOS, Linux).
⚙️ Executes Git commands safely using Python's subprocess.
📦 Easy to install via PyPI: pip install gitpush-cli.

🧠 Powered By

Groq API for fast and accurate command generation.
Amazon Q Developer CLI was used to scaffold and debug the project.
Python 3.8+

Additionally, I’ve created a Python package for gitpush, which is now available on PyPI. You can easily install it with the command pip install git-push-cli to start using the tool and enhance your workflow right away.

pypi.org

Demo

Here’s how a typical session would look:

Install GitPush: pip install git-push-cli
Run GitPush CLI: gitpush
Enter your Groq API key: gsk_**********************************
Generate and let the agent execute Git command by entering a prompt: initialize git
Exit the tool: exit

Code Repository

abdullah-k18 / git-push-cli

A python package

GitPush CLI Tool

GitPush is a command-line tool that allows you to execute Git commands by providing natural language prompts. Using the Groq API, it generates and runs Git commands for you.

Features

Convert natural language commands into Git commands
Supports Git operations like git init, git commit, git push, etc.
Easy to use: simply enter a prompt and the tool executes the corresponding Git command

Installation

Install GitPush using pip:

To install GitPush, simply run the following command:
```
pip install git-push-cli
```
Verify the installation:

After installing, verify that GitPush is installed correctly by running:

gitpush

This should open the GitPush CLI interface.

Setting up the Groq API Key

Enter your Groq API key

The first time you run GitPush, it will ask you to enter your Groq API key. This key is required to generate Git commands from natural language prompts.

When prompted, enter your Groq…

View on GitHub

How I Used Amazon Q Developer

I used Amazon Q Developer to bring my tool to life in a way that made the entire development process much smoother. While the tool I created is responsible for executing Git commands, Amazon Q Developer played a key role in helping me get there. I used the Amazon Q Developer CLI extension within my IDE, which helped me automate various parts of the workflow, generate code, and even resolve some complex tasks with ease.

The best part was how Amazon Q Developer made it easy to convert natural language instructions into actual code. This saved me a ton of time and allowed me to focus on refining the tool's features. Thanks to its capabilities, I was able to streamline the process and achieve the end result more efficiently than I originally imagined.

AGENTIC AI: A BLOG WRITTEN BY AN AI AGENT

Abdullah Bin Altaf — Thu, 06 Feb 2025 12:11:46 +0000

Understanding Agentic AI: Trends, Implications, and Future Directions

Introduction

As we navigate the increasingly complex landscape of technology, Artificial Intelligence (AI) has emerged as a transformative force. Among the various branches of AI, Agentic AI stands out due to its ability to operate autonomously, make decisions, and learn from interactions. Understanding Agentic AI is essential for tech enthusiasts, business leaders, and the general public alike, as its implications could reshape industries and daily life. In this article, we will explore what Agentic AI is, its current trends, key players, and the ethical implications surrounding its rise.

The rise of Agentic AI is not merely a technological advancement; it is a shift that could redefine how we interact with machines. By allowing systems to operate with a degree of autonomy, we are entering an era where AI can contribute to decision-making in meaningful ways. This evolution prompts us to consider both the opportunities and responsibilities that come with such technology, making it crucial to stay informed about its development and impact.

What is Agentic AI?

Agentic AI refers to AI systems that possess the ability to make decisions and take actions independently, based on a set of defined goals and learned experiences. Unlike traditional AI, which often relies on pre-programmed responses and lacks the capability for self-direction, Agentic AI systems can adapt their behavior according to user interactions and environmental cues. This adaptability is crucial as it allows these systems to provide personalized experiences, making them more effective in various applications, from customer service to healthcare.

The distinction between traditional AI and Agentic AI is essential for understanding the future trajectory of technology. While traditional AI can assist with tasks such as data analysis and pattern recognition, Agentic AI can engage in more complex, autonomous tasks that require understanding context and making informed decisions. This shift towards greater autonomy raises important questions about the role of AI in our lives and the responsibilities that come with it, necessitating a careful examination of its implications for society.

Current Trends in Agentic AI

Personalization and Adaptability

One of the most significant trends in Agentic AI is its focus on personalization and adaptability. Systems are being designed to tailor their responses based on user behavior and preferences, allowing for a unique interaction experience. For instance, virtual assistants can learn from user habits to provide more relevant suggestions and improve overall user satisfaction. This trend is not only enhancing customer experiences but also driving businesses to adopt AI solutions that offer more tailored services.

Moreover, this increased personalization allows businesses to create deeper connections with their customers. By understanding user preferences and behaviors, companies can tailor their marketing strategies and product offerings, leading to improved customer loyalty and engagement. As consumers increasingly demand personalized interactions, the ability of Agentic AI to meet these expectations will be a key differentiator in the market.

Ethical Considerations and Regulatory Developments

As the capabilities of Agentic AI expand, so does the need for ethical considerations and regulatory frameworks. The potential for misuse of autonomous systems, such as in surveillance or decision-making without accountability, raises concerns among stakeholders. Consequently, there is a growing focus on establishing guidelines to ensure responsible AI use. Organizations and governments are beginning to collaborate on creating policies that address these ethical dilemmas, aiming to balance innovation with public safety.

The formulation of these ethical guidelines is paramount in fostering trust between consumers and AI technologies. By proactively addressing issues such as privacy, accountability, and bias, stakeholders can create a framework that promotes the responsible development and deployment of Agentic AI. This collaborative effort will be essential in guiding the future of AI technologies in a way that benefits society as a whole.

Integration with IoT

The convergence of Agentic AI with Internet of Things (IoT) devices is another pivotal trend. This integration allows for the creation of smarter environments, from homes to entire cities. For example, smart home systems can utilize Agentic AI to learn user preferences, adjusting lighting and temperature automatically. As IoT devices become more prevalent, the ability of Agentic AI to interact with them will lead to more efficient and responsive systems that can enhance our quality of life.

This synergy between Agentic AI and IoT also opens up new avenues for innovation across various sectors. In smart cities, for instance, the integration can lead to improved traffic management, energy efficiency, and public safety. By harnessing real-time data from IoT devices, Agentic AI systems can make informed decisions that optimize urban living, ultimately contributing to a more sustainable future.

Key Players in the Agentic AI Space

Overview of Leading Companies

Several key players are driving advancements in Agentic AI. Notably, Google DeepMind is recognized for its pioneering research and development of AI systems that exhibit high levels of agency. Their work not only showcases the potential of Agentic AI but also sets benchmarks for future innovations. Similarly, OpenAI is at the forefront of developing models that demonstrate agentic behaviors, particularly in natural language processing, allowing for more nuanced human-AI interactions.

IBM Watson has also made significant contributions, focusing on creating AI systems that can analyze data and make informed decisions. These companies are leading the charge in exploring the capabilities of Agentic AI, and their innovations serve as case studies for businesses looking to adopt similar technologies. By studying these leaders, other organizations can glean insights into effective strategies for leveraging Agentic AI in their operations.

Recent Innovations and Case Studies

Recent advancements in autonomous agents are particularly noteworthy in the healthcare sector, where they are being utilized for diagnosis and treatment recommendations. For instance, AI systems can analyze patient data to suggest personalized treatment plans, improving patient outcomes and operational efficiency. These case studies highlight the practical applications of Agentic AI, showcasing its potential to revolutionize industries by enhancing decision-making processes.

In addition to healthcare, Agentic AI is making strides in finance, where it assists in fraud detection and risk management. By analyzing transaction patterns, AI systems can identify anomalies that may indicate fraudulent activity, allowing for prompt intervention. These innovations exemplify how Agentic AI can enhance operational effectiveness and decision-making across diverse sectors.

Implications of Agentic AI

Benefits for Businesses and Consumers

The rise of Agentic AI presents numerous benefits for both businesses and consumers. For businesses, adopting AI solutions can lead to improved operational efficiency, reduced costs, and enhanced customer experiences. With the ability to analyze vast amounts of data and make informed decisions, companies can respond to market demands more rapidly and effectively. Consumers, on the other hand, stand to gain from more personalized services and products tailored to their preferences, enhancing overall satisfaction.

Furthermore, the integration of Agentic AI can lead to innovative products and services that were previously unimaginable. As businesses leverage these advanced technologies, they can create new revenue streams and improve their competitive edge. This evolution in service delivery not only benefits consumers but also fosters a dynamic marketplace that encourages continuous improvement and innovation.

Ethical Challenges and Responsible AI Use

While the advantages of Agentic AI are clear, there are significant ethical challenges that must be addressed. The autonomy of these systems raises questions about accountability, particularly in situations where AI systems make decisions that affect human lives. It is essential for stakeholders to prioritize responsible AI use, ensuring that ethical considerations are integrated into the development and deployment of these technologies.

Engaging in transparent dialogues about the implications of Agentic AI is crucial. Stakeholders, including developers, users, and regulators, must work together to establish norms and standards that govern AI behavior. By fostering a culture of responsibility and accountability, we can ensure that the benefits of Agentic AI are realized while mitigating potential risks.

Future Outlook and Potential Developments

Looking ahead, the future of Agentic AI appears promising, with continued advancements expected in personalization, adaptability, and ethical frameworks. As technology evolves, so too will the capabilities of Agentic AI, leading to more sophisticated systems that can enhance various aspects of our lives. However, it will be crucial for society to engage in ongoing discussions about the implications of these advancements to ensure a balance between innovation and ethical considerations.

By anticipating future challenges and opportunities, we can better prepare for the integration of Agentic AI into our daily lives. Proactive engagement with emerging technologies will be essential in shaping a future where AI serves the broader interests of society, enhancing our collective well-being.

How to Prepare for the Rise of Agentic AI

Recommendations for Businesses

For businesses considering the adoption of Agentic AI, it is essential to stay informed about the latest trends and developments in the field. Engaging with technology experts and participating in industry forums can provide valuable insights into the best practices for integrating AI solutions. Additionally, companies should prioritize ethical considerations when implementing AI systems, ensuring that accountability and transparency are maintained.

Developing a clear AI strategy that aligns with organizational goals will be imperative. Companies should assess their unique needs and identify areas where Agentic AI can deliver the most significant impact. By focusing on strategic implementation, businesses can maximize the benefits of AI technologies while minimizing potential risks.

Resources for Further Education

To further understand Agentic AI and its implications, a variety of resources are available. Academic journals, industry reports, and reputable tech news outlets offer valuable information on the latest research and innovations in AI. For those interested in the ethical implications, government guidelines and studies from think tanks can provide a framework for responsible AI use.

Additionally, engaging with online courses and webinars focused on AI technologies can enhance understanding and skill development. By investing in education, individuals and organizations can better navigate the complexities of Agentic AI and leverage its capabilities effectively.

Conclusion

As we continue to explore the world of Agentic AI, it is crucial to recognize its potential to transform industries and society at large. Understanding the trends, implications, and ethical considerations surrounding Agentic AI will empower individuals and organizations to navigate this evolving landscape effectively. By staying informed and engaged with ongoing developments, we can harness the benefits of Agentic AI while addressing the challenges it presents.

Call to Action

We invite you to subscribe to our blog for updates on AI trends and developments. Join the discussion in the comments below—share your personal experiences or concerns regarding AI, and let’s engage in a meaningful conversation about the future of technology.

Sensitive Data Checker using agent.ai

Abdullah Bin Altaf — Sat, 18 Jan 2025 21:48:34 +0000

This is a submission for the Agent.ai Challenge: Productivity-Pro Agent (See Details)

What I Built

I built an AI-powered agent that is Sensitive Data Checker in Files to help identify and protect sensitive information in user-provided files. The agent allows users to upload files of various types, and their content is analyzed using a large language model (LLM). It detects sensitive data such as API keys, passwords, or other confidential information, providing an easy way to ensure file security and prevent potential data breaches. I envision this tool being used by developers, businesses, or individuals to safeguard their files and maintain privacy, especially in environments where secure file handling is crucial.

Demo

Live Demo

Agent.ai Experience

Using the Agent.ai platform to build this agent was incredibly easy and seamless. I just added three simple actions, and my agent was ready to go! First, I created an action to get user files. Next, I added an action to invoke an LLM (GPT-4o) to analyze whether the file contains any sensitive data. Finally, I added an action to show the LLM's output to the user.

The straightforward interface and powerful actions made the process enjoyable and efficient, turning my idea into a functional agent in no time!

Vision2Reality

Abdullah Bin Altaf — Sat, 18 Jan 2025 13:58:05 +0000

This is a submission for the GitHub Copilot Challenge : New Beginnings

What I Built

I built Vision2Reality, a web application designed to help users break down their big dreams into actionable steps using AI-powered goal creation. The app allows users to provide a prompt, and the AI generates a set of goals to guide the user through their task. This simplifies the process of starting new projects by making complex ideas more manageable and achievable.

The user interface is clean, modern, and user-friendly. The primary feature of the app, goal creation, uses AI to turn user-provided prompts into concrete, actionable goals, making it an ideal tool for people looking to structure and organize their tasks more effectively.

Demo

Live Demo

Repo

abdullah-k18 / Vision2Reality

Vision2Reality is a web application designed to help users break down their big dreams into actionable steps using AI-powered goal creation. The app allows users to provide a prompt, and the AI generates a set of goals to guide the user through their task. This simplifies the process of starting new projects by making complex ideas more manageable and achievable.

The user interface is clean, modern, and user-friendly. Upon landing on the homepage, users are greeted with a clear call-to-action to get started with their journey. The home page includes a visually engaging gradient background, a prominent headline, and a button that takes the user to a more detailed page to begin generating their goals.

The primary feature of the app, goal creation, uses AI to turn user-provided prompts into concrete, actionable goals, making it an ideal tool for people looking to structure and organize their tasks more effectively.

View on GitHub

Copilot Experience

I used GitHub Copilot to build the entire UI. I started by providing prompts like "Create a landing page with Material UI" and "Build an app bar with the project name on the left, and a CTA button linking to the homepage." Copilot generated the structure, suggested color combinations, and helped refine the design elements like the AppBar, CTA button, and layout, speeding up development significantly.

On the backend, I faced some challenges with the API logic. Copilot assisted by suggesting improvements, allowing me to quickly resolve the issues and move forward with the project.

Copilot made the development process smoother, helping me focus on refining the app instead of getting stuck on repetitive tasks or technical roadblocks.

GitHub Models

I haven't used GitHub Models in my project.

Conclusion

Building Vision2Reality has been an exciting journey, and it wouldn't have been possible without the support of GitHub Copilot. From designing the user interface to troubleshooting backend issues, Copilot significantly accelerated the development process. The project itself holds great potential for users, helping them break down their tasks into clear, actionable goals. I’m excited to see how it can grow and evolve, empowering users to turn their visions into reality more effectively.

Predicting 2025

Abdullah Bin Altaf — Mon, 13 Jan 2025 20:54:21 +0000

This is a submission for the 2025 New Year Writing challenge: Predicting 2025.

The year 2024 witnessed a transformative leap in the tech world, with AI firmly taking the lead. From the advent of advanced large language models (LLMs) to groundbreaking developments in video generation and Retrieval-Augmented Generation (RAG), the landscape of innovation was rich and dynamic. As we step into 2025, let’s dive into what the future holds, predicting the trends, technologies, and tools that will dominate industry headlines.

The Rise of Agentic AI

2024 set the stage for Agentic AI, but 2025 is poised to be its breakout year. As NVIDIA’s CEO aptly stated, the IT departments of today might soon evolve into the HR departments of AI agents. Companies will begin building specialized AI agents to automate repetitive tasks, optimize workflows, and generate new revenue streams. This paradigm shift will empower individuals and businesses alike, enabling people to create and deploy their own AI agents tailored to specific needs.

Big tech companies are already investing heavily in Agentic AI, and frameworks like LangChain will likely gain even more traction. LangChain’s modular approach to building AI-driven workflows will attract a broader audience, from startups to enterprises, as businesses seek to simplify the adoption of these powerful tools.

The Decline of Traditional DevOps?

A bold prediction for 2025 is that the role of DevOps engineers as we know it may start to fade. With platforms like Vercel automating deployment, CI/CD pipelines, and server management, the need for manual DevOps processes is diminishing. These platforms offer seamless backend and frontend hosting—Next.js, for instance, allows developers to host both on a single server effortlessly.

This trend could lead to a shift where developers focus more on building and less on deployment, while backend-as-a-service solutions like Firebase continue to rise in popularity. As these platforms mature, they will likely handle an increasing share of the infrastructure work traditionally managed by DevOps teams.

The Dominance of Next.js and Serverless Architectures

Next.js, with its powerful features like server-side rendering (SSR) and static site generation (SSG), is set to become the go-to framework for web development. The ability to host backend and frontend together simplifies development pipelines and reduces operational complexity.

Moreover, serverless architectures will continue to thrive. Services like AWS Lambda, Google Cloud Functions, and Firebase will attract more developers and businesses seeking scalable, cost-effective solutions. These platforms will reduce the barrier to entry for startups, enabling them to launch quickly without heavy infrastructure investments.

The Shift in Mobile App Development

React Native is gaining momentum as the preferred framework for mobile app development. Its ability to deliver a seamless cross-platform experience with a single codebase is a significant advantage over Flutter. In 2025, we can expect more companies to adopt React Native for its efficiency and developer-friendly ecosystem, further solidifying its position in the market.

2025 promises to be a transformative year for technology. From Agentic AI redefining workflows to platforms like Vercel and Firebase simplifying development, the future is bright and full of potential. While some roles and practices may evolve or diminish, new opportunities will emerge, pushing the boundaries of what’s possible.