DEV Community: Ashan_Dev

Google I/O 2026: My Annotated Field Notes (The Version They Don't Tweet)

Ashan_Dev — Wed, 20 May 2026 10:39:55 +0000

This is a submission for the Google I/O 2026 Writing Challenge

I took notes during Google I/O the way I take notes during any conference — obsessively, out of order, with a lot of question marks.

What follows isn't a summary. Summaries flatten everything to equal importance, and not everything announced this week has equal importance. This is closer to a field guide: what I noticed, what I tested, what confused me, and what I think is actually worth your time.

I'll be specific where I can. Where I'm speculating, I'll say so.

The context window is real. The reasoning is not automatically better.

Gemini's 2 million token context window is not a marketing number. I fed it a full production codebase — about 180,000 tokens of actual working code, not a demo project — and it didn't choke. It loaded. It answered questions about files I hadn't mentioned.

Here's the problem: big context and good reasoning are not the same thing.

I asked it to find the source of an intermittent bug. It gave me a confident, detailed, structurally convincing answer. The answer was wrong. Not slightly wrong — completely fabricated. It invented a race condition that matched the symptom description so well that I spent 40 minutes verifying it before accepting that the race condition didn't exist.

The actual bug was a missing await in a file I hadn't explicitly mentioned.

Long context makes hallucinations harder to catch, not less frequent. The model has more material to build a plausible-sounding wrong answer from. Keep that in mind before you dump your entire monorepo into the prompt.

Practical note: Use long context for retrieval-style questions ("does this codebase have any usage of X?") not for debugging or reasoning tasks. The former works well. The latter is a confidence trap.

Agents went from demo toy to something I'd actually deploy

I've been skeptical of "AI agents" since the phrase entered the hype cycle. Most implementations I've seen are just chains of API calls with a marketing layer on top.

The Gemini agent demos at I/O this year were different in one concrete way: error recovery.

Previous agent demos I've watched fail gracefully — they stop, report the error, wait for a human. These ones rerouted. Not always correctly, but they rerouted. The agent assigned to pull data from a malformed JSON endpoint didn't quit — it tried a fallback, logged why, and continued with partial data.

That's the behavior that makes agents actually useful in production. Not perfect execution. Graceful degradation.

I haven't run this on my own infrastructure yet. The session I'm watching is the What's New in Google AI stream from May 19. I'll update this after I test it on a real task this week.

Google AI Studio: the tool the developer relations team isn't talking about enough

Everyone covered the Gemini API features. Almost nobody covered the quality-of-life changes to AI Studio itself.

Session persistence. This is the one that changed how I work. AI Studio now holds context between turns in a way that feels stateful — you can leave a session, come back, ask a tangentially unrelated question, return to the original task, and it still knows what you were building. I don't know if this is a context management trick or something deeper in the session architecture. What I know is that I stopped having to paste my component spec back into the chat every time I changed tabs.

Side-by-side diff view. When you ask it to revise code, it now shows you what changed instead of just the full rewrite. Obvious feature in hindsight. Surprisingly rare before now.

Direct API export. You can take any successful Studio session and export it as a curl command, Python snippet, or Node.js call with one click. Sounds small. Cuts about 15 minutes out of every "ok this worked in Studio, now how do I reproduce it in my app" workflow.

Firebase security rules + Gemini: the announcement I'm watching most carefully

Firebase security rules are where junior devs make expensive mistakes and senior devs still have to be careful. The rules syntax is specific, the failure modes are security holes that don't announce themselves, and the feedback loop is terrible — you write rules, deploy, and find out months later that a path was too permissive.

Google announced Gemini integration that can analyze your rules against your data model and flag mismatches.

I haven't tested this. I want to test this. My hesitation is that "AI reads your security rules" could mean one of two things:

It does a pattern check against known antipatterns (useful, limited)
It actually understands the relationship between your schema and your rules and flags the specific path where a user could read someone else's data (very useful, hard to build) I'll find out next week on a project where the rules have been making me nervous for two months.

The thing nobody's calling out: Google is betting on the API layer

Read the I/O announcements as a product person, not a developer, and something becomes clear: Google is not trying to win the UI layer. Gemini isn't competing with ChatGPT for consumer mindshare as its primary goal. The goal is the API and infrastructure layer — the part that sits underneath every product you build.

AI Studio, Firebase integration, Vertex AI updates, the Gemini API in Android Studio — these are all targeting the developer who is building something else and needs AI infrastructure underneath it.

This is smart for Google and slightly uncomfortable if you're a startup building AI-native tools on top of Google's APIs. The infrastructure provider and the application layer are getting closer together.

Not saying it's bad. Just worth knowing when you're making architectural decisions.

What I'm actually going to use this week

In order of how likely I am to get to it:

AI Studio with session persistence — replacing my current workflow of pasting context into every new conversation
Long-context code review — specifically for retrieval questions, not reasoning. "Find all places where we're not handling the error case in async functions."
Firebase rules analysis — one real project, one set of rules I've been nervous about
Gemini 1.5 Pro API — I have a document processing task that's been barely within the 1M token limit. 2M gives me room. I'm skipping the agent stuff for now. Not because it's uninteresting — because the agent architecture I'd want to use it in doesn't exist yet in my stack. That's a me problem, not a Google problem.

The honest summary

Google I/O 2026 was a solid developer conference with a few genuinely useful announcements buried under a lot of infrastructure noise that only matters if you're running things at scale.

The useful stuff: AI Studio improvements, the actual behavior of agent error recovery, the Firebase rules analysis if it's as deep as the demo implied.

The stuff I'll check back on in six months: the 2M token context window for reasoning tasks (I expect the model quality to improve, not just the window size), and anything involving on-device Gemini Nano — interesting in theory, and I've been burned enough times by "on-device AI" claims to wait for real-world latency numbers.

If you want to watch the sessions yourself: the Google I/O session explorer has everything. The Gemini API session and the What's New in Google AI keynote are the two I'd start with if you're a developer who doesn't have six hours.

I'll update this post after I test the Firebase rules integration. Probably Thursday.

If you spotted something in the sessions I missed, drop it in the comments — I'm specifically curious if anyone tested the on-device Gemini features on non-Pixel hardware.

I Got Tired of AI Black Boxes So I Built One You Can Break Into

Ashan_Dev — Wed, 13 May 2026 05:39:33 +0000

Dead Star AI — A Human-in-the-Loop Reasoning Engine Built on Gemma 4

This is my submission for the Gemma 4 Challenge: Build with Gemma 4

What I Built

I work with LLMs constantly and I've hit the same wall dozens of times. You write a careful prompt, attach a complex diagram, and wait. If the model misreads one assumption in the middle of its reasoning, the final answer is wrong and you have no idea where. You just try again.

Dead Star AI is what I built to fix that.

It's not a chatbot. When you give it a problem, it streams its reasoning into discrete logic nodes on your screen before generating an answer. And before it commits to that answer, it stops — and gives you the keyboard back.

You can click any reasoning node and rewrite it. If the model misread your database schema from an image upload, you fix that node directly, hit Commit Intelligence, and the final answer gets generated from your corrected reasoning — not as a patch, but as the actual starting point.

There's also an Influence Score that uses a custom diffing algorithm to show exactly how much your edits changed the output. Small feature, but it makes the whole thing feel less like prompting and more like actual collaboration.

Demo

Live app: https://deadstarai.vercel.app

Fastest way to see it work: click "Analyze System Architecture" on the home screen, wait for the reasoning nodes to load, then intercept one and rewrite it. That's the whole idea in about 30 seconds.

Code

Repository: GitHub →

Worth looking at:

app/api/think/route.ts and app/api/answer/route.ts — the two-pass reasoning pipeline
lib/diff.ts — the diffing algorithm behind the Influence Score
lib/security.ts — Edge rate-limiting and prompt sanitization

How It Works

The Two-Pass Pipeline

Most LLM apps make one API call and display the result. Dead Star makes two, intentionally.

User Input + Image
       │
       ▼
 /api/think ──► Gemma 4 streams <|think|> tokens
       │               │
       │        Reasoning Nodes
       │        rendered in UI
       │               │
       │        User edits nodes
       │               │
       ▼               ▼
 /api/answer ◄── Corrected reasoning
       │         fed back as context
       ▼
  Final Answer

Pass one (/api/think) extracts Gemma 4's raw <|think|> reasoning and streams it directly to the UI as editable components. Pass two (/api/answer) takes whatever the user left in those nodes — corrected or not — and synthesizes the final response from that shared context.

The model doesn't know you edited its thoughts. It just reasons from what's in the context window.

The Influence Score

// lib/diff.ts
export function calculateInfluenceScore(
  original: string[],
  edited: string[]
): number {
  const changes = computeDiff(original, edited);
  return Math.round((changes / original.length) * 100);
}

Every character change between Gemma's original reasoning and your edited version gets tracked. The final score tells you what percentage of the reasoning was yours. A 0% score means you let the model run clean. An 80% score means you basically rewrote the logic and used Gemma to execute your thinking.

How I Used Gemma 4

The app routes between gemma-4-31b-it and gemma-4-26b-a4b-it with an 8-model failover chain. The 31B Dense model runs as primary for two reasons: multimodal vision and 128k context depth.

Users upload messy architecture diagrams and large code dumps. Smaller models lose coherence under that kind of load. The 31B holds the thread.

Gemma 4 Features Used

Feature	Status	How
Multimodal (vision)	✅ Active	Images encoded as `inlineData` and passed through both API passes
Long context (128k)	✅ Active	Full conversation history + edited reasoning nodes held in context
`<\	think\	>` tags
Function calling	✅ Active	Gemma triggers Tavily web search autonomously mid-reasoning
Model failover	✅ Active	31B Dense → 26B MoE → fallback chain across 8 configurations

Function Calling in the UI

When a prompt requires live data, Gemma decides mid-reasoning to call the search tool. A glowing blue Action Node shows up in the thought stream the moment that decision happens — before the answer, during the thinking. You can see the model acting as an agent in real time.

Architecture

┌─────────────────────────────────────────────┐
│                 Next.js App                  │
│                                             │
│  ┌──────────┐    ┌───────────────────────┐  │
│  │ ChatInput│    │   Intelligence Lab    │  │
│  │ + Images │───►│   (Reasoning Nodes)   │  │
│  └──────────┘    │   - ThoughtNode       │  │
│                  │   - ActionNode        │  │
│  ┌──────────┐    │   - [editable]        │  │
│  │  Answer  │◄───└───────────────────────┘  │
│  │  Panel   │              │                │
│  └──────────┘              ▼                │
│                    useReasoningEngine        │
└─────────────────────────────────────────────┘
          │                   │
          ▼                   ▼
   /api/think           /api/answer
   (Gemma 4 31B)        (Gemma 4 31B)
          │
          ▼
   lib/security.ts
   - Upstash Redis rate limiting (Edge)
   - CORS origin validation
   - Prompt sanitization

Edge Security

Most hackathon projects skip this entirely. Dead Star runs global rate limiting via Upstash Redis at the Edge runtime level — before any request reaches the model. CORS validation locks the API to the production origin. Prompt content gets sanitized before it touches the model context.

It's not exciting to write about but it's the difference between a demo and something you'd actually deploy.

What I'd Do Differently

The on-device inference angle is missing. The app is entirely API-based right now. Adding a toggle to route to a local Ollama endpoint (http://localhost:11434/v1) would let privacy-sensitive users run the whole thing without their data leaving their machine. That's on the roadmap.

The long context window is used but not demonstrated explicitly. A next version would let you drop an entire codebase or research paper into the context and watch the reasoning nodes handle it — that's a more honest showcase of the 128k capability.

Try It

Live: https://deadstarai.vercel.app

Repo: GitHub →

The fastest path to the interesting part: load the app, click an example prompt, wait for nodes, intercept one, change something, commit. The Influence Score at the end tells you how much of the final answer was actually yours.

I Got Tired of AI Black Boxes So I Built One You Can Break Into

Ashan_Dev — Wed, 13 May 2026 05:39:33 +0000

Dead Star AI — A Human-in-the-Loop Reasoning Engine Built on Gemma 4

This is my submission for the Gemma 4 Challenge: Build with Gemma 4

What I Built

Dead Star AI is what I built to fix that.

Demo

Live app: https://deadstarai.vercel.app

Code

Repository: GitHub →

Worth looking at:

app/api/think/route.ts and app/api/answer/route.ts — the two-pass reasoning pipeline
lib/diff.ts — the diffing algorithm behind the Influence Score
lib/security.ts — Edge rate-limiting and prompt sanitization

How It Works

The Two-Pass Pipeline

Most LLM apps make one API call and display the result. Dead Star makes two, intentionally.

User Input + Image
       │
       ▼
 /api/think ──► Gemma 4 streams <|think|> tokens
       │               │
       │        Reasoning Nodes
       │        rendered in UI
       │               │
       │        User edits nodes
       │               │
       ▼               ▼
 /api/answer ◄── Corrected reasoning
       │         fed back as context
       ▼
  Final Answer

The model doesn't know you edited its thoughts. It just reasons from what's in the context window.

The Influence Score

// lib/diff.ts
export function calculateInfluenceScore(
  original: string[],
  edited: string[]
): number {
  const changes = computeDiff(original, edited);
  return Math.round((changes / original.length) * 100);
}

How I Used Gemma 4

The app routes between gemma-4-31b-it and gemma-4-26b-a4b-it with an 8-model failover chain. The 31B Dense model runs as primary for two reasons: multimodal vision and 128k context depth.

Users upload messy architecture diagrams and large code dumps. Smaller models lose coherence under that kind of load. The 31B holds the thread.

Gemma 4 Features Used

Feature	Status	How
Multimodal (vision)	✅ Active	Images encoded as `inlineData` and passed through both API passes
Long context (128k)	✅ Active	Full conversation history + edited reasoning nodes held in context
`<\	think\	>` tags
Function calling	✅ Active	Gemma triggers Tavily web search autonomously mid-reasoning
Model failover	✅ Active	31B Dense → 26B MoE → fallback chain across 8 configurations

Function Calling in the UI

Architecture

┌─────────────────────────────────────────────┐
│                 Next.js App                  │
│                                             │
│  ┌──────────┐    ┌───────────────────────┐  │
│  │ ChatInput│    │   Intelligence Lab    │  │
│  │ + Images │───►│   (Reasoning Nodes)   │  │
│  └──────────┘    │   - ThoughtNode       │  │
│                  │   - ActionNode        │  │
│  ┌──────────┐    │   - [editable]        │  │
│  │  Answer  │◄───└───────────────────────┘  │
│  │  Panel   │              │                │
│  └──────────┘              ▼                │
│                    useReasoningEngine        │
└─────────────────────────────────────────────┘
          │                   │
          ▼                   ▼
   /api/think           /api/answer
   (Gemma 4 31B)        (Gemma 4 31B)
          │
          ▼
   lib/security.ts
   - Upstash Redis rate limiting (Edge)
   - CORS origin validation
   - Prompt sanitization

Edge Security

It's not exciting to write about but it's the difference between a demo and something you'd actually deploy.

What I'd Do Differently

Try It

Live: https://deadstarai.vercel.app

Repo: GitHub →

I Stopped Writing Changelogs Manually — Here's the AI Tool That Does It in Seconds (Free)

Ashan_Dev — Sat, 18 Apr 2026 23:42:59 +0000

The Problem Every Developer Ignores Until It's Too Late

You've just merged 47 commits. The sprint is done. Your PM is pinging you for release notes. Your users are waiting for the changelog.

And you're staring at this:

fix: edge case in auth
chore: update deps
feat: add stripe webhook
refactor: clean up user service
fix: typo in README
feat: dark mode toggle

Now write that as a professional changelog. Go.

Yeah. That's what I thought.

Why Changelogs Are a Developer's Least Favorite Task

Here's why most developers skip or half-ass their changelogs:

🧠 Context switching is brutal — you just finished coding, now you're a copywriter?
⏰ It takes forever — reading every commit, grouping them, writing human-readable descriptions
😴 It's boring — there's no dopamine hit from writing "Fixed authentication edge case in OAuth flow"
🤷 Nobody teaches you how — there's no "Changelog Writing 101" in CS degrees So what happens? Developers ship with either:
No changelog at all
A raw git log dump nobody can read

- A 2-line "bug fixes and improvements" that tells users nothing

What I Built to Fix This

I built Changelog AI — a free tool that transforms your raw Git commits into three polished formats in seconds:

Output Format	Use Case
📋 Professional Changelog	Your `CHANGELOG.md`, product docs, Notion updates
🐙 GitHub Release Notes	Paste directly into GitHub Releases
🐦 Twitter/X Announcement	Ship updates to your audience instantly

No account needed. No credit card. No 14-day trial. Just open, paste, ship.

How It Works (30-Second Demo)

Step 1: Copy your commits from terminal:

git log --oneline --since="2 weeks ago"

Step 2: Paste them into Changelog AI

Step 3: Click generate. Get this back instantly:

## v2.3.0 — What's New

### ✨ New Features
- **Dark Mode** — Full dark mode support across all pages
- **Stripe Webhooks** — Real-time payment event handling now live

### 🛠️ Improvements
- Authentication system hardened with edge case handling
- User service architecture refactored for better performance

### 🐛 Bug Fixes
- Fixed typo in README documentation

That's it. Three clicks and you're done.

Why This Beats Writing It Yourself (Or Using ChatGPT)

I know what you're thinking: "I can just paste my commits into ChatGPT."

You can. But here's what Changelog AI does differently:

✅ Purpose-built prompts — Generic LLMs give generic output. This is fine-tuned for developer release communication specifically.

✅ Three formats in one shot — ChatGPT gives you one output. Changelog AI gives you the changelog, the GitHub release, AND the tweet simultaneously.

✅ Zero friction — No prompt engineering. No "make it more professional." No back-and-forth. Paste → Generate → Ship.

✅ Consistent tone — Every release sounds polished, not like it was written by 3 different interns.

The Real Cost of Skipping Changelogs

If you maintain an open source project, a SaaS, or any software people depend on — changelogs aren't optional. They're trust signals.

Users want to know what changed before they update
Contributors need to understand what shipped
Your future self will thank you at 2am debugging a regression A good changelog is developer marketing. It shows you care about your users enough to communicate with them.

Changelog AI makes that zero-effort.

Try It Free

👉 change-log-ai.vercel.app

No signup. No friction. Open it right now in another tab, paste your last 10 commits, and see what comes back.

What's Coming Next

I'm actively building this out. On the roadmap:

[ ] GitHub App integration (auto-generate on push)
[ ] Jira/Linear ticket linking
[ ] Team workspaces for consistent changelog style
[ ] Slack/Discord announcement format
[ ] Custom changelog templates Drop a comment below if there's a feature you'd want — I'm reading every reply.

Built With

Next.js — Frontend + API routes

- Vercel — Deployment

If this helped you, drop a ❤️ and share it with your team. Every dev I know has complained about changelogs — let's fix that.

→ Try Changelog AI free

UnProductive™: An Enterprise Dashboard for Accomplishing Absolutely Nothing

Ashan_Dev — Wed, 08 Apr 2026 17:22:14 +0000

This is a submission for the DEV April Fools Challenge

What I Built

UnProductive™ — The Anti-Productivity Suite.

A full bento-grid dashboard that looks like a legitimate SaaS product at first glance. Dark background, sidebar nav, real-time clock, progress charts, an AI advisor, a terminal. Everything a productivity app needs.

Except every single feature is engineered to fail, flee, gaslight, or accomplish nothing whatsoever.

Here's what's inside:

The Evasive Button — A box labeled "Important Decision Matrix" with a button that says "Acknowledge." It physically runs away when your cursor gets within 110px of it. If you actually manage to click it, the response is: "Click registered. Action: none. You are welcome."

Thought Shredder — Type your billion-dollar idea. While you type, it randomly scrambles your characters and injects glitch symbols. Hit Obliterate and the text corrupts into garbage on-screen before disappearing to /dev/null/forever.

UnProductive AI™ — Consults "The Oracle." The advice includes things like "Analysis complete. You are 97% procrastination, 2% good intentions, 1% cached regret." and "ERROR 418: Goal detected. Initiating avoidance protocol." Response accuracy: 0%. Powered by 0 neurons and pure vibes.

Vibe Check Terminal — A fake terminal with real commands. Run npm install and it adds 9,847 packages with 12,674 vulnerabilities. Three of them are sentient. Run git blame and it just says "you did this." Try to exit and it tells you the void doesn't have a door.

The Anti-Ledger — A to-do list. Click any item and it shakes, denies your access, and changes the status to "ACCESS DENIED." The task label gets a strikethrough. You did not complete it. You were rejected by it.

Chaos Clock — Keeps time, mostly. 10% of the time it steps backwards. 12% of the time it jumps several hours in either direction with a color flash and a CSS skew. Feels eerily plausible.

Productivity Donut — Animates up to 99% with great confidence, then immediately crashes to 0% and fires a toast: "Productivity peaked at 99%. System reset to preserve institutional standards."

Gaslight Toasts — Random notifications every 7–21 seconds. "You blinked 5 times. Recommended: 3. Please calibrate." and "Your cursor is moving at an unsustainable velocity."

Synergy Optimizer Modal — Full-screen takeover with a spinner and a progress bar permanently stuck at 99%. The Cancel button runs away from your cursor. Auto-dismisses after 28 seconds with: "Results: statistically indistinguishable from before."

FIX UI Button — Hue-rotates the page, mirrors it, rotates it slightly, or removes all color. Always reverts. Never fixes anything.

Daily Motivation Engine™ — Cycles through quotes like "Every expert was once a beginner who gave up and rebranded as a consultant." and "A plan without execution is a very impressive document."

The Developer's Confession — A "CLASSIFIED" section leaked as evidence that I have, outside of UnProductive™ hours, been observed writing real software. Links to my actual GitHub automation repos under a redacted watermark. The irony is intentional.

Demo

🔗 devaprilfoolschallenge.vercel.app

For the full experience, try these in order:

Try to click the "Acknowledge" button
Type something important into the Thought Shredder, then hit Obliterate
Run git blame in the Vibe Terminal
Click "Run AI Optimizer" and try to cancel it
Press FIX UI a few times
Just... wait for a gaslight toast

Code

itxashancode / DEV-April-Fools-Challenge

How I Built It

Vanilla HTML, CSS, and JavaScript. No framework. Intentionally.

Three.js for two things: a background particle field (2,200 points in acid/magenta/cyan pulled by the mouse), and the entropy visualizer widget which renders a wireframe torus knot that randomly glitches its scale, position, and color.

Tailwind (CDN) for layout. The bento grid is a 12-column CSS grid with span classes per widget — w1 through w9, full-width for the GitHub confession section.

The 3D card tilt on hover uses CSS custom properties set by mousemove on each widget:

card.style.setProperty('--local-mouse-x', x.toFixed(3));
card.style.setProperty('--local-mouse-y', y.toFixed(3));

Then consumed in CSS:

.widget:hover {
  transform: perspective(900px)
             rotateX(calc(var(--local-mouse-y) * -12deg))
             rotateY(calc(var(--local-mouse-x) * 12deg))
             translateZ(20px);
}

No JS touches the transform. Keeps it smooth.

The evasive button logic (used in both the Acknowledge button and the Synergy Cancel button) tracks mouse distance to the button center and randomizes top/left within the parent's bounding rect if you get too close:

if (Math.hypot(e.clientX - cx, e.clientY - cy) < 110) {
    btn.style.top  = `${4 + Math.random() * maxY}px`;
    btn.style.left = `${4 + Math.random() * maxX}px`;
}

The noise overlay is a single <div> with an SVG feTurbulence filter tiled over the whole page at 4% opacity with mix-blend-mode: overlay. Basically free performance-wise.

The Chaos Clock has weighted randomness — most ticks advance normally, 10% go backwards, 12% jump by up to ±10 hours with a visual flash. Random clocks tend to feel too chaotic; weighted behavior makes it feel almost plausible until it isn't.

Fonts: Space Mono for the monospace/terminal aesthetic, Playfair Display for the big italic headings. The contrast between them does a lot of work.

Prize Category

Best Ode to Larry Masinter — the HTTP 418 easter egg is hardcoded in the AI advisor responses ("ERROR 418: Goal detected. Initiating avoidance protocol."), the project name gestures at RFC 2324's whole ethos, and the entire thing is built on the premise that software can be technically correct and completely useless. That feels like the spirit of the teapot to me.

Built by @itxashancode

I built a bot that answers GitHub Discussions using free AI models — here's what I learned

Ashan_Dev — Wed, 08 Apr 2026 13:16:48 +0000

Heads up: This is an educational project. The bot can post to GitHub Discussions, which means you need to use it carefully. I'll cover what responsible use looks like at the end.

A few months ago I wanted to get GitHub's Galaxy Brain badge — the one you earn by getting answers marked as Accepted in Discussions. I figured automating the search part would be interesting. Finding relevant open questions manually is genuinely tedious.

What started as a script to find unanswered threads turned into a project I actually care about. Not because of the badge, but because of the infrastructure problems it forced me to solve.

Here's what's in the codebase and what I learned building each piece.

The basic idea

The bot does four things:

Discovers GitHub repos that have Discussions enabled, filtered by topic tags and star count
Fetches open, unanswered Discussion threads from those repos
Sends the question to a free LLM via OpenRouter and gets an answer
Optionally posts that answer (with your confirmation, by default)

None of that is complicated. The interesting problems came from making it reliable.

Problem 1: Free LLM models are flaky

OpenRouter's free tier is great — 18+ models, no billing required. The catch is availability. A model that worked yesterday might 404 today. A model that worked an hour ago might be rate-limited now.

My first version just tried one model and crashed when it failed. The fix was a rotation list:

_DEFAULT_MODELS = [
    "qwen/qwen3.6-plus:free",
    "stepfun/step-3.5-flash:free",
    "nvidia/nemotron-3-super-120b-a12b:free",
    "meta-llama/llama-3.3-70b-instruct:free",
    "google/gemma-3-27b-it:free",
    # ... 13 more
]

The bot tries them in order. If a model returns an empty response, a 404, or a 429, it logs the failure and moves to the next one. At session end, --models shows a table of which models succeeded, failed, and how fast they were.

One thing I noticed: "success" and "quality" are different. A model can return a response that passes all the checks but still gives a generic non-answer. The answer length filter (ANSWER_MIN_CHARS, ANSWER_MAX_CHARS) catches the worst cases, but it doesn't catch confident-sounding garbage.

Problem 2: Retrying the wrong way

Before adding proper backoff, the bot would hit a rate limit and immediately retry. Then retry again. Then again. GitHub's API would respond with 429 for the rest of the session.

The fix was reading Retry-After headers:

retry_after = int(response.headers.get("Retry-After", RATE_LIMIT_RETRY_AFTER_DEFAULT))
time.sleep(retry_after)

GitHub is inconsistent about including that header. When it's missing, the bot falls back to exponential delay. It's not perfect, but it's miles better than hammering an endpoint that's already telling you to stop.

Problem 3: One bad endpoint killing the whole session

This took me a while to notice. If a particular GraphQL query started timing out — say, because a repo was unusually large — the bot would retry it over and over, spending most of the session waiting.

Circuit breakers solve this. After a configurable number of consecutive failures, the circuit "opens" and blocks further requests to that endpoint for a timeout period. Then it half-opens: one probe request goes through. If that succeeds, the circuit closes again.

class CircuitBreaker:
    CLOSED = "closed"
    OPEN   = "open"
    HALF   = "half_open"

    def __init__(self, name, threshold=5, timeout=120):
        self.state    = self.CLOSED
        self.failures = 0
        self.opened_at = None

The effect in practice: the bot now skips broken endpoints and moves to the next repo in the list, instead of getting stuck.

Problem 4: Ctrl+C corrupting the stats file

The stats file (galaxy_brain_stats.json) gets written at the end of each session. If you hit Ctrl+C mid-write, you get a partial JSON file, which breaks the next session.

The fix was a ShutdownHandler that catches SIGINT/SIGTERM and sets a flag:

class ShutdownHandler:
    def __init__(self):
        self._shutdown = False
        signal.signal(signal.SIGINT,  self._handle)
        signal.signal(signal.SIGTERM, self._handle)

    def _handle(self, *_):
        self._shutdown = True

    @property
    def requested(self):
        return self._shutdown

Every loop in the bot checks shutdown.requested before its next iteration. Ctrl+C finishes the current task cleanly, then exits. The stats file always gets written to disk before the process ends.

What else is in there

In-memory TTL cache. Avoids re-fetching the same GraphQL results within a session. Default TTL is 5 minutes. When you're processing 50 repos, this matters.

Multi-modal support. If a Discussion post contains images and the selected model supports vision, the bot fetches the images and includes them in the prompt. Same for external links — it fetches the page content and appends it.

Key rotation. You can put multiple OpenRouter API keys in .env, comma-separated. When one hits its rate limit, the bot rotates to the next.

Webhook notifications. Discord and Slack. Sends an alert when an answer gets accepted, and a summary at the end of each session.

Stats by org. Breaks down your answer history by repository owner. Useful for seeing which communities you've been most active in.

Setting it up

git clone https://github.com/YOUR_USERNAME/galaxy-brain-bot.git
cd galaxy-brain-bot
pip install -r requirements.txt
cp .env.template .env
# Fill in GITHUB_TOKEN, GITHUB_USERNAME, OPENROUTER_KEYS
python test_bot.py  # run this before anything else
python galaxy_brain_bot.py

The test suite checks all your credentials and API connections before you run the main bot. Run it first.

By default, the bot asks for confirmation before posting each answer (AUTO_APPROVE_ANSWERS=false). Keep it that way until you've seen a few answers and trust the output quality on the repos you're targeting.

Responsible use

A few things I want to say directly:

Don't run it unsupervised at scale. The MAX_ANSWERS_PER_SESSION setting exists for a reason. Posting 50 answers in an hour is a good way to get flagged.

Read the answers before posting. LLMs are wrong sometimes. Posting a confident wrong answer in a GitHub Discussion is worse than posting nothing.

Check the repo's rules. Some repos have Codes of Conduct that explicitly restrict automated participation. The bot tries to detect this, but it can miss things.

It's a research tool, not a farming tool. The badge is a byproduct. If you're using this to post low-effort answers at volume, you're not using it for what it was built for.

Source code

Full source, setup instructions, and config reference: https://github.com/itxashancode/Galaxy-Brain-Automation

The whole thing is one Python file (galaxy_brain_bot.py) plus a test suite. No frameworks, no magic — just requests, rich for the terminal UI, and python-dotenv. If you want to understand a specific piece, it's all in one place.

Happy to answer questions in the comments. If you spot something in the circuit breaker or backoff logic that could be better, I'm genuinely interested.

Built for learning. MIT licensed.

🏥 gh-repo-health: Check Your GitHub Repo's Health Score in Seconds

Ashan_Dev — Thu, 19 Mar 2026 03:56:43 +0000

Have you ever opened a GitHub repo and wondered "is this project actually maintained?" — or pushed your own project and asked "does this even look professional?"

I asked myself the same questions. So I built gh-repo-health — a CLI tool that audits any GitHub repository and gives it a health score based on community standards.

🤔 Why I Built This

When I was exploring open source projects to contribute to, I kept manually checking:

Does it have a README?
Is there a CONTRIBUTING guide?
Any issue templates?
A LICENSE file?
A CODE_OF_CONDUCT?

Doing this for every repo was exhausting. I wanted a single command that tells me everything at once.

So I built gh-repo-health.

⚡ What It Does

gh-repo-health scans any public GitHub repository and checks for key community health files:

File	Why It Matters
`README.md`	First impression — does the project explain itself?
`LICENSE`	Legal clarity for contributors and users
`CONTRIBUTING.md`	Guides new contributors on how to help
`CODE_OF_CONDUCT.md`	Sets community standards
`SECURITY.md`	Responsible disclosure for vulnerabilities
Issue Templates	Structured bug reports and feature requests
Pull Request Template	Consistent PR process

Each check passes or fails, and you get an overall health score at the end.

🚀 Getting Started

Clone the repo and run it against any GitHub repository:

git clone https://github.com/itxashancode/gh-repo-health
cd gh-repo-health
pip install -r requirements.txt

Then audit any repo:

python main.py itxashancode/Pull-Shark-Automation

You'll get output like:

✅ README.md          found
✅ LICENSE            found
❌ CONTRIBUTING.md    missing
❌ CODE_OF_CONDUCT    missing
✅ Issue Templates    found
❌ SECURITY.md        missing
❌ PR Template        missing

Health Score: 43% — Needs Improvement

🛠️ How It Works

The tool uses the GitHub REST API to check for the existence of community health files. No cloning required — it's all API calls.

import requests

def check_file(owner, repo, filepath):
    url = f"https://api.github.com/repos/{owner}/{repo}/contents/{filepath}"
    response = requests.get(url)
    return response.status_code == 200

It checks common file locations — root, .github/, and docs/ — so it doesn't miss files tucked in subdirectories.

💡 What I Learned Building This

This was one of my early Python projects, and it taught me a lot:

GitHub's API is incredibly powerful — you can inspect almost anything about a repo without cloning it
Community health files genuinely matter — repos with them get more contributions
CLI tools are satisfying to build — instant feedback, no UI needed
Error handling is critical — private repos, rate limits, and missing tokens all need to be handled gracefully

🔮 What's Next

I'm planning to add:

[ ] Badge generation — embed a health score badge in your README
[ ] Batch scanning — audit all repos in an organization at once
[ ] GitHub Actions integration — fail CI if health score drops below a threshold
[ ] JSON output — for piping results into other tools

🌟 Try It on Your Own Repo

Run gh-repo-health against your own projects. You might be surprised what's missing!

👉 GitHub: itxashancode/gh-repo-health

If you find it useful, drop a ⭐ on the repo — it genuinely motivates me to keep building.

I'm Ashan, an APTECH student from Karachi building GitHub automation tools and learning in public. If you have ideas for features, drop them in the comments below — I read every one! 👇

🎮 What I Learned Building a Minecraft Voting Portal with Pure HTML, CSS & JS (No Frameworks!)

Ashan_Dev — Sun, 15 Mar 2026 01:50:54 +0000

I'm a student developer from Karachi, Pakistan 🇵🇰 — studying at APTECH and building real projects to level up my skills. This one started as a fun side project for a Minecraft server community called HustlersMC and turned into one of the biggest learning experiences of my journey so far.

No React. No Vue. No Tailwind. Just pure HTML, CSS, and JavaScript — and way more depth than I expected.

Here's everything I genuinely learned. 👇

🤔 Why Build a Voting Portal?

Minecraft servers live and die by their ranking on voting sites like Planet Minecraft and Minecraft Server List. The more players vote, the higher the server ranks, the more new players join.

Most voting portals out there are ugly, slow, or just a boring list of links. I wanted to build something that actually made players want to vote — something that felt premium, fast, and exciting the moment you landed on it.

That became Vote-for-HustlersMC.

✨ What I Built

Here's the feature list at a glance:

🪟 Glassmorphism UI — frosted glass cards, layered transparencies, depth without weight
✍️ Typewriter text effects — dynamic headlines that animate on load
🌌 Animated backgrounds — subtle motion that brings the page to life
🔗 10+ verified voting platforms integrated in one place
📈 SEO-ready structure — meta tags, semantic HTML, Open Graph
📊 Analytics-ready — plug in your tracking ID and you're live
♿ Accessibility-first — keyboard navigable, proper contrast, ARIA labels

And it runs on zero dependencies. No npm. No build step. Just open index.html.

💡 Lesson 1: Pure CSS Can Do Incredible Things

I went into this thinking I'd need a CSS framework to pull off the glassmorphism look. I was wrong.

The glass card effect is just a few lines:

.glass-card {
  background: rgba(255, 255, 255, 0.08);
  backdrop-filter: blur(16px);
  -webkit-backdrop-filter: blur(16px);
  border: 1px solid rgba(255, 255, 255, 0.15);
  border-radius: 16px;
  box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
}

That's it. backdrop-filter: blur() is the magic. It blurs everything behind the element, creating that frosted glass illusion.

What I learned: Before reaching for a framework, ask yourself — can CSS do this natively? More often than not, the answer is yes. Frameworks add weight. Native CSS adds nothing.

💡 Lesson 2: The Typewriter Effect Taught Me JavaScript Timing

The animated typewriter headline was something I'd seen on hundreds of sites but never built myself. I assumed it required a library. It doesn't.

Here's the core logic I wrote:

const phrases = [
  "Vote. Rise. Conquer.",
  "Support HustlersMC Today.",
  "Every Vote Counts. ⚔️"
];

let phraseIndex = 0;
let charIndex = 0;
let isDeleting = false;

function typeWriter() {
  const current = phrases[phraseIndex];
  const displayed = isDeleting
    ? current.substring(0, charIndex--)
    : current.substring(0, charIndex++);

  document.querySelector('.typewriter').textContent = displayed;

  if (!isDeleting && charIndex === current.length) {
    setTimeout(() => isDeleting = true, 1500); // pause before deleting
  } else if (isDeleting && charIndex === 0) {
    isDeleting = false;
    phraseIndex = (phraseIndex + 1) % phrases.length;
  }

  setTimeout(typeWriter, isDeleting ? 60 : 100);
}

typeWriter();

What I learned: setTimeout recursion is incredibly powerful for animations. Understanding the difference between typing speed (100ms) and deletion speed (60ms) is what makes it feel human. Small timing details create big UX impact.

💡 Lesson 3: SEO Is Not Just for Big Websites

This one surprised me most. I thought SEO was something you worry about when you have a blog or a business. But even a simple static page benefits enormously from it.

I added:

<!-- Basic SEO -->
<meta name="description" content="Vote for HustlersMC — the fastest growing Minecraft server in Pakistan. Support us on 10+ platforms!">
<meta name="keywords" content="HustlersMC, Minecraft server, vote, Pakistan Minecraft, server ranking">

<!-- Open Graph for social sharing -->
<meta property="og:title" content="Vote for HustlersMC 🎮">
<meta property="og:description" content="Click to vote and help us climb the rankings!">
<meta property="og:image" content="https://yoursite.com/preview.png">
<meta property="og:type" content="website">

<!-- Semantic HTML -->
<main>, <section>, <article>, <nav>, <footer>

The moment I shared the link on Discord, the Open Graph preview card showed up beautifully — the server logo, title, and description. Players were more likely to click it. The server's visibility on Google improved too.

What I learned: Semantic HTML + meta tags = free marketing. It costs you 10 minutes and pays back for months.

💡 Lesson 4: Animated Backgrounds Are About Restraint, Not Complexity

My first attempt at the animated background was too intense — particles flying everywhere, colors shifting rapidly. It looked like a nightclub, not a website.

The version I shipped uses a subtle CSS keyframe animation:

@keyframes gradientShift {
  0%   { background-position: 0% 50%; }
  50%  { background-position: 100% 50%; }
  100% { background-position: 0% 50%; }
}

body {
  background: linear-gradient(135deg, #0f0c29, #302b63, #24243e);
  background-size: 300% 300%;
  animation: gradientShift 8s ease infinite;
}

Slow. Smooth. Atmospheric. It adds life without distracting from the content.

What I learned: Great animation is mostly about what you don't do. Subtlety wins. If users notice the animation more than the content, you've gone too far.

💡 Lesson 5: Building for a Real Community Changes Everything

This wasn't a practice project for a fake client. Real players from HustlersMC were going to use this. That pressure made me:

Test on mobile obsessively (most Minecraft players are on phones between sessions)
Check contrast ratios for accessibility
Make sure every voting link opened correctly in a new tab
Add a smooth loading state so it didn't flash unstyled content (FOUC)

I also integrated Google Analytics so the server owner could see which voting platforms were being used most and which players were dropping off. That turned a static page into an actual growth tool.

What I learned: Building for real users forces you to care about details you'd ignore in a tutorial. Ship something real as early as possible — even if it's small.

🛠️ The Tech Stack (Zero Dependencies)

What	How
Structure	Semantic HTML5
Styling	Pure CSS3 (glassmorphism, keyframe animations, CSS variables)
Interactivity	Vanilla JavaScript (typewriter, scroll effects)
SEO	Meta tags, Open Graph, semantic markup
Analytics	Google Analytics (plug-and-play)
Hosting	GitHub Pages (free, instant)

No npm. No node_modules. No build pipeline. Just files.

🚀 The Result

A voting portal that looks like it cost money to build — but didn't. Players actually commented on how clean it looked. The server owner could share the link anywhere and it looked professional on every platform.

You can explore the full source code here 👇

🔗 GitHub: github.com/itxashancode/Vote-for-HustlersMC

💬 What Would You Build Next?

I'm currently exploring:

Adding a live vote counter with localStorage
A leaderboard showing top voters of the month
A Discord webhook that pings the server when someone votes

If you've built something for a game community — or if you're curious about any of the techniques above — drop a comment below! I'd love to see what you're working on. 🎮

If this helped you, consider giving the repo a ⭐ — it genuinely means a lot to a student developer from Pakistan trying to make his mark!

🐍 5 Python Scripts Every Student Dev Should Automate First

Ashan_Dev — Fri, 13 Mar 2026 16:04:02 +0000

I'm a student dev from Karachi. No internship. No senior to guide me.
Just a laptop, Python, and a habit of automating everything that bored me twice.
Here's what I wish I had automated sooner.

1. 🔁 Auto-Rename & Organize Your Downloads Folder

Your downloads folder is a graveyard. Fix it in 15 lines.

import os
import shutil

FOLDER = os.path.expanduser("~/Downloads")
TYPES = {
    "Images": [".jpg", ".jpeg", ".png", ".gif", ".webp"],
    "Docs":   [".pdf", ".docx", ".txt", ".xlsx"],
    "Code":   [".py", ".js", ".ts", ".html", ".css"],
    "Videos": [".mp4", ".mov", ".mkv"],
    "Zips":   [".zip", ".rar", ".tar"],
}

for file in os.listdir(FOLDER):
    ext = os.path.splitext(file)[1].lower()
    for folder, exts in TYPES.items():
        if ext in exts:
            dest = os.path.join(FOLDER, folder)
            os.makedirs(dest, exist_ok=True)
            shutil.move(os.path.join(FOLDER, file), dest)

Run it once a week with Task Scheduler (Windows) or a cron job. You'll feel like a wizard.

2. 📸 Bulk Screenshot → PDF Converter

Got lecture slides scattered as screenshots? Merge them into one PDF instantly.

from PIL import Image
import os

def screenshots_to_pdf(folder, output="merged.pdf"):
    images = sorted([
        Image.open(os.path.join(folder, f)).convert("RGB")
        for f in os.listdir(folder)
        if f.endswith((".png", ".jpg", ".jpeg"))
    ], key=lambda x: x.filename)

    images[0].save(output, save_all=True, append_images=images[1:])
    print(f"✅ Saved: {output}")

screenshots_to_pdf("./slides")

Install: pip install Pillow

This saved me hours before exams. Seriously.

3. 🔔 Desktop Notifier for Any Website Change

Watching for a job post? A price drop? A new batch opening?
Stop refreshing. Let Python do it.

import requests
import hashlib
import time
from plyer import notification

URL = "https://example.com/jobs"  # replace with your target
CHECK_EVERY = 300  # seconds

def get_hash(url):
    r = requests.get(url, timeout=10)
    return hashlib.md5(r.text.encode()).hexdigest()

last = get_hash(URL)
print("👁️ Watching for changes...")

while True:
    time.sleep(CHECK_EVERY)
    current = get_hash(URL)
    if current != last:
        notification.notify(title="🚨 Page Changed!", message=URL, timeout=10)
        last = current

Install: pip install requests plyer

Set it, forget it, get notified.

4. 📂 Auto-Backup Your Projects to a Zip

Before you break something (you will), back it up.

import zipfile
import os
from datetime import datetime

def backup_project(source_dir, output_dir="./backups"):
    os.makedirs(output_dir, exist_ok=True)
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    zip_name = os.path.join(output_dir, f"backup_{timestamp}.zip")

    with zipfile.ZipFile(zip_name, "w", zipfile.ZIP_DEFLATED) as zf:
        for root, dirs, files in os.walk(source_dir):
            dirs[:] = [d for d in dirs if d not in ["node_modules", ".git", "__pycache__"]]
            for file in files:
                filepath = os.path.join(root, file)
                zf.write(filepath, os.path.relpath(filepath, source_dir))

    print(f"✅ Backup saved: {zip_name}")

backup_project("./my-project")

Notice: it skips node_modules, .git, and __pycache__ — so the zip stays small.

5. 🤖 GitHub Auto-Commit Streak Keeper

Missing a day on your contribution graph hurts.
This script makes a tiny commit so your streak stays alive when life gets in the way.

import subprocess
from datetime import datetime

LOG_FILE = "streak.log"

with open(LOG_FILE, "a") as f:
    f.write(f"streak kept: {datetime.now()}\n")

subprocess.run(["git", "add", LOG_FILE])
subprocess.run(["git", "commit", "-m", f"chore: streak {datetime.now().date()}"])
subprocess.run(["git", "push"])
print("✅ Streak alive!")

Set this on a cron job at 11:50 PM. Sleep peacefully.

⚠️ Use on a personal/practice repo — not your main project.

🎯 Quick Recap

#	Script	What It Solves
1	Downloads Organizer	Chaos in your folders
2	Screenshots → PDF	Messy lecture notes
3	Website Change Notifier	FOMO on opportunities
4	Project Backup	That "oh no" moment
5	Streak Keeper	GitHub anxiety

💬 Drop Your Script in the Comments

What's the first thing YOU automated as a student dev?
I'm building a list — your script might end up in part 2. 👇

Built in Karachi. Tested at 2am. Working on more automation tools at github.com/itxashancode

I Have 18 GitHub Repos at 17 — Here's What I Built, Broke, and Learned

Ashan_Dev — Thu, 12 Mar 2026 23:42:21 +0000

When I joined GitHub, I didn't have a plan.

I just started building things — some useful, some broken, some embarrassing.
But 18 repositories later, I've learned more from pushing code than from any tutorial.

Here's an honest breakdown of what I built, what flopped, and what actually taught me something real.

🦈 The One That Started Everything: Pull Shark Automation

Automate GitHub PR creation at scale — 62 PRs/min with Python

This was my first "real" project. I wanted the GitHub Pull Shark badge, but doing it manually was painfully slow. So I automated it.

What it does:

Dual modes: Sequential (stable) and Parallel (blazing fast async)
Multi-token rotation to stay within rate limits
Auto-merge, Discord/Slack webhooks, proxy support
Windows compatible

# Sequential mode
python main.py

# Parallel mode (fast)
python parallel_automation.py --count 100 --concurrent 10

# Test without committing
python main.py --dry-run

Real-world result: 62.5 PRs/min with 3 tokens and 20 parallel workers.

⚠️ Built for learning and CI/CD stress testing. Use responsibly.

🔗 Pull-Shark-Automation on GitHub — drop a ⭐ if it helps!

🤝 Pair Extraordinaire — Automating Co-Author Badges

After Pull Shark, I went after the Pair Extraordinaire badge.
Same idea — understand how GitHub's contribution system works by building around it.

This one taught me:

How Git co-authoring actually works under the hood
Managing multiple identities in commits
Token scoping and permission management

🔗 Pair-Extraordinaire on GitHub — drop a ⭐ if it helps!

💡 What 18 Repos Actually Taught Me

1. READMEs matter more than code quality at first

Nobody digs into your code on first impression. They read your README.
Write it like you're explaining to a smart friend who's never seen your project.

2. Stars don't validate you — but they do signal clarity

Pull Shark got 27 stars in a week not because the code was perfect,
but because the README was clear and the use case was specific.

3. Broken repos are fine. Abandoned repos are not.

I have repos I haven't touched in weeks. That's okay.
What's not okay is leaving them with no description, no README, no context.
Even a one-liner description helps someone understand what you were thinking.

4. Your GitHub is a portfolio before you have a portfolio

I don't have a deployed portfolio site yet (it's in progress 👀).
But recruiters and collaborators can still see exactly what I can do
by looking at my repos. Treat every repo like a mini-resume.

5. Committing consistently beats committing perfectly

Green squares on your contribution graph tell a story.
Don't wait until your code is "ready." Push early, push often.

🛠️ My Current Stack Across All Projects

Language/Tool	Used For
Python	Automation, scripting, GitHub tools
JavaScript / TypeScript	Web apps, frontend logic
React + Next.js	UI, full stack projects
Node.js	Backend, API building
Firebase	Auth, real-time DB
HTML + CSS	Foundations, landing pages

🔭 What I'm Building Next

Personal portfolio site with Next.js (almost done)
AI-powered web app integrating Claude / OpenAI APIs
More open source tools for developers

🤙 Let's Connect

If you're a dev from Pakistan, a beginner just starting out,
or someone who loves building weird automation tools — let's connect.
Drop a comment, follow along, or check out my repos.

📦 GitHub → itxashancode
🌐 Linktree → itxashanvibes

What was your first GitHub repo? Drop it in the comments 👇

🤝 Automate GitHub's Pair Extraordinaire Badge with Python

Ashan_Dev — Wed, 11 Mar 2026 10:13:57 +0000

A deep dive into Pair Extraordinaire Automation — a Python framework that streamlines co-authored PRs at scale, with dual execution modes, token rotation, webhook notifications, and smart state resumption.

🔗 Full source code on GitHub: Pair-Extraordinaire — drop a ⭐ if it helps!

Ever wondered how some developers rack up GitHub achievement badges at scale? Or wanted to deeply understand how GitHub co-authoring workflows actually function under the hood? That's exactly what Pair Extraordinaire Automation is built for.

This open-source Python framework automates co-authored Pull Request workflows — giving you a hands-on way to explore GitHub API integration, token management, webhook notifications, and stateful automation design, all in one project.

⚠️ Heads up: This tool is built for educational purposes — to study GitHub automation and co-authoring patterns. Always use it responsibly and in line with GitHub's Terms of Service.

🏆 What Is the Pair Extraordinaire Badge?

GitHub awards the Pair Extraordinaire achievement when you co-author and merge Pull Requests with a collaborator. The badge has four tiers:

Tier	Required PRs
Default	1 PR
🥉 Bronze	10 PRs
🥈 Silver	24 PRs
🥇 Gold	48 PRs

The magic happens through Git's Co-authored-by commit trailer — a simple but powerful convention that GitHub recognises to credit multiple authors on a single commit.

🎯 What Does This Project Do?

Pair Extraordinaire Automation is a configurable Python framework that:

Creates branches, makes co-authored commits, opens Pull Requests, and merges them — all automatically
Supports sequential and parallel execution modes
Handles rate limits with exponential backoff and smart retry logic
Rotates across multiple GitHub tokens for higher throughput
Sends real-time progress updates to Discord or Slack via webhooks
Persists state so you can resume after any interruption
Includes a dry-run mode for testing without touching your repository

🏗️ Architecture Overview

The project is cleanly structured into four layers:

Pair Extraordinaire Automation
│
├── run.py              ← Entry point & orchestrator
├── src/                ← Core bot logic (git ops, GitHub API, token mgr)
├── config/             ← JSON settings + .env variables
└── templates/          ← Commit message & PR body templates

The orchestration flow looks like this:

Start → Load Config → Choose Mode (Sequential / Parallel)
      → Create Branch → Co-authored Commit → Push → Open PR
      → Auto-Merge → Save State → Notify → Repeat

What I like about this design is its clear separation of concerns. The src/ layer handles all Git and GitHub API interactions, while config/ and templates/ let you customise behaviour without touching any core logic.

⚙️ Getting Started

Prerequisites

You'll need Python 3.8+, Git 2.0+, and the GitHub CLI installed. You also need two GitHub accounts — your own and a collaborator's.

Installation

# Clone the repo
git clone https://github.com/itxashancode/Pair-Extraordinaire-Automation.git
cd Pair-Extraordinaire-Automation

# Install dependencies
pip install -r requirements.txt

# Authenticate GitHub CLI
gh auth login

Configuration

Copy .env.example to .env and fill in your details:

GITHUB_TOKEN=your_personal_access_token
REPO_OWNER=your_github_username
REPO_NAME=your_repository_name

CO_AUTHOR_NAME=Collaborator Name
CO_AUTHOR_EMAIL=collaborator@email.com
CO_AUTHOR_TOKEN=collaborator_token_optional

# Optional webhooks
DISCORD_WEBHOOK=https://discord.com/api/webhooks/...
SLACK_WEBHOOK=https://hooks.slack.com/services/...

Then set your run parameters in config/:

{
  "pr_count": 50,
  "delay_seconds": 15,
  "auto_merge": true,
  "dry_run": false,
  "max_retries": 3
}

🚀 Usage

Always test first with dry-run

python run.py --dry-run --count 5

This simulates the full workflow — branch creation, commits, PRs — without making any real changes. It's a great way to catch config mistakes before they matter.

Run for real

# Basic run (uses config defaults)
python run.py

# Custom count with specific delay
python run.py --count 50 --delay 10

# Resume after an interruption — state is automatically tracked
python run.py

Sample output

🚀 Starting Pair Extraordinaire Automation from PR #1

🔹 Processing PR #1
  ├─ 🌿 Created branch: pair-auto-1-a1b2c3d4
  ├─ 💾 Committed with Co-authored-by trailer
  ├─ 📤 Pushed to remote
  └─ ✅ PR #101 created and merged

⏱️  Waiting 15 seconds...

🔹 Processing PR #2
...

🔑 The Co-authored-by Mechanic

The key to how this project works is a Git commit trailer that GitHub specifically recognises:

feat: automated update #1

This is an automated co-authored commit.

Co-authored-by: Collaborator Name <collaborator@email.com>

When a PR containing this trailer is merged, GitHub awards the Pair Extraordinaire badge to both the author and the co-author. The email in the trailer must match an email associated with the collaborator's GitHub account — that's a common gotcha.

🛡️ Security Considerations

A few things to keep in mind when running this:

Never commit your .env file — it's already in .gitignore, keep it that way
Use fine-grained personal access tokens scoped to specific repos only
Rotate tokens every 30–90 days as a good hygiene practice
Monitor your rate limit with gh api rate_limit — you get 5,000 requests/hour per token, and multi-token rotation lets you stack that

🐛 Common Issues

gh: command not found → Install GitHub CLI for your platform and verify with gh --version

Authentication failed → Run gh auth login and follow the prompts, or use echo "TOKEN" | gh auth login --with-token

Co-authored-by not recognized → Double-check that CO_AUTHOR_EMAIL exactly matches an email registered on the collaborator's GitHub account

API rate limit exceeded → Increase delay_seconds in config, or add a second token for rotation

📈 Real-World Benchmarks

Badge Goal	PRs	Approx. Time
Default	2	~30 seconds
Bronze	10	~3 minutes
Silver	24	~5 minutes
Gold	48	~10 minutes

💡 What I Learned Building This

This project is a great reference for several Python and GitHub automation patterns:

Stateful automation — persisting progress to a JSON file so a long-running task can be safely interrupted and resumed
Exponential backoff — retry logic that doubles the wait time on each failure (5s → 10s → 20s) to avoid hammering a rate-limited API
Token rotation — cycling through multiple API tokens to multiply your effective request quota
Template-based commit messages — separating message content from code so customisation doesn't require touching logic
Webhook integration — pushing structured notifications to Discord/Slack with colour-coded severity levels

Even if you never use this for badge automation specifically, these patterns come up constantly in real-world automation and DevOps work.

🤝 Contributing

The project is MIT licensed and welcomes contributions. If you want to jump in:

gh repo fork itxashancode/Pair-Extraordinaire-Automation
git checkout -b feature/your-improvement
# Make changes, commit with conventional commits
git commit -m "feat: add your amazing feature"
gh pr create

The codebase follows type hints and clear docstrings — black for formatting, flake8 for style, mypy for type checking.

🔗 Links

📦 GitHub Repo: itxashancode/Pair-Extraordinaire-Automation
👤 Author: @itxashancode
🌐 More from the author: linktr.ee/itxashanvibes

If you found this interesting, drop a ⭐ on the repo and let me know in the comments — what GitHub automation patterns have you built or wanted to build?

I'm a Self-Taught Dev from Pakistan — Here's What My First 6 Months Looked Like

Ashan_Dev — Thu, 05 Mar 2026 16:37:40 +0000

"Everyone talks about learning to code. Nobody talks about learning to code when resources cost money you don't have, and people around you don't understand why you're staring at a screen at 2 AM."

I'm Ashan — a student at APTECH Pakistan and an aspiring full stack developer. This is my honest, unfiltered story.

📅 Month 1–2: HTML & CSS (The Honeymoon Phase)

I started the way everyone does — building a portfolio page that looked nothing like what I imagined.

I spent 3 hours trying to center a div. No joke.


Please just center



  Finally.

The lesson? Everyone struggles with CSS at first. It's not you — it's the box model.

⚡ Month 3–4: JavaScript Hit Different

HTML/CSS felt visual and rewarding. JavaScript felt like being handed a book written in a language I'd never seen.

// My first real "aha" moment
const greet = (name) => `Hello, ${name}! You can actually code.`;
console.log(greet("Ashan")); 
// → Hello, Ashan! You can actually code.

The moment functions clicked for me, everything changed. I started building small projects:

✅ A to-do app
✅ A quiz game
✅ A basic calculator

None of them were pretty. All of them taught me something.

🔥 Month 5–6: React & The Real World

React blew my mind. Components, state, props — it felt like thinking in building blocks.

function WelcomeCard({ name }) {
  return (

      Welcome, {name}! 👋
      You're building something real.

  );
}

export default WelcomeCard;

The mental shift from "writing HTML" to "composing UI" was huge.

💡 3 Things Nobody Told Me

1. You will Google everything — and that's completely normal

Senior devs do it too. The skill isn't memorizing syntax. It's knowing what to search for.

2. Build ugly projects first

Pretty comes with practice. Shipping something broken teaches you more than planning something perfect.

3. Your background doesn't disqualify you

It's your superpower story. Developers from non-traditional backgrounds bring perspectives the industry desperately needs.

📊 My Honest Progress Chart

Month	Focus	Feeling
1	HTML basics	🤩 Excited
2	CSS layouts	😤 Frustrated
3	JS fundamentals	😵 Confused
4	JS projects	😤→😊 Getting it
5	React intro	🤯 Mind blown
6	React + Firebase	🔥 Building real things

🚀 What's Next for Me

I'm now diving into:

Next.js — for server-side rendering and full stack apps
Firebase — for auth, databases, and real-time features
AI integrations — because that's where the web is going

The journey is far from over — but I'm proud of how far I've come from that mis-centered div.

💬 If you're starting — what's the hardest thing you've hit so far? Drop it in the comments. Let's figure it out together. 👇