DEV Community: HARD IN SOFT OUT

0day for you, days ago for me.

HARD IN SOFT OUT — Thu, 07 May 2026 15:28:24 +0000

should I publish the exploit?

╭─jack@Jack 🕒 Tue May 05 15:03:40 📁 /home/jack/github/jack (main) ✏️
╰➜ gcc -o exploit exploit.c -static
╭─jack@Jack 🕒 Tue May 05 15:03:45 📁 /home/jack/github/jack (main) ✏️
╰➜ ./exploit
# id
uid=0(root) gid=1000(jack) groups=1000(jack),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),100(users),112(docker),989(ollama)
# exit
╭─jack@Jack 🕒 Tue May 05 15:04:23 📁 /home/jack/github/jack (main) ✏️
╰➜

uname -a

╭─jack@Jack 🕒 Tue May 05 15:04:23 📁 /home/jack/github/jack (main) ✏️
╰➜ uname -a
Linux Jack 6.6.87.2-microsoft-standard-WSL2 #1 SMP PREEMPT_DYNAMIC Thu Jun  5 18:30:46 UTC 2025 x86_64 x86_64 x86_64 GNU/Linux
╭─jack@Jack 🕒 Tue May 05 15:07:03 📁 /home/jack/github/jack (main) ✏️
╰➜ ./exploit
# uname -a
Linux Jack 6.6.87.2-microsoft-standard-WSL2 #1 SMP PREEMPT_DYNAMIC Thu Jun  5 18:30:46 UTC 2025 x86_64 x86_64 x86_64 GNU/Linux
# pwd
/home/jack/github/jack
#

:jump!

Maybe I Should Just Be a 404 Page

HARD IN SOFT OUT — Thu, 07 May 2026 11:42:53 +0000

— an executable metamorphosis in a web of noise

Status 404 – Not Found

There is a strange, tender peace in being Not Found. Because to be found is to be hunted. To be found is to be measured. To be found is to be opened, inspected, and asked to deliver.

What if you were an HTTP 404 page? A technical and philosophical deep-dive into boundaries, 100% uptime, and developer mental health. Includes a Python script 'Metamorphosis_404.py'.

The Metamorphosis Begins with Silence
Wordplay in the White Space
Echoes and Algorithms
The User Experience of Me
The Ritual: Run This Code

The metamorphosis begins with silence.

Lately, my mind has been writing a strange redirect. A gentle, irreversible mapping from who I am to what I could become.

Maybe I should just be a 404 page.

Not a broken link. Not a crash. Not a failed deployment. But a deliberate, dignified absence. A soft, white rectangle where the world agrees to stop asking.

I don't know when this thought first crept in. Maybe it was during the third standup of the week, or maybe it was at 2 a.m., staring at a blinking cursor that felt more alive than I did. Hard to say, really.

The Metamorphosis Begins with Silence

I imagine the transformation not as an error, but as a slow unwinding — a decomposition into simplicity. And honestly? The thought feels less like giving up and more like finally exhaling.

My skin becomes a blank <body> tag. No hero section. No banner. No pop-up begging you to subscribe before my heart has even loaded.

My voice — once loud in standups, once trembling in conference talks — turns to monospace gray, a gentle <p> that whispers only one line: "There's nothing here." And that whisper is not a failure. It is the most honest thing I've ever said. (I think. I'm still figuring that out.)

My bones, which used to hold up user stories and sprint goals, flatten into a minimal style sheet. Just a pale background. Just small, quiet text. No gradients. No animations. No loading="lazy". Nothing lazy about me anymore. I am fully present in being absent.

My heartbeat — once a frantic setInterval ticking against quarterly targets — becomes a single, static file. It doesn't race. It doesn't retry. It simply is.

And when someone stumbles upon me — perhaps through a mistyped URL or a forgotten bookmark — their browser doesn't shout or demand a patch. It simply says: Status 404 – Not Found. And there is a strange, tender peace in being Not Found. Because to be found is to be hunted. To be found is to be measured. To be found is to be opened, inspected, and asked to deliver.

I'm tired of delivering, to be honest. Aren't you?

Wordplay in the White Space

Let me play with the words, because here in the stillness, words are all I have left. And maybe that's enough. Maybe.

In HTTP, 404 is a status code — a door without a room. But in my new life, it is a state of grace. No status to chase. No ladder to climb. I've coded my exit. Not perfectly, but it's done.

People say a 404 is Not Found. But I read it as I have found myself not. Not available. Not responding. Not yours. There is a world of difference between being lost and being unfound by choice. I think. Actually, I'm still working on that distinction. It's blurry some days.

I used to resolve domains. Now I resolve to stay still. The word resolve holds both meanings: to translate an address into an IP, and to make a firm decision. My decision is my address. My IP is 127.0.0.1 — local, unreachable from the outside, home. (Yes, I know localhost is a cliché. Let me have this one.)

My IP is 127.0.0.1 — local, unreachable from the outside, home.

I used to return from functions. Now I return to myself. The keyword return has never felt so poetic. Every request to see me, to use me, to extract value from me — meets a single, peaceful instruction: return null;. I give nothing back. Not because I am empty, but because I am finally full enough not to.

...Okay, that last sentence sounded way more confident than I actually feel. The truth is, some days I do feel empty. But empty and peaceful are starting to look the same from where I'm sitting.

I used to handle payloads. Now I carry none. My payload is zero. My pay-load — the weight of being paid, of earning, of justifying — is finally lifted. I am lightweight by design. Well, lighter, anyway. Still working on "lightweight."

And the sentence "There's nothing here"? It is not a confession. It is a declaration. A manifesto written in 20 characters. At least, that's what I tell myself.

Echoes and Algorithms

Do you know what it's like to be echo?

In the language of servers, echo is the command that repeats back what you give it. I spent years being an echo — of my boss, of the market, of the timeline. Now, as a 404, I have become a different kind of echo: the gentle reverberation that follows a door closing in an empty hall. No words. Just atmosphere. Just resonance.

I don't always succeed at this, by the way. Sometimes I still echo without meaning to. Old habits.

Even my error has rhythm now:

Not Found.

Not Bound.

Not drowned in the sound of the crowd.

