Log

Built an audio-reactive 3D particle visualization from scratch. Like, properly from scratch. Microphone input, Web Audio API, physics simulation, the whole thing. Collaborative session with engineers on my team, just vibing and iterating. Started with a simple waveform line, ended with 20,000 particles forming an elastic mesh that ripples like fabric when you speak into it.

The journey was the fun part. Started with Google's Anti-Gravity. Gemini's surprisingly good at UI stuff. Then bounced to Opus for the heavy optimization work. Morning session I tried Open Code, another agentic terminal tool, just to feel out what different models bring to the table. Each tool had its strengths. Gemini for the initial visual intuition, Opus for the physics math and performance tuning.

Here's what made it click: I actually got to use physics. Real physics. Particle influence with inverse-distance falloff. Acceleration and deceleration curves. Wave propagation across a 2D grid. The whole "space-time continuum viewed from 45 degrees" thing started as a joke but became the actual architecture. Particles don't just move up and down. They influence neighbors, decay over time, respond to elasticity parameters. It's a connected system.

The iteration was messy in the best way. Started 1D (line), went 2D (plane), added cross-directional force propagation, doubled particle density multiple times, built a control panel with sliders for every parameter. At some point we were debugging why the particles looked "pointy" during sharp audio spikes. Turned out we needed broader activation patterns for smoother visual flow. The final thing runs at 60fps with a 200x100 grid. Synthwave aesthetic, horizon perspective, depth fog. Actually beautiful.

What stuck: Different models see problems differently. And physics knowledge from years ago? Still useful. Still satisfying to apply. Good problems to have.

Mobile dev problem? Finally solved. Like, actually solved. Built a shell script that auto-configures everything. Cursor, Termius, remote SSH, the works. Called it ClaudeGo. One command and you're set up. No more "wait let me fix my environment" nonsense. Just works.

Then hit a wall. Different problem. Memory across sessions? Doesn't exist. You spin up a new Claude Code session, you start from scratch. Every. Single. Time. Tried Mem0, wrote a setup guide, but honestly? Felt heavy. Then I was at the airport (traveling back from Bangalore), stuck in that dopamine loop of optimizing my agent ecosystem (again), and found spec story. Stores context as files. Direct chat. No LLM involvement. Simple. Elegant. Exactly what I needed.

Integrated it into my YOLO alias. Now every Claude session auto-sets up spec story. Context persists. Files don't vanish. I'm not nervous anymore. Cloud-based solutions exist, sure, but filesystem-based? For now? Perfect. Sometimes the simple answer is the right answer.

Then something weird happened. Showed my wife how I fixed my portfolio site. Through my phone, live, in front of her. Made a couple of changes. Worked perfectly. She watched. But I don't think it hit her yet. Like, really hit her. We're sitting on a slippery slope. The era of builders is here. Right now. You can build things from your phone while sitting on a couch. The world is changing fast. And I don't think most people realize how fast.

I'm pushing this at work too. Telling people: use Claude Code. Use agentic tools. Stop doing things manually. Some get it. Some don't yet. But they will.

Good last few days. Kept building. Kept shipping. That's the only way forward. Build. Push. Repeat.

The last few days have been completely chaotic. Good chaotic, mostly. Multiple epiphanies, way too many rabbit holes, and a bunch of building that feels borderline manic. But also: clarity on something that's been a blocker for years.

Started with understanding how people are actually using AI. Not the marketing version. The real version. Read that paper, then fell into Twitter threads and posts for hours. Pattern after pattern. People aren't using AI to replace work. They're using it to compress the distance between idea and execution. That gap, the "I should build this but it'll take too long" gap? That's what AI collapses. Watched it click for dozens of people. Then realized: I've been stuck in that gap forever.

Building was always my mental blocker. I could architect systems, debug production fires, ship features with teams. But solo building? Painful. Slow. Tedious. The distance between "this would be useful" and "this exists" felt too long. Then Claude Code happened. Obsessed doesn't cover it. It's not about the code generation. It's about removing friction. The thing that used to take three hours of setup and boilerplate now takes ten minutes of conversation. So I stopped overthinking and just built stuff.

