DEV Community: MAGNETiX

How VS Code (and Explorer UIs) Quietly Programmed My Brain

MAGNETiX — Tue, 02 Jun 2026 23:43:13 +0000

I thought something was wrong with my VS Code setup.

Turns out nothing was wrong with VS Code.

It was my brain.

Or more specifically:
my brain had been trained for decades by Explorer UIs.

The Tiny UI Convention I Never Questioned

For years, my folders looked like this:

001_start.md
002_notes.md
003_update.md
...
011_latest.md

Newest files at the bottom.

Why?

Because almost every file explorer since the 90s silently taught us:

Top = old
Bottom = new

I never consciously chose this model.
I inherited it from operating systems.

Windows Explorer.
Finder.
Nautilus.
VS Code.
Everywhere.

And after enough years, the pattern stops feeling like UI design and starts feeling like “reality”.

The Moment I Noticed It

I’m currently building a structured “Brain” system for my projects.

Daily discussions.
Architecture decisions.
Research logs.
Codex files.
Chronological project memory.

The structure itself was fine:

2026-06-03/
001_initial_discussion.md
002_structure_notes.md
003_final_codex.md

But every time I opened the folder, something felt inefficient.

Why was the newest context always at the bottom?

Especially because every other modern information system already solved this differently:

chats → newest first
notifications → newest first
logs → newest first
Grafana → newest first
journalctl → newest first
monitoring dashboards → newest first
timelines → newest first

Modern operational systems prioritize recency.

But file explorers still largely inherit a document-era mental model.

A model optimized for printed paper stacks instead of living information streams.

The Weird Part

When I finally enabled reverse sorting in VS Code:

"explorer.sortOrderReverse": true

my first reaction was:

“This feels wrong.”

Not because it was wrong technically.

Because my brain had been conditioned.

That realization was honestly fascinating.

A single UI convention had quietly shaped how I thought about:

chronology
importance
navigation
recency
workflow structure
information access

for almost two decades.

Then Something Unexpected Happened

After about 15 minutes, the new layout suddenly felt obvious.

My folders now looked like this:

2026-06-03/
011_latest_context.md
010_previous_step.md
009_older_note.md

And immediately:

active work became easier to access
current context became visually dominant
scrolling decreased
cognitive friction dropped

Most importantly:
the explorer now matched how my brain actually works during development.

File Explorers Are Not Neutral

This is the interesting part.

Developer tools don’t just help us work.

They train us.

Quietly.

Continuously.

Over years.

We usually think about programming languages shaping thought.
Or frameworks shaping architecture.

But UI conventions shape cognition too.

And because they are subtle, we rarely question them.

The Bigger Lesson

Sometimes workflow optimization is not about adding tools.

It’s about noticing invisible assumptions.

The defaults we inherited.
The patterns we stopped questioning.
The mental models installed by software we used every day.

In my case, the solution was literally one setting:

"explorer.sortOrderReverse": true

But the interesting part wasn’t the setting.

It was realizing how deeply a tiny design decision from old Explorer UIs had programmed my perception of “correct” chronology.

And honestly?

Now I can’t imagine going back.

Why is my browser using THAT audio device?

MAGNETiX — Sun, 31 May 2026 10:03:01 +0000

Today I finally switched one of my Linux/KDE systems from classic PulseAudio to PipeWire — and honestly… this is the first time Linux audio suddenly made visual sense.

I opened qpwgraph and immediately saw my entire live audio topology:

microphones
browser streams
speakers
monitor channels
MIDI devices
USB capture devices

…and suddenly debugging audio became almost fun.

At first I only saw MIDI nodes and thought something was broken:

14:Midi Through
Midi-Bridge

Turns out my system was still running classic PulseAudio:

pactl info

showed:

Server Name: pulseaudio

After migrating to PipeWire, everything appeared dynamically in the graph.

Now when Firefox opens a tab or requests microphone access, I literally see the stream appear live inside the graph.

Very funny moment:
I instantly noticed:

browser audio routed to the wrong output
microphone permissions failing
applications using unexpected devices

This is the kind of visibility Linux audio was missing for years.

Installation (Debian/KDE)

execute as root

apt install pipewire pipewire-pulse wireplumber qpwgraph pavucontrol

Then disable old PulseAudio:

systemctl --user --now disable pulseaudio.service pulseaudio.socket

Enable PipeWire:

systemctl --user --now enable pipewire pipewire-pulse wireplumber

Restart user session or reboot.

Verify:

pactl info

Expected result:

Server Name: PulseAudio (on PipeWire ...)

Then launch:

qpwgraph
Screenshot

“This is where Linux suddenly becomes a modular audio laboratory.”

(Insert screenshot here)

What I really like:

