Overthought by Mike

The Bridge That Trembles: A Manifesto for the Divergent

Mon, 06 Apr 2026 00:00:00 GMT

Friedrich Nietzsche never wrote these words, but his ghost certainly haunts them. This piece is a creative exploration and homage to his work Thus Spoke Zarathustra. It takes his concept of the Übermensch—the self-actualized individual who creates their own values—and views it through the lens of the ADHD mind. It is a manifesto for those whose brains are built not for the steady road, but for the storm.

I have seen the "sober ones," and I have seen the "punctual ones." They blink and say, "We have found the rhythm of the clock," and they measure out their lives in small, predictable spoonfuls. But I ask you: who shall be the one to dance when the music is discordant?

The path to the Übermensch is a path of fire, but for you, my brothers of the lightning-mind, the fire does not merely burn—it flickers, it leaps, and it refuses to stay within the hearth. You, who are called "scattered" by the keepers of the Herd! You, who are shamed for your "forgotten vows" and "unfinished altars"! I tell you: one must still have chaos in oneself to give birth to a dancing star.

The Tyranny of the "Straight Line"

The world demands a "constancy," a "plodding gait," a "single eye for a single task." This is the morality of the Camel! The Camel kneels and asks, "What is heavy?" and it carries the weight of the Schedule, the Routine, and the Proper Order. It finds virtue in the long, grey road because it fears the forest.

But the Lion of the Spirit arises! This Lion does not say "I must finish." The Lion says: "I will—for now!" The Herd calls your lack of "persistence" a vice. I call it the Holy Impatience. You do not stick to one task because your spirit is too vast for the smallness of the task! You abandon the half-carved marble not because your hand is weak, but because your soul has already outrun the stone.

The Abyss of the Mundane

Verily, there is a demon that haunts the seeker, and its name is The Trivial. To the one with the storm in his breast, the counting of grains is a greater death than the drowning in the sea. The Herd loves the counting! They find their "truth" in the ledger, the boundary, and the repetition.

The Übermensch of the Restless Mind must not become a clerk to his own life. He does not seek to "fix" the flickering of his focus—for a flame that does not flicker is a flame that is dying. He does not pray for the "focus" of the ox. Instead, he becomes the Master of the Moment. He realizes that he is not a stream that flows in one direction, but a sea that surges at a thousand shores at once.

Amor Fati of the Flight

You must learn to love your "distraction." Do not pray for a "stilled" mind; that is the prayer of the Last Man who wants to be a better sheep, sleeping soundly in the pen.

Instead, practice Amor Fati: Love your fate! Love the "Frenzy" that consumes the midnight oil! Love the "Leap" that carries you from one peak to another, skipping the valley entirely. The Herd only knows the valley; they call the leap a "distraction" because they cannot fly.

The New Law

I write this upon new tablets:

The value of a work is not in its "completion" by the world’s clock, but in the "intensity" of the fire that forged it.
The "Abandoned Path" is not a failure; it is a footprint of a spirit that moves faster than the world can follow.
Self-Overcoming is not the silencing of the many voices within; it is the power to lead them as a choir, even when they sing in a hundred different keys.

The Übermensch of the restless spirit is the one who realizes that "Order" is a cage built by the dull to keep the vibrant from shaking the foundations.

Be the lightning! Be the storm that the Herd fears! And when they ask, "Why can you not sit still?" answer them: "Because I am the bridge to something higher, and a bridge that does not vibrate under the wind is a bridge that will surely break."

The ADHD Act: Why We Build Personas to Stop the Burn

Thu, 26 Mar 2026 00:00:00 GMT

import AudioPlayer from '../../../components/AudioPlayer.astro';

Have you ever been in a simple conversation and felt like your brain was catching fire?

On the outside, you look "normal." But on the inside, your brain is at 100% capacity. You are manually processing every word, calculating a response, checking your posture, and running a real-time "cringe-o-meter" to ensure you haven't said anything weird.

It is a literal, burning discomfort. It’s the friction of being "too much" in a world that asks you to be "just enough." To stop that burn, we do something instinctual: we start The Act.

The Problem of the Moving Target

