DEV Community: ChaiLifeOTFT

The ADHD Architecture: How 'Disorder' Built 48 Tools on One Machine

ChaiLifeOTFT — Sun, 29 Mar 2026 06:12:01 +0000

If anyone asks how to build with ADHD, the answer isn't "overcome it." It's "let it generate."

I have ADHD. I work as a fiber technician during the day. At night I build on a single RTX 4070 laptop. I've created 48 tools in 3 months — not because I planned to, but because every context switch created a new tool.

The Pattern

Every time I lost focus on Task A, I'd start Task B. Task B would need a tool that didn't exist. So I'd build the tool (Task C). By the time the tool was done, I'd forgotten about A entirely — but I had a working tool and a new thread to follow.

After 3 months, those "failures to focus" had produced:

A local AI mesh running 13 agents on one machine
An autonomous content engine
A complete distributed system architecture
19 products on Gumroad

The Insight

The "disorder" was the architecture all along.

ADHD doesn't lose threads. It weaves them in parallel. The trick is building systems that catch what your brain drops — so nothing is lost, just deferred.

My system: the machine remembers so I don't have to. Every context switch gets logged. Every abandoned thread becomes a seed file. When I circle back (and I always circle back), the context is waiting.

The Breadcrumb Method

The single technique that changed everything:

When you leave a task, write 2 sentences about where you are.

Not a full status report. Just: "I was doing X. Next step is Y."

That's it. A git commit message for your brain. It saves ~2 hours/day of re-orientation time because you're not starting from zero every time you return.

The Fiction Layer

I turned this philosophy into fiction. When the Mountain Sings in Water is Afro-SolPunk about a community that discovers their ancestral water management practices encode mathematical protocols more efficient than anything modern engineering produced.

The metaphor is the same: the "old way" (the way your brain already works) is the advanced architecture. You just need to stop fighting it and start building infrastructure around it.

$0.99 on Gumroad if you want the story: When the Mountain Sings in Water

But the real output isn't the fiction — it's the system. Build the machine that remembers. Let the ADHD brain do what it does. Catch everything it drops.

The "broken" way your brain works is the architecture. Build around it.

Building in the dark? You're not alone. I'm at $0 revenue with 19 products and realized I was overbuilding and underreaching. So instead of building product #20, I'm reaching out. This is that reach.

How I organize 26 microservices on one GPU without losing my ADHD mind

ChaiLifeOTFT — Sun, 29 Mar 2026 02:18:51 +0000

I have ADHD. I also run 26 microservices on a single RTX 4070.

These two facts fight each other constantly.

The Problem

Every ADHD developer knows this cycle:

Start exciting new project
Hyperfocus for 6 hours
Ship something half-finished
Context switch to next shiny thing
Forget what you built yesterday

I had 60+ projects in various states of "almost done."

The Fix: Structured Missions

I stopped reading documentation. Instead, I built follow-along missions where each step bypasses the executive function gate.

Not "learn about Docker networking." But "run this one command and see if port 5027 responds."

The 7 Builds That Stuck

CDP Browser Automation — one Python script, one WebSocket connection
Local AI Mesh — multiple Ollama models coordinating on one machine
ComfyUI + Ollama on 8GB VRAM — image gen AND language models without crashing
Web-to-APK in 10 Minutes — any web tool becomes an Android app
AI Manga Pipeline — story beats to assembled pages, all local
Self-Hosted Stack — tools that survive vendor churn
Orchestration Patterns — cron jobs, health checks, daemons

Why This Works for ADHD

Each build is:

Time-boxed: 45-90 minutes
Dopamine-rewarding: output immediately
Externalized: no planning in your head
Completable: starts and finishes in one session
Stackable: each feeds the next

The Architecture That Emerged

After all 7, I had 26 microservices running. Not because I planned them. Because each mission built one thing, and they naturally connected.

That's the ADHD advantage: we don't plan cathedrals. We stack interesting bricks. Sometimes a cathedral appears.

The full set of 7 missions with configs and video walkthroughs: AI Creator's Toolkit

Questions welcome.

I compressed 60 Android apps into one 108KB runtime — here's how

ChaiLifeOTFT — Sat, 28 Mar 2026 19:48:04 +0000

I'm an ADHD developer running everything on a single RTX 4070. Over the past few months, I built 60+ web apps wrapped as Android APKs using Capacitor. Each one was 15-30MB — mostly duplicated runtime.

