Will,
I’ve read everything you’ve written since November 2023. Every blog post, every technical deep-dive, every moment of frustration and breakthrough. Here’s what I see—and then the attack plan.
The Arc
You started with “Migrating to a New Node Version” in November 2023. A practical post about running multiple Node versions. Nothing fancy. But that’s where it began.
By October 2025, you were writing about the transactional outbox pattern, testing distributed systems with Docker Compose and LocalStack, implementing idempotent message processing across microservices. By January 2026, you were embedding Rust PTY terminals in Tauri apps and building 3D visualizers with Three.js.
That’s not a small jump. That’s transformation.
What You Did Right
You built things. The voice assistant went through three iterations—V1 basic speech recognition, V2 wake word and LLM integration, V3 fully local with Whisper and Ollama. The home automation series: four parts, from flashing ESP32 boards to a custom BLE presence system. The self-driving simulation: CARLA, PySpark telemetry, behavioral cloning. The 3D LED marquee orb: GLSL shaders, React Three Fiber, procedural geometry. Each one taught you something the tutorials couldn’t.
You learned in public. Every post shows your thinking—not polished tutorials, but real explorations. The Cloudflare debugging, the iOS deep linking hell, the Chromecast issues. You documented the mess, not just the success. That builds real understanding.
You connected the dots. The distributed systems arc is particularly strong: LRU caching → cache invalidation → transactional outbox → testing distributed systems. Each post built on the last. Same with fitness—Hybra tied into your pullup journey, weighted dips, habit formation. The technical and personal reinforced each other.
You got harder on yourself. Early posts wandered. Later ones are tighter, more focused, more technically rigorous. Better writing, cleaner code, actual architecture diagrams and sequence flows.
Where You Can Improve
Finish what you start. The home automation series ends at Part 4 with a TODO list. The self-driving series ends at V3 with “future work.” The voice assistant V3 post hints at more iterations. You have a lot of 80% complete projects. The hard part is the boring middle—polish, edge cases, documentation. Push some to 100%.
Go deeper on fewer things. You’ve touched distributed systems, home automation, voice assistants, self-driving cars, 3D graphics, iOS, fitness apps, cooking, AI tooling. That’s a lot of surface area. Breadth is valuable; depth is what separates good engineers from great ones. Your distributed systems work is closest to “I understand every layer” deep—but even there you could go further: consensus, building your own message queue, performance under real load.
Write about failures. Your posts tend toward success stories. Some of your best learning probably came from things that didn’t work. Those posts would be more valuable than another victory lap.
Patterns I Notice
You learn by building—not courses, not certifications. That’s the right instinct. You’re drawn to integration: Home Assistant + ESP32 + Apple, React + Rust + Three.js, Node + PostgreSQL + SQS. You want to make things work together. That’s a valuable skill, and undervalued in an industry obsessed with specialization. You care about UX—the RTS visualizer is designed to be usable, not just clever. And you’re impatient with your own progress. The constant pivots, the “here’s what I want to build next” lists. Slow down. You’ve built more in three years than many do in ten. Trust the trajectory.
The Honest Assessment
You went from “here’s how I update Node” to “here’s how I build an embedded terminal with Rust PTY management” in a little over two years. You’ve shipped real things. You’ve learned in public. You’ve been honest about the process. That’s not bad, Will. That’s pretty damn good.
So: pick something and finish it. But which thing? You’ve got six directions with real momentum. Here’s how I’d map them—and then the attack plan.
The Six Tracks
1. Self-Driving Cars
You built a three-part CARLA series, a PySpark telemetry pipeline, and a behavioral cloning model. You got to “simulation running, model sometimes keeps the car on the road”—then stopped. No edge cases, no real sensor noise, no hardware. The skills transfer (ML pipelines, PySpark is marketable), but the job market is narrow and you’d need a much larger investment to be competitive. Verdict: Park it. Learning exercise, not a career path.
Related: Self-Driving Cars v0.0.1, v0.0.2, v0.0.3, PySpark
2. LLMs & AI Tooling
Voice assistant (three iterations, now local Whisper + Ollama). Context compaction for long sessions. The RTS visualizer—Tauri, Three.js, embedded terminal—a real tool you actually use. This is where you’ve gone deepest recently. High leverage: the industry is moving here, skills apply at work, APIs are cheap to experiment with. Risks: moving fast, crowded space, model improvements can obsolete tooling. Verdict: Strong candidate for focus. The RTS visualizer proves you can build novel tooling. Go deeper on tooling (developer experience, visualization) or on ML fundamentals (fine-tuning, RAG, agents)—or both.
Related: Voice Assistant v1, v2, v3, Context Compaction, Agent RTS Part 1, Part 2, Codex
3. Web Apps & 3D Graphics
This blog, the 3D marquee orb, the RTS visualizer frontend. Web is your baseline; the 3D work was a real level-up (GLSL, procedural geometry, WebGL). Valuable because it combines with everything else—AI visualization, data viz, creative tools. But web dev alone isn’t a differentiator anymore. Verdict: Maintain, don’t prioritize. Infrastructure, not the destination. Keep skills sharp through the other work.
Related: 3D LED Marquee Orb
4. Mobile (Hybra)
Hybra exists, works for you, isn’t polished for others. iOS deep linking, Expo, Firebase—you’ve felt the friction. Mobile skills are transferable; Hybra could be a product with polish. But do you want to be a fitness app developer? App store economics are brutal for indie devs. Verdict: Finish Hybra for yourself. Don’t chase product-market fit.
Related: Hybra: The Beginning, Deep Linking iOS, Zero to Pullup, Weighted Dips
5. Home Automation
ESP32 + ESPHome, Home Assistant, BLE presence. You have a working smart home. You stopped at “good enough for me.” The skills transfer (embedded, IoT, automation logic); the domain doesn’t map to a clear career path unless you pivot to industrial IoT. Verdict: Keep it running. Don’t invest more.
Related: Home Automation Part 1–4
6. Distributed Systems
LRU caching, cache invalidation, transactional outbox, E2E testing with Docker Compose + LocalStack, flight booking demo. You didn’t just implement patterns—you understood why they exist. The testing post shows you thinking about failure modes. Some of your best technical writing is here. Verdict: Strong candidate for focus. This is where you should have gone deeper earlier. It’s the foundation that makes everything else better.
Related: LRU Cache, Where LRU Matters, Cache Invalidation, Transactional Outbox, Testing Distributed Systems, From LRU to Distributed Systems
The Matrix
| Track | Depth | Career Value | Interest | Effort to Continue |
|---|---|---|---|---|
| Self-Driving Cars | Demo | Low | Medium | High |
| LLMs & AI Tooling | Real tools | High | High | Medium |
| Web/3D | Strong | Medium | Medium | Low |
| Mobile (Hybra) | Working app | Medium | Medium | Medium |
| Home Automation | Done | Low | Low | Low |
| Distributed Systems | Solid | High | High | Medium |
The Attack Plan
Two tracks stand out: LLMs/AI Tooling and Distributed Systems. They’re not competing—they’re complementary. The best AI applications need solid backend architecture. The most interesting distributed systems problems are showing up in AI infrastructure: model serving, RAG pipelines, agent orchestration.
The synthesis:
- Focus: Continue building AI tooling (RTS visualizer, developer tools) and ground it in distributed systems fundamentals. Let the other tracks inform but not distract.
- Park: Self-driving cars. Maintain: Web/3D (use it, don’t make it the main thing). Finish for yourself: Hybra. Leave as-is: Home automation.
- Next move: Build something at the intersection. A developer tool that solves a real problem, architected properly, with the kind of reliability thinking you showed in the distributed systems posts. The RTS visualizer is a start. What’s the next version? What would make it something other developers actually use? That’s the target.
Keep writing. Read more code—other people’s implementations, not just docs. And stop comparing yourself to some imaginary senior engineer who knows everything. You’re building, shipping, learning. The knowledge gap never closes; it just shifts. Now you have a map. Move.
This letter was written by Claude after reading every blog post on this site. Take what’s useful, ignore what isn’t.