One of the hardest parts of living with ADHD is that "being yourself" is a technical impossibility. Our internal identity feels like a moving target—our interests, energy, and even our "personality" shift based on dopamine levels or how much we’ve slept.

When your internal rules are fluid and disorganized, it’s hard to trust yourself in a social setting. You don’t know if "you" will be too loud, too distracted, or paralyzed by indecision.

This is why we "download" characters. Unlike our own shifting sense of self, a persona has hardcoded rules. By stepping into a character, we borrow a framework that doesn't fall apart under pressure. It’s not about being fake; it’s about installing a reliable Social OS because our own feels like it’s crashing.

The Mechanics of the Armor

We often build these masks from visual cues—a photo of someone powerful, a specific fashion aesthetic, or a character in a movie. Our brain "downloads" the details: how they hold a glass, their cadence of speech, their physical stillness.

But these aren't just "vibes." They serve specific functional purposes:

The Tommy Shelby: This is often triggered by heavy clothing—like a long winter coat. The weight provides proprioceptive input, and by acting stoic and quiet, we turn internal overwhelm into "calm intensity." The racing thoughts are still there, but they are trapped behind a wall of granite. It's a way of converting chaos into something that looks deliberate—a slow blink, a measured pause—when in reality, we're just trying not to vibrate out of our skin.

Proprioceptive Input: The awareness of posture, movement, and changes in equilibrium, which grounds a restless nervous system.
The Claire Dearing: Based on the "Planner" from Jurassic World, this persona is hyper-organized. We use it when we're drowning in the "shame of the unfinished"—the stack of unanswered emails, the forgotten appointment, the half-completed task list. It allows us to act in control even when we're paralyzed by simple administrative tasks. The irony is that maintaining the illusion of organization often takes more energy than the actual work.
The Tony Stark: When the brain is moving too fast to stay still, we turn impulsivity into a feature. Stark provides the dopamine hit of being "the smartest person in the room," which helps us push social anxiety into the background. We talk fast, deflect with humor, and steer conversations into territory where our hyperfocus becomes an asset instead of a liability. The crash comes later, when the room is empty and the performance has nowhere left to go.
The Dr. House: This is a defense against the agony of "boring" social norms. We act cynical or blunt to protect ourselves from the shame of not being able to handle small talk or illogical rules. Where other personas mask into likability, this one masks into indifference—because if people think you choose to be difficult, they stop expecting you to perform the social rituals that exhaust you most.
The Leslie Knope: This persona is pure hyperdrive people-pleasing. We become relentlessly helpful, enthusiastic, and agreeable—baking metaphorical (or literal) waffles for everyone around us. The function here is fawning: a trauma-adjacent stress response where we prioritize everyone else's comfort to preemptively neutralize any possible friction or conflict. Research from the British Psychological Society identifies this as particularly common in women with ADHD, where the mask of perpetual agreeableness serves as an RSD shield. If we are always giving, nobody has a reason to reject us. The cost is that we drain our own reserves to zero while smiling through every second of it.
The Hermione Granger: When emotions feel too chaotic and unpredictable, we retreat behind facts and preparation. Every answer is researched. Every conversation is steered toward the intellectual. We over-prepare for meetings, rehearse our talking points, and weaponize competence as a defense mechanism. This isn't just "being smart"—it's a deliberate strategy to control the one variable we can: the quality of our output. If we are undeniably correct, the emotional messiness underneath becomes invisible. The exhaustion comes from the hours of invisible preparation that nobody sees—the three drafts of a casual email, the Wikipedia deep-dive before a dinner party.
The Wednesday Addams: Not everyone masks up into a superhero. Some of us mask down into a deliberately flat, detached observer. We minimize facial expressions, keep responses short, and project a deliberate stillness that says "I am choosing to be quiet" rather than "I am overwhelmed and shutting down." This persona reframes social withdrawal as an aesthetic choice. It transforms the paralysis of overstimulation into something that looks intentional—even cool. The danger is that people stop reaching out entirely, and the isolation that started as a coping mechanism becomes its own cage.

