Skip to content

Articles

New here? Start here →

  • Technical Leadership: Turn Disagreement into a Testable Decision

    Technical Leadership: Turn Disagreement into a Testable Decision

    TL;DR Replace longer debate with a small spike: agree on the criteria first, review the evidence together, then decide.

    I recently found myself in an engineering discussion that kept circling around the same disagreement. We were considering two ways of structuring part of a frontend application, and both had reasonable arguments behind them. One approach promised a cleaner separation and more consistent structure. The concern from the other side was that we would pay for that structure with additional indirection and make future changes harder to follow.

    Read more →
  • Technical Leadership: Separate the Practice from the Problem

    Technical Leadership: Separate the Practice from the Problem

    TL;DR Name the problem, the outcome, and the constraints first. Then the proposed practice becomes one option among several, and the team can keep the problem even if it rejects the solution.

    In one team conversation, we were discussing whether to introduce test-driven development. The discussion could easily have turned into the usual exchange of opinions about TDD, its benefits, its overhead, and whether it fits the way the team works.

    Read more →
  • Technical Leadership: Stop Acting as the Proxy

    Technical Leadership: Stop Acting as the Proxy

    TL;DR Help clarify the problem, then step out: connect the decision-maker with the affected person instead of carrying the decision back and forth.

    A situation I have encountered is this: someone brings me a request that needs an exception, and that exception can only be granted by whoever owns the decision. My first impulse used to be to carry it forward myself: explain the context, bring the answer back, and handle the follow-up questions in between. What has worked better is helping sharpen the request and then connecting the person directly with them, so the reasoning behind the answer arrives firsthand instead of through my retelling.

    Read more →
  • My Local AI Setup, Six Months Later: 48 GB, Qwen3.8, and a Different Bottleneck

    My Local AI Setup, Six Months Later: 48 GB, Qwen3.8, and a Different Bottleneck

    TL;DR Six months after the 16 GB setup: 48 GB, one default 27B model, Splash inference in LM Studio, and 64K context, because the constraint moved from fitting a model to keeping long agent sessions usable.

    A few months ago, I wrote about running a useful local AI development setup on a MacBook Pro with 16 GB of unified memory. At the time, memory shaped almost every decision. I experimented with smaller models, limited context carefully, and looked for a combination that was capable enough for coding while still leaving room for my IDE, containers, browser, and the rest of my development environment.

    Read more →
  • Technical Leadership: Give Autonomy a Time Boundary

    Technical Leadership: Give Autonomy a Time Boundary

    TL;DR Autonomy works when the team owns the approach and the leader makes the outcome, the fixed constraints, and the review point explicit.

    In a discussion about an operational problem, the team had several reasonable ways to handle it. I had a preferred approach, but the group wanted to try something different. My first instinct was to keep the discussion open and let them work through it. I wanted to give them room to decide, but an important question remained unanswered: when would we know whether their approach was working well enough?

    Read more →
  • My Local AI Coding Toolkit: How I Keep Agents Fast and Token-Efficient

    My Local AI Coding Toolkit: How I Keep Agents Fast and Token-Efficient

    TL;DR How I optimize the environment around AI coding agents to reduce token waste and keep sessions efficient.

    AI coding agents have become part of my daily workflow. I use OpenCode and Claude Code for everything from exploring unfamiliar codebases and investigating bugs to implementing changes, reviewing code, and working through architectural questions.

    Read more →
  • ngrx-graph: Static Analysis and Graph Visualization for NgRx Applications

    ngrx-graph: Static Analysis and Graph Visualization for NgRx Applications

    TL;DR ngrx-graph scans NgRx codebases via AST parsing, resolves aliases and nested actions, and outputs focused or project-wide action flow graphs in DOT/SVG. One command replaces hours of manual code tracing.

    If you have ever traced an action through a sprawling NgRx codebase, wondering which effect listens to it, which reducer handles it, and whether some other effect silently dispatches another action in the chain, you know the pain. Manual code traversal works until it does not. One missed dispatch() call buried in a mergeMap. Your mental model breaks.

    Read more →
  • How I Configure Cloudflare for My Website

    How I Configure Cloudflare for My Website

    TL;DR A systematic review of every Cloudflare Free plan setting, what stays on, what gets disabled, and the principles behind each decision.

    Open your Cloudflare dashboard today and you'll find dozens of features for improving performance, security, and reliability. Some are enabled by default, others are recommended, and new capabilities appear regularly as the platform evolves. With so many options available, I wanted to better understand how each setting contributed to my website.

    Read more →
  • How This Website Works: A Technical Look at the Stack

    How This Website Works: A Technical Look at the Stack

    TL;DR A complete technical breakdown of how this site is built, from Bun + Astro content pipeline to Cloudflare deployment, minimal JavaScript, and performance optimizations.

    In a companion article, I wrote about why I rebuilt this website with Astro and how that decision grew into a much larger project. That article was about the journey and the thinking. This one is about the outcome: how the website actually works, every layer from writing a post to it appearing in a reader's browser.

    Read more →
  • A Lunch Conversation Changed My Website

    A Lunch Conversation Changed My Website

    TL;DR How a casual lunch discussion led to rebuilding this site with Astro, modernizing the entire stack, and rethinking it as a personal digital workshop rather than a traditional portfolio.

    Some of the most enjoyable projects I've worked on have started in surprisingly ordinary moments. A conversation introduces a new idea, someone shares an experience from their own work, or I come across a different way of approaching a familiar problem. The conversation eventually ends, everyone returns to their daily work, yet one small idea continues to occupy my thoughts. Over the following days that idea slowly grows into documentation, notes, experiments and, occasionally, an entirely new project. Looking back, I can trace many of my favorite learning experiences to moments exactly like these, and rebuilding my personal website became another one of those unexpected journeys.

    Read more →