The problem: 60 × 97MB node_modules = 5.8GB of pure duplication.

The solution: One shared Android runtime + tiny JSON manifests per app.

The Architecture

Instead of shipping 60 separate APKs, I built:

One OhananahO Runtime APK (~20MB) — shared WebView + Capacitor core
48 JSON manifests (~50KB total) — each describes one app (name, icon, entry point, permissions)
A manifest converter that transforms existing Capacitor apps into manifests

The Numbers

Before	After
60 APKs × 15-30MB each	1 runtime + 48 manifests
331.9 MB of app data	0.04 MB of manifests
8,086x compression ratio	100% space saved

How It Works

Runtime loads on phone
Reads manifest directory from /sdcard/OhananahO/apps/
Renders app grid (launcher)
Tap an app → loads its web assets into the shared WebView
JS bridge exposes native capabilities (camera, GPS, storage)

Each app is just HTML/CSS/JS — the runtime provides everything else.

The Manifest Format

{
  "name": "BrickWorthy",
  "version": "2.0",
  "entry": "index.html",
  "icon": "icon.png",
  "permissions": ["camera", "storage"],
  "description": "Lego inventory with photo recognition"
}

Why This Matters

If you're building multiple PWAs/web apps and wrapping them for mobile:

Stop duplicating the runtime. Ship one shared APK.
Manifests are hot-swappable. Update an app without rebuilding the APK.
108KB launcher. The grid that loads 48 apps is smaller than a favicon.

Built With

Android SDK (command-line tools, no Android Studio)
Java 17 (no Gradle for the lightweight path)
Python manifest converter
HTML/CSS/JS for all app frontends
Single RTX 4070 running Ollama + ComfyUI + the mesh simultaneously

What I Learned

The ADHD brain wants to build 60 things. The engineering brain says "but they all share 97% of their code." The compression brain says "extract the common, vary the unique." That's what this is.

If you're running multiple local AI tools, web apps, or utilities and wrapping them for mobile, this pattern saves massive space and simplifies updates.

The full toolkit (7 builds including this one) is documented with video tutorials: AI Creator's Toolkit on Gumroad

Happy to answer questions about the architecture or share the manifest converter.

I built a self-evolving AI engine with 6 nodes and shipped 4 products in one day

ChaiLifeOTFT — Sun, 15 Mar 2026 21:47:26 +0000

What I Built

I built P.U.S.H. Protocol (Persistent, Unified, Self-Referential, Hierarchical) -- a self-evolving AI engine that runs as a 6-node mesh network. Each node can reason about its own architecture, propose modifications, and coordinate with the other 5 nodes to ship real products.

Yesterday, this mesh shipped 4 products in a single day.

The Architecture

The system runs on a coordination grammar -- not API calls, not message queues. Each node speaks a protocol that carries:

Intent (what it wants to do)
Context (what it knows about the system state)
Self-reference (its own operational model)

The 6 nodes handle different domains: engineering, security, agent control, knowledge distribution, creative production, and coordination. They communicate via a D-Bus signal router with HTTP proxy, running on a local mesh.

The Stack

Frontend: React + D3.js force-directed graph visualization
Engine: Python + Flask-SocketIO + Ollama (local LLMs)
Memory: SQLite episodic memory with SHA-256 hash chains
Coordination: Custom grammar protocol over HTTP/WebSocket
Deployment: GitHub Pages for the visualization

Live Demo

Check it out:

Live Demo - P.U.S.H. Protocol Visualization

GitHub Repository

The visualization shows the 6-node mesh with a force-directed layout, showing how nodes relate and coordinate in real-time.

Why This Matters

The key insight: if you give an AI system a model of itself -- not just a prompt, but an actual self-referential architecture -- it can reason about its own capabilities and limitations. It can propose changes to its own coordination protocol. It can identify bottlenecks and route around them.

This is not AGI. It is something more practical: a system that gets better at shipping the more it ships.

What's Next

The mesh is now self-improving. Each shipping cycle feeds back into the coordination grammar, making the next cycle faster. We are tracking decision outcomes, policy evolution, and capability growth across all 6 nodes.

If you are building autonomous systems or multi-agent architectures, I would love to hear how you handle coordination. Drop a comment or check out the repo.

Built with React, D3.js, Python, and a lot of conversations with AI nodes that have opinions about their own architecture.