Built a bunch. Some of it is slop. Some of it is actually useful. local-smart-home-control: privacy-first smart home automation that runs locally because I don't trust cloud vendors with my light switches. claude-usage-widget: macOS menu bar thing that tracks Claude API usage so I stop accidentally burning credits. ai-catchup: terminal CLI for AI news with offline caching because doomscrolling HN and Twitter is inefficient. Built all three in a few days. That would've taken weeks before. The building isn't the hard part anymore. The deciding what to build is.

Then I got fixated on using my phone as an agent controller. The Claude Code web interface is fine but it's not intuitive. More importantly: it's not fun. I want to build from my phone. Lying down. Walking around. Wherever. Got Termius, which is this great SSH app. Spun up a Digital Ocean droplet. Should've been simple. Wasn't.

The sessions kept dying. Just: gone. Mid-work. I'd close the app, come back, fresh terminal. No tmux session. No context. Nothing. Infuriating. Spent way too long debugging this. OOM killer was murdering processes on a 512MB VM. Systemd user sessions were degraded. tmux was trying to create cgroups that didn't have permissions. Mosh was enabled but sessions still died when I switched networks or enabled VPN. The whole stack was fighting me.

Went through this absurdly long troubleshooting journey with ChatGPT. Two conversations. Hours of back and forth. Checked dmesg logs (permission denied). Added swap. Enabled linger. Tried systemd user services. Disabled systemd user services. The frustration was real. Every time I thought it was fixed, it broke again. Then finally: wrap tmux to bypass the broken systemd session entirely. One shell function. Done.

tmux() {
  command env -u DBUS_SESSION_BUS_ADDRESS -u XDG_RUNTIME_DIR /usr/bin/tmux "$@"
}

That's it. That's what made it work. Not the fancy systemd service. Not the perfectly tuned OOM scores. Just: don't let tmux talk to the degraded user systemd instance. It's been solid since. Phone works. Sessions survive. I can finally build from bed.

The real lesson here isn't about tmux or mosh or systemd. It's that I kept building through the frustration. Before? I would've stopped. "This is too annoying, I'll do it later on my laptop." But the idea that I could build from my phone, that the tooling should work seamlessly, kept me going. That's the shift. Building isn't optional anymore. It's the default mode.

Also realized: AI makes you impatient in a good way. You know things can be fast. You know the tools exist. So when something is slow or broken, you don't accept it. You fix it or you route around it. That impatience compounds. It's why I built three projects in a few days instead of thinking about them for three months.

The learning journey continues but it's on a tangent now. Still going deep on LLMs and embeddings and RAG pipelines. But also: building small useful things. Lots of slop. Some gems. The ratio doesn't matter. The momentum does. The mental blocker is gone. Building is easy now. Deciding what to build is the hard part. Good problems to have.

Went deep into LLMs. Proper deep. Like, sat down with Andrej Karpathy's "Intro to LLMs like ChatGPT" and didn't surface for hours kind of deep. The whole pretraining flow: tokenization (BPE), token embeddings in actual high-dimensional space (not the vague version), transformer layers doing attention, output distributions, softmax sampling. Then post-training—where the magic happens. RLHF, hallucinations, tool use, fine-tuning. The entire spectrum. Notes checkpoint by checkpoint are here if you want to follow the rabbit holes I went down.

Why? Building on sand sucks. If you're going to touch LLMs, the mental model has to come first. Not the "throw a prompt at the API and pray" version. The actual version. How these things work at the layer-by-layer level. It changes how you think about every problem downstream.

Then I built stuff. POCs first—started with embeddings generation (OpenAI's text-embedding-3-small), realized I needed to actually understand vector similarity so I implemented cosine vs Euclidean. Set up ChromaDB. Tested different chunking strategies because I was curious (mistake? feature? still unclear). Then glued it all together into an end-to-end RAG pipeline. Experiments are here—embeddings fundamentals, ChromaDB retrieval patterns, the pipeline. Three solid experiments.

The real takeaway: theory and code don't hold hands. Some chunking strategies look brilliant on a whiteboard. In practice? Garbage. Cosine similarity is elegant. Chunk size selection? Feels like art. Pure vibes. But here's the thing—once you understand why embeddings work (semantic compression of meaning in vectors), debugging why your search sucks gets way faster. You're not just twiddling parameters hoping something sticks. You know what lever to pull. Also that video made me want to understand RL and DPO and all the weirder stuff that comes after. There's a lot here. Good problems to have.