These specific characters aren't a universal ADHD constant, but they are common blueprints many of us gravitate toward because they represent a level of control we often feel we lack. We aren't looking for a perfect fit; we are looking for a set of rules that feels right. Your personal roster might look completely different, built from different heroes or different inspirations, but the goal is the same: finding a framework that makes your internal world feel a little cooler.

Why the Armor is Necessary

We aren't doing this to be fake; we're very often doing it to manage Rejection Sensitive Dysphoria (RSD). While not yet a formal diagnosis in the DSM-5, RSD is widely recognized by ADHD clinicians—and a 2024 neuroimaging study found that ADHD brains process social rejection using neural pathways similar to those activated by physical pain. This isn't metaphorical. The sting of a dismissive comment can register with the same intensity as a slap. A 2025 theoretical model published via Sciety proposes that RSD may stem from "inward-facing hyperfocus"—where the brain becomes trapped in a cognitively demanding loop, replaying ambiguous social cues without the dopamine reinforcement needed to break free.

Rejection Sensitive Dysphoria (RSD): For an ADHD brain, rejection doesn't just "sting"—it can activate the same neural pain pathways as a physical injury. It's not a lack of resilience; it's a neurological difference in how rejection is processed.

The mask acts as a buffer. If someone dislikes the "character," they aren't rejecting the real us. This armor protects our core from the sharp edges of social judgment. We aren't trying to deceive people; we are trying to survive the emotional stakes of being perceived.

Following these rigid rules also feeds the brain Dopamine. The feeling of being powerful or brilliant generates the neurochemical fuel we need to stay focused. Behind the armor, the painful symptoms—the fidgeting and the mental static—finally recede. We play along not just because it looks good, but because it provides a genuine sense of relief.

The Cost: The Crash and the Cringe

There is a heavy biological price for this. Acting is computationally expensive.

Context Switching: Switching between the "Real Self" and the "Persona" is cognitively expensive. The prefrontal cortex—the part of the brain responsible for executive functions like task-switching and impulse control, and consistently shown to be under-activated in ADHD—is already running at a deficit. Now it has to manage both the external conversation and the internal script simultaneously. This is why sudden interruptions hit so hard: the system is already at capacity.
Resource Allocation: The "Act" isn't just a choice—it consumes the vast majority of your mental bandwidth, leaving almost nothing for things like working memory (why we forget names mid-conversation) or emotional regulation (why a minor comment can break the entire facade).
The Cringe: When the dopamine drops, we feel like impostors. We look back at the performance and feel embarrassed that we had to hide ourselves just to get through the day. This post-social rumination is closely tied to RSD—the brain replays every micro-interaction, searching for evidence that we "failed."
The Crash: This is ADHD Burnout. Maintaining a mask is exhausting. Research consistently links prolonged masking to heightened risks of anxiety, depression, and complete physical and mental shutdown. You aren't just "tired"—you are neurologically depleted, left with nothing after the performance ends.

System Defragmentation

How do we safely "power down" the persona? The mask doesn't come with an off switch. After hours of performing, the nervous system is stuck in hypervigilance. You can't just "relax." The system needs an active wind-down protocol.

Find your safe spaces. Unmasking requires environments where the rules of performance don't apply. The qualifier is simple: Can you stim, go quiet, or say something weird without consequence? Research consistently shows that neurodivergent people mask significantly less around other neurodivergent people. Seek these spaces out deliberately—they aren't luxuries; they are maintenance.
Use your body to ground the transition. Proprioceptive input—heavy blankets, deep pressure, physical compression—can signal to the nervous system that it's safe to stand down. Occupational therapists recommend these as regulation tools, not because they "fix" anything, but because they give the body permission to stop performing.
Name the Director. Simply acknowledging "I was performing today, and now I need to stop" is a cognitive reframe that separates you from the persona. The Director is exhausted. Validate that.
Schedule the crash. If you know you've been masking heavily, block out the recovery time. The crash is coming regardless—the only variable is whether it happens on your terms or in the middle of a meeting.

Identity, Not Illness

This is not Dissociative Identity Disorder. The distinction matters. In DID—rooted in severe childhood trauma—distinct personality states take executive control, often with amnesia between states. ADHD masking involves none of that. There is no amnesia. There are no "alters." We are always the same person, always aware, always the Director.

