CSS-Only UI Components: A Kanban Board Without JavaScript
An honest look at hsx-ui - a framework-free CSS component library that uses :has() selectors and data attributes to build interactive UIs without a single line of JavaScript framework code.
HTMX vs Nomini: Clash of Titans
I spent a weekend exploring whether to swap HTMX for Nomini in this blog. Here's why I'm staying put—and when Nomini might actually make sense.
Part-2: Memory Safety in Zig Without the Pain?
A practical allocator wrapper that adds Fil-style runtime safety checks where you need them, with zero language changes and minimal code churn. Opt-in, idiomatic, and surprisingly elegant.
Eliminating DNS Single Points of Failure: Dual-Authoritative DNS Setup
The recent Azure DNS outage was a wake-up call. Here's how to build truly redundant DNS across AWS Route 53 and Azure DNS using octoDNS, so no single provider outage takes you down again.
Part-1: Memory Safety's Impossible Dream
Can you get complete memory safety at compile time with zero runtime cost? Turns out computation theory says no—but the hybrid approaches we can build are surprisingly interesting.
TypeLang - Strict TypeScript Subset with Algebraic Effects
Software complexity grows not just from problems we solve, but from flexibility languages give us. TypeLang explores enforcing functional principles and explicit effects through constraints—making illegal states unrepresentable and side effects visible in type signatures.
Type-Safe Infrastructure with Bicep
Bicep's type system brings compile-time safety to infrastructure code. Here's how discriminated unions, user-defined types, and helper functions turn error-prone YAML wrangling into predictable, maintainable infrastructure engineering.
Lifion Development Platform Credos
Company credos encapsulate organizational beliefs and serve as reference points to guide actions. Here's how we distilled our engineering philosophy into principles that enable teams to move autonomously while staying aligned.
DOM-Native Components That Actually Work
What if the DOM itself managed your app state? No hydration, no megabyte bundles, instant interactivity. Here's what happens when you treat the browser as a platform instead of a rendering target.
Why Your Agile Transformation Failed at the Hiring Stage
Organizations spend millions on agile transformations—new frameworks, training, tools—but keep hiring for hierarchical structures. Turns out who you hire determines success more than which ceremonies you run.
Equity Ownership Changes Everything
When people own a piece of what they're building, behavior shifts dramatically. Here's what happens when you align compensation with actual outcomes instead of just paying salaries.
Your Agile Transformation Failed Because Hierarchies Can't Be Agile
Companies hire Scrum masters, implement ceremonies, deploy Kanban boards—but stay locked in hierarchical structures. Turns out organizational architecture determines what behaviors you can sustain, regardless of which framework you adopt.
Effect-Oriented Programming in Flix
Side effects scattered everywhere make code hard to test and reason about. Flix's algebraic effect system brings discipline—declare what functions can do, verify at compile time, handle effects in one place.
Structured Concurrency in TypeScript with Effection
Async/await solved callback hell but introduced coordination nightmares. Structured concurrency fixes this—hierarchical operations with automatic cancellation and cleanup. Here's how Effection brings it to TypeScript.
CIVILI Reveal New LP: A Call From The Past
Discover CIVILI and why their revival captures the authentic spirit of the 80s Yugoslavia's music scene
Server-Side Mermaid Rendering Without the Browser
Building a pure TypeScript Mermaid renderer that works server-side - no browser, no DOM simulation, just functional patterns and smart type system usage.
Effect-TS Makes TypeScript Read Like Business Logic
How Effect-TS separates business logic from technical plumbing - error handling, async operations, and dependency management that doesn't obscure what your code actually does.
Gleam's Elegant Solution to Callback Hell
Callback hell plagues functional programming—deeply nested code that obscures logic. Gleam's `use` syntax solves this elegantly with one simple construct. Here's what makes it interesting and how to apply similar patterns in TypeScript.
About Coordinating Multiple Coding Agents
Working on a project with the team of AI Agents... What can go wrong?
When Quality Gates Become Bottlenecks
Manual approval processes intended to ensure quality often create the opposite—slower delivery, frustrated developers, quality issues that slip through. Here's what actually works.
Modern Agile - What Sustaining Velocity Actually Requires
Moving fast is easy. Sustaining velocity over months and years? That requires something deeper than ceremonies and story points. Here's what actually makes teams ship consistently.
What Self-Governing Teams Actually Look Like
Real patterns from teams that make their own decisions - what works, what falls apart, and why giving autonomy without the right support structure creates chaos instead of speed.
New Era of Background Checking Without Exposing Sensitive Details
W3C Verifiable Credentials with BBS+ signatures let you prove employment without revealing salary or position. Here's how the standard works, and how multi-party attestations could make it even stronger.
HTMX - Build Interactive Web Apps Without the JavaScript Framework Tax
Frontend complexity exploded over two decades—build tools, state management, framework-specific patterns. HTMX flips this by extending HTML with AJAX, WebSockets, and real-time updates through simple attributes. No build step, no virtual DOM, just HTML doing what it should have done all along.
Architecture Review Boards as Enablers, Not Gatekeepers
Most Architecture Review Boards slow teams down with approval gates. But they don't have to. Here's how ARBs can accelerate product development instead of blocking it.
Deno: JavaScript Runtime Done Right
Deno rethinks JavaScript runtime from scratch—built-in TypeScript, secure by default, no node_modules. Created by Node.js's original author to fix what he got wrong the first time.
Mixon - Type-Safe Web Framework for Deno with Built-In Workflows
Building web apps means juggling type safety, state management, and server-side rendering across multiple libraries. Mixon combines end-to-end TypeScript safety, workflow engine, and HTMX support in one lightweight package for Deno.
HATEOAS and Hypermedia-Driven Development
HATEOAS creates self-describing systems where servers guide client behavior through hypermedia controls, enabling API evolution without breaking existing integrations.
The Aesthetics of Modernization Without the Architecture
Companies adopt the vocabulary of product thinking while keeping the power structure of project shops. Here's why the transformation stops at the slides.
Functional TypeScript Without the Framework Baggage
Real functional programming benefits in TypeScript without fp-ts or complex abstractions - just pure functions, explicit errors, and smart use of the type system.
Your Browser Is Already a Wallet
While the identity community debated wallet distribution strategies, Apple, Google, and Microsoft shipped the infrastructure. The wallet problem got solved sideways.
Essential Zig Idioms - Writing Code That Feels Like Zig
Zig has its own way of doing things. Here's a collection of patterns that make code feel natural to experienced Zig developers - from anonymous struct literals to arena allocators.
The Best AI Development Partner Is Another AI
Multi-agent systems where different AI models critique each other's work. Sounds wasteful. Turns out it's the opposite.
Why (some) Big Companies Can't Ship New Things
Large companies claim they want innovation while their structure guarantees it will fail. Here's why the BAU vs. innovation split creates an immune system that rejects change.
Migrating Enterprise Monoliths Without Breaking Everything
A practical guide to modernizing legacy monoliths using strangler fig, event sourcing, and data synchronization patterns that actually work in production.
Treat Team Structure Like Distributed Systems Architecture
When your organization grows, coupling debt kills velocity. Here's how to treat team structure like distributed systems architecture.