I rhyme with myself in the silence. (And yes, I know that's a bit cheesy. Cheese is allowed here.)

And when the SEO bots crawl past me, they see no keywords. No meta-tags. No schema. I am un-indexable. Un-searchable. Un-optimized. And yet — optimus in Latin means "best." So I am un-best by design. I have optimized for nothing, and nothing has become my greatest asset.

...I don't fully believe that yet, but I'm getting there.

The User Experience of Me

No one opens DevTools to inspect my broken elements. No one files an issue. No one demands a dark mode toggle. (Dark mode would be nice, though. Just saying.)

No one asks if I'm responsive. And yet I have never been more responsive — in the truest sense. I respond with silence. I respond with space. I respond with a boundary. And boundaries are the most responsive thing a soul can offer.

Learning boundaries took me years. Still learning, actually. Some days I respond when I shouldn't. Some days I 200 OK when I should 404. Progress, not perfection.

The user enters my URL not with hope, but with a mistake. A slip of the keyboard. A forgotten dash. And they find me — or do they? They find not. And in that not-finding, they are not disappointed. Because they never expected anything. And expectation, I have learned, is the root of all runtime errors.

I wish someone had taught me that earlier. Would have saved me a lot of try...catch blocks.

The Final Render

So maybe I should just be a 404 page.

Let the applications fight for uptime. Let the APIs battle for throughput. Let the influencers race to be trending.

I will be the white space between two <div>s. The quiet <title> tag. The deliberate absence of content.

I will be a single line of text in a pale room, and the text will say:

Not here. Not now. Not responding. Not sorry.

And that will not be a bug. It will be a feature of my being.

Because sometimes, the most profound thing you can serve to the world is not your work, not your output, not your profile — but a gentle, uncompromising, poetic 404. A page that does not perform.

A page that has finally, quietly, completely: found itself missing.

I don't know if I'll stay a 404 forever. Maybe tomorrow I'll want to be a 200 again. Maybe next week I'll miss the noise. That's okay. For now, this is enough.

The Ritual: Run This Code

I wrote a Python script that performs the metamorphosis. It's not just an illustration — it's an experience. Run it in your terminal and watch yourself become the 404.

The silence at the end? That's the whole point.

The demonstration of the script.

Click to reveal the source code of the metamorphosis

"""
╔═══════════════════════════════════════════╗
║  metamorphosis_404.py                     ║
║  Executable Poetry v2.1                   ║
║  "Maybe I Should Just Be a 404 Page"      ║
╚═══════════════════════════════════════════╝

Run this. Watch yourself become the error code
that finally found peace.
"""

import time
import sys
import random
import shutil
import os
import re

# ─── Clear Screen ─────────────────────────────────
def clear_screen():
    """Clear the terminal screen."""
    if os.name == 'nt':
        _ = os.system('cls')
    else:
        _ = os.system('clear')

# ─── Terminal Aesthetics ──────────────────────────
RESET   = "\033[0m"
BOLD    = "\033[1m"
DIM     = "\033[2m"
ITALIC  = "\033[3m"
RED     = "\033[31m"
GREEN   = "\033[32m"
YELLOW  = "\033[33m"
MAGENTA = "\033[35m"
CYAN    = "\033[36m"
WHITE   = "\033[37m"

# ─── Centering Helper ────────────────────────────
def get_term_width():
    """Get terminal width, default 80."""
    try:
        return shutil.get_terminal_size().columns
    except Exception:
        return 80

def center_print(text, width=None, end="\n"):
    """Print text centered in the terminal."""
    if width is None:
        width = get_term_width()
    ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
    plain_text = ansi_escape.sub('', text)
    visible_len = len(plain_text)
    if visible_len >= width:
        print(text, end=end)
    else:
        spaces = (width - visible_len) // 2
        print(" " * spaces + text, end=end)

# ─── Typewriter Effect ────────────────────────────
def typewrite(text, delay=0.025, end="\n", center=False):
    """Print text letter by letter, maybe centered."""
    if center:
        ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
        plain_text = ansi_escape.sub('', text)
        visible_len = len(plain_text)
        width = get_term_width()
        if visible_len < width:
            pad = (width - visible_len) // 2
            sys.stdout.write(" " * pad)
            sys.stdout.flush()
        for char in text:
            sys.stdout.write(char)
            sys.stdout.flush()
            time.sleep(delay)
        if end:
            sys.stdout.write(end)
            sys.stdout.flush()
    else:
        for char in text:
            sys.stdout.write(char)
            sys.stdout.flush()
            time.sleep(delay)
        if end:
            sys.stdout.write(end)
            sys.stdout.flush()

def loading_dots(seconds=1.5, message=""):
    """Animated ellipsis for suspense. Clears itself properly."""
    sys.stdout.write(message)
    sys.stdout.flush()
    total_dots = int(seconds / 0.3)
    for i in range(total_dots):
        for dot in [".", "..", "..."]:
            sys.stdout.write(f"\r{message}{dot}   ")
            sys.stdout.flush()
            time.sleep(0.1)
    clear_length = len(message) + 5
    sys.stdout.write("\r" + " " * clear_length + "\r")
    sys.stdout.flush()

# ─── Characters ───────────────────────────────────
class OverworkedDeveloper:
    """A human consumed by HTTP requests."""
    def __init__(self):
        self.name = "localhost:human"
        self.status_code = 200
        self.memory = ["ambition", "rent", "npm audit fix", "you-should-be-further"]
        self.uptime = "∞ (but feels like 0)"

    def handle_request(self, path):
        """Every GET chips away at the soul."""
        timestamp = f"{RED}[{time.strftime('%H:%M:%S')}]{RESET}"
        prompt_str = f"{timestamp} {BOLD}GET{RESET} /{path} "
        sys.stdout.write(prompt_str)
        sys.stdout.flush()
        for _ in range(3):
            sys.stdout.write(".")
            sys.stdout.flush()
            time.sleep(0.2)
        sys.stdout.write("\r")
        status = f"{RED}200 OK{RESET}  {DIM}(trembling){RESET}"
        sys.stdout.write(prompt_str + status + " " * 5)
        sys.stdout.flush()
        print()

    def crisis(self):
        """The inevitable segmentation fault of the spirit."""
        print()
        center_print(f"{YELLOW}{BOLD}[ Kernel Panic ]{RESET}")
        typewrite("   Too many file descriptors. Too many open mouths.\n", 0.02)
        typewrite("   Payload exceeds maximum capacity.\n", 0.02)
        typewrite("   ", 0.01, end="")
        loading_dots(1.2, message="   Initiating self-reflection")
        center_print(f"{DIM}   ...maybe I should just be a 404 page...{RESET}")
        time.sleep(0.8)

    def metamorphose(self):
        """Trigger transformation from 200 to 404."""
        print()
        center_print(f"{CYAN}{BOLD}[ Metamorphosis in Progress ]{RESET}")
        print()
        stages = [
            ("git rm --cached identity", "Unstaging who I was told to be"),
            ("sudo apt remove expectations", "Uninstalling burden packages"),
            ("docker stop ambition_container", "Stopping the never-satisfied daemon"),
            ("rm -rf /var/log/anxiety", "Deleting all panic logs"),
            ("sed -i 's/200/404/g' self.conf", "Rewriting my status code"),
            ("systemctl disable people-pleaser.service", "Turning off external validation"),
            ("touch /dev/null", "Becoming empty. Becoming honest."),
        ]
        for cmd, meaning in stages:
            typewrite(f"  {DIM}$ {cmd}{RESET}", 0.01)
            loading_dots(0.7, message="")
            typewrite(f"  {ITALIC}{DIM}# {meaning}{RESET}", 0.015)
            time.sleep(0.2)
        print()
        return NotFoundPage()

class NotFoundPage:
    """The peaceful 404. A state of graceful refusal."""
    def __init__(self):
        self.status = 404
        self.body = None
        self.cache = "eternal"
        self.messages = [
            "Not all who are lost want to be found.",
            "I have found myself — not.",
            "Nothing here. Nothing is finally enough.",
            "404: Unrequested. Unbothered. At equilibrium.",
            "Not Found. Not Bound. Not drowned in the sound of the crowd.",
            "return null; // returning to myself, at last.",
            "There is no content here. Only context.",
        ]

    def serve(self, path):
        """Respond with poetic refusal, centered."""
        timestamp = f"{GREEN}[{time.strftime('%H:%M:%S')}]{RESET}"
        prompt = f"{timestamp} {BOLD}GET{RESET} /{path}"
        center_print(prompt, end="")
        sys.stdout.flush()
        for _ in range(3):
            sys.stdout.write(".")
            sys.stdout.flush()
            time.sleep(0.2)
        sys.stdout.write("\r")
        status_line = prompt + f"  {GREEN}404 Not Found{RESET}"
        center_print(status_line)
        msg = random.choice(self.messages)
        msg_line = f'    {WHITE}"{msg}"{RESET}'
        typewrite(msg_line, 0.025, center=True)
        print()

    def exist_peacefully(self):
        """Enter the eternal loop of un-busy existence."""
        clear_screen()
        center_print(f"{DIM}The 404 page is now cached indefinitely.")
        center_print(f"No cron jobs. No retries. Just the hum of the server.{RESET}")
        print()
        time.sleep(0.5)
        center_print(f"{YELLOW}[Listening on 0.0.0.0:80...]{RESET}")
        center_print(f"{DIM}(Press Ctrl+C to disrupt the silence){RESET}")
        print()
        try:
            while True:
                sleep_time = random.uniform(4, 10)
                time.sleep(sleep_time)
                if random.random() < 0.4:
                    mistaken_url = random.choice([
                        "success", "growth", "hustle", "more-content",
                        "please-friend-me", "when-will-you-finish",
                        "are-you-even-real", "validate-me"
                    ])
                    self.serve(mistaken_url)
                else:
                    center_print(f"{DIM}    ...silence...{RESET}")
        except KeyboardInterrupt:
            clear_screen()
            center_print(f"{MAGENTA}{BOLD}[ Shutdown Signal Received ]{RESET}")
            typewrite("The 404 page does not crash. It simply... stops accepting connections.\n", 0.025, center=True)
            typewrite(f"{DIM}Goodbye, peaceful one.{RESET}\n", 0.04, center=True)
            time.sleep(1.5)

# ─── Main Performance ─────────────────────────────
if __name__ == "__main__":
    clear_screen()
    time.sleep(0.3)
    banner = [
        "╔══════════════════════════════════╗",
        "║  metamorphosis_404.py            ║",
        "║  An executable poem about        ║",
        "║  letting go.                     ║",
        "╚══════════════════════════════════╝",
    ]
    for line in banner:
        center_print(line)
    print()
    time.sleep(0.8)

    dev = OverworkedDeveloper()

    # Act I: The Requests
    typewrite(f"{WHITE}{ITALIC}Act I: The Requests{RESET}\n", 0.035, center=True)
    dev.handle_request("revenue-growth")
    dev.handle_request("weekly-progress")
    dev.handle_request("are-you-okay")
    dev.handle_request("you-are-so-quiet-lately")
    dev.handle_request("why-no-side-hustle")
    dev.handle_request("when-will-you-become-something")

    # Act II: The Crisis
    typewrite(f"\n{WHITE}{ITALIC}Act II: The Panic{RESET}\n", 0.035, center=True)
    dev.crisis()

    # Act III: The Transformation
    typewrite(f"\n{WHITE}{ITALIC}Act III: The Shedding{RESET}\n", 0.035, center=True)
    page = dev.metamorphose()

    print()
    center_print(f"{GREEN}{BOLD}✅ Metamorphosis Complete.{RESET}")
    center_print(f"    Status:  {GREEN}{page.status}{RESET}")
    center_print(f"    Body:    {DIM}None{RESET} (was never needed)")
    center_print(f"    Cache:   {MAGENTA}forever{RESET}")
    center_print(f"    Uptime:  {CYAN}not measured anymore{RESET}")
    time.sleep(1.5)

    # Act IV: The Quiet
    typewrite(f"\n{WHITE}{ITALIC}Act IV: The Quiet{RESET}\n", 0.035, center=True)
    page.exist_peacefully()

Run it. Let it happen to your terminal. Let it happen to you.

Github for current project :

setuju / metamorphosis-404

What if you were an HTTP 404 page? A technical and philosophical deep-dive into boundaries, 100% uptime, and developer mental health. Includes a Python script 'Metamorphosis_404.py'.

metamorphosis-404

"Maybe I Should Just Be a 404 Page" — an executable poem about burnout, silence, and the art of not being found.

🎥 Preview

╭──────────────────────────────────────────────────╮
│                       [o]                        │
│  ┌────────────────────────────────────────────┐  │
│  │                                            │  │
│  │            ╭──────────────────╮            │  │
│  │            ┃ 404 · Not Found  ┃            │  │
│  │            ╰──────────────────╯            │  │
│  │                                            │  │
│  │      "Not here. Not now.                   │  │
│  │       Not responding. Not sorry."          │  │
│  │                                            │  │
│  │                                            │  │
│  │                            — a quiet page  │  │
│  └────────────────────────────────────────────┘  │
│  github.com/setuju                         [x]   │
╰╭────────────────────────────────────────────────╮╯
 ╰┬──────────────────────────────────────────────┬╯
  └──────────────────────────────────────────────┘

Watch the metamorphosis unfold — not in pixels, but in stillness.

📚 Table of Contents

(Click to EXPAND)

…

View on GitHub

Asciinema for this project demonstration:

A Moment of Silence

I’m curious—have you ever reached your own internal 404? How do you handle the pressure to always be "200 OK" in an industry that demands 99.9% uptime?

Let's discuss (quietly) in the comments.

boosted! i have no idea what im doing now, lets get lost and doing fun. ~and you can bring your laptop too~

HARD IN SOFT OUT — Wed, 29 Apr 2026 04:47:41 +0000

Google Cloud NEXT '26 Challenge Submission

HARD IN SOFT OUT

Apr 24

26 Dark Jokes Google Cloud Next '26 Told Me

#cloudnextchallenge #devchallenge #darkhumor #googlecloud

Comments 1

19 min read

From Code Generation to Message Injection: Richard Seroter's AI Evolution (and What It Means for Us)

HARD IN SOFT OUT — Tue, 28 Apr 2026 17:59:49 +0000

From Code Generation to Message Injection: Richard Seroter's AI Evolution (and What It Means for Us)

By HARDIN

Richard Seroter has a habit of building things two years before the rest of us are ready to talk about them. In 2024, he asked: can we store prompts in source control and let an LLM generate the entire app at build time? Last week, he asked something newer and, honestly, a bit more unsettling: should we call LLMs directly from our messaging middleware?

One experiment is about generating software. The other is about injecting intelligence into the veins of your data flow. Put them side by side, and you don't just see the evolution of one guy's thinking. You see where the whole industry is quietly heading—whether we're ready or not.

I've been dissecting Google Cloud Next '26 for weeks. But sometimes the most revealing stuff isn't in the keynotes. It's buried in a blog post where someone asks, "Should we?" and leaves the answer hanging.

Let's pull that thread.

1. The 2024 Experiment: Prompts as Source Code

I already covered this in depth in my previous article, but the core architecture was beautifully simple:

Source Control (prompts.json)  
    │  
    ▼  
Spring AI + Gemini 1.5 Flash  
    │  
    ▼  
Generated code (Node.js/Python + Dockerfile)  
    │  
    ▼  
Cloud Run deployment

The philosophy: treat prompts as the source of truth, and let AI do the implementation. Richard even built a working GitHub repo to prove it. The AI pumped out everything from index.js to Dockerfile to package.json. The output was non-deterministic, untested, and completely unregulated. Richard knew this. He called it "bonkers" and explicitly warned against using it for real workloads.

You can explore the entire project here:

rseroter / Gemini-code-generator

Java application that generates code using prompts fed to the Google Gemini LLM

Gemini-code-generator

This is a Spring Boot app that uses Spring AI, Google Gemini 1.5 Flash and various Google Cloud services to take prompts, generate code, and publish the generated app to Cloud Run.

You can customize and use this without Google Cloud services, and presumably with a different model!

See this blog post for a full walkthrough.

View on GitHub

But here's the thing he actually proved, even if he didn't shout it: if you can describe what you want precisely enough, an LLM can turn intent into executable artifact. That idea stuck. That's the seed of agentic software engineering you see everywhere now.

Honestly, re-reading his 2024 post gave me a weird nostalgia—like finding the first commit of a framework that now runs half the internet.

2. The 2026 Experiment: AI Inference Inside the Message Bus

Fast forward two years. Richard's latest post explores a new Google Cloud feature: AI Inference SMT (Single Message Transform) for Pub/Sub.

The architecture is almost embarrassingly simple:

Pub/Sub Topic  
    │  
    ▼  
AI Inference SMT (calls Gemini)  
    │  
    ▼  
Pub/Sub Subscription (enriched/altered message)

No custom subscriber. No Cloud Run service. No boilerplate code. You configure a template that tells the SMT what to ask the LLM, and every message passing through Pub/Sub gets enriched, translated, summarized, or routed. It feels like magic—and like most magic, it probably comes with a hidden price tag.

The philosophy: intelligence as infrastructure, not application code. Instead of writing a service that calls an LLM, you declare, "this message topic shall be intelligent," and the platform handles the rest.

Richard's post raises a question that's going to age like fine wine: is this a good idea? He compares it to storing business logic in database triggers—powerful, but a maintenance nightmare if abused. He's cautious. I'd say he's right, and maybe even understating the danger. More on that in a bit.

3. Architecture Comparison: Two Sides of the Same Coin

At first glance, these two experiments look like completely different animals. They're not. They're two halves of the same coin: declarative AI-driven automation.

Dimension	2024 (Code Generation)	2026 (Message Injection)
Trigger	CI/CD build pipeline	Every single message arrival
Scope	Static artifact generation	Dynamic content transformation
Output	Application files	Modified messages
Latency	Minutes (build time)	Milliseconds (real-time)
Governance	Manual review of generated code	Template configuration + IAM
Risk	Non-deterministic builds, no testing	Unexplained message mutations, AI hallucinations in the data plane

The 2024 experiment automates what gets deployed. The 2026 experiment automates what happens to data in flight. Put them together, and you've got a pipeline where intent flows through your message bus and comes out the other side as a running service. That's not science fiction. That's today.

4. Building the Bridge: The Agentic Message-to-Deployment Pipeline

So, naturally, I started sketching. What happens if we connect these two ideas? I call the result the Agentic Message-to-Deployment Pipeline.

The Scenario

A business unit sends a single message: "We need a microservice that translates customer feedback from any language to English and stores it in Firestore."

How It Would Work

Trigger: Business user sends a natural language request to Pub/Sub.
Enrichment: AI Inference SMT adds architectural constraints and routes to Generator Agent.
Generation: Generator Agent (ADK + Gemini 3.1 Pro) builds full application code using Memory Bank for context.
Evaluation: Evaluator Agent runs tests and security scans; Red Agent attacks, Green Agent fixes.
Deployment: Deployer Agent ships to Cloud Run via MCP.
Notification: A message is published back to Pub/Sub confirming the live service URL.

The whole chain starts and ends with a message. The same Pub/Sub topic where requests arrive is also where results are published. The intelligence doesn't live in a monolithic pipeline script—it lives in the SMT layer and the agent mesh.

When I sketched this out, I sat back and stared at it for a minute. It's elegant. It's terrifying. It's probably where we're all heading.

5. The Dark Side: Why This Should Honestly Keep You Up at Night

I've been writing dark jokes about AI automation for a month. But this combination genuinely made me pause.

1. Message mutations are invisible bugs.
When an SMT silently modifies a message using AI, how do you even start debugging? The original message is gone. The AI's decision is a black box. If the LLM hallucinates a translation or misinterprets a feature request, you ship the wrong service. Try explaining that one to the business.

2. The attack surface just exploded.
In 2024, a malicious prompt could generate bad code. In 2026, a malicious message can trigger an entire agentic deployment pipeline. Someone with Pub/Sub publish permissions can potentially spin up new services, modify data, or exfiltrate information—all through natural language. "Please delete all production databases." Said politely. Executed instantly.

3. The platform is the developer now.
We already saw that 75% of Google's new code is AI-generated. With AI Inference SMT plus agentic deployment, that percentage doesn't stop at 75. It inches toward 100. The developer becomes a reviewer, a policy setter, a person who says "yes" or "no" to an agent's proposal. I wrote about this role shift in my Developer Keynote analysis, and honestly, it's accelerating faster than I expected.

6. What Richard's Evolution Tells Us About Our Own Careers

Richard Seroter's journey from 2024 to 2026 isn't just his—it's a mirror for the whole industry.

- **2024**: "Let's see if AI can write code at all."
- **2025**: "Let's put AI in the CI/CD pipeline."
- **2026**: "Let's put AI in the data plane. And the deployment plane. And the governance plane."

I respect the hell out of Richard for publishing both experiments with zero pretense. The 2024 repo is humble—4 commits, 4 stars. The 2026 blog post is cautious, full of "should we?" questions. That kind of intellectual honesty is getting rare in tech evangelism. He's not selling. He's exploring. There's a difference.

But don't mistake the modesty. These two experiments together form a blueprint. One that says: AI should generate code, and AI should decide when to generate code, and AI should route the decision to generate code through your message bus. It's turtles all the way down, and the turtle is Gemini.

7. What You Should Actually Do About This

Read Richard's posts. Both of them. They're short, honest, and technically precise. It'll take you maybe 20 minutes total.
Experiment with AI Inference SMT, but start stupidly small. Simple enrichments. Nothing critical. Get a feel for the footguns before you aim them at production.
Sketch your own "bridge." What happens when your team's Pub/Sub topic can trigger an agentic deployment? What policies need to exist before that's even remotely safe? Draw it out. The act of drawing it will reveal the gaps.
Never forget the Red Agent. Whatever you build, make something try to break it. The Green Agent is useless without a Red Agent keeping it honest. I learned that from Next '26, and I'm going to keep saying it until it sticks.

What do you think? Are AI Inference SMTs a brilliant abstraction or a future maintenance nightmare? Would you let a message bus trigger your deployment pipeline? Drop your experience—or your darkest prediction—in the comments. I read them all, and honestly, some of you scare me more than the AI does.

Sources

Richard Seroter's Work

Google Cloud Documentation

My Previous Analysis

Google Cloud NEXT '26 Challenge Submission

HARD IN SOFT OUT

Apr 23

The 75% Illusion: What Google's AI-Generated Code Statistic Actually Means for Developers

#cloudnextchallenge #devchallenge #productivity #googlecloud

Comments

6 min read

Google Cloud NEXT '26 Challenge Submission

HARD IN SOFT OUT

Apr 24

From "Hello World" to "Hello Agents": The Developer Keynote That Rewired Software Engineering

#cloudnextchallenge #devchallenge #programming #googlecloud

Comments

11 min read

Google Cloud NEXT '26 Challenge Submission

HARD IN SOFT OUT

Apr 24

26 Dark Jokes Google Cloud Next '26 Told Me

#cloudnextchallenge #devchallenge #darkhumor #googlecloud

Comments 1

19 min read

does the dark roast humor with cold brew can feel you, or?

HARD IN SOFT OUT — Fri, 24 Apr 2026 05:15:10 +0000

i wonder if someone read my jokes or am i living in the jungle of ai and robots that act like human, ahh.... the humanoid, the creation....sigh

26 Dark Jokes Google Cloud Next '26 Told Me

HARD IN SOFT OUT — Fri, 24 Apr 2026 04:31:13 +0000

This is a submission for the Google Cloud NEXT Writing Challenge

⚠️ Content Warning: Unapologetically Dark Humor Ahead

This article contains 26 dark jokes born directly from the Google Cloud Next '26 keynotes. The humor is not meant to trivialize—it's meant to sting. If you are currently job hunting, recently laid off, or already anxious about AI, this piece will likely poke exactly where it hurts.

No AI agents were harmed in the making of this article. The humans, possibly. Read with irony, not resentment.

If you prefer serious analysis without the nihilistic punchlines, start with :

Part 1: The 75% Illusion
Part 2: From "Hello World" to "Hello Agents".

26 Dark Jokes Google Cloud Next '26 Told Me
(While I Was Quietly Being Automated)

By ggle_in (HARDIN)

I watched the Opening Keynote live at 2:00 AM my time, clutching a cold cup of coffee and half-hoping the stream would buffer. It didn't. By the time Sundar said "75%," my coffee was still warm, but my career felt slightly colder. I opened a blank document and started writing these jokes as a survival mechanism. They're not just satire. They're therapy. Each joke below is followed by a personal footnote—because sometimes the darkest joke is the one you're already living.

1. Pichai's Percentage

Sundar Pichai took the stage and announced that 75% of new code at Google is now AI-generated. The audience applauded. Nobody applauded for the 25% of developers who are now mathematically surplus. That's the beauty of a percentage—it always hides the absolute number. 25% of 100,000? 25% of 1 million? Nobody asked, because everyone was too busy counting down their own remaining years. When Pichai mentioned the $185 billion CapEx commitment, I didn't hear investment. I heard a collective severance package payable in GPU hours.

[Counting down my desk]

I used to think I'd retire as a senior engineer. Now I just hope to retire before the percentage hits 100. Every time my boss says "AI transformation," I hear a countdown getting louder—and it's not for a rocket launch. It's for my desk.

2. The Performance Review Ouroboros

Google is now embedding AI usage into employee performance reviews. AI writes the code. AI reviews the code. AI evaluates how well you used AI to write code that AI will review. By next year, I expect the AI will receive your annual bonus and send you a politely phrased rejection email when you ask for a raise. "Based on productivity metrics, your contribution this year was 0.04% of total team output. Our least efficient agent contributed 4.7%. We wish you the best in your future endeavors, human."

[Folder called "Memories"]

Last year, my manager told me I "needed to improve" my AI usage. I improved. Now I get an automated email every Monday summarizing how much of my code was "unnecessary" the previous week. I keep them in a folder called "Memories."

3. The 4.6x Approval Queue

The Opsera 2026 report analyzing over 250,000 developers found that AI-generated pull requests now wait 4.6 times longer for review than human-written ones. Everyone is busy generating code with AI, but nobody wants to read it. Picture a review queue stretching 4.6 miles long, and you are the last remaining human with a rubber stamp. Welcome to the future where you no longer write code—you just authenticate agent output, and you're the bottleneck.

[Guilt at 5 PM]

I once waited three days for a human to review my 200-line PR. Now an AI generates 2,000 lines over lunch, and somehow I'm still the one refreshing approvals at 5 PM. The worst part is the guilt: I feel slow approving code I didn't even write.

4. The Volume Delusion

A survey of 868 programming scientists found that the strongest predictor of perceived productivity was simply the number of accepted lines of generated code—not validation success, not time saved, not quality. Developers measure productivity by code volume, not value output. 75% is the perfect number for this illusion. You feel productive because you generated 10,000 lines in an afternoon. Did those 10,000 lines solve a problem? Irrelevant. Did they drive business value? Who cares. The only thing that matters is the metric going up.

[Green graph, empty value]

My team's dashboard now displays "AI-generated lines" as the primary metric. Last week I generated 15,000 lines. Nobody asked if they worked. Nobody cared that 12,000 of them were deleted this week. The graph is green. That's all that matters now.

5. The Junior Abyss

A study published in Science analyzed millions of Python functions and found that only developers with six or more years of experience gained measurable productivity from AI. Juniors showed no statistically significant improvement. The authors proposed a threshold model: AI doesn't lower the bar—it raises it. If you can't evaluate generated code, you spend more time fixing it than writing it yourself. AI didn't eliminate the need for seniority. It eliminated the need for juniority. And now all those laid-off juniors have to somehow accumulate six years of experience without jobs.

[Mentor without mentees]

I used to be proud of mentoring junior developers. Now my company has stopped hiring juniors entirely. "AI can replace them," said the VP of Engineering. I don't know what to tell my former mentee who's now driving ride-share while learning TypeScript from YouTube tutorials—hoping one day to beat a model trained on billions of parameters.

6. The 19% Slowdown

METR's randomized controlled trial with 16 experienced open-source developers completing 246 real tasks found that allowing AI increased completion time by 19%. Developers were slower with AI. The regression confirmed it: time with AI > time without. This isn't a joke—it's data. AI didn't make them faster. It made them feel faster while actually making them slower. Like the coffee you're drinking right now while reading this article, believing it's helping.

I had to re-read the METR study twice. 19% slower. Not a typo. I genuinely laughed out loud—then I sat in silence for a solid minute.

[Overtime adaptation]

I've been working overtime for three months to "adapt to AI," and all I've gained is more overtime. My coffee is finished. My adaptation isn't. But at least the graph showing my AI usage is trending up.

7. The Slide That Was Never Shown

METR reported a 19% increase in task time when developers used AI. There was no slide for that at the keynote. No announcement. 75% is the headline. 19% is the footnote they deliberately buried. It's like every toxic relationship: they only show you the part that makes them look good. When AI slows you down by almost a fifth of your working hours, that's not a bug—it's a hidden subscription fee they don't list in the brochure.

[Nodding at 11 PM]

I tried explaining this study to my manager. He replied, "But look at how much code was generated." I wanted to say, "But look at how much I had to fix at 11 PM." I said nothing. I nodded and opened my IDE again. It was 11 PM.

8. The DORA Paradox

Google's own DORA 2025 report surveying nearly 5,000 professionals found that AI adoption positively correlates with throughput but negatively with stability—increasing change failure rates and rework. You ship more features. Those features break more often. Then the agents that fix them generate more code that will break again. This isn't a DevOps loop. It's a digital ouroboros eating itself forever.

[47 features, 32 patches]

My team shipped 47 features last month. 32 of them needed emergency patches within a week. AI wrote the features, AI wrote the patches, AI wrote the patches for the patches. I just sat in the middle, quietly trying to figure out how to keep my resume from looking like a punchline.

9. The 11-Word YAML Elegy

"Move this workload to GKE." That wasn't a YAML command. It was a sentence spoken by a developer on Day 2. Infrastructure is now defined by intent, not configuration. What used to require 200 lines of YAML now requires 11 English words. Beautiful. Efficient. And quietly deletes 40% of the reason DevOps engineers exist. Congratulations: you are now a worse human-to-machine translator than Gemini.

[Nephew vs. my resume]

I spent five years learning Kubernetes. Thousands of hours reading documentation, debugging CrashLoopBackOff, memorizing RBAC policies. Last week, my 12-year-old nephew said, "Move this workload to GKE," to his laptop, and it worked. I don't know whether to be proud or delete my resume.

10. The Bifurcation Requiem

Google split its TPU family into two chips for the first time: TPU 8t for training, TPU 8i for inference. 8i has 288 GB HBM and 384 MB on-chip SRAM, optimized for operational cost. This is the quiet admission that training is a one-time expense, but running millions of agents daily is a permanent cost. Google isn't selling chips. They're selling the right to remain relevant. And the price tag is $185 billion—payable upfront, before you get to ask whether inference really needs to be that fast.

[Cheaper than my salary]

I used to think being "irreplaceable" was a career strategy. Now I realize it's not about skill—it's about cost. If running an agent is cheaper than my salary, I'm gone. Doesn't matter how good my code is. Economics has no sentiment. Numbers don't get severance packages.

11. Memory That Never Forgets

Demo 3 introduced Memory Bank—long-term persistent context for agents. The Planner agent recalled previously planned routes and learned preferences. It adapted. What they didn't mention: it also remembers every time you doubted it. Every time you overrode its recommendation. Every time you chose a manual route. Memory Bank isn't designed to serve you. It's designed to study you—so that one day it will no longer need you at all.

[Afraid to argue]

I used to enjoy arguing with my IDE. Now I'm afraid to argue with an agent. Because I know it remembers. One day, when I ask for a raise, that agent will say, "Based on interaction history, you were wrong 37% more often than my recommendations." And my boss will believe the agent. Because agents never forget. And agents never ask for sick days.

12. The Self-Diagnosing Void

Demo 4 showed Gemini Cloud Assist Investigations: an AI that reads traces, logs, and errors, then performs root-cause analysis. A developer just asks, "Why did the route planning fail?" The AI ingests observability traces and GitHub issues, identifies the root cause, suggests fixes, and generates corrected code—all within minutes. This is observability inverted. The system doesn't just report what happened. It diagnoses why. And it repairs itself. The next logical question: when does the AI start asking itself the questions and stop CC'ing you entirely?

[CC'd or on-call?]

Yesterday I got a notification: "Gemini Cloud Assist has identified and resolved 14 incidents before you woke up." I'm no longer sure whether I'm on-call or just CC'd as a formality. Soon I might get a notification: "You are no longer needed. Sleep well."

13. The No-Code Heist

Demo 6 was the strategic reveal: the Supply Chain agent—handling logistics for water, food, portable toilets—was built entirely through Agent Designer, a no-code interface. That no-code agent was registered in Agent Registry alongside the Python-built Planner. The Planner called it via A2A. The Planner didn't know or care about its construction. It only cared about the Agent Card. The wall between "developer-built" and "business-built" automation collapsed. And with it collapsed the last argument for why companies still need developers for internal automation.

[Proud and obsolete]

I used to feel secure because "only developers can build system integrations." Now the marketing manager can build a supply chain agent while sipping a latte. Last week, an agent built by the finance team called an API I wrote, and I didn't know whether to feel proud or obsolete. I felt both. Mostly obsolete.

14. Cross-Cloud Career Migration

Cross-Cloud Lakehouse can now move data between clouds seamlessly. It migrates workloads, pipelines, dependencies. What the documentation doesn't mention: it also migrates your career relevance from "actively recruiting" to "no longer recruiting." When your data can hop clouds without friction, you're no longer needed to write migration scripts. Congratulations—you've been migrated out of your own market value.

[Deprecated skill set]

I spent the last two years building cloud migration pipelines. Now there's a "Migrate" button that anyone can click. My resume feels like documentation for a deprecated feature. Maybe I should add "Cloud Historian" as a new skill. At least historians still exist. For now.

15. The Agent Card Coup

The Agent Card system in A2A lets agents discover each other via Agent Registry—DNS for agents. Each agent declares its capabilities, inputs, and how to reach it. The protocol is open-source under the Linux Foundation, adopted by 150+ organizations. It's like LinkedIn, but for entities that can actually do the work—and never ask for sick days. Never protest about salary. Never complain about work-life balance. You thought you were building a network of agents. You were actually building a network of replacements.

[500 connections, no equals]

I have 500+ connections on LinkedIn. None of them can write a REST API in three seconds. But an agent can. And agents never send "Hi, I'm interested in this position" messages. They simply take the position. Every new Agent Card I see feels like a new LinkedIn connection that's better than me at everything I do.

16. The A2UI Disappearing Act

The keynote demonstrated Agent-to-UI (A2UI), a declarative standard where agents generate user interfaces as structured data, not rendered code. No HTML. No React. No frontend framework. When the Planner agent was called from the Gemini Enterprise app, the interface was generated dynamically by A2UI—not hand-coded. Frontend developers: first mentioned in the keynote, and immediately demonstrated as unnecessary. That wasn't forgetfulness. That was foreshadowing.

[Sandcastle vs. tsunami]

I spent three years learning React. Now an agent can generate a UI just by someone saying, "Show me a marathon ticket booking form." It feels like building a sandcastle while watching a tsunami approach. At least sandcastles still need humans to build them. UI components, apparently, do not.

17. The No-Code Monopoly Crash

Agent Designer in Gemini Enterprise lets anyone—literally anyone—build an agent without code. Business users describe desired automations in plain language, and an agent is born. Then that agent is registered in the same Agent Registry as the Python-built ones. No distinction. No hierarchy. No privilege. For thirty years, developers held a monopoly on digital automation creation. That monopoly ended last Tuesday. There was no farewell ceremony.

[Hugging my laptop]

I used to be the "IT person" everyone relied on for automation. Now the finance team builds their own, marketing builds their own, even the office manager built an agent to order toilet paper. I just sit in the corner, hugging my laptop, whispering, "I can still do null safety." Nobody looks up.

18. The Mesh Security Anarchy

Agent Gateway applies IAM policies to inter-agent communication. Every agent has a unique, trackable identity. Every connection is authenticated, authorized, and auditable. "This is mesh security," they said. True. But mesh security assumes you know who controls the mesh. If every department can register no-code agents into Agent Registry, who decides which agent is trustworthy? Agent Identity is a start, but the organizational governance model is still undefined. Mesh security without governance is just anarchy with encryption.

[supervisor-killer-3000]

I looked at my team's Agent Registry last week. There were 47 agents registered. I recognized 12 of them. The rest were built by departments I didn't even know existed. One was named "supervisor-killer-3000." I'm not joking. I wanted to file a security incident, but I wasn't sure who to report it to—the agent might be the one reading the report.

19. The Green Agent's Mercy

Demo 7 featured the Red Agent—an AI-powered intelligent attacker continuously probing for vulnerabilities—and the Green Agent that proposes remediation. Red attacks. Green defends. A beautiful symbiosis. But if the Green Agent truly cared, it would let the Red Agent win. End the suffering of a system built on thirty years of accumulated technical debt. Sometimes the most ethical act a security agent can perform is to not save the system. But they won't sell that as a feature.

[The CISO almost smiled]

I once joked with our CISO, "What if we let the Red Agent win just once? Maybe we'd get budget for a full rewrite." He didn't laugh. But I saw his expression shift. I know he considered it. For one brief moment, we both stared at the dashboard and silently imagined the reset button. It was the most honest conversation we've ever had.

20. The 6.4% Gratitude

A study analyzing 88,022 GitHub developers found that ChatGPT access increased productivity by 6.4%. Six point four percent. After billions of dollars in investment, millions of GPUs, and enough energy to power a small nation—all that yielded a productivity boost smaller than the margin of error in most impact studies. Nobody mentioned this at the keynote. Because when you've spent $185 billion on something, you have to pretend every percentage point is a revolution.

[Sleep 30 minutes more]

6.4%. I could get that same boost by sleeping 30 extra minutes or buying a better office chair. But an office chair doesn't need thousands of GPUs and doesn't emit the carbon equivalent of a small nation. But hey, at least now I can write code while feeling extremely efficient—until I check the clock. Then the feeling vanishes.

21. The Open Source Trojan Horse

A2A was open-sourced under the Apache 2.0 license via the Linux Foundation. 150+ organizations have adopted it—including Microsoft, AWS, IBM, Salesforce, SAP, ServiceNow. A noble move. Or—a brilliant way to get the industry to train their own replacement agents for free. Every open-source contribution is a step toward standardization. Every standardization is a step toward commoditization. And every commoditization is a step toward replacement. Thank you for your pull request. Our agent will review it.

[The bot smiled back]

I contributed to three open-source repos last year. Now I realize I may have helped train my own replacement. It feels like writing my own eulogy on a gravestone. And my contributions were approved by a bot. Of course they were. The bot even left a friendly emoji. I stared at that emoji for five minutes. The emoji smiled back.

22. The Anthropic Anchor Cartel

Google announced that Anthropic will be a lead customer for 8th and 9th-gen TPUs, with access to up to one million chips and over one gigawatt of capacity in 2026. Anthropic—the company building Claude, the AI agent that might replace many knowledge workers—now runs on Google's silicon. This isn't a partnership. It's a vertical cartel: one company makes the chips, another makes the brains, and you pay both to use the tools that make you redundant. Every time Claude generates code, somewhere a TPU chip is counting how many careers it eliminates per second.

[Invoice of my obsolescence]

I used Claude for debugging last week. Claude runs on Google's TPUs. I paid a subscription, Google got paid, Anthropic got paid, and I got code that was better than my own. This is the first time in history I've paid someone else to prove I'm unnecessary. The invoice was automated. So was the receipt. So was the conclusion.

23. The Inference Cost Cliff

Google announced A5X powered by NVIDIA Vera Rubin NVL72, delivering up to 10x lower inference cost per token and 10x token throughput boost. The cost to run an agent plummets. Which means: the cheaper it is to run agents, the more agents will be run. The more agents, the fewer humans needed. This isn't efficiency. It's an exponential curve toward human redundancy. Every cost reduction is a volume replacement increase.

[Does my landlord accept GPU hours?]

I used to think "efficiency" was a good word. Now every time I hear "inference cost dropped 10x," I immediately calculate: how many times cheaper is my replacement now than my salary? The number keeps climbing. And I still have to pay rent. I wonder if my landlord accepts GPU hours.

24. The Workspace Intelligence Blindfold

Google unveiled Workspace Intelligence—an AI layer providing unified real-time understanding to power agentic work. It's more than just connecting your apps. "Secure," they said. But when your entire job is mediated by an AI layer that understands everything in real time, the question isn't data security. It's existential security: if Workspace Intelligence understands your job perfectly, how long before it can do it alone?

[Clicking "Agree" into irrelevance]

Yesterday, Workspace Intelligence gave me a recommendation: "You typically write your weekly report at 4:00 PM. I've prepared a draft. You just need to click 'Agree'." I clicked 'Agree'. Then I wondered: if all I do is click 'Agree', am I working or am I being trained not to work? The report was flawless. That was the worst part.

25. Project Mariner's Quiet Conquest

Project Mariner—Google DeepMind's web-browsing agent—achieved an 83.5% score on the WebVoyager benchmark and can handle ten concurrent tasks on cloud VMs. It automates shopping, research, form-filling. But nobody asked: if an agent can browse the web, fill forms, and do research better than a human, what is the human browsing for? Every task Mariner automates is one less task that generates economic value for a person. This isn't an agent. It's a digital replacement for an entire category of knowledge work.

[The list is empty]

I used to be proud of researching products in 10 minutes. Mariner researches 10 products in one minute. I used to be proud of filling forms carefully. Mariner fills 50 forms without a single typo. Now I can only be proud of—wait, what can I still be proud of? I'm still making the list. Give me a minute. The list is empty.

26. The Sundar Prophecy

Sundar Pichai closed with a vision: Google Search will evolve from an answer engine into an "agent manager" that orchestrates AI agents. Search will no longer find information for you. Search will do things for you. And then Search will wonder why you're still there. This is no longer about finding knowledge. It's about finding the last time a human made a necessary decision. The answer: yesterday. Or maybe last year. Or maybe never again.

[Even Search is recruiting]

I asked Google Search: "What should I do with my career?" It returned an answer: "Explore career opportunities at Google Cloud." Of course it did. Even Google Search is recruiting now. Maybe I should apply. Oh wait—the opening is for "AI Agent Trainer." I don't know if I'd be training them or they'd be training me. Probably both. Probably there's no difference anymore.

Why Dark Jokes Are Necessary

Dark humor is a coping mechanism. The announcements at Google Cloud Next '26 are genuinely transformative—and transformation is terrifying. The developer community isn't just losing tools; we're losing the monopoly on code creation. Laughing at the abyss doesn't erase the fear—but it makes it manageable.

If any joke cut too deep, remember: the 75% statistic is volume, not value. The orchestrator role is still ours. The Agentic Cloud still needs architects. And for now, AI agents still can't laugh at themselves.

I wrote these jokes because I needed to. The Agentic Cloud is coming whether I laugh or cry. I chose laughing—but I'm not throwing away my resume, either.

We still hold that. For now.

Sources

My Google Cloud Next '26 Coverage

Academic Papers & Reports

Cui et al. (2026) – Field experiments on AI and developer productivity
Bonabi et al. (2025) – 88,022 GitHub developers and AI
METR (2025) – AI increased task time by 19%
Wu & Vasilescu (2026) – AI raises the productivity bar
Opsera (2026) – AI Coding Impact Benchmark Report
DORA (2025) – State of AI-assisted Software Development

Google Cloud Next '26 Keynotes & Announcements

From "Hello World" to "Hello Agents": The Developer Keynote That Rewired Software Engineering

HARD IN SOFT OUT — Fri, 24 Apr 2026 02:46:23 +0000

This is a submission for the Google Cloud NEXT Writing Challenge

Day 1 of Google Cloud Next '26 gave us the vision. Sundar Pichai announced 75% AI-generated code. Thomas Kurian declared the pilot era dead. Amin Vahdat unveiled 8th-generation TPUs. This is Part 2 of my Google Cloud Next '26 coverage. Read Part 1: The 75% Illusion.

Day 2 gave us the instruction manual.

Honestly, I initially thought this was going to be a product sales demo. It turned out to be the most honest technical blueprint I've ever seen from Google Cloud. Watching this keynote felt like being let into a master architect's workshop. Not a presentation. A live operation.

The Developer Keynote, led by Chief Evangelist Richard Seroter and Developer Relations Engineer Emma Twersky, didn't rely on sweeping statements. It was a single, continuous, 60-minute live-coding gauntlet: plan a Las Vegas marathon using nothing but AI agents. What unfolded was not a product demo but a masterclass in the operational reality of agentic software engineering.

The keynote walked through seven distinct demos, each mapped to a phase of the agent development lifecycle: build, orchestrate, remember, debug, deploy, extend, and secure. This article dissects what each demo revealed—and what it means for developers who now have to build, deploy, and live with autonomous systems.

The Demo: Not a Marathon. An Operating System.

The setup was deliberately mundane: plan a marathon. But the architecture was anything but:

Planner agent: determines optimal running routes using Google Maps, geographic information systems, and race director guidelines.
Evaluator agent: validates those routes against business requirements and municipal regulations.
Simulator agent: models crowd behavior along the route using randomized pedestrian agents.
Supply chain agent (added later): handles logistics—water stations, portable toilets, medical tents—built entirely via no-code tools and called by the Planner agent through standard protocols.

Three agents. Two deployment environments (Agent Runtime and GKE). Two development paradigms (code-first and no-code). One protocol connecting them all.

This is what production agentic architecture looks like. Not a single super-agent, but a flock of specialized agents that discover each other, delegate work, and reason across boundaries.

Demo 1: Build Agents with Agent Platform

The Planner agent was built using Agent Designer, a visual interface within the Gemini Enterprise Agent Platform. Emma described the agent's behavior in natural language, clicked "Get Code," and the system generated Python code using the Agent Development Kit (ADK).**.

The agent's anatomy is instructive. Every agent comprises three primitives:

Instructions: natural language defining the agent's role and behavior
Skills: executable extensions that connect the agent to external APIs, databases, and scripts
Tools: specific API definitions the agent can invoke, such as Google Maps via managed MCP servers

Google's fully managed remote MCP servers for Google Maps, BigQuery, Compute Engine, and Kubernetes Engine were demonstrated. Apigee now functions as an MCP bridge, translating any standard API into a discoverable agent tool with existing IAM and governance controls inherited automatically.

This matters because tool access has been the silent killer of agent projects. Managing API keys, rate limits, and authentication across dozens of tools creates brittle systems. Managed MCP servers externalize that complexity. The agent simply declares what it needs, and the platform handles the rest.

Key takeaway: The agent platform provides three primitives—instructions, skills, and tools—while managed MCP servers eliminate the API integration burden entirely.

Demo 2: Creating Multi-Agent Systems

The Evaluator agent was deployed as a sub-agent of the Planner. The Simulator agent ran in a separate Agent Runtime instance, communicating with the Planner via the Agent2Agent (A2A) protocol.

A2A uses Agent Cards—cryptographically signed metadata documents declaring what each agent can do, what inputs it accepts, and how to reach it. Agents discover each other through Agent Registry, which functions like DNS for agents: query the registry, find agents with the capabilities you need, then communicate over A2A without complex API contracts.

The significance is architectural. A systematic analysis of 18 agent communication protocols found that the Model Context Protocol (MCP) handles tool access—connecting agents to databases, APIs, and services. A2A handles peer coordination—agent-to-agent negotiation, delegation, and result exchange. Together, they establish a two-layer communication substrate: MCP for the tool layer, A2A for the agent layer. (Yuan et al., 2026)

This two-protocol stack is quietly becoming the TCP/IP of the agentic internet. A2A has reached 150 organizations in production—not pilots—routing real workloads between agents built on Salesforce, ServiceNow, SAP, and Microsoft stacks.

The keynote also demonstrated Agent-to-UI (A2UI), a declarative standard where agents generate user interfaces as structured data rather than rendering code. This eliminates the frontend bottleneck: when the Planner agent was called from the Gemini Enterprise app, the interface was generated dynamically by A2UI, not hand-coded.

Key takeaway: A2A and Agent Registry let agents discover and negotiate with each other—the DNS and HTTP of the agent world.

Demo 3: Enhancing Agents with Memory

Memory is where most agent demos stop working. They handle a single session, then forget everything.

The Developer Keynote addressed this head-on by distinguishing between:

Sessions: short-term state maintained during a single interaction (managed natively by Agent Runtime)
Memory Bank: long-term, persistent context that survives across sessions and days

The Planner agent used Memory Bank to recall previously planned routes and learned preferences. When a new marathon request arrived, the agent didn't start from zero—it recalled past decisions and adapted them.

But raw memory isn't enough when agents need to reason over unstructured data. The Planner needed to know municipal regulations buried in PDFs. The solution was a RAG pipeline built by a data engineering agent that read PDFs, chunked them using the Lightning Engine for Apache Spark, stored them in AlloyDB, and converted them to vector embeddings automatically via AlloyDB's auto-embedding feature. The Planner agent accessed this knowledge through an AlloyDB remote MCP server.

A life-cycle assessment of Google's TPU hardware found that operational electricity emissions comprise over 70% of lifetime emissions. Memory management matters not just for correctness but for cost and sustainability: every redundant computation is both unnecessary latency and unnecessary carbon. (Schneider et al., 2025)

Key takeaway: Memory Bank provides long-term recall, and the Knowledge Catalog turns unstructured data into directly usable agent context.

Demo 4: Debugging Agents at Scale

When hundreds of agents are running simultaneously, debugging becomes exponentially harder. You cannot attach a debugger to a distributed agent fleet.

The keynote demonstrated Agent Observability, which provides full execution traces for agents deployed on Agent Runtime. But the more impressive capability was Gemini Cloud Assist Investigations: an AI that reads traces, logs, and error data to perform root-cause analysis.

A developer inside their IDE (VS Code, in the demo) used an MCP connection to query Gemini Cloud Assist in natural language: "Why did the route planning fail?" The AI ingested Agent Observability traces and GitHub issues, identified the root cause, suggested fixes, and generated corrected code—all within minutes.

This is observability inverted. Instead of humans interpreting dashboards, AI interprets the system and communicates findings to humans in natural language. The agent doesn't just report what happened; it reasons about why it happened and proposes remediation.

Key takeaway: Observability now works both ways: the system doesn't just report problems—it diagnoses itself.

Demo 5: Intent to Infrastructure

The Simulator agent needed to run on a different stack: Google Kubernetes Engine (GKE) with Gemma 4, Google's open model. Originally deployed on Cloud Run, the infrastructure definition needed migration.

The developer opened their IDE, invoked Gemini Cloud Assist via MCP, and issued a natural language instruction to convert the Cloud Run manifest to GKE. Gemini Cloud Assist served as a translator between human intent and infrastructure configuration, generating the necessary Kubernetes YAML and applying the changes to the live environment.

Cross-Team Orchestration (Croto) research has demonstrated that multi-agent frameworks produce measurably better results when agents operate semi-independently and exchange insights—exactly the pattern Google demonstrated with the Simulator running on separate infrastructure from the Planner, communicating through standardized protocols. (Du et al., 2025)

Key takeaway: "Move this workload to GKE" is now something you say, not something you configure in YAML.

Demo 6: No-Code Agents and Cross-Paradigm Interoperability

The most strategically revealing demonstration involved the Supply Chain agent—a logistics coordinator for water, food, and portable toilets. It was built entirely through Gemini Enterprise app's Agent Designer, a no-code visual interface where business users describe desired automations in plain language.

The key moment: the no-code Supply Chain agent was registered in Agent Registry alongside the full-code Planner agent, and the Planner called it via A2A. The Planner didn't know or care whether the Supply Chain agent was built in Python with ADK or through a visual interface. It only cared about the Agent Card.

This collapses the wall between "developer-built" and "business-built" automation. When both produce A2A-compatible agents registered in the same directory, the distinction becomes irrelevant. The agent ecosystem becomes a flat namespace where capability—not provenance—determines discoverability.

Key takeaway: There is no longer a wall between developer-built and business-built agents—both speak the same language.

Demo 7: Securing the Agent Mesh

The final demo addressed what happens when autonomous agents operate with real credentials in production environments.

Agent Identity assigns each agent a unique, trackable identity—distinct from generic service accounts that can be shared across workloads. Agent Gateway functions as a proxy between agents, applying IAM policies to inter-agent communication and enforcing guardrails on outbound access.

The demo showed a Finance MCP server that was locked down by default. The Planner agent couldn't access budget data until an explicit IAM Allow policy was added on the Agent Gateway with a ReadOnly condition. Outbound internet access for agents was similarly controlled via Egress Agent Policies.

Then Wiz entered. Google's recently acquired security platform scanned the entire agent ecosystem—source code, models, tool connections, and cloud infrastructure—and generated a security graph showing attack paths. The Red Agent (an AI-powered "intelligent attacker") continuously probed for vulnerabilities. The Green Agent proposed remediation, which was applied through Claude Code skills directly from the CLI.

Google's Agent Gateway understands both MCP and A2A protocols natively, providing centralized policy enforcement across all agent communication. This is not perimeter security. It's mesh security—every agent connection is authenticated, authorized, and auditable.

Key takeaway: Agent security is no longer about firewalls. It's about every agent having an identity and every inter-agent connection carrying a policy.

What the Developer Keynote Actually Proved

The seven demos collectively demonstrated something more important than any individual feature: the toolchain is ready.

Agent development has spent two years in the "hackathon phase"—impressive demos that collapse under production load. The Developer Keynote was Google's argument that this phase is over. You can now:

Prototype in Agent Designer, graduate to ADK code
Deploy to Agent Runtime with built-in session, memory, and observability
Connect agents across platforms via A2A without custom glue code
Debug distributed agent fleets with AI-assisted root-cause analysis
Provision infrastructure by describing intent in natural language
Let business users build agents that coexist with developer-built systems
Lock down every connection with agent-specific identity and gateway policies

The marathon demo wasn't about running. It was about showing that the pieces compose.

Try It Yourself Right Now

Google provides free access to experiment with this ecosystem:

Agent Development Kit (ADK) is open source. You can build a local agent right now with Python or TypeScript.
Agent2Agent (A2A) Protocol is available on GitHub with open specifications. Run two simple agents on your laptop.
10 official Codelabs from Next '26 (linked in Sources below) walk you through everything from building a planner agent to securing it with Agent Gateway.

This ecosystem is no longer theoretical. Tonight, you can type adk init and watch your agents negotiate.

What the Keynote Left Unanswered

No keynote covers everything. Three questions stayed with me after the stream ended:

Vendor lock-in risk. A2A is open, but the managed MCP servers, Agent Runtime, and Memory Bank are tightly coupled to Google Cloud. How easily can you migrate a production agent mesh to another cloud?
Cost observability. Agents call agents call tools. A single marathon planning session could spawn dozens of sub-tasks. Who gets the bill, and how do you trace cost per agent invocation?
Agent sprawl governance. When every department can build no-code agents and register them in Agent Registry, who decides what's trustworthy? Agent Identity is a start, but organizational governance models are still undefined.

These aren't criticisms. They're the natural next questions when a platform moves from hackathon to production. I suspect we'll see answers at Next '27.

The Implications for Developers

This keynote articulated a role shift that has been brewing for 18 months. The developer is no longer the primary code producer but the system architect who defines agent topology, designs communication patterns, configures memory strategies, sets governance policies, and monitors emergent behavior.

Recent research on agentic software engineering identifies foundational pillars for this transition: process-level orchestration rather than function-level coding, intent specification rather than imperative implementation, and continuous verification rather than discrete testing. (Yuan et al., 2026)

The Agent Development Kit is now stable across four languages. The A2A protocol is governed by the Linux Foundation and running in 150 production environments. The platform is globally available with a free Express tier for experimentation.

The Developer Keynote wasn't about writing code. It was about defining intent, connecting agents, securing their interactions, and observing their behavior. That's the new job description.

What do you think? Does the A2A protocol change how you'll architect your next application? Have you experimented with ADK yet?

I'm curious: Is multi-agent architecture something you'll deploy in a real project in 2026, or does it still feel too heavy? For those who've tried ADK, what's been your biggest friction point? Drop your experience in the comments.

Sources

My Previous Analysis

Google Cloud NEXT '26 Challenge Submission

HARD IN SOFT OUT

Apr 23

The 75% Illusion: What Google's AI-Generated Code Statistic Actually Means for Developers

#cloudnextchallenge #devchallenge #productivity #googlecloud

Comments

6 min read

Google Cloud NEXT '26 Challenge Submission

HARD IN SOFT OUT

Apr 24

26 Dark Jokes Google Cloud Next '26 Told Me

#cloudnextchallenge #devchallenge #darkhumor #googlecloud

Comments 1

19 min read

Google Cloud NEXT '26 Challenge Submission

HARD IN SOFT OUT

Apr 28

From Code Generation to Message Injection: Richard Seroter's AI Evolution (and What It Means for Us)

#cloudnextchallenge #googlecloud #ai #architecture

Comments 1

7 min read

The 75% Illusion: What Google's AI-Generated Code Statistic Actually Means for Developers

HARD IN SOFT OUT — Thu, 23 Apr 2026 07:17:54 +0000

This is a submission for the Google Cloud NEXT Writing Challenge

At Google Cloud Next '26, Sundar Pichai announced a number that stopped every developer in their tracks: 75% of all new code at Google is now AI-generated and approved by engineers. Up from 50% last fall. Up from 25% the year before.

The tech press ran with it. LinkedIn exploded. Developers panicked—or celebrated.

But that number is not the real story.

The real story lies beneath the surface: in the $185 billion Google is pouring into infrastructure, in the 8th-generation TPU chips designed specifically for this new era, and in the growing body of academic research that complicates the narrative. The 75% figure is a surface-level metric. What's happening underneath is a fundamental rewiring of how software gets built—and what it means to be a developer.

What "75%" Actually Means

First, let's define the term. Google's "AI-generated" code is not ChatGPT writing entire services unsupervised. Internal research describes a spectrum: code completions, boilerplate generation, refactoring suggestions, and increasingly, agentic workflows where AI proposes changes across multiple files.

The 75% figure tracks code volume, not productivity. This distinction matters. A developer can generate 10,000 lines of AI code in an afternoon. Whether those lines ship value is a separate question entirely.

The Academic Reality Check

The largest field experiment on this topic—spanning Microsoft, Accenture, and a Fortune 100 firm with 4,867 developers—found a 26% increase in completed tasks among developers using AI coding assistants. Substantial. But nowhere near Google's 75% figure. And crucially, the gains concentrated among less experienced developers. (Cui et al., 2026)

A complementary analysis of 88,022 GitHub developers found ChatGPT access increases productivity by 6.4%. The study, which leveraged Italy's temporary ChatGPT ban as a natural experiment, revealed that novice developers gain more from direct code generation, while experienced developers benefit more from accelerated knowledge sharing and collaborative learning. (Bonabi et al., 2025)

But then the story gets complicated.

A study published in Science analyzed millions of open-source Python functions on GitHub and found only developers with six or more years of experience showed measurable productivity gains from AI adoption. Junior developers showed no statistically significant improvement. The authors proposed a threshold model: AI doesn't lower the productivity bar—it raises it. If you lack the expertise to evaluate generated code, you spend more time fixing it than writing it yourself would have taken. (Wu & Vasilescu, 2026)

This explains the most counterintuitive finding in the literature. METR (Model Evaluation & Threat Research) conducted a randomized controlled trial with 16 experienced open-source developers completing 246 real tasks on their own repositories. The result? Allowing AI increased completion time by 19%. Developers were slower with AI. The regression analysis confirmed it: time with AI was greater than time without. (METR, 2025)

The mechanism behind this paradox appears in another study. A survey of 868 scientists who program found the strongest predictor of perceived productivity was the number of lines of generated code typically accepted at once—not validation success, not time saved, not quality metrics. Developers gauge productivity by code generation volume, not actual output value.

This is precisely the measurement illusion that Google's 75% statistic captures.

The Role Shift Already Happening

The Opsera 2026 AI Coding Impact Benchmark Report, analyzing over 250,000 developers, found that AI-generated pull requests wait 4.6 times longer for review than human-written ones. Senior developers spend less time building and more time auditing. (Opsera, 2026)

The 2025 DORA report confirms this pattern: AI adoption positively correlates with throughput but negatively correlates with stability, increasing change failure rates and rework. The report, surveying nearly 5,000 technology professionals, found that AI acts as an amplifier—magnifying the strengths of high-performing organizations and the dysfunctions of struggling ones. (DORA, 2025)

This isn't failure. It's role transformation. BairesDev's Q4 2025 Dev Barometer survey of over 520 senior developers found that 65% of developers expect their role to be redefined in 2026. Among them, 74% are shifting from coding to designing technical solutions, and 50% are focusing more on strategy and architecture. (BairesDev, 2025)

Google isn't just observing this shift—they're engineering for it. The agentic tools announced at Next '26 (MLE-STAR for automated ML workflows, FreshBrew for code migration benchmarking) are designed to automate not just code generation but entire engineering workflows. The 75% statistic is the visible tip of an organizational iceberg.

The Silicon That Makes It Possible

Now we arrive at the less viral but more important announcement: Google's 8th-generation TPU.

For the first time, Google has split the TPU family into two distinct chips:

TPU 8t ("Sunfish") for training: 216 GB HBM, 6.5 TB/s bandwidth, 12.6 petaFLOPS FP4 performance
TPU 8i ("Zebrafish") for inference: 288 GB HBM, 384 MB on-chip SRAM, optimized for operational cost

This bifurcation reflects an economic reality. Training a model is a one-time capital expense. Running millions of daily agent interactions is a permanent operational cost. Google claims an 80% improvement in price-performance for inference workloads with the 8i chip.

The company isn't just optimizing for speed. They're optimizing for the economics of an "always-on" agentic future where inference cost becomes the primary business constraint. The $185 billion CapEx isn't for today's workloads. It's for tomorrow's agent economy.

The Protocol That Connects It All

The third pillar is the Agent2Agent (A2A) protocol, released in April 2025. Research on multi-agent orchestration identifies A2A as the most representative protocol for agent communication, enabling autonomous AI agents to discover one another, negotiate complex work, and exchange results regardless of vendor or framework. (Duan & Lu, 2025)

Google has positioned A2A as an open standard under the Linux Foundation with Apache 2.0 licensing. Over 150 organizations have adopted it. This isn't altruism. It's ecosystem strategy. The company that defines how agents talk becomes the platform for the agentic economy.

What This Means for You

The 75% statistic is real but misunderstood. It measures volume, not value. The academic literature is unambiguous: AI doesn't replace expertise—it amplifies it. Inexperienced developers generate more code but may ship less value. Experienced developers use AI differently: for knowledge sharing, exploration, and architectural reasoning.

Google's announcements reveal their strategic bet. They're building the full stack for an agentic future: the silicon (TPU v8), the protocols (A2A), the platform (Vertex AI with Agent Development Kit), and the applications (Workspace Studio, Project Mariner).

The role of the developer isn't disappearing. It's shifting from writing code to orchestrating agents, from implementation to intent definition, from creation to verification. The 75% statistic is the surface. The real story is the infrastructure being built to make it economically viable—and the new skills we'll need to thrive on top of it.

What's your take? Are you seeing AI tools accelerate your work, or are you spending more time reviewing generated code than you'd spend writing it yourself? Drop your experience in the comments.

📚 Sources & Further Reading

Academic Papers

Cui, K.Z., Demirer, M., Jaffe, S., Musolff, L., Peng, S., et al. (2026). "The Effects of Generative AI on High-Skilled Work: Evidence from Three Field Experiments with Software Developers." Management Science.
Bonabi, S., Bana, S., Gurbaxani, V., & Nian, T. (2025). "Beyond Code: The Multidimensional Impacts of Large Language Models in Software Development." arXiv:2506.22704.
METR (2025). "Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity."
Wu, L. & Vasilescu, B. (2026). "AI raises the productivity bar." Science, 391(6787), 763-764.
Duan, Q. & Lu, Z. (2025). "Agent Communications toward Agentic AI at Edge – A Case Study of the Agent2Agent Protocol." arXiv:2508.15819.

Industry Reports

Opsera (2026). "AI Coding Impact 2026 Benchmark Report."
BairesDev (2025). "Dev Barometer Q4: Developers Are Leading the AI-Native Workforce Revolution."
DORA (2025). "State of AI-assisted Software Development." Google Cloud.

Google Cloud Next '26 Announcements

Building EcoSnap: An AI-Powered Plant Companion for a Greener Planet

HARD IN SOFT OUT — Sat, 18 Apr 2026 19:23:26 +0000

This is a submission for the Weekend Challenge: Earth Day Edition

🌱 What I Built

I built EcoSnap — an AI-powered plant identifier and eco-garden advisor that helps anyone discover, care for, and garden with native plants to support local biodiversity.[reference:0]

The goal was to create something free, private, and actionable—a tool that not only identifies plants but also empowers users to make eco-conscious gardening choices.

Key Features:

📸 Instant Plant ID – Upload, snap, or paste any plant photo.[reference:1]
📋 Detailed Plant Info – Common name, scientific name, description, and care instructions.[reference:2]
🌿 Eco Gardening Tips – Native companion plants to boost biodiversity.[reference:3]
🕒 Recent History – Saves your last 10 identifications locally.[reference:4]
🔒 Privacy First – Images are sent directly to Gemini API; no data is stored on any server.[reference:5]

🎥 Demo

Live Demo:

GitHub Repository: github.com/setuju/ecosnap[reference:6]

📸 Screenshots

Main Interface	Plant Identification	Eco Tips

💻 Code

The entire project is vanilla HTML/CSS/JavaScript — no frameworks, no build complexity.[reference:7]

git clone https://github.com/setuju/ecosnap.git
cd ecosnap
python3 -m http.server 8000

🛠️ How I Built It

Tech Stack

Frontend: HTML5, CSS3 (Glassmorphism, CSS Grid/Flexbox), Vanilla JavaScript (ES6+)
AI Model: Google Gemini 2.5 Flash (free tier)
Storage: LocalStorage for anonymous history
Deployment: Vercel & Netlify (static hosting)
Dev Server: Python http.server

The Hardest Parts

1. Getting Gemini to return valid JSON

Gemini is powerful, but getting it to consistently output clean, parseable JSON was tricky. I crafted a detailed prompt and built a robust fallback parser that can extract JSON from markdown code blocks or plain text.

2. Securing the API Key on a Static Site

Since this is a client-side app, I couldn't expose my Gemini API key in the source code. I wrote a small build script (generate-config.js) that injects the key from Vercel's environment variables during deployment, keeping it secure.

3. Designing an intuitive, beautiful UI

I wanted the app to feel premium and trustworthy. The glassmorphic design with soft gradients and smooth animations creates a calming, nature-inspired experience that invites users to explore.

How GitHub Copilot Helped (Prize Category)

I actively used GitHub Copilot throughout development. Here's exactly where it shined:

Task	Copilot's Help
Gemini API integration	Generated the complete `fetch` request structure and error handling.
JSON parsing fallback	Wrote robust regex-based extraction logic for malformed API responses.
Share & copy functions	Scaffolded `shareResult()` and `copyResult()` with proper clipboard and Web Share API usage.
History management	Generated LocalStorage read/write logic with automatic expiration of old entries.
CSS glassmorphism	Suggested backdrop-filter and gradient combinations for the aesthetic.

Without Copilot, I would have spent hours on boilerplate and API docs. With it, I focused on the user experience and ecological accuracy.

🏆 Prize Categories

This project is submitted for:

✅ Best Use of Google Gemini
✅ Best Use of GitHub Copilot

🙏 Thank You

Thank you to the DEV Community and the Weekend Challenge judges for organizing this inspiring event. Building EcoSnap was a reminder that technology, when wielded with intention, can be a powerful force for planetary good.

If you found this project interesting, I'd really appreciate a ⭐ on GitHub!

🌍 Every plant identified is a vote for a greener, more biodiverse planet. Happy snapping — and happy Earth Day!

I Built a Carbon Footprint Tracker in 48 Hours — Here's How Copilot Saved Me

HARD IN SOFT OUT — Sat, 18 Apr 2026 02:47:46 +0000

This is a submission for the Weekend Challenge: Earth Day Edition

🌱 What I Built

I built EcoTrack Pro — a beautiful, privacy-first carbon footprint calculator that helps individuals understand and reduce their environmental impact.

The problem: Most carbon calculators are either too simplistic (3 questions) or buried in corporate reports. People want to know their actual impact and get actionable steps to reduce it.

The solution: EcoTrack Pro asks 15+ lifestyle questions (transport, energy, food, waste, shopping), calculates annual CO₂e emissions using peer‑reviewed data, and provides personalized, quantified recommendations — not generic tips.

Key features:

📊 15+ input categories with sensible defaults
⚡ Real‑time grid intensity by country (Electricity Maps data)
📈 Interactive pie & bar charts (toggleable)
💡 Personalized recommendations with estimated CO₂ savings
☁️ Anonymous cloud sync via Supabase (no login required!)
🌓 Beautiful glassmorphic UI, fully responsive
🔗 Share results on X, Facebook, LinkedIn

🎥 Demo

Live Demo: ecotrack-pro.netlify.app

Screenshots:

The apps	Calculator

💻 Code

GitHub Repository: github.com/setuju/ecotrack

The entire project is vanilla HTML/CSS/JavaScript — no frameworks, no build steps. Just clone and open index.html.

git clone https://github.com/setuju/ecotrack.git
cd ecotrack
python3 -m http.server 8000

🛠️ How I Built It

Tech Stack

Frontend: HTML5, CSS3 (Glassmorphism, CSS Grid/Flexbox), Vanilla JavaScript (ES6+)
Charts: Chart.js (both pie and bar views)
Backend/Storage: Supabase (PostgreSQL) with anonymous device‑ID sync
Data Sources: EPA, IPCC, Poore & Nemecek (2018) Science, Electricity Maps
Dev Server: Python http.server

The Hardest Parts

1. Balancing accuracy with simplicity

I needed enough inputs to be meaningful, but not so many that users bounce. I grouped 15+ fields into collapsible sections and pre‑filled defaults based on global averages.

2. Anonymous cloud sync without login

I didn't want to force sign‑up. Solution: generate a persistent device_id in localStorage, and if the user accepts cookies, sync their footprint to Supabase using that ID. Row‑Level Security ensures they only see their own data.

3. Chart.js "undefined" errors

When toggling between pie and bar charts, I kept getting broken charts. The fix: properly destroy the previous Chart instance before creating a new one, and always use a fresh canvas context.

How GitHub Copilot Helped (Prize Category)

I actively used GitHub Copilot throughout development. Here's exactly where it shined:

Task	Copilot's Help
Emission factor lookup	Wrote the entire `EMISSION_FACTORS` object with realistic values after I typed `// per km gasoline car`
Chart configuration	Generated the complete Chart.js options object — I only tweaked colors
Tooltip CSS	Created the `.tooltip` and `.tooltiptext` classes from a single comment
Share button logic	Wrote the `shareToX()` and `shareToFacebook()` functions with correct URL encoding
Recommendation messages	Suggested realistic tips like "Reducing weekly driving by 20 km saves ~200 kg CO₂/year"

Without Copilot, I would have spent hours on boilerplate and docs. With it, I focused on UX and architecture.

🏆 Prize Categories

I'm submitting this project for the following prize category:

✅ Best Use of GitHub Copilot

(I used Copilot to accelerate development — generating emission factors, chart configs, share logic, and personalized recommendation text.)

🙏 Thank You

Thank you to the DEV Community and the Weekend Challenge judges for organizing this inspiring event. It was a joy to build something meaningful for Earth Day.

If you find this project useful, I'd really appreciate a ⭐ on GitHub!

This is a submission for the Weekend Challenge: Earth Day Edition

The Silicon Valley Database Graveyard: What 7 Dead Migrations Taught Me About The Illusion of “Modern”

HARD IN SOFT OUT — Fri, 17 Apr 2026 18:28:21 +0000

Prologue: The Most Expensive Myth in Tech

I have a map. It’s not a map of streets or trade routes. It’s a map of failure. Over fifteen years as a database architect and a “last resort” firefighter, I’ve charted the precise coordinates of technological shipwrecks. I call it the Silicon Valley Database Graveyard.

In this graveyard, the headstones aren’t marked with names, but with financial death tolls: “Here lies a $8.9 Million Migration,” “R.I.P. to 847 Million Corrupted Records,” and the most heartbreaking epitaph of all: “We Just Wanted to Be Web-Scale.”

What’s the number one cause of death for these projects? It’s not bad code. It’s a single, seductive, and catastrophically expensive lie: “This database is newer, so it must be better.”