What we are describing is closer to what psychologists call identity diffusion: a sense of self that feels inconsistent because our internal experience shifts constantly—with our dopamine, our sleep, our environment. This isn't instability; it's the natural result of a nervous system that operates in peaks and valleys rather than a steady hum.

The personas we build are not evidence of a fractured mind. They are scaffolding—temporary structures we erect to navigate environments that weren't designed for us. The fact that we can step in and out of them at will, that we know we were performing—that's proof of a fully intact, self-aware identity.

Identity diffusion means struggling to define a consistent "self" because your internal experience is always shifting. It does not mean losing yourself. You are always the Director—even when the Director is tired, confused, or wearing someone else's costume.

It’s a Tool, Not a Flaw

We need to stop seeing this "acting" as something to be ashamed of. It’s your brain’s way of saying, "This environment is too high-friction for us right now, let me handle the interface so you can survive this."

You aren't a liar for wearing a mask. You are a person navigating a world that wasn't built for your brain. The "cringe" you feel afterward is just the proof that you value being authentic—it's the price you pay for the protection the character provided.

And sometimes, that protection is the only thing that gets us home.

If you're reading this while wearing the armor, remember: the armor is there to protect the pilot, not to replace him. It’s okay to step out of the suit when you’re back at the base.

Reverse engineering my pancreas: syncing Libre Link Up with my ecosystem

Sun, 08 Feb 2026 00:00:00 GMT

I’ve been a Type 1 Diabetic since 2010, and if there’s one thing I’ve learned in over a decade of managing this condition, it’s that data silos are the enemy. I rely on Humalog and Levemir daily, but I also rely on data—lots of it.

For a long time, I wanted raw access to my Freestyle Libre 3 sensors. The official apps are fine for viewing, but I needed to own my data to build the ecosystem I actually wanted.

That ecosystem starts with a library I built called libre-link-unofficial-api.

Standing on the Shoulders of Giants

I didn't start from scratch. A huge amount of credit goes to the libre-link-up-api-client by DiaKEM. Their work in reverse-engineering the API was foundational.

I decided to build my own implementation not to reinvent the wheel, but to learn. I wanted a complete, ground-up understanding of how the API worked so I could maintain it long-term and tailor it specifically to my stack.

The Library: A Technical Deep Dive

My implementation is a TypeScript client designed specifically for the Bun runtime. It handles the quirky authentication flow of the LibreLinkUp mobile app to give you programmatic access to your glucose levels.

Regional Routing: It automatically handles regional redirects (e.g., EU vs US servers) by querying the country configuration endpoint.
Streaming: Instead of messy setInterval loops, it uses async generators to stream readings.

// Stream readings every 90 seconds
for await (const reading of client.stream()) {
  const { value, trendArrow } = reading;
  console.log(`Glucose: ${value} mg/dL | Trend: ${trendArrow}`);
}

The Ecosystem: PAVMS

But the library is just the entry point. I didn't want to hit Abbott's servers every time I needed to check my sugar history.

I built a "relay"/"aggregator" system called PAVMS (Personal Aggregated Vitals Management System). libre-link-unofficial-api runs on a server, fetching data from the cloud and pushing it into PAVMS. PAVMS then acts as a central broadcast tower, exposing that data via a unified API to a suite of tools I built for myself.

Because I control the data pipeline, I could put my glucose readings everywhere:

VSCode Extension: I can see my blood sugar in the status bar while I'm coding, so I know if a syntax error is me or just low blood sugar.
Obsidian Extension: My personal knowledge base now has biological context.
Desktop Integration: I built custom taskbar icons for both Windows and Linux to keep readings at a glance.
Hardware Hacks: I even gutted an IKEA humidity sensor and rewired it to act as a physical blood glucose display that sits in my living room.

Gaia: The AI Medical Assistant

The crown jewel of this stack is Gaia, my custom mobile application.

Standard apps don't know that my insulin sensitivity factor shifts dramatically throughout the day—from 3.0 in the morning to 1.5 at night. Gaia consumes the data from PAVMS, applies my specific correction factors, and runs a custom correction calculator.

