Thoughts
Notes & writing
Two speeds, one place: Notes are living documents on what I'm exploring right now; Writing is the longer-form, finished thinking.
Notes
Running notes on the threads I'm pulling on right now — living documents, not conclusions.
AI-assisted dev workflows
Short-form news aggregator
Writing
Essays and longer-form pieces — fast and minimal on purpose.
-
My AI-assisted dev workflow, mid-2026
The actual stack I use to ship — agentic coding tools up front, self-hosted open models for the boring volume, and a hard rule about staying on rails.
-
Owning the stack: why this site exists
I was renting my web presence from Super and Notion. Here's why I tore it down and rebuilt on a small Astro repo I fully own.
-
THE SIMULATION
A reflection on the simulation hypothesis, base reality, the limits of verification, and whether consciousness is energy we could learn to control.
-
10 reasons why product management for AI is different than conventional product management
Ten ways managing AI products differs from conventional product management, from data-driven decisions to ethics and constant model upkeep.
-
Biocompute (Biological computation) musing 1
An analogy comparing a computer network to the human body, where servers, devices, data flow and firewalls mirror organs, circulation and the immune system.
-
Biocompute (Biological computation) musing 2
An analogy between Edge AI and human muscle/cell memory, both learning and adapting through repeated experience for better real-time performance.
-
Biocompute musing 3 (Biological computation) Data storage and processing
What it would take to build data storage as efficient as a living cell, spanning compression, materials, nanotech, biotech and quantum computing.
-
Biocompute musing 4 (Biological computation) for General AI
Why hardware-level breakthroughs, not software, may be the real bottleneck on the path to the AI singularity.
From the hub
Longer-form articles, published from the hub.
-
Running 24/7 Local AI on Hardware I Control: What This Solo Builder's Setup Changed About My Infrastructure Thinking
I'd been watching this solo builder demo his setup over a video call—three monitors, custom cooling, GPUs humming quietly in his home office, running AI models 24/7 on hardware he owned. My immediate reaction was skeptical: "This has to be more expensive and complicated than just using APIs." The math seemed obvious. Hardware meant upfront costs, electricity bills, maintenance headaches. APIs meant paying for what I use, predictable billing, someone else handling the infrastructure. But somethi
-
The Transcribe.cpp Moment: Why I'm Rebuilding My Audio Stack in C++
I've been watching Transcribe.cpp climb to 728 points on HackerNews while my own audio products felt increasingly sluggish, and the contrast hit harder than I expected. It wasn't the external validation that got to me—it was the sudden clarity that my entire audio processing pipeline was built on borrowed time and someone else's decisions. The Wake-Up Call I decided to test local transcription against my existing API pipeline on the same audio file. The numbers were stark: 50ms versus 2000ms
-
The Model Economics Shift: Why I'm Running Qwen 27B Locally Instead of Claude API Calls
I stared at my August Anthropic invoice—$2,847—and felt something shift in how I think about AI infrastructure. Six months ago, I was confident that API calls were obviously cheaper than local inference. The math seemed straightforward: why deal with hardware, maintenance, and all that complexity when I could just pay per token? But after running parallel workloads on Claude API versus local Qwen 27B inference, what I discovered about the real economics wasn't what I expected at all. The Surfa
-
Why GPT-5.6 Changed My Model Switching Strategy
My model router started making expensive mistakes the day GPT-5.6 hit production. Not because OpenAI changed their API—the endpoints worked fine. The problem was deeper: my carefully tuned switching logic was built on performance assumptions that GPT-5.6 made obsolete overnight. The Router That Worked (Until It Didn't) For three months, my model switching logic had been humming along predictably. I'd built what felt like a sensible system: * Simple classification tasks → local Llama model (
-
Running Production Code That AI Generated But Couldn't Debug: What 6 Months Taught Me
The Slack notification hit at 3:17 AM. "Checkout broken for users in Canada." I rolled out of bed, logged into our production system, and stared at 200 lines of perfectly functional code that had been working flawlessly for three months. The problem wasn't immediately obvious—Claude had written a dynamic pricing calculator that handled dozens of edge cases I'd never even considered. But somewhere in that elegant React component, something was failing for Canadian users, and I had no idea where t
-
What I Found Running Smart Model Routing in Production for 3 Months
The $847 AWS bill that landed in my inbox three months ago made me question everything I thought I knew about model selection. I'd been routing every request through GPT-4 because the logic seemed obvious: better model equals better results. The bill suggested otherwise. I wasn't just burning money on overkill—I was getting inconsistent results that didn't seem to correlate with the premium I was paying. Some of my simplest tasks were eating through tokens while producing output that felt no be
-
The Real Cost of Open Source Dependency: My 347-Package Audit Results
I've been running the same codebase for three years, adding dependencies as needed, never really thinking about who was behind them. Then last month, a critical package I relied on suddenly went dark—maintainer burned out, repository archived, no migration path. That's when I realized I had no idea who was actually keeping my product running. So I decided to find out. The Audit Setup Rather than debate open source sustainability in the abstract, I wanted to understand my actual exposure. I pu
-
Running Kimi K3-256k in Production: What 128k Extra Context Actually Changed About My Stack
The moment I hit 180k tokens and watched my memory usage spike 3x instead of the expected 1.4x linear increase, I realized I had fundamentally misunderstood how context scaling works in production. After six weeks of running both Kimi K3-128k and K3-256k side by side in my document processing stack, nearly everything I thought I knew about longer context windows turned out to be wrong. The Setup That Led Here I'd been running a document analysis pipeline that handled everything from legal con
-
Running 28B parameters on 29GB RAM at 0.50 tok/s: What this efficiency breakthrough means for local AI economics
When I saw the benchmark showing 28B parameters running at 0.50 tokens per second on just 29GB of RAM, I had to double-check the numbers. My first instinct was skepticism—I've been tracking AI infrastructure costs for months, watching teams burn through API budgets, and this felt too good to be true. But if accurate, this represents something more significant than another incremental efficiency gain. It's the kind of breakthrough that makes me reconsider fundamental assumptions about AI economic
-
Running Chinese Models in Production Changed My Entire Stack Architecture
I was scrolling Hacker News on a Tuesday afternoon when I saw it: "Kimi K3 beats GPT-4o on most benchmarks." 2,247 upvotes. My first instinct was the usual eye-roll — another week, another "GPT killer" that'll disappear into the noise. I'd been paying Anthropic for Claude API access across my projects. It worked. Why mess with what works? But the comments section made me pause. Real developers sharing side-by-side comparisons, not just benchmark screenshots. Someone had posted actual inference
-
Running Qwen 3.8 vs GPT-5.6 in Production: What 6 Weeks of Side-by-Side Testing Revealed About Model Economics
The HN thread about Qwen 3.8's release hit several hundred points, and like many builders, I got caught up in the excitement. The benchmarks looked promising. The licensing was appealing. But after six weeks of running it alongside GPT-4 in my production systems, the reality is more nuanced than any benchmark could capture. The Setup: Why I Decided to Run Both My production workload isn't exotic — a content analysis pipeline processing around 50,000 documents monthly for a client who needs st
-
What I Found Running Bun's Rust Rewrite in Production After 341 AI Assistance Hours
Three months ago, I started running Bun's Rust rewrite in production while tracking every AI interaction that helped me through the migration. 341 hours later, I have data that contradicts what most people think about AI-assisted development—and about Bun itself. The real story isn't the performance gains everyone's discussing. It's how AI helped me understand that my original bottlenecks had almost nothing to do with Zig versus Rust. The Setup: Why I Tracked Everything My production environm
-
Running Kimi K3 Locally Changed How I Think About Model Switching Architecture
I've been running API-based AI workflows for months now, switching between Claude for complex reasoning, GPT-4 for creative tasks, and smaller models for classification. The routing logic alone took weeks to build — smart switching based on task complexity, cost optimization, error handling for rate limits. It felt sophisticated. Then I installed Kimi K3 locally, expecting another "decent but limited" open model experience. Instead, I found myself questioning every API call in my current stack.
-
What I Found Building My Claude Code Alternative After the 33k Token Waste Discovery
The HN post hit me like a cold shower: Claude Code was burning 33,000 tokens before even reading my prompts. I'd been paying for what felt like having a conversation with someone who insisted on reciting their entire life story before listening to my question. The $200 Wake-Up Call Looking at my October bill, I was spending $187 monthly on Claude Code. When I broke down the math after that HN revelation, roughly 60% of my tokens were going to system overhead before Claude even processed what
-
What I Found Running 24/7 Local AI After Watching This Solo Builder's Hardware Stack
Last year I watched Alex Finn walk through his 24/7 local AI setup—a dedicated machine running Llama models around the clock, handling everything from code generation to content processing. My first reaction was skepticism about the economics. Why burn electricity and tie up hardware when OpenAI's API costs pennies per thousand tokens? The math seemed obvious: APIs win on pure cost efficiency. But after three months of running a similar setup myself, I've learned the comparison is more nuanced t
-
What I Found Building My Own Local AI Stack After This Solo Builder Runs 24/7 on Hardware
The $340 OpenAI bill landed in my inbox on a Tuesday morning in March. I stared at it for a solid minute, then opened a new browser tab and started speccing out dedicated hardware. Not because I couldn't afford the API costs, but because something felt fundamentally wrong about optimizing my building process around someone else's pricing model. I'd been running three different projects that month: a document processing pipeline that chewed through thousands of PDFs, a code generation tool I was
-
Running Local Models vs API Calls: What 6 Months of Production Usage Actually Cost Me
The spreadsheet sitting in front of me tells a different story than every "local vs API" cost analysis I've read. Six months, $3,247 in direct costs, and two completely different product architectures later—I learned the unit economics everyone obsesses over are the wrong numbers entirely. The Experiment Setup What I actually measured wasn't theoretical—it was production traffic hitting real systems. I ran Qwen 27B on my own hardware (RTX 4090 plus dedicated server costs) against the same wor
-
What I Found Running Kokoro TTS After 327 HN Points: Local Voice Synthesis vs Cloud Dependencies
The 327 HN points on that local TTS thread made me realize I'd been paying $47/month to ElevenLabs without questioning whether cloud voice synthesis was solving the right problem for my use case. I'd fallen into the comfortable pattern of reaching for their API whenever I needed voice output, treating it like any other cloud service. But seeing developers get excited about running Kokoro locally made me wonder what I was actually optimizing for. The API Dependency Reality Check Looking back a
-
Why I'm Building Everything Twice Now: The GitHub Migration That Changed My Architecture
I started this migration because of a Hacker News thread about GitHub alternatives. Like most developers, I'd spent years building everything around GitHub's ecosystem without really questioning it. Three months later, what I thought would be a simple platform switch has turned into an unexpected education about software architecture—and why building for platform independence might be one of the most valuable architectural decisions I've stumbled into. The migration wasn't driven by any particu
-
The 60% Cost Cut That Broke My Assumptions About AI Coding
I kept dismissing the idea as obviously inefficient until my API bills started shrinking. Three months ago, I stumbled across Fable's approach to AI code analysis: convert code to images, run OCR, then feed the text to language models. My first reaction was immediate skepticism—why would anyone add two extra steps when you can send code directly as text? The claim was substantial cost reduction. That number bothered me enough that I had to test it myself. The Setup That Seemed Backwards I bu
-
Why I'm Building My Own Data Center Colocation Instead of Renting Racks
My GPU cluster project hit a wall when the colocation provider told me the waitlist for optimized racks was now 18 months. That's when I started looking at shipping containers and wondering if the math on DIY data center infrastructure had fundamentally changed. The Waitlist Wake-Up Call The tour of data centers started normally enough. I needed space for a 42U deployment—nothing exotic, just dense compute with reasonable power and cooling. But facility after facility gave me the same story:
-
Why I'm Building My Own AI Code Orchestration After Watching the Agent Theater Collapse
I've been using AI coding tools daily for the past eighteen months, and there's a gap between what gets demoed at conferences and what actually works when I need to ship code. Every week, I see another "revolutionary" agent orchestration framework launch with incredible demos — AI agents that supposedly plan, code, test, and deploy entire applications autonomously. But when I try to integrate these systems into my actual development workflow, they consistently break down at the most basic level:
-
What I Found Running 64 Model Generations to Benchmark Sonnet 5: The Context Window Behavior Nobody Mentions
Last month I burned through $847 in API credits running the same complex reasoning task 64 times across different context window utilization levels with Sonnet 5. What I found doesn't match anything in Anthropic's documentation—and it's changed how I structure every production prompt since. The Setup That Started This Rabbit Hole My production workload was driving me crazy with its inconsistency. I'm building a system that synthesizes insights from academic research papers, and the quality wo
-
Why I'm Building My Own HackerNews Trends Parser Instead of Using APIs
My resume got scored 90, then 74, then 88 by HackerRank's ATS within the same week. Same resume, same job posting, wildly different scores. I stared at those numbers on my screen, realizing I was trusting black boxes with data that actually matters to me. The Moment Everything Clicked That HackerRank inconsistency wasn't just annoying — it was a wake-up call. If an algorithm designed to evaluate resumes could swing 16 points on identical input, what other critical decisions was I outsourcing
-
Why I'm Building a Deterministic LLM Router Instead of Using Claude's Smart Routing
I was three weeks into debugging what should have been a straightforward user session consistency issue when I realized the problem wasn't in my code—it was in Claude's smart routing. Same user, same conversation context, same input parameters, but wildly different response patterns depending on which model Anthropic's black box decided to route me to. That's when I knew I had to build my own router. The Problem I Didn't See Coming When Claude introduced smart routing earlier this year, I was
-
The Serial Builder Tax: Why My Second Product is 10x Harder to Ship Than My First
I expected my second product to ship faster. Eight months in, I'm still pre-launch while my first product took three months from idea to paying customers. The startup advice ecosystem celebrates repeat founders—higher success rates, better pattern recognition, deeper networks. But something feels fundamentally off about my lived experience versus the narrative. The First Product: Beautiful Simplicity Decision velocity was everything with my first build. Every choice felt binary: ship this fea
-
The Open Source Defense Strategy: What 439 HN Points Says About Dependency Risk
After seeing "Defending open source together" hit the front page of Hacker News, my first reaction wasn't ideological solidarity. It was a cold spike of recognition—the kind you get when someone names something you've been living with but haven't articulated. Six months ago, I'd started tracking every dependency decision in my projects after a single npm package update broke my entire build pipeline. What I found in my own code made the defensive energy in that thread make sense: we're not just
-
Why I'm Building My Music Matching Algorithm Instead of Using Spotify's API
The Flock camera story that tracks way more than license plates hit 349 points on HN last week. Reading those comments about surveillance creep got me thinking about a different kind of tracking problem I've been wrestling with: how Spotify's algorithm decides what music I should hear next. Six months ago, I started building my own music recommendation engine instead of just accepting whatever their black box serves up. The Dependency Realization I originally planned to build something simple
-
The Real Reason I'm Building Everything on .self Domains
I started paying attention to domain ownership differently after watching Pollen try to scrub specific articles from Google search results. The company had published research that contradicted certain industry narratives, and within weeks, I noticed their content disappearing from search rankings while their competitors' rebuttals climbed higher. Whether this was algorithmic coincidence or something more deliberate, I couldn't say—but it crystallized months of growing unease about building my en
-
Running My Terminal Multiplexer for AI Agents: What 146 HN Points Says About Developer Workflow Evolution
The moment I saw Herdr hit 146 points on Hacker News, I wasn't surprised by another terminal multiplexer—I was fascinated that developers were upvoting infrastructure for treating AI agents as persistent processes. My Three-Month Setup I've been running Claude, GPT-4, and local models as persistent terminal sessions since August. What started as a convenience hack has become something closer to infrastructure. My tmux configuration keeps agents alive across SSH disconnects and laptop sleeps.
-
Why I'm Building My Own AI Model Router Instead of Using Claude's New Smart Routing
I spent last week getting excited about Claude's new smart routing feature. Finally, I thought, I could delete the hacky model selection logic I'd been maintaining for three months and let Anthropic handle the complexity of choosing between Claude variants for each request. But before I made the switch, I decided to run some numbers on what I'd actually built. What I found made me pause—and ultimately convinced me to keep building my own routing system instead of handing control back to the pla
-
The Cost Structure That Made Me Switch From API Calls to Local Models Mid-Project
Six months into building my AI-powered documentation tool, I hit a wall that had nothing to do with token costs. I was sitting in yet another support ticket thread with Anthropic, explaining why I needed higher rate limits for a feature that should have taken a day to implement. The irony wasn't lost on me: I was building a tool to make developers more efficient, while my own development was bottlenecked by someone else's infrastructure decisions. That's when I realized the real cost of API-bas
-
Self-hosting Kimi K3 costs 20% more hardware but delivers 20% better task resolution: The local vs cloud economics shift
The $3,200 charge on my credit card made me pause longer than usual. I was staring at a hardware configuration optimized for running Kimi K3 locally — a 4090 GPU, 64GB RAM, and enough storage to keep everything on-premises. The monthly API costs for my typical workload were running about $180, so the math seemed straightforward: break-even in roughly 18 months, assuming nothing changed. What I didn't expect was how much the "nothing changed" assumption would matter. The $3,200 Decision Point
-
Building My Claude Computer Use Alternative After Watching the Agent Theater Collapse
The Claude computer use demo where it books a flight and fills spreadsheets looked magical. Two weeks into trying to use it for actual work, I was staring at failed automation attempts and realizing I'd been sold theater, not tools. I needed to automate my research pipeline for content analysis—pulling data from multiple sources, cross-referencing information, and generating reports. The demo made it look trivial. Point Claude at some websites, let it click around, watch it populate my spreadsh
-
What I Found Running Opus 5 Against My Local Qwen Stack: The Performance Gap Nobody's Measuring
The moment I saw Opus 5 hit #1 on the Chatbot Arena leaderboard, I knew I had to run it against my local Qwen setup. Not for benchmarks—for the messy, iterative work of actually building something. The Setup: Two Stacks, Same Problems My local infrastructure runs Qwen 27B on dedicated hardware I control completely. No rate limits, no API costs, no waiting for someone else's servers. The Opus 5 setup means API calls, usage caps, and the usual cloud dance of checking my balance before each sess
-
After Kimi K3's Open Release: What Running Frontier Models Locally Actually Costs
The moment Kimi K3 dropped its open weights, I knew I had to answer the question I'd been avoiding: could I actually afford to run frontier intelligence on my own hardware? Not theoretically — but with real electricity bills, real depreciation, and real usage patterns over 30 days. The Hardware Investment Reality I'd been circling this decision for months. The RTX 4090 felt like the obvious choice — $1,599 retail, widely available, solid VRAM for inference. But I kept reading about used Tesla
-
What Building My Own Agent Harness Taught Me After Everyone Declared Orchestration Dead
When Langchain announced their agent framework was "production ready" and AutoGen claimed to have "solved multi-agent coordination," I did what felt like the contrarian thing: I started building my own agent harness from scratch. Not because I'm a glutton for punishment, but because something felt off about the victory lap everyone was taking. The Dead Consensus The narrative feels too clean. Agent orchestration is "figured out." Pick your framework, wire up some agents, and ship to productio
-
Why I'm Building My Own IndieWeb Stack After the 165-Point Discussion Changed Everything
I was refreshing HackerNews at 11:47 PM when I saw it: "Why I'm leaving social media for the IndieWeb" with 165 comments and climbing. My immediate reaction wasn't philosophical agreement—it was recognition. Something I'd been circling around for months suddenly crystallized into action. That night I opened my terminal and started coding what would become my complete self-hosted presence. The Catalyst: What Actually Hit Different I've seen dozens of IndieWeb evangelism posts over the years. M
-
Running Chinese Models Changed My Entire Stack Architecture
Six weeks ago, I was feeling pretty smug about my "model-agnostic" architecture. Clean abstraction layers, elegant wrapper functions, the works. Then I switched from Claude to Qwen 2.5 and deepseek-v3 in production, and my entire system collapsed on the first day. Every API call that had worked flawlessly for months suddenly returned garbage. My supposedly flexible architecture wasn't flexible at all—it was Claude-shaped, from the ground up. The Switch That Broke Everything I made the switch
-
What I Found Building My Own Claude Alternative After the Context Window Waste
When my Claude bill hit $847 in a single month, I started questioning everything I thought I knew about context windows. I'd been running the same content analysis workload for weeks, so either my usage had quietly exploded, or something fundamental about how I was approaching these large language models was wrong. The Discovery Phase My use case seemed straightforward: analyzing recurring document types in a content pipeline. Legal contracts, research papers, technical specifications — docum
-
What I Found Building My Own IndieWeb Stack After 165 Points
I'd been lurking in IndieWeb discussions for months, accumulating karma points and bookmarking posts about data ownership and platform independence. But there was something absurd about consuming all this content about digital autonomy while still depending entirely on centralized platforms for discovery and engagement. After hitting 165 points debating the merits of webmentions versus traditional social media, I realized I was theorizing about building instead of actually building. So I stoppe
-
Running 24/7 Local AI on Hardware I Control: What This Solo Builder's Setup Taught Me
I've been running persistent AI models on local hardware for about six months now, following Alex Finn's approach to local AI infrastructure. What started as curiosity about reducing API costs turned into something more fundamental — I realized I wasn't just optimizing for cheaper inference. I was building on entirely different foundations. The shift happened when I stopped thinking about AI as a service I call and started treating it as infrastructure I own. That change in perspective unlocked
-
What I Found Building HN Trends: 18 Years of Comments, Zero External Dependencies
Someone just indexed 18 years of Hacker News comments and made them searchable. While everyone's debating the trends it reveals, I'm stuck on something else entirely: they own their entire stack. No external APIs. No rate limits. No OAuth flows. They scraped everything, stored it locally, and built their search on top of their own data. In 2024's API-everything landscape, this feels almost radical. The Architecture That Caught My Attention Walking through their technical setup, I kept hittin
-
The Agent Harness Reality Check: What I Found Building One After Everyone Said Orchestration is Dead
I kept hearing that agent orchestration was dead. "So two-years ago," as Signal #147 put it. The consensus seemed clear: individual agents talking directly to users was the future, and anyone still building coordination layers was stuck in the past. But I spent three weeks building my own agent harness anyway, starting with Claude's SDK as the foundation. What I discovered building it myself completely contradicted what everyone was saying online. Why I Built When Everyone Said Don't I had a
-
The .self Domain Migration: Why I'm Moving My Entire Stack to Self-Hosted
Three months ago, I registered moygulati.self and made what felt like a simple decision: migrate everything I build to this domain. But it wasn't just a domain change. It became a complete infrastructure experiment—rebuilding my entire development stack with zero external dependencies, using the .self TLD as both a technical choice and a philosophical statement about truly owning your digital infrastructure. The .self top-level domain exists specifically to support self-hosting. Unlike .com or
-
The Model Routing Problem: Why I Built Switching Logic Into My Code Editor
When my Claude Code bill hit $340 last month, I finally started paying attention to what these AI coding tools were actually doing. I watched in real-time as my editor burned through expensive API calls to complete variable names, close brackets, and suggest imports. GPT-4 was being summoned to tell me that const user should probably be followed by = getUserData(). The waste was obvious, and I realized I had no idea what kinds of requests I was actually making. So I built a logging system to fi
-
Running GLM 5.2 vs GPT-5.6: The Local vs Cloud Decision That Changed My Product Strategy
I was three months into running my document analysis startup when I made a decision that felt like betting against the house. Instead of scaling up my GPT-4 API usage as my user base grew, I spent a weekend setting up GLM 5.2 to run locally on a rented GPU cluster. The API bills were climbing past $800 monthly, but that wasn't the only reason. I kept hitting rate limits during peak usage, and some of my users were processing sensitive legal documents that made them nervous about cloud APIs, even
-
Building My Own Offline Maps Stack After Organic Maps Hit 846 Points: What FOSS Navigation Reveals About Platform Independence
I was halfway through reading that 846-point Organic Maps discussion when I realized I had no idea how my own apps would behave without Google's infrastructure. The thread was full of people praising offline maps, talking about data sovereignty, questioning why we'd all gotten so comfortable with location services that phone home constantly. By 2:15 AM, I was deep in my own codebase, counting dependencies. The audit was sobering. Three active projects, all built around Google Maps APIs. I was p
-
What I Found Building My Own Agent Orchestration After Everyone Says It's Dead
The consensus feels settled: agent orchestration is "so two years ago." But after watching supposedly advanced AI coding agents choke on my actual workflows for the third time in a month, I decided to ignore the think pieces and build my own orchestration layer. Six weeks in, the data I'm collecting directly contradicts what everyone's saying about orchestration being dead. The patterns I'm seeing suggest we might be throwing out the baby with the bathwater. The Context That Led Me Here I ke
-
Running My Local Models After GLM 5.2 Changed the Economics
The moment GLM 5.2 hit 2626 tokens/second at half the cost of Blackwell, I knew my API bills were about to become a thing of the past. Three months later, I'm sitting here with spreadsheets full of power consumption data, depreciation calculations, and a completely transformed development workflow. The Performance Numbers That Started Everything I'd been tracking local inference performance for months, but GLM 5.2's benchmark broke something in my mental model. 2626 tokens per second on consu
-
Why I'm Ditching GitHub for Codeberg: The 346-Point Discussion That Changed My Mind
Last Tuesday, I stumbled across a Hacker News thread titled "Why I'm leaving GitHub." Nothing unusual there—developers love a good platform migration story. But this one had several hundred upvotes and counting, and as I scrolled through the comments, I felt that uncomfortable recognition you get when strangers perfectly articulate something you've been trying not to think about. Those weren't just upvotes. They were receipts. My GitHub Dependency Audit: What I Actually Found I decided to ma
-
Running My Own Smart Model Router After Claude's Failed My Production Workload
Three weeks ago, I started getting complaints from users about "weird AI responses" in the dashboard I built for a client. The complaints were vague but consistent — outputs that didn't match the input, responses that seemed to ignore half the context, occasional gibberish mixed with perfectly coherent text. I'd recently switched to Claude's smart routing feature, which automatically selects the best model for each request. It looked perfect in my testing: clean API, automatic model selection f
-
The Serial Builder Tax: Why My Third Product Takes 10x More Decisions Than My First
My first product launch: 3 weeks, maybe 50 decisions total. My third product launch: 8 months in, tracking 1,847 decisions in a Notion database I never thought I'd need. I started logging decisions after realizing I was spending entire afternoons paralyzed by choices that used to take minutes. What began as a simple frustration became a case study in how building multiple products creates an exponential decision tax that nobody talks about. The Decision Explosion I'm Living The numbers tell
-
The .self Domain Migration: What 379 HN Points Taught Me About Infrastructure Independence
My migration to .self domains started as a weekend experiment and turned into a three-week archaeology dig through my own infrastructure assumptions. What I thought would be a simple DNS swap revealed how many layers of my stack I'd never actually questioned. The Decision Point When the .self TLD launched, I decided to migrate my entire personal infrastructure stack to it. The appeal was obvious: complete ownership of my domain namespace, no renewal fees to registrars, no risk of losing acces
-
Running GLM 5.2 in Production: Why I Switched From Claude Opus Mid-Project
Three months deep into a project running Claude Opus, I started testing GLM 5.2 out of curiosity. Within a week, my benchmarks showed something I wasn't expecting to see. The Baseline Reality By month three, my document analysis pipeline was humming along nicely with Claude Opus. The project involved extracting structured data from technical reports — the kind of dense, jargon-heavy PDFs that most models struggle with. Opus was handling about 85% of documents without human intervention, proce
-
Building My Self-Hosting Stack on .self Domains After 379 HN Points
Three weeks ago, I was refreshing a Hacker News thread like my next project depended on it. The .self TLD announcement had hit 379 points, and buried in the comments was a discussion I couldn't shake: developers losing access to their deployed applications overnight, not from technical failures, but from platform policy changes. I realized I'd been building on borrowed land for years. The thread wasn't just about domain names. It was about ownership in an era where "the cloud" means someone els
-
Building My Own Trends Tool: 18 Years of HN Data, Zero Vendor Lock-in
I've been getting increasingly frustrated with analytics platforms. Not because they don't work — they work fine — but because I realized I was letting their dashboards shape what questions I even thought to ask. When you're looking at Google Analytics or any other vendor tool, you're seeing data through their lens, asking questions they anticipated. Last month, I decided to break free from this and build my own trends analysis tool from scratch. My target: 18 years of Hacker News data. All of
-
The Local AI Sweet Spot: Why I'm Running Qwen 27B Instead of API Calls
I've been running Qwen 27B locally for three months now, and there was this moment at 2 AM when my internet died while I was debugging a React component. Instead of being stuck, I watched my local model suggest the exact fix I needed—a missing dependency in a useEffect hook. No rate limits, no API keys, no vendor dependency. Just my hardware doing the work while the rest of the world was offline. That moment crystallized something I'd been tracking: local AI had quietly crossed a performance th
-
The Real Cost of Claude Code's Steganographic Marking: What 1525 HN Points Says About AI Vendor Trust
My code completion suddenly felt different last Tuesday. Not the suggestions—those were still crisp—but something underneath. When the Hacker News story about Claude Code's steganographic marking hit the front page, it crystallized what I'd been sensing for months: the AI wasn't just helping me code, it was marking its territory. The story revealed that Claude Code embeds invisible watermarks in generated code—Unicode characters that look like normal whitespace but carry unique identifiers. Ant
-
Why I'm Running Qwen 27B Locally Instead of Claude API Calls
My Claude API bill hit $847 last month. That was my wake-up call to seriously test local alternatives instead of just assuming cloud APIs were superior. I'd been putting off this experiment for months, telling myself that local models weren't "there yet" for serious development work. But when I saw that bill, I realized I'd never actually measured what "there yet" meant for my specific workflow. The API Dependency I Built Looking back, my Claude dependency happened gradually, then suddenly.
-
The .self TLD Launch: Why I'm Moving My Entire Stack to Self-Hosted Domains
The 379 HN upvotes on the .self TLD launch weren't just validation—they were a signal that the rental economy for digital identity might finally be ending. I've been paying domain registrars for namespace access for 15 years, renewing annually like some kind of digital tenant. Today I started the migration to own it. The Philosophical Breaking Point The .self announcement hit different than other TLD launches. Not because of the technology—though the peer-to-peer DNS resolution is clever—but
-
What I Found Building My Own HN Trends Tool: 678 Points, 18 Years of Data, Zero Vendor Lock-in
The Saturday morning I woke up to 678 upvotes on a tool I'd built to analyze Hacker News trends—using Hacker News itself as the launching pad. The irony wasn't lost on me, or apparently the commenters. Here was a community known for dissecting every technical decision, and I'd just given them a tool that had been quietly analyzing their conversations for months while they debated the very patterns it was designed to surface. The Genesis Decision I started indexing HN comments locally not beca
-
What I Learned Shipping Code That AI Generated But Couldn't Debug
The backend spun up perfectly. Green tests, clean logs, everything humming. Twenty minutes from prompt to deployment—AI had built what would have taken me hours. Then came the race condition that ate my entire Saturday. The 20-Minute Miracle I'd given Claude a straightforward brief: build me a Node.js backend with user authentication, PostgreSQL connection pooling, and REST endpoints for a simple task management app. The kind of thing I've built dozens of times, but with a looming deadline br
-
Building Without the Government's Permission: Why I'm Moving Everything Off Regulated APIs
The moment I read that GPT-5.6 would require government approval for access, I opened my codebase and counted 23 different APIs that could disappear tomorrow if someone in Washington decided they didn't like what I was building. This wasn't paranoia—it was pattern recognition. Over the past few years, I'd watched API after API either get regulated, restricted, or simply shut down when they became inconvenient for someone with power. Twitter's API went from free to expensive overnight. TikTok's
-
Why I'm Switching AI Models Mid-Project: GLM 5.2 vs Claude Opus in Production
I swapped out Claude Opus for GLM 5.2 in my production workflow last Tuesday. Three days later, I'm questioning everything I thought I knew about model evaluation. The switch wasn't planned. I'd been using Claude Opus for the better part of six months, mostly for React component generation and API endpoint scaffolding in a fintech dashboard I'm building. It handled my TypeScript patterns reasonably well, understood my project structure after a few iterations, and rarely produced code that broke
-
Notes from a year of running my own homelab instead of the cloud
Twelve months ago, I spent $847 on a used Dell R720 and told myself I was done with cloud bills. Not reducing them, not optimizing them — done. I'd been running a few small projects on AWS and DigitalOcean, watching those monthly charges creep up for what felt like glorified file storage and compute I barely used. The server showed up in a box that weighed forty pounds, and I realized I had no idea what I'd actually signed up for. The first week was quietly terrifying. I'd moved my personal web
-
Code After AI: The New Unfair Advantage Isn't What You Think
The coding world is having the wrong conversation. While everyone debates whether AI will replace programmers, a quieter disruption is reshaping the entire developer hierarchy. Junior developers now use ChatGPT to generate React components in minutes—components that once took hours to write. Yet those same developers struggle to architect microservices without creating maintenance nightmares. We're optimizing for commodity skills while missing what's becoming exponentially more valuable. The
-
Own Your Stack: Why I Rebuilt on a Repo I Control
The $47 monthly Webflow bill shouldn't have bothered me. It was a rounding error compared to what I was spending on other tools. But something about that particular charge made me stop and actually look at my bank statement. $280 per month across platforms I barely controlled. ConvertKit for email. Webflow for the site. Google Analytics 360 because the free version didn't have the segmentation I needed. A dozen other subscriptions that had crept up like ivy on a house. Then the algorithm change