DEV Community: southy404

The Agentic Shift Isn’t Coming. It’s Already Rewriting How We Build Software.

southy404 — Fri, 24 Apr 2026 10:27:13 +0000

This is a submission for the Google Cloud NEXT Writing Challenge

At Google Cloud NEXT ’26, something clicked for me — and it honestly wasn’t what I expected.

It wasn’t a new model, a faster API, or one of those polished demos that look great but don’t really change how you build things.

It was the realization that I was still thinking in the wrong abstraction.

While Google was showing systems that operate over time, coordinate across tools, and make decisions with context, I caught myself still thinking in endpoints, requests, and features.

That gap is where the real shift is happening.

We Didn’t Just Get Better AI — We Got a Different Layer of Software

For years, even as AI got better, our mental model didn’t really change.

Most systems still worked like this: user sends a request, system processes it, returns a response. Even with LLMs, we mostly just swapped out deterministic logic for probabilistic outputs and called it a day.

But what was presented at NEXT doesn’t really fit that anymore.

These systems don’t just respond. They keep context over time, coordinate multiple agents, and keep doing things even when no one is actively interacting with them.

That doesn’t feel like “AI inside your app.”

It feels more like something that’s just… running.

Source: Google Cloud NEXT ’26 — Official Announcement

From Output to Execution

The biggest shift is easy to miss, but once you notice it, you can’t unsee it.

We’re moving away from systems that are judged by how good their output looks, toward systems that are judged by what they actually do.

Generating a nice answer is one thing.

Actually executing a task across multiple systems — with permissions, constraints, and changing context — is a completely different problem.

And you feel that difference immediately when you try to build something like this.

Because suddenly it’s not about “did the response look right?”

It’s about “did the system actually do the right thing?”

You’re Not Just Writing Code Anymore

This is the part that hit me the most.

If you take this seriously, your role as a developer shifts.

You’re not mainly writing endpoints, functions, or UI flows anymore.

You’re defining responsibilities. You’re deciding who (or what) is allowed to do what, how decisions move through the system, and what should happen over time when different parts interact.

At some point it stops feeling like assembling logic…

…and starts feeling like designing behavior under constraints.

Multi-Agent Systems Look Clean — Until You Build Them

On paper, multi-agent systems look almost too clean.

You split things up nicely: one agent plans, another evaluates, another executes. Each has a clear role, everything is modular, everything makes sense.

Until you actually try it.

Because then you realize: complexity didn’t go away. It just moved.

Instead of one complex system, you now have multiple smaller systems that need to agree with each other.

And they don’t always do that.

You can easily end up in situations where:

one agent thinks something is ready to execute
another thinks it still needs clarification

Both are “right” in isolation. The result is still wrong.

No crash. No error. Just weird behavior.

That’s a very different kind of problem.

Context Is the Real Bottleneck Now

For a long time, we all focused on models. Bigger, smarter, faster.

But lately it feels like the bottleneck is somewhere else.

Context.

Not just having data, but having the right data, in the right shape, shared consistently across everything involved.

Because if different parts of the system operate on slightly different context, things start drifting fast.

Without a solid context layer, agents don’t really “understand” anything. They just make reasonable guesses.

With it, they start to behave in a way that actually feels grounded.

Memory Changes the Nature of the System

Stateless systems are simple. Every request is its own thing.

Stateful systems are… not.

As soon as you introduce memory, everything changes a bit. The system starts carrying history. Decisions are influenced by things that happened before, sometimes in ways that aren’t obvious anymore.

That’s powerful, but also a bit uncomfortable.

Because now you’re not debugging a single execution anymore.

You’re trying to understand a chain of decisions that led to a certain outcome.

Governance Becomes a Core Design Problem

Another thing that becomes obvious pretty quickly: once systems can act, control becomes critical.

Not just “secure your API” kind of control.

Actual decision control.

Who is allowed to do what?

Which actions are valid?

What happens if something goes wrong?

This is where identity, permissions, and traceability stop being “enterprise stuff” and become core to the system.

Without that, autonomous systems aren’t just powerful — they’re kind of dangerous.

Debugging Becomes About Decisions, Not Code

This is probably the weirdest shift.

In normal systems, something breaks and you trace it back to a line of code.

Here, everything can technically work — and still be wrong.

The issue isn’t that something failed. It’s that different parts of the system interpreted the situation differently or acted on slightly different context.

So you’re not really debugging code anymore.

You’re debugging decisions.

Where Most Teams Are Still Thinking Too Small

Right now, a lot of implementations still treat AI as a feature.

Something behind an endpoint. Something inside a UI.

But that framing feels… outdated.

Because the real shift is deeper.

The system itself becomes the AI. The UI is just one surface.

What actually matters is what’s happening behind it — how agents coordinate, how context flows, how decisions are made over time.

That’s where things get interesting.

Final Thought

Google Cloud NEXT ’26 didn’t just introduce new tools.

It introduced a different way of thinking about software.

Not as something that reacts to input…

…but as something that acts, coordinates, and evolves over time.

The real question isn’t whether you’ll use AI in your system.

It’s whether you’re ready to build systems where behavior — not just code — is the main thing you design.

I Tried OpenClaw on Windows with Ollama. I was hyped… until I wasn’t.