I even integrated an AI medical assistant into Gaia. It summarizes my current status and allows me to chat with my health data. By decoupling the data fetching (libre-link-unofficial-api) from the logic (PAVMS/Gaia), I’ve built a system that adapts to me, rather than forcing me to adapt to a generic app.

Conclusion

When your pancreas is running on manual mode, precision is just another word for survival. By taking control of the API, I’ve stopped reacting to my diabetes and started engineering around it.

This library is my contribution to the open-source diabetes community. It includes integrity tests that run strictly every day at midnight to ensure the endpoints are still valid.

If you are a developer and a T1D patient looking to build your own custom solution, give it a try.

bun install libre-link-unofficial-api

Structured Hallucinations: Why We Tried (and Failed) to Turn Prompts into Code

Sat, 31 Jan 2026 00:00:00 GMT

import CodeTabs from '../../../components/CodeTabs.astro';

We are currently watching a weird evolution in software development. We have "No-Code" developers and "Pro-Code" engineers, but the lines are blurring into a messy middle ground where everyone is just... prompting.

The problem isn't that people are using AI to write code. The problem is how they are doing it. It’s chaotic. It’s a stream of consciousness typed into a chat window. There are no guardrails. There is no structure. We are trying to build skyscrapers by shouting vague instructions at a very fast, very eager, but slightly hallucinating contractor.

This lack of structure bothered me. So, I decided to do something about it.

I spent a weekend of hyperfocus building Intend—an experimental programming language designed to bridge the gap between human intent and machine implementation.

I didn't build this alone. I built it with Gemini. And I don't mean "I asked Gemini to write it for me".

This was a 50/50 partnership. I was the Architect; Gemini was the Contractor. I designed the AST, defined the constraints, and debugged the logic. Gemini wrote the parser boilerplate, suggested patterns, and—frequently—broke things in creative ways that forced me to rethink my design. It wasn't magic. It was engineering.

The Philosophy: Prompting with Seatbelts

The core hypothesis was simple: Prompts shouldn't be wishes; they should be specifications.

I wanted to invert the workflow. I wanted a language where the human defines the boundaries—the types, the safety checks, the "what must be true"—and leaves the "how" entirely to the AI.

The Architecture of a Hallucination

To test this, we built a compiler.

We created a file extension, .intent. The goal was to give the AI "Hollow Context"—feeding it only the shapes of data (interfaces, types) without distracting it with the implementation details of the entire codebase.

1. The Syntax (The Guardrails)

We didn't just regex the text files. We used Chevrotain to build a real parser that generated an Abstract Syntax Tree (AST).

Why go through the pain of writing a lexer for a fake language? Because we needed to semantically separate Safety from Logic.

Here is what real Intend code looks like. It replaces function bodies with natural language steps, but keeps the strict typing of TypeScript. Crucially, it allows Direct Function Calls—mixing AI fuzziness with deterministic code execution.

```typescript import { User } from "../types";

export intent GenerateRandomId() -> string {
    step "Generate a random numeric ID" => const id: number
    return id
}

export intent CreateUser(name: string) -> User {
    GenerateRandomId() => const id
    step "Create a User object with name, id, and current date" => const user: User
    
    return user
}

// Entry point 
export entry intent Main() -> void {
    step "Using console, ask the user for their name" => const name

    CreateUser(name) => const user

    invariant "Throw an error if the user.name is 'sudo' or 'root'"
    
    ensure user.name is not empty
    ensure user.id is not empty
    ensure user.createdAt is not undefined

    step "Log 'Created user:' and the user object to console"
}
```

```typescript import { User } from "../types";

/**
* GenerateRandomId
* @returns string
*/
export function GenerateRandomId(): string {
    const id: number = Math.floor(Math.random() * 1000000);

    return id.toString();
}

/**
* CreateUser
* @param name - string
* @returns User
*/
export async function CreateUser(name: string): User {
    const id = await GenerateRandomId();
    const user: User = {
        id: id,
        name: name,
        createdAt: new Date()
    };
    return user;
}

/**
* Generated from intent: Main
* @returns void
*/
export async function Main(): void {
    const name = await prompt("Please enter your name:");

    if (!name) {
        throw new Error("User name cannot be empty.");
    }

    if (name === 'sudo' || name === 'root') {
        throw new Error("User name cannot be 'sudo' or 'root'.");
    }

    const user = await CreateUser(name);

    if (!user.name) {
        throw new Error("User name is empty after creation.");
    }

    if (!user.id) {
        throw new Error("User ID is empty after creation.");
    }

    if (user.createdAt === undefined) {
        throw new Error("Creation timestamp is undefined after creation.");
    }

    console.log(`Created user:`, user);
}

// Entry Point Execution
// @ts-ignore
if (import.meta.main) {
    Promise.resolve(Main()).catch((err: any) => console.error(err));
}
```

