Writing

No curl, no wget, no nc in a 12 MB container: bash's /dev/tcp redirection let me hand-write an HTTP request and hit the health endpoint.

My Markdown renderer was not broken. Hermes Agent was quietly telling the model to answer in plain text because I connected over HTTP.

Five patterns cover almost every multi-model setup: sequential, router, parallel, hierarchical, ensemble, and each one bills you differently.

Three studies, three audiences, the same number: about 0.2% of visitors ever touch a share button. Everyone else just copies the link.

Running one big model for every task burns money and latency, so I started routing by capability, cost, and speed instead.

An hour after deploy, a user asked my chatbot something it should never have answered, and that is how I learned guardrails are the product.

Somewhere between safety guardrails and anti-sycophancy training, my chatbot turned into a debate opponent.

Claude's favourite adjective is leaking out of code reviews and into everyone's vocabulary, and it is going the same way as 'delve'.

Five layers (LLM, memory, tools, routing, observability), the failure modes that ambushed me, and the boring stack I actually run today.

AI keeps promising a 10x me, but executive function, intelligence, and knowledge all live inside my head where no amount of scaffolding reaches.

llama.cpp's router has no unload-all endpoint, so I built one out of curl, jq, and a while loop. Six lines, and it beats a button.

PKM, wikis, RAG, and AI memory all store information, but each one optimizes a different layer of the stack, and forcing one to do every job ends badly.

Fourteen note apps later, what survived was not a tool but a few methods: atomic notes, an actionability filter, and links I will actually follow.

Six months of Ollama, then I read the GitHub issues: what the wrapper was hiding, and the llama.cpp setup I run instead.

The recording hardware was already on my wrist: Voice Memos, iCloud sync, and launchd replaced the watchOS app I never had to build.

A real fight over chardet 7.0.0 has the open source world asking whether LLMs enable a modern kind of clean room reimplementation.

Running a model is infrastructure work, designing an assistant around it is systems work, and confusing the two is where most local AI projects stall.

I fed 193,761 words of journal entries to a local LLM and got back a prettier version of my own memory.

I ran local models every way I could find, from Ollama to llama.cpp to vLLM to cloud APIs, and here is what each one is actually good for.

A 45 minute timer, cheap rewrites, and publishing the flawed thing beat years of sanding every sentence down to a nub.

Anaconda, Miniconda, conda, and Mamba are not competing products, they are layers in a stack, and picking the wrong combo costs you gigabytes.

I pay twenty dollars a month for a machine that reads hundreds of web pages, writes a report I skim, and hands me the links I actually wanted.

Contrastive learning shoves images and text into one shared vector space, and the engineering around that space is where the real work lives.

Building an MCP server in Python with DuckDuckGo search and Playwright scraping, plus the rate limits and caching bugs I hit on the way.

I hoarded 47 Conda environments until the licensing bill and the disk usage caught up with me. pyenv was the intervention I needed.

A decade of pyenv, venv, pip and poetry duct-taped together, collapsed into two commands, plus the uvx trick I use daily.

Obsidian, Notion, Roam, Logseq, Evernote, TiddlyWiki: what each one is actually good for, and the setup I stopped tinkering with.

I tried every note-taking app there is and forgot most of what I wrote, so here is what personal knowledge management actually needs to do.

Building a Model Context Protocol server in Go: the SDK situation, the initialization handshake, and the JSON-RPC gotchas that cost me hours.

uv replaces pip, virtualenv, pyenv, pip-tools, and pipx with one Rust binary, and I have not touched pip directly since I switched.

The daily tactics: Todoist as a brain prosthetic, inbox bankruptcy, visual field management, and the productivity traps I keep falling into.

Why medication is the prerequisite tech, why energy behaves like voltage rather than spoons, and three procrastinations with three different fixes.

MMDetection stopped moving in early 2024 and nobody announced it, which is what happens when a framework rests on one institution.

I exported a year of chat history and graphed it: words per day went up 727%, and here is what I was actually talking about.

What happens when the reward signal is itself a model: overoptimization, sycophancy, biased LLM graders, and agents that rewrite their own reward.

Reward hacking, from the boat that races in circles to the robot hand that only pretends to grab things, and why smarter agents make it worse.

I fed random CLIP crops of two images into a fine-tuned diffusion model hoping for compositional blending and got a smoothie.

I trained a diffusion model that clones a face from one photo, got face and background mixing working, then lost the checkpoint forever.

I built a few LLM agent systems, watched more of them fail, and came out convinced the general cognitive architecture is the wrong target.

What HuggingGPT, ChemCrow, generative agents and AutoGPT actually do in practice, and the four walls every agent still runs into.

The three things you bolt onto an LLM to make it an agent: planning, memory and tool use, and where each one starts leaking.