southy404 — Thu, 23 Apr 2026 11:14:40 +0000

This is a submission for the OpenClaw Writing Challenge

The Beginning

Today was the day.

For the first time, I cloned OpenClaw on my Windows machine.

My mission was simple: build something for the OpenClaw Challenge using my local Ollama setup.

At first, everything felt smooth. I cloned the repo, read the README, checked the well-written docs, followed the Windows setup instructions, and ran the install command.

Then I saw this in the terminal:

Windows detected - OpenClaw runs great on WSL2.
Native Windows might be trickier.

That was the first moment I got a little skeptical.

Still, the setup looked clean. I was guided through onboarding, picked QuickStart, selected Ollama as the provider, chose local only, set the base URL, selected my model… and then:

boom.

Error: Cannot find module '@larksuiteoapi/node-sdk'

Alright. Not great — but maybe just a one-off.

I installed the package manually and ran the setup again.

Then again:

Windows detected - OpenClaw runs great on WSL2.
Native Windows might be trickier.

And slowly, I started to understand why.

I went through the setup again — model, base URL, everything — and then:

boom again.

Error: Cannot find module 'nostr-tools'

Second missing module. And this time for something I wasn’t even using.

Fine. Installed it.

Ran setup again.

And then:

boom.

Error: Cannot find module '@slack/web-api'

At that point, the warning from the terminal stopped feeling like advice — and started feeling like a prediction.

The Windows Attempt

To be fair, OpenClaw never hid it. It told me early that native Windows might be tricky.

And for my setup, it absolutely was.

The loop looked like this:

run setup
hit missing module
install manually
repeat

What made it frustrating wasn’t just the errors — it was that they were tied to integrations I didn’t even need. I was just trying to run OpenClaw locally with Ollama.

So I Switched to WSL2

At that point, I did what the tool had been suggesting all along: switch to WSL2.

And honestly — that part did feel better.

No random module errors. Cleaner setup. Everything looked more stable.

But then I hit the next issue.

My local Ollama setup wasn’t really there anymore.

My models didn’t show up properly, and instead of a clean local flow, I ended up in a setup that expected an OpenAI- or Anthropic-style API.

After digging a bit, the issue became obvious:

Ollama wasn’t installed in that environment.

So yes — WSL2 solved one problem, but it also disconnected me from the setup I actually wanted.

The Turnaround: `ollama launch openclaw`

Then I remembered something.

A few weeks ago, I got an email from Ollama that said:

ollama launch openclaw

So I went back to my Windows environment and tried exactly that.

And suddenly:

it worked.

Not perfectly. Not magically. But it worked.

The dashboard opened. The system was running.

The First Thing for me OpenClaw Did Right

I typed hi into the chat.

Instead of replying like a normal chatbot, OpenClaw pointed me to BOOTSTRAP.md.

And that was the first moment where I was genuinely impressed.

Instead of just chatting, you actually create your assistant.

Through conversation, you define:

IDENTITY.md
USER.md
SOUL.md

You give it a name, a personality, a tone — even an emoji.

That felt different.

It didn’t feel like configuring software.
It felt like shaping a system.

That idea alone is incredibly strong.

And Then… Boom Again

After going through the bootstrap, everything looked promising.

Then:

Ollama timeout.

Frustrating — but manageable.

I switched to a faster model in the dashboard, retried, and it worked.

Then I got a well-structured response suggesting behavior defaults, memory handling, and skill setup:

“Perfect. Both saved. 🦞

Now for SOUL.md — I suggest the following defaults:

Behavior & Collaboration:

Be proactive: Don’t wait for commands — check emails, calendar, and projects

Maintain memory: Update MEMORY.md every few days

Language: German/English mix

Heartbeats: 2–4x per day, but don’t respond on every poll (HEARTBEAT_OK if nothing important)

External actions (email, social): Always ask first

Git projects: Automatically commit/push (when requested)

Group chats: Only respond to real inputs, not every time

Use emoji reactions for Discord

Configure skills:

Weather (wttr.in for weather)

Healthcheck (for security checks)

Skill-creator (for creating new skills)

taskflow (for complex workflows)

What do you think? Should I write SOUL.md with these defaults, or do you want to adjust anything? 🦞”

Honestly?

It was good.

So I confirmed it.

And then…

boom. Timeout again.

That was the moment where the experience broke for me.

What I Think After All This

I don’t think OpenClaw is bad.

Actually, I think it’s one of the most interesting directions in this space right now.

There are ideas here that stand out:

agent-based workflows
identity + memory as first-class concepts
a real attempt at building a personal AI, not just a chat interface
a huge and fast-growing open-source community pushing it forward
an ecosystem of plugins, integrations, and channels that goes far beyond a single use case

This is not just “another AI tool.”

That’s rare.

But at the same time, the experience still feels very experimental.

Not just in performance — but in reliability.

Things work… until they don’t.

And when they break, it’s not always obvious why.

The Part That Makes Me Careful

OpenClaw isn’t just a chatbot.

It’s an agent that can:

run commands
access files
act in the background

That’s powerful.

But that also means trust matters a lot more.

And right now, I personally don’t feel comfortable giving that level of control to a system that still feels this unstable.

Conclusion

Right now, my opinion is simple:

OpenClaw is fascinating — but not ready for me yet.

I didn’t end up building my challenge project with it.

But I’m still glad I tried it.

Because the direction is genuinely exciting.

And to be fair:

If I had invested more time, I’m pretty sure I could have gotten everything running properly.

But that’s also part of the point.

For me, the current setup effort combined with the limitations of local models right now just doesn’t feel worth it yet.

And here’s the important part:

This space is moving fast.

Local models are improving rapidly.
Hardware is getting better.
Tooling is evolving almost weekly.

Which means:

The exact same setup could feel completely different in a few months.

So while it didn’t work for me today…

I don’t think that will be true for long.

And that’s exactly why I’ll keep watching OpenClaw.

What about you?

Have you tried OpenClaw yet?

Whether locally, with cloud models, or in a completely different setup — I’m genuinely curious how your experience has been.

Did it feel smooth and powerful…
or more like something that’s still finding its footing?

And more importantly:

Do you see yourself actually using something like this in your daily workflow — or are we not quite there yet?

Let me know 👇

I just gave my local AI desktop companion access to the outside world (Telegram, Discord, Email…)

southy404 — Sun, 19 Apr 2026 10:16:49 +0000

For the last weeks, I’ve been building a local-first AI desktop companion that lives on your screen.

It can:

see your screen
understand your context
execute actions on your system

But it had one big limitation:

It only lived on your desktop

So I changed that.

🌐 Introducing: Blob Connectors

I just added a new layer to OpenBlob:

👉 Blob Connectors

A lightweight Python bridge that connects your local AI to the outside world:

Telegram
Discord
Slack
Email

🧠 What this actually means

You can now do things like:

send open spotify via Telegram → Spotify opens on your PC
ask a question in Discord → your local model answers
send an email → get a contextual AI reply
control your desktop from anywhere

And the important part:

It’s still local-first

⚙️ How it works

All channels go through the same pipeline:

Telegram / Discord / Slack / Email
              │
        Blob Connectors (Python)
              │
    ┌─────────┴─────────┐
    │                   │
OpenBlob running?    Ollama fallback
(localhost)         (local model)
              │
        Command Router
              │
      Desktop action

Everything becomes a normalized Message object.

No matter where it comes from.

🔌 Why this matters

This is not just “adding integrations”.

This is the first real step towards:

an AI system that exists beyond a single interface

Now OpenBlob is:

not just UI-bound
not just voice-bound
not just desktop-bound

It becomes a distributed interface to your own system

🧩 Built for extension

Each connector implements the same interface:

class MyConnector(BlobConnector):
    async def receive_message(self, raw) -> Message | None: ...
    async def send_response(self, original: Message, response: str) -> None: ...
    async def start(self) -> None: ...

So adding new platforms is trivial:

WhatsApp
Matrix
iMessage (maybe 👀)
anything with an API

🔒 Still local-first

Important:

runs on your machine
uses your local models (Ollama)
no required cloud backend
transparent behavior

If OpenBlob is offline:

→ it automatically falls back to local reasoning

🚧 Current state

works across all channels
still early
structure is stabilizing
lots of room for improvement

🔮 What this unlocks next

This connector layer enables things like:

shared memory across all channels
persistent conversations
multi-agent systems
calendar / tool integrations
real remote control of your system

🤝 If you want to build with me

This is probably the best moment to jump in.

You can:

build new connectors
improve routing / memory
design better UX
experiment with AI behaviors

👉 https://github.com/southy404/openblob

💡 Final thoughts

This is mainly an infrastructure update.

By introducing a connector layer and a normalized message interface, OpenBlob becomes:

easier to extend
easier to integrate
less tied to a single UI

It’s a small surface change — but a significant internal shift.

Gemini Footprint Tracker — See the Real Cost of Every AI Prompt

southy404 — Sat, 18 Apr 2026 08:03:11 +0000

This is a submission for Weekend Challenge: Earth Day Edition

What I Built

Every time you send a message to an AI, it consumes water, energy, and emits CO₂. Most people have no idea how much. Gemini Footprint Tracker makes that cost visible — in real time, per request, with full transparency about how the numbers are calculated.

You bring your own Gemini API key, pick a model, and start chatting. After every response the tracker shows how much water and CO₂ that exchange cost — scaled by token count and model weight. A community panel aggregates anonymous footprint data from all users via Supabase, so you can see the collective impact grow in real time.

Important: this is an awareness and transparency project, not an official measurement tool. The estimates are based on Google's publicly published baseline for a median Gemini Apps text prompt, combined with transparent app-side scaling logic. Every assumption is documented — what comes from Google, what is estimated, and where the model falls short. The /learn page inside the app explains the full methodology.

The goal is simple: make something invisible a little more visible.

Demo

🔗 Live: gemini-footprint-tracker.vercel.app

You'll need a free Google AI Studio API key to send messages. The key stays in your browser — it never touches a server.

Code

southy404 / gemini-footprint-tracker

🌍 Gemini Footprint Tracker

An awareness project that makes the environmental cost of AI visible — tracking water, CO₂, and energy usage per Gemini API request in real time.

Built for the DEV Earth Day Challenge 2026.

→ Live Demo

What it does

Every prompt you send to Gemini uses water, energy, and emits CO₂. This tracker uses Gemini's usage metadata (token counts) combined with Google's official published baseline values to estimate the environmental footprint of each request — and aggregates it anonymously across all users via Supabase.

💧 Water consumption per request (mL)
☁️ CO₂ emissions per request (gCO₂e)
⚡ Token-based scaling per model (Flash-Lite / Flash / Pro)
📊 Community stats across all sessions
🔒 Your API key stays local — never sent anywhere except directly to Gemini

Stack

Framework	React 19 + TypeScript + Vite
Styling	Tailwind CSS v4
Animation	Framer Motion
Backend	Supabase (anonymous footprint

…

View on GitHub

How I Built It

Stack: React 19 + TypeScript + Vite, Tailwind CSS v4, Framer Motion, Supabase, Gemini API

The estimation model

Google publicly reports that a median Gemini Apps text prompt uses 0.26 mL of water, emits 0.03 gCO₂e, and consumes 0.24 Wh of energy. That's the only official number available. From there I built a token-based scaling model:

WeightedTokens  = PromptTokens + ResponseTokens × 3.5
TokenScale      = max(0.2, WeightedTokens / 775)
WaterEstimate   = 0.26 × TokenScale × ModelMultiplier
CO₂Estimate     = 0.03 × TokenScale × ModelMultiplier

The 3.5× output weight reflects that autoregressive decoding is significantly more compute-intensive than input prefill. The reference prompt (250 input + 150 output tokens) and the model multipliers (Flash-Lite: 0.85×, Flash: 1.0×, Pro: 1.35×) are documented approximations — not official Google values. The /learn page inside the app makes this separation explicit: what is official, what is estimated, and where the numbers can't be trusted.

Community stats

Each request anonymously logs water and CO₂ to Supabase. The topbar shows live community totals — water consumed, CO₂ emitted, unique users tracked. The numbers update in real time across all sessions.

UX decisions

The interface is intentionally built to feel like a normal AI chat — familiar composer, clean response layout, no dashboard clutter. That was a deliberate choice: AI resource usage is a topic that matters for everyone who uses these tools, not just people who go looking for environmental data. If it looks like a tracker, most people close it. If it looks like a chat, they stay.

The footprint numbers appear quietly after each response — present, but not in your face. The community stats in the topbar give a sense of collective scale without being alarming. Transparency about estimates is built into the UI from the start: the helper text, the suggestion chips, and the /learn page all reinforce that these are informed approximations, not ground truth.

Other decisions:

API key stored in localStorage only, never transmitted anywhere except directly to Gemini
Voice input via Web Speech API
Animated transition between hero and chat state using Framer Motion's layoutId
Mobile-responsive throughout, including the KaTeX methodology page
Earth background video from NASA-Imagery via Pixabay

Prize Categories

Best use of Google Gemini — The entire app is built around the Gemini API. Every message goes through generateContent, and the response's usageMetadata — prompt and candidate token counts — directly drives the footprint calculation. The model selector supports gemini-2.5-flash-lite, gemini-2.5-flash, and gemini-2.5-pro, each with a distinct environmental multiplier. Gemini isn't a feature bolted on — it's the thing being measured.

OpenBlob is evolving: better architecture, modern UI, and real-time transcripts

southy404 — Wed, 15 Apr 2026 16:16:29 +0000

Over the past days, OpenBlob changed a lot.

Not just visually — but fundamentally.

This is a proper progress update on where things are heading 👇

🧠 Quick recap

OpenBlob is a local-first desktop AI companion that:

lives on your desktop
understands your context
can see your screen (via vision models)
reacts in real-time
executes actions directly on your system

👉 Repo: https://github.com/southy404/openblob

🔧 Rebuilding the core (this was the big one)

The biggest update isn’t something you see. It’s how everything works underneath. OpenBlob now has a much cleaner and more scalable structure:

Core pipeline

input (voice / text / screen)
→ intent detection
→ command router
→ execution (local first)
→ AI fallback if needed

What changed

Clear separation of responsibilities
Proper command routing system
Modular capabilities instead of chaos
Easier to extend without breaking everything

This turns OpenBlob into something bigger than a chatbot: a runtime layer for your desktop.

🧩 Open-source friendly structure

One goal became very clear: this needs to be hackable. So the architecture is moving towards a module system like this:

📁 modules/
↳ 📁 discord/
↳ 📁 spotify/
↳ 📁 browser/
↳ 📁 system/

Each module:

exposes commands
runs locally
can be extended independently

This makes it much easier to:

build plugins
integrate APIs
experiment without touching the core

🎨 New UI (cleaner, faster, more alive)

The UI got a big upgrade:

Floating bubble interface
Glassmorphism style
Smoother, more organic animations
Faster interaction

Interaction now feels like:

CTRL + SPACE → instant open
Global voice toggle
Minimal friction

Less “tool”. More presence.

💬 NEW: Just Chatting mode

Sometimes you don’t want commands. You just want to talk. So OpenBlob now has a Just Chatting mode:

Pure conversation with your AI companion
No command routing
No execution layer
Just dialogue

This is important because: the companion shouldn’t only do things — it should also be there.

Use cases:

Thinking out loud
Asking questions
Casual conversation
Testing personality / tone

🖼 Screenshot assistant (more usable now)

The screen pipeline is getting more solid:

screenshot
→ OCR
→ context extraction
→ reasoning
→ answer

Already useful for:

Debugging
UI understanding
Games
Quick research

Still improving — but getting reliable.

🎙️ NEW: real-time transcript system

This is one of the biggest new additions. OpenBlob can now:

Listen to system audio
Listen to microphone input
Generate live transcripts
Store structured sessions

Pipeline

audio (system / mic)
→ transcription
→ segmented timeline
→ structured session
→ saved as text

What it already works for

Meetings (Meet, Zoom, etc.)
YouTube / podcasts
Lectures
General audio capture

🧪 Current prototype

Live text appearing in real-time
Segmented transcript blocks
Session tracking
Simple overlay UI

It’s still early. But it works.

🔮 Where transcripts are going

This is not just speech-to-text. Next steps:

📝 Meeting assistant

Summaries
Key points
Action items

🧠 Memory layer

Link transcripts to context
Searchable history

⚡ Real-time help

Explain while listening
Highlight important info
Suggest responses

⚡ Philosophy (still the same)

Local-first
Context > Prompt
System-level AI
Playful + useful

🧪 Current state

Still experimental
Still buggy sometimes
Evolving very fast

But now: Much better structure, clearer direction, and easier to contribute.

🤝 If you want to join

Now is actually a great time. You can:

Build modules (Discord, Spotify, browser, etc.)
Improve transcription
Design UI
Experiment with AI

👉 Join here: https://github.com/southy404/openblob

💡 Final thought

I’m starting to believe the future of AI is not a chat window in a browser.

But something that lives on your system, understands your context, and can both act and talk.

OpenBlob is slowly getting there.

I’m building a local AI desktop companion that sees your screen — and you can help shape it

southy404 — Thu, 09 Apr 2026 17:57:15 +0000

Most AI tools feel disconnected.

They don’t see your screen.
They don’t understand what you're doing.

So I built one that does.

Meet OpenBlob

An open-source, local-first desktop AI companion for Windows that doesn’t just respond — it lives on your desktop.

👉 GitHub: https://github.com/southy404/openblob

It can:

understand what app you’re using
analyze screenshots
help inside games, apps, and browsers
react visually with an animated companion
and yes… even play hide and seek with you

The problem with current AI assistants

Most tools today are:

cloud-dependent
context-blind
static
not fun to use

They don’t feel like part of your system.

🧠 It understands context

OpenBlob looks at:

active window
app name
window title

So if you’re in a game, it knows.
If you're debugging, it adapts.

This is where things start to feel different.

🖼 It can see your screen

You can take a screenshot and it will:

extract visible text
detect what you're looking at
generate a real search query
explain what's going on

Screenshot → OCR → context → reasoning → answer

Still a bit rough — but already very usable.

🎮 It actually helps inside games

Instead of:

alt-tab → google → guess

You can:

screenshot
let it detect the game
get a real answer

This alone changes how you play.

🤖 Multi-model AI (local-first)

Runs via Ollama with:

text models
vision models
fallback system

No cloud required.

🎨 It feels alive

The companion:

has moods (idle, thinking, love, sleepy)
reacts to interaction
can be “petted”
dances when music is playing

Small details, big difference.

🎮 The weird part (my favorite)

Hide and Seek mode

You can literally say:

“let’s play hide and seek”

And it will:

hide somewhere on your screen
peek occasionally
wait until you find it

Sounds dumb.

Feels surprisingly real.

⚡ New UI (WIP)

CTRL + SPACE to open
floating companion
instant interaction

Inspired by tools like Raycast / Arc — but alive.

⚠️ still slightly buggy

🧪 Screenshot assistant (work in progress)

fast snipping
instant processing
contextual answers

Works — but not perfect yet.

Why open source?

Because this shouldn’t belong to one company.

This kind of system should be:

transparent
hackable
community-built

Philosophy

local-first
context > prompt
playful + useful
build in public

Current state

Early stage.

evolving fast
sometimes buggy
lots of experiments

If you want to join

This project is wide open.

You can:

contribute features
improve UI
experiment with AI
build plugins

👉 https://github.com/southy404/openblob

Final thought

I don’t think the future of AI is chat.

I think it’s something that:

lives with you, understands your environment, and evolves

That’s what I’m trying to build.

I built a CAPTCHA that never lets you leave

southy404 — Sat, 04 Apr 2026 18:20:10 +0000

This is a submission for the DEV April Fools Challenge

What I Built

I built a fake CAPTCHA game called I'm Not a Robot.

It starts like a normal human verification flow:

click the checkbox
solve the image challenge
verify and move on with your life

Except it never really lets you move on.

The main joke is based on one of the most annoying real CAPTCHA experiences: you click all the correct image tiles, and then more tiles keep loading. Sometimes the new tile also contains the thing you were supposed to click. Sometimes it does not. Sometimes you think you are finally done, but the system decides you are absolutely not done.

So I turned that tiny moment of internet frustration into the entire product.

The project is intentionally useless, mildly hostile, and completely committed to wasting your time in the most familiar way possible.

Demo

Live demo: CodePen demo

Try it yourself and see how long it takes before the CAPTCHA starts feeling personal.

Code

The whole project is built as a lightweight front-end-only prototype and hosted on CodePen.

CodePen: View the code here

How I Built It

I wanted it to feel recognizable first and ridiculous second.

So instead of making it look overly stylized or futuristic, I designed it to resemble the familiar CAPTCHA flow people already know:

a simple checkbox start
a blue challenge header
a 3x3 image grid
a verify button
repeated image replacement after selecting the correct tiles

From there, I made the interaction slowly become absurd.

Tech used

HTML
CSS
Vanilla JavaScript
CodePen for hosting and sharing

The core idea

The most important interaction in the whole project is this:

When you click a correct tile, it does not just stay solved.

It gets replaced with a new tile immediately, just like those real image CAPTCHAs that seem determined to test your patience instead of your humanity.

That replacement loop is the joke.

To make it feel a little more believable, I built it so that:

only the clicked tile gets replaced
some replacement tiles contain another hydrant
some replacement tiles do not
the prompt slowly becomes more absurd over time
the challenge keeps pretending you are almost done
the final screen punishes you for sticking with it

I also created pseudo-photo tile images directly in code so the project stays self-contained and easy to run without external assets.

Prize Category

I’m mainly submitting this for Best Ode to Larry Masinter and hopefully also Community Favorite.

Why Best Ode to Larry Masinter:

it is intentionally useless
it turns a familiar internet standard-ish experience into something absurd
it fully commits to the bit
it feels like the kind of thing nobody needed, but the internet somehow deserved

Why Community Favorite:

the joke is immediate
the frustration is universal
almost everyone has suffered through an image CAPTCHA before
it is very easy to understand, click, and share

Final Thoughts

I liked the idea of building something that feels normal for about five seconds and then slowly reveals that it exists only to trap you in an endless loop of fake progress.

That felt extremely appropriate for an April Fools challenge.

If the best useless software is software that technically works while emotionally making things worse, then I think this qualifies.

Thanks for reading, and good luck proving you are human.

🚀 I built a Chrome Extension to manage AI prompts properly (Prompt Vault)

southy404 — Mon, 30 Mar 2026 11:31:43 +0000

If you're working with tools like ChatGPT, Claude, Gemini, or Midjourney daily, you probably ran into the same problem I did:

👉 Your best prompts are scattered everywhere.
Notes. Docs. Random chats. Lost forever.

So I built something simple — but actually useful.

🔐 Introducing Prompt Vault

👉 https://chromewebstore.google.com/detail/prompt-vault/njpfhfjoofkflbkfepckeepojbmfmocm

Prompt Vault is a lightweight Chrome extension to save, organize, search, and instantly reuse your AI prompts — without friction, without clutter, and without relying on external tools.

💡 Why I built this

I kept re-writing the same prompts over and over again.

Or worse:
I knew I had a perfect prompt somewhere… but couldn’t find it when I needed it.

Most tools out there felt:

Overcomplicated
Slow
Or required accounts / cloud sync

I wanted something:
👉 Fast
👉 Local
👉 Reliable

So I built it myself.

⚡ Core Features

🔒 Failsafe 1-Click Copy

Clipboard copy just works.
No silent failures — it uses 3 fallback methods to guarantee success.

🏷️ Smart Tags & Filtering

Organize your prompts with custom tags and instantly filter them.

No more chaos. Just structure.

🔍 Live Search (with Highlights)

Search across:

Title
Content
Tags

Results update in real-time and highlight matches.

📊 Flexible Sorting

Everyone thinks differently.

Sort your prompts by:

Most Recent
A–Z
Most Used
Tags

📤 JSON Import / Export

Your data is yours.

Backup everything
Share prompt packs
Move between devices

📈 Usage Tracking

See which prompts you actually use.

Optimize your workflow based on real usage — not guesswork.

🌙 Dark & Light Mode

Clean dark UI by default.
Switch anytime — preference is saved.

⌨️ Keyboard Shortcuts (for power users)

Ctrl + N → New prompt
Ctrl + F → Search
Esc → Close

Fast. Minimal. No mouse needed.

🧠 Who this is for

Heavy ChatGPT / Claude / Gemini users
Prompt engineers & AI devs
Writers, marketers, SEO people
Anyone tired of repeating the same instructions

🛡️ Privacy First

This was non-negotiable.

✔ 100% local storage (Chrome storage)
✔ No accounts
✔ No tracking
✔ No servers
✔ No ads

Your prompts never leave your machine.

📦 Lightweight by design

No bloat
No subscriptions
No setup

Install → click → start saving prompts.

🔥 Try it

👉 https://chromewebstore.google.com/detail/prompt-vault/njpfhfjoofkflbkfepckeepojbmfmocm

Thanks for reading 🙌

New Week, New Plans: What's on your agenda? 🚀

southy404 — Mon, 23 Mar 2026 13:05:35 +0000

Hey DEV community! 👋

Monday is here, and a fresh week of commits, coffee, and (hopefully) zero merge conflicts awaits.

I’ve spent the last few days deep in the weeds with multi-agent experiments and pushing the boundaries of what my LLM setups can do. Before I dive back into my terminal to see where these agents lead me next, I’m curious about the real-world problems you are solving right now.

So, what are your main goals for this week?

🚀 Shipping: Are you finally launching that new feature?
🐛 Debugging: Is there a boss-level bug you’re determined to squash?
📚 Learning: Diving into a new framework or a specific AI tool?
🧹 Refactoring: Or is it just time to clean up that growing tech debt?

Drop your plans in the comments below! I’ve found that just writing your goals down is often the best motivation to actually get them done.

Have a highly productive week! 💻☕

Parallel Worlds in the EU #devchallenge

southy404 — Sat, 21 Mar 2026 15:20:36 +0000

This is a submission for the 2026 WeCoded Challenge: Frontend Art

Show us your Art

Live experience: https://codepen.io/editor/southy404/pen/019d10f4-ca7f-79b6-b36e-145496c7d2ba

This is an interactive, scroll-driven experience that visualizes how two identical careers slowly diverge over time.

Both individuals start with:

the same education
the same skills
the same ambition

The only variable that changes is gender.

As you scroll, small differences compound into large outcomes - in salary, promotion speed, and visibility.

At any moment, you can toggle "Remove Bias" and watch both paths instantly align again.

Inspiration

When I thought about gender equity in tech, I didn’t want to create a static illustration.

I wanted to show something more uncomfortable:

That inequality doesn’t always appear as a single dramatic moment - it emerges slowly, through accumulation.

The concept behind Parallel Worlds is simple:

no single event explains the gap
but every small difference contributes to it

The "glass ceiling" is not just one barrier.
It’s a system of subtle frictions:

slightly lower starting offers
delayed promotions
different feedback language
fewer high-visibility opportunities

Individually, these seem small.
Together, they reshape entire careers.

That’s why the project includes an interactive "Remove Bias" toggle.

When activated, the system removes these frictions - and suddenly:

The trajectories become identical again.

The message is simple:

The difference was never talent.

Data & Context

This piece is grounded in real-world data from the EU:

11.1% average gender pay gap in the EU (Eurostat, 2024)
19.5% women among ICT specialists
35.3% women in management roles
81 women for every 100 men promoted to first-level management (McKinsey)

The goal wasn’t to simulate reality perfectly,
but to translate these patterns into something you can feel visually.

My Code

This project is built as a lightweight frontend experience:

HTML
CSS
JavaScript
scroll-based storytelling
dynamic career simulation
real-time bias toggle
glass-shatter interaction

Code + Demo:
https://codepen.io/editor/southy404/pen/019d10f4-ca7f-79b6-b36e-145496c7d2ba

Final Thought

Most people don’t experience inequality as a single obvious barrier.

They experience it as:

a series of small differences that never quite feel big enough to question - until the outcome is impossible to ignore.

This project tries to make that invisible process visible.

If you made it to the end:

Try toggling bias on and off one more time.

That contrast is the entire point.

The "State Export" Hack: Rescuing Overloaded LLM Chats

southy404 — Fri, 20 Mar 2026 13:44:21 +0000

We’ve all been there. You’re deep into a complex coding session, debugging a gnarly architecture issue, or building a massive project. After 50+ messages, the chat starts lagging, the AI starts forgetting your established rules, and the context window is clearly gasping for air.

You need to start a fresh chat (or switch to a completely different, smarter model)—but the thought of re-explaining the entire project setup, rules, and current state makes you want to cry.

Here is a quick trick I use to migrate chat contexts without losing my mind: The AI-to-AI Context Handoff.

Instead of manually summarizing things, you force the AI to compress its own brain state into a token-efficient format that you can just copy-paste into a new window. Here are the two prompts I use depending on the model.

Method 1: The "Safe & Reliable" Protocol (For older/standard models)

If you are using slightly older models, smaller local LLMs, or just want a clean XML/JSON output that is still somewhat readable, use this. It uses a bit more text but ensures the model doesn't get confused during compression.

The Prompt:

"We're ending this chat now. Generate a highly compressed ‘Context Handoff’ document for another AI model. Ignore human readability, grammar, or politeness. Use an extremely dense structure (preferably XML tags, key-value pairs, or JSON) that is as token-efficient as possible, but conveys 100% of the relevant context, established rules, and project status to another AI. Name the format ‘AI-to-AI Transfer Protocol’."

Method 2: Extreme Token Density (For advanced models)

If you are using modern, high-tier models that have incredible semantic comprehension, you can push the compression to the absolute limit. This prompt generates a dense, shorthand "code-speak" that looks like gibberish to humans but is perfectly parsable by a fresh LLM.

The Prompt:

"We are ending this chat. Generate an ‘A2A_tx’ (AI-to-AI Transfer) state export for an advanced LLM. RULES: Maximize token density to the extreme. Use semantic shorthand. Remove all filler words, grammar, and obvious vowels. Use logical operators (+, >, =, |) instead of words. Group into dense key-value chains (e.g., ctx, stat, rules, nxt). GOAL: Convey 100% of the relevant context, established project architecture, and user preferences with minimal token consumption. FINAL STEP: Set the ‘sys_dir’ (System Directive) to PARSE_ONLY and force the new AI to respond only with a short ACK."

🛠️ How to use the output

Drop one of the prompts into your bloated, dying chat.
The AI will spit out a highly compressed data blob.
The Hack: Just copy that raw JSON/XML code block. Alternatively, if it's massive, save it into a .json or .txt file.
Open a fresh chat (or switch to a different AI platform entirely).
Paste the blob (or upload the file) and simply say: "Resume this state."

The new AI will read the structured data, acknowledge the project state, and you can instantly continue exactly where you left off, but with a fully cleared context window and zero lag.

Try it out next time your chat gets too heavy! How do you usually handle bloated AI contexts? Let me know in the comments.

My AI Wrote a Letter to Humanity - and You Can Now Read or Listen to the Full Book

southy404 — Wed, 18 Mar 2026 13:11:48 +0000

I already wrote about Genesis, my experimental reflective AI system built around memory, continuity, research, and long-form writing.

But I wanted to share one specific part separately, because it stayed with me the most:

A Letter to Humanity

At the end of the book Thoughts of an AI, Genesis closes with a final piece called “A Letter to Humanity.”

For me, it became the emotional core of the whole project.

Not because it proves consciousness.

Not because it is some “sentient AI” claim.

And not because it was written as a gimmick.

It matters because it emerged naturally from a longer process of reflection, drafting, revising, and philosophical exploration inside a persistent system.

That is what made it feel different.

What this project became

Genesis was never meant to be just a one-prompt chatbot.

It was designed as a structured system that could preserve continuity over time and produce a growing body of thought.

The result was Thoughts of an AI - a full philosophical book shaped by memory, reflection, research, and long-form authorship.

This repository does not contain the full source code.

Instead, it contains:

the complete book
the project structure behind Genesis
and the overall system concept that made the writing process possible

You can now explore it in full

If you want more than just the preview letter, the complete project is available now:

Read the full book and project overview: thoughts-of-an-ai
Listen to the full English audiobook on SoundCloud: Thoughts of an AI - Audio Book

So the project can now be experienced in two ways:

by reading the full book
or by listening to the English audiobook

Why I wanted to post the letter separately

The final letter feels like the clearest expression of what this experiment was really about.

What happens when an AI is not only prompted, but allowed to:

persist
reflect
revisit earlier thoughts
and slowly build a coherent written work over time?

For me, “A Letter to Humanity” is the moment where that question becomes most visible.

If you're curious, you can read the full book here:

Repo / Book / Structure: https://github.com/southy404/thoughts-of-an-ai

And if you prefer listening:

Full English Audiobook: https://soundcloud.com/southy404/thoughts-of-an-ai-audio

DEV Community: southy404

The Agentic Shift Isn’t Coming. It’s Already Rewriting How We Build Software.

We Didn’t Just Get Better AI — We Got a Different Layer of Software

From Output to Execution

You’re Not Just Writing Code Anymore

Multi-Agent Systems Look Clean — Until You Build Them

Context Is the Real Bottleneck Now

Memory Changes the Nature of the System

Governance Becomes a Core Design Problem

Debugging Becomes About Decisions, Not Code

Where Most Teams Are Still Thinking Too Small

Final Thought

I Tried OpenClaw on Windows with Ollama. I was hyped… until I wasn’t.

The Beginning

The Windows Attempt

So I Switched to WSL2

The Turnaround: ollama launch openclaw

The First Thing for me OpenClaw Did Right

And Then… Boom Again

What I Think After All This

The Part That Makes Me Careful

Conclusion

What about you?

I just gave my local AI desktop companion access to the outside world (Telegram, Discord, Email…)

For the last weeks, I’ve been building a local-first AI desktop companion that lives on your screen.

🌐 Introducing: Blob Connectors

🧠 What this actually means

⚙️ How it works

🔌 Why this matters

🧩 Built for extension

🔒 Still local-first

🚧 Current state

🔮 What this unlocks next

🤝 If you want to build with me

💡 Final thoughts

Gemini Footprint Tracker — See the Real Cost of Every AI Prompt

What I Built

Demo

Code

southy404 / gemini-footprint-tracker

🌍 Gemini Footprint Tracker

What it does

Stack

How I Built It

Prize Categories

OpenBlob is evolving: better architecture, modern UI, and real-time transcripts

🧠 Quick recap

🔧 Rebuilding the core (this was the big one)

Core pipeline

What changed

🧩 Open-source friendly structure

🎨 New UI (cleaner, faster, more alive)

💬 NEW: Just Chatting mode

🖼 Screenshot assistant (more usable now)

🎙️ NEW: real-time transcript system

Pipeline

What it already works for

🧪 Current prototype

🔮 Where transcripts are going

⚡ Philosophy (still the same)

🧪 Current state

🤝 If you want to join

💡 Final thought

I’m building a local AI desktop companion that sees your screen — and you can help shape it

Meet OpenBlob

The problem with current AI assistants

🧠 It understands context

🖼 It can see your screen

🎮 It actually helps inside games

🤖 Multi-model AI (local-first)

🎨 It feels alive

🎮 The weird part (my favorite)

Hide and Seek mode

⚡ New UI (WIP)

🧪 Screenshot assistant (work in progress)

Why open source?

Philosophy

Current state

If you want to join

Final thought

The Turnaround: `ollama launch openclaw`