graphical patching of audio streams
live visibility of browser/device routing
JACK-style workflows without pain
debugging WebRTC/microphone issues visually
OBS + browser + USB devices all in one graph

Honestly impressive how far Linux audio has evolved.

Why DMX Infrastructure is Still Stuck in the 90s

MAGNETiX — Sat, 23 May 2026 00:41:39 +0000

Screenshot tomorow…

Every lighting manufacturer ships PDFs.

Every lighting software rebuilds fixture profiles manually.

Every technician copies channel mappings again and again.

And somehow this is still normal.

So I started building an AI-powered OpenDMX skill for XvX Systems.

The idea:
• Upload fixture manuals
• OCR + parse DMX tables
• Extract channel mappings automatically
• Store fixture knowledge centrally
• Build an open ecosystem for lighting infrastructure

The goal is not another closed lighting software.

The goal is open infrastructure.

Linux-native.
AI-assisted.
Community-maintained.

Current prototype:
https://xvx-systems.de/skills/dmxcontrol?lang=en

Future plans:
• OLA integration
• ArtNet support
• AI-assisted fixture setup
• Web-based patching
• Open fixture database
• Club automation

Lighting infrastructure should behave more like open software ecosystems — not isolated vendor islands.

Today I implemented Hetzner DNS hosting structure to XvX , it checken Zone files acoording to Hetzner and Google @hetznerdev why are txt records so compacted that are long.

MAGNETiX — Wed, 20 May 2026 15:12:42 +0000

VS Code Codex "Create Agent" — and Suddenly Your AI Has the IQ of a Goldfish

MAGNETiX — Wed, 20 May 2026 10:48:50 +0000

At first glance it feels magical:

Click button → AI becomes autonomous engineer.

Reality check:

The moment you do this on a real project, you discover something very funny:

The agent has absolutely no idea what your infrastructure looks like.

No conventions. No memory. No project architecture. No operational rules. No understanding of existing tooling. No clue what was already decided three weeks ago.

So even if your repository already contains:

prompts
configs
standards
workflows
APIs
skill systems
deployment logic
output structures
naming conventions
security policies

…the agent still starts asking things like:

"Where should generated files go?"

Brother. There are 40 markdown files explaining that.

The Funny Part

People imagine "AI Agents" like this:

[ GPT ]
↓
Instant Autonomous Company

But in reality it's more like:

[ GPT ]
↓
Confused Intern With Root Access

And that becomes dangerous surprisingly fast.

Because without infrastructure, the agent starts inventing things.

New folders. New architectures. New APIs. New abstractions. New config formats.

Every five minutes:

"I created a robust scalable foundation..."

No. You created three YAML files and emotional damage.

What Actually Matters

The real product is not the model.

The real product is:

conventions
memory
repository discipline
project instructions
safety boundaries
reproducible workflows
operational structure

The AI is only one component.

Without infrastructure, an agent is basically:

Autocomplete with confidence issues.
What We Do at XvX Systems

Inside XvX we started treating agents less like chatbots and more like workers joining an existing organization.

Meaning:

Every skill has structure.
Every output has a defined location.
Every workflow has routing.
Every system has conventions.
Every AI process is inspectable.
Every automation should be reversible.

A good agent bootstrap should answer things before the agent even asks.

Example:

Use English for code comments.
Do not invent folder structures.
Use existing config files.
Read /prompts first.
Do not modify unrelated files.
Store outputs in user-separated directories.
Avoid destructive commands.

This sounds boring.

But THIS is the infrastructure that turns "AI magic" into something operational.

The Current State of AI Agenting

Honestly?

A lot of current AI agent demos are held together by:

vibes
screenshots
terminal recordings
optimism
caffeine
and one developer screaming internally at 3 AM

And that's okay.

We're still early.

But I think the next big shift is not:

"better prompting"

It's:

operational architecture for AI workers.

The companies that understand this first will build systems that are actually maintainable.

Final Thought

The funniest thing about "Create Agent" was not that it failed.

The funniest thing was realizing:

The AI wasn't stupid.

It simply had no infrastructure.

And honestly?

Most human companies don't either. - sadly

get digital first - then try AI, trust me otherwise you do the job twice :)

Written by MAGNETiX XvX Systems // Cologne

Infrastructure first. Then intelligence.

Building XvX Systems

MAGNETiX — Sat, 16 May 2026 12:42:10 +0000

a Linux-first AI infrastructure project focused on real-world automation, voice AI, OCR, APIs and human-auditable workflows.

Not another AI wrapper.
Trying to build systems that actually help humans work better.

Stack:

Python
Laravel
FastAPI
MariaDB
Asterisk
Whisper
Linux

Currently experimenting with:

AI agents
OCR pipelines
voice interfaces
infrastructure automation
accessibility-aware UX

Greetings from Cologne. 👋

opensource #linux #ai #python #laravel #automation