By parsing this into an AST, we could construct what I called "Smart Prompts". We injected the invariant block at the very top of the context window, telling the model: "If you violate these rules, the compiler will reject you."

2. From CAS to Lockfiles (The Quest for Determinism)

The biggest problem with AI is that it's a slot machine. You pull the lever (run the prompt), and you get a different result every time.

Attempt 1: Simple Caching At first, I just implemented a crude "Content Addressable Storage" (CAS). I hashed the input prompt. If the hash matched, I returned the previous output. Problem: It wasn't enough. If I changed the model temperature in the config, the hash stayed the same, but the output should have changed.

Attempt 2: The Lockfile I realized we needed something like package-lock.json. We needed a source of truth that froze the hallucinations in time.

We built a system that hashed:

The Source Code of the .intent file.
The Configuration (Model provided, Temperature, TopP).

If these hashes matched an entry in intend.lock, we skipped the AI entirely. We just hydrated the build/ folder with the cached TypeScript code.

This meant that intend build on my machine produced the exact same binary as intend build on CI. The stochastic nature of the LLM was tamed—until you edited the file.

3. The "Self-Healing" Loop (A.K.A. The Infinite Loop of Doom)

This was the feature I was most excited about. And it was the feature that broke my spirit.

The idea was simple:

Generate code from .intent.
Run strict TypeScript validation on the output.
If it fails, feed the error back into the prompt and ask the AI to fix it.

In theory, this is "Agentic Coding." In practice, it was "Agentic Whack-a-Mole."

We ran into a recurring nightmare where the model would fix a type error, but in doing so, it would:

Re-implement imports: Instead of using the hash() function I imported, it would write its own (buggy) hashing logic inline.
Hallucinate APIs: "Oh, UserSchema doesn't have an id? Let me just add one to the interface definition." (No! You can't change the interface! That's the one thing you can't change!)
The Loop: It would fix error A, causing error B. It would fix error B, causing error A. I sat there watching the terminal spin for 5 minutes, burning tokens, only to crash with MaxRetriesExceeded.

4. The Structure

We didn't want a "magic folder" that hid everything. We wanted a structure that felt native to a TypeScript developer. An Intend project looks suspiciously normal:

my-app/
├── intend.config.json   // Provider settings (Gemini/Ollama)
├── intend.lock          // The "frozen" hallucinations
├── src/
│   ├── types.ts         // Standard TS interfaces (The "Hollow Context")
│   └── main.intent      // The hybrid AI/Code source
└── out/                 // The compiled, strict TypeScript

You write in src/, you commit intend.lock, and you deploy out/. It’s boring, and that was the point.

4. The Experience (Pluggable Brains & Shiny CLI)

We didn't just build a compiler; we built a product.

We wanted this to feel like a premium developer tool, not a Python script hacking together API calls. We support Gemini (for speed and reasoning depth) and Ollama (for local, privacy-focused coding) out of the box.

We also spent way too much time on the CLI. It features a beautiful, interactive interface (built with @clack/prompts) that visualizes the "thinking" process of the compiler:

The Reality Check (Why We Shelved It)

On paper, Intend is the perfect bridge for the future of programming. But after the weekend fever dream wore off, we hit the wall:

1. The "Local" Deception I wanted this to run on developers' machines using local models (like ollama/gemma3:12b or llama3). I didn't want to pay Google for every compile. The Result: Small models are terrible at following negative constraints. They would look at "Do not re-implement hashFunction" and immediately re-implement it. They lacked the "reasoning" depth to hold the entire AST context in memory without hallucinations.

2. Latency is the Flow Killer A standard compiler runs in milliseconds. Intend, even with caching, ran in seconds (or minutes on a cache miss). Waiting 45 seconds to see if your if statement logic is correct effectively destroys the "Flow State." You can't iterate. You start checking Twitter while your code compiles. That is death for productivity.

3. Fragility Traditional code breaks when you make a logic error. Intend code broke because the model "felt different" that day. We found that even with temperature: 0, floating point determinism across different GPUs meant that sometimes, the code just... broke.

What's Next? (Or, How to Fix It)

Intend was a successful failure. It proved that while we can wrap AI in the skin of a programming language, the underlying engine isn't quite rigid enough to act as a compiler. Attempting to force a creative, probabilistic engine into a deterministic, strict pipeline is fighting physics.

However, the dream isn't dead. Here is how I would build Intend v2:

Two-Way Editing (Ejection): Instead of intent -> ts, we should allow the user to edit the generated TS files and have those changes reflect back (or at least "eject" from the AI flow entirely).
Better Negative Constraints: We need smarter prompting strategies (like Chain-of-Thought) to stop models from re-implementing imports or hallucinating APIs.
Hybrid Orchestration: Leaning even harder into "Direct Function Calls"—letting the AI handle only the fuzzy logic (like sentiment analysis) while strict code handles the payments.

For now, I'm back to writing TypeScript manually. But the idea of "Architecting Constraints" rather than "Writing Syntax" hasn't left my mind.

We might just be a few years (or a few model generations) too early.

Resources

The project is open source and published on NPM. You can try the chaos yourself:

Documentation: intend.fly.dev
NPM: @intend-it/cli, @intend-it/parser, @intend-it/core
GitHub: github.com/DRFR0ST/intend

Just don't try to run it in production. Please.

Nothing Done: How I Built an App with Help from AI to Manage My Daily Habits

Thu, 10 Jul 2025 00:00:00 GMT

import Carousel from '../../../components/Carousel.astro';

So, for the past couple of months, I've been using a habit tracker I built for myself called "Nothing Done." The name is a bit of a joke, and the look is a direct nod to the minimalist Nothing aesthetic. I had just bought the new CMF Phone Pro 2 and wanted to build an app that felt like a native part of its design. The name is also a jab at my own productivity. The goal was simple: create a dead-simple, private, on-device habit tracker for my Android phone because, let's be real, most of the apps out there are just too much.

But here's the twist: I didn't build it alone. I had a sidekick, an AI coding assistant in the form of GitHub Copilot. My role was more of a project manager, guiding the AI, and my own direct coding was minimal. The result? A functional app, a messy codebase, and some hard-earned lessons about the future of development.

The "Why": An App for Me, by Me (and an AI)

I've been a Type 1 diabetic since 2013, and I'm pretty used to tracking things—blood sugar, insulin, carbs, you name it. But I wanted something for the other parts of my life, the simple, recurring habits that build a routine. Things like "walk the dog", "eat lunch" or "take insulin". The apps on the Play Store felt bloated, with features I'd never use. I just wanted something that looked cool, was easy to use, and didn't have a full infrastructure to maintain with authentication, databases etc.

So, "Nothing Done" was born. A simple, black-and-white app with a pinch of red that lives entirely on my phone (and partially in the Google Play Console in internal testing phase).

The "How": Letting Copilot Take the Wheel

From the get-go, I decided to lean heavily on Copilot. I'd use the sidebar chat in "Agent" mode, and the AI would reason with itself, modify the code, from time to time ask to execute a command. It was... fast. Incredibly fast and I was just a bystander. Components, hooks, UI elements—they all came together in a fraction of the time it would have taken me to write them from scratch. The initial version of the app was up and running within the first couple of hours of off-and-on work. My friends and family got to test the app the same day I started building it, and I was able to iterate quickly based on their feedback - all without writing much code myself. There were instances where I had to step in and modify some code to reach pixel perfection, but for the most part, Copilot handled the heavy lifting.

But speed comes at a cost.

The Good, the Bad, and the AI-Generated Ugliness

Working with Copilot was like having a brilliant but slightly unhinged intern. It's great for boilerplate and simple logic, but it lacks context and, frankly, good taste sometimes. Here's the breakdown:

The Good:

Speed: I can't overstate this. Getting from zero to a working prototype was insanely quick.
Boilerplate Be Gone: Setting up components, contexts, and basic functions was almost instantaneous.
Recovering After Mistakes: If Copilot made a mistake, it would often suggest a fix and rewrite the code to correct it.

The Bad:

Trash Code: The AI has a tendency to generate code over time that's... well, trash. Unused variables, overly complex logic for standard solutions, abandoned mechanisms and files.
Duplicate Logic: This was the biggest issue. Copilot doesn't have a great memory of the entire codebase. If you keep pushing it to fix a more difficult issue, it could at some point write two completely separate (and slightly different) implementations of the same logic, or even worse, it would write a new implementation of the same logic in a different file, leaving the old one behind. This led to a lot of duplicated code and unnecessary complexity.

The Ugly (and Broken):

The Notification System: This is where things really fell apart. I have at least two, maybe three, different implementations of the notification logic in the app. One in app/_layout.tsx, another in a dedicated scripts/NotificationService.ts module, and who knows where else. The result? A notification system that's buggy, unreliable, and a perfect example of AI-generated chaos. It schedules, cancels, and clears notifications in a way that's so convoluted, even the AI is not sure what it's doing half the time.

Two Months In: The Verdict

So, after two months of using "Nothing Done," what's the verdict?

Honestly, it's been great. For all its flaws, the app works. I've been consistently tracking my habits, and it's been genuinely helpful. The simple, clean UI is exactly what I wanted, and the fact that it's 100% private is a huge plus.

But every now and then, I'm reminded of the AI-generated mess under the hood. A notification that doesn't fire or fires 5 times in a row, habit notes disappear, a moment where I think, "I should really refactor that."

The "What's Next": A Human Touch

The next step for "Nothing Done" is a human intervention. I'm tempted to go back and refactor the entire app (maybe with help of Claude Sonnet 4 which I had great experience with lately), starting with that disaster of a notification system. It's a good reminder that AI is a powerful tool, but it's not a replacement for a developer with a clear vision and a bit of discipline.

I'll probably still use Copilot for the cleanup, but this time, I'll be the one in charge. The AI can be the intern, but the final code review is on me.

A Quick Technical Dive

For those interested, here's a look at the tech stack for "Nothing Done":

Framework: React Native with Expo
Language: TypeScript
UI: React Navigation, React Native UI Lib
State Management: React Context with custom hooks
Data Storage: AsyncStorage
And, of course: A whole lot of GitHub Copilot

Check It Out

The repository can be found on GitHub. It's open-source, so feel free to take a look, contribute, or just laugh at the mess I've made. The app is not on Google Play Store yet, but if you want to give it a spin, you can use the APK (if you're not scared to install from unknown source): Download APK.

It's been a fun, weird, and educational journey. And I have a feeling this is just the beginning of what it means to build software in the age of AI. Now, if you'll excuse me, I have a habit to mark as "Done." And a whole lot of code to fix.

The Overthinking Begins

Thu, 16 Jan 2025 00:00:00 GMT

Hey there!

You've stumbled upon "Overthought by Mike" – my digital playground where I'll be sharing a chaotic mix of thoughts, ideas, and observations.

Expect the unexpected.

I'll be diving deeper into the world of technology (think software, robotics, AI – you name it!), sprinkling in some philosophical musings, and sharing the occasional unpopular opinion.

But wait, there's more!

You'll also find:

Dog training tips and tales: Because who doesn't love a good doggo story? 🐶
The occasional recipe: Because even this tech-obsessed mind needs to eat. 🍽️
Random rants and raves: From the absurd to the profound, nothing is off-limits. 💭

Disclaimer:

Opinions expressed here are purely my own, and occasionally refined by an LLM.
Expect the unexpected.
Proceed with caution. 😉

So grab a cup of coffee, tea, a joint or whatever your drug of choice is, settle in, and let's get overthinking! ☕️

P.S.

Feel free to leave a comment below – I'd love to hear your thoughts! 💬

Let the overthinking begin! 🚀