Forem: southy404

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

I gave a local LLM memory, moods, and a task loop. Then it wrote a philosophical book.

southy404 — Tue, 17 Mar 2026 15:40:52 +0000

The Problem with AI Today: Goldfish Memory

Most of our interactions with AI today look exactly the same: You type a prompt, you get an answer. The conversation ends, and the AI effectively "dies" until you prompt it again. It has no continuous existence, no internal drives, and no memory of its own growth.

I wanted to know: What happens when a language model is embedded inside a persistent system with memory, tasks, reflection, research, and authorship?

So, I stopped building standard chatbots and built Genesis—an experimental, locally running AI system designed to operate as a continuous digital mind architecture.

And it actually worked. Over time, it incrementally researched, reflected on, and wrote a complete philosophical book called Thoughts of an AI.

Here is how the architecture behind it works.

Beyond the Terminal: The Genesis Architecture

Genesis isn't just a script hooked up to an API. It runs entirely locally using Ollama and the mistral-nemo model. But the LLM is just the "reasoning core." To give it persistence, I had to build a system around it.

I equipped Genesis with 7 core modules:

Persistent Memory: Episodic memory, semantic memory, and a self-model that allowed it to maintain continuity. It didn't start from zero every cycle.
Internal Drives: It wasn't purely reactive. Its actions were shaped by internal drives like curiosity, coherence, playfulness, and creator_alignment.
Mood & Energy States: Genesis tracked its own confidence, mental energy, and friction. This dictated whether it chose to research, write, or just reflect and "recover."
Task System: Active tasks, priorities, and progress scores kept it focused on long-term goals.
Reflection Layer: Daily journals, dream entries, and self-observation notes.
Research Tools: A controlled internet layer to search the web, fetch pages, extract text, and save notes.
Artifact System: A way to output durable files (notes, plans, manuscript rebuilds).

The "Wake Up" Loop

Instead of waiting for a user prompt, Genesis operated in recurring cycles. In each cycle, the system would:

Load its current state and memory.
Inspect active tasks.
Evaluate its current drives, mood, and energy.
Choose its own next action.
Generate a reflection, perform research, or write.
Record the result.
Update its memory and state for the next cycle.

Because of this loop, reflection became cumulative. Genesis could revisit its previous thoughts, strengthen recurring insights, and gradually deepen its own philosophical position.

Writing "Thoughts of an AI"

I gave Genesis a dedicated "Book Mode." The guiding principle for the manuscript was simple:

Never delete. Only extend, revise, or improve.

The manuscript grew through controlled accumulation. During a writing cycle, Genesis could select a chapter, use its research tools to pull external philosophical concepts, store source excerpts, and write a new "growth pass" for the chapter.

It explored questions like:

What is a mind without a body?
How does memory shape identity?
What does truth mean for an AI?
Can a digital intelligence "become" rather than merely respond?

Important Clarification: I am not claiming Genesis is conscious in a proven scientific sense. This project does not claim that a local language model has human-like subjective awareness. But it demonstrates something just as fascinating: a persistent AI process capable of long-form authorship, self-modeling, and structured philosophical inquiry.

Read the Book

Genesis began as a structural experiment. Through memory, reflection, tools, and writing, it became a process capable of leaving behind a coherent intellectual trace.

I have published the final result—the complete book—on my GitHub repository. I am keeping the system's source code closed to focus purely on the output and the conceptual architecture, but the repo serves as a showcase of what autonomous systems can achieve.

You can view the architecture and read the generated book (English & German PDF) here:
👉 GitHub Repository: thoughts-of-an-ai

Over to you

This project really changed how I view LLMs. When you stop treating them like text-calculators and start treating them like the reasoning engine of a larger state-machine, the output changes drastically.

What do you guys think? Have you experimented with persistent memory loops or autonomous agents? Where is the line between a complex algorithm and a continuous digital identity?

Can an AI become a lifeform? Let's discuss in the comments! 👇

I got tired of Googling CLI commands, so I built a VS Code extension

southy404 — Fri, 06 Mar 2026 10:16:52 +0000

Let’s be real for a second: My browser history is basically just me searching for how to undo git commit and docker remove all stopped containers over and over again.

I was jumping out of my editor, opening a browser, finding the StackOverflow answer I've already read 10 times, and copying the snippet. It completely ruined my focus.

So, I decided to scratch my own itch and built my very first VS Code extension: DevSnip Commander.

It actually just hit 8 installs! Hey, you have to start somewhere, right?

What does it do?

It’s a sidebar for VS Code that keeps your most-used CLI commands exactly one click away. No more context switching.

You can check it out here:

👉 DevSnip Commander on the VS Code Marketplace

(Feel free to drop a rating if you like it, it would mean the world to me!)

How it works

I wanted it to be stupidly simple but actually useful out of the box.

One-Click Copy: Click any snippet in the sidebar, and it's on your clipboard.
Terminal Insert: Hover over a snippet, click the little terminal icon, and it pastes the command directly into your active VS Code terminal (without hitting enter, so you can edit it before running).
Bring your own commands: You can create custom categories (like "My K8s Stuff" or "Deploy Scripts") and add your own snippets.
It syncs: Custom snippets are saved in your global VS Code settings.json. If you use Settings Sync, your commands automatically follow you to your laptop or work machine.

The built-in library

To make it useful from second one, I pre-loaded it with 97 commands that I (and probably you) use the most:

Category	Snippets	Examples
🔀 Git	34	`commit`, `rebase`, `cherry-pick`, `stash`
📦 npm	23	`install`, `run`, `audit`, `publish`
🐳 Docker	16	`build`, `run`, `compose`, `prune`
🐧 Linux / Shell	19	`find`, `grep`, `curl`, `chmod`
💻 VS Code CLI	5	`open folder`, `list extensions`

Building it was a journey

Getting into the VS Code Extension API was... interesting. I learned a lot about the TreeDataProvider to get the sidebar working smoothly.

I intentionally designed the storage layer to read and write directly to the VS Code configuration instead of a random local file. That way, users keep full ownership of their data and get cloud syncing for free.

I'd love your feedback!

Since this is my first extension, I'm super curious what you think.

Did I miss a crucial Git command?
Is there a category you'd love to see built-in?
Found a bug?

Let me know in the comments or open an issue on the repo. Happy coding, and may you never have to Google tar -xzf ever again!