Modern Development Blog
Agentic memory is a technique used in AI agents that integrates long-term and short-term memory to enable persistence, allowing LLMs to store, retrieve, update, and summarize information across conversations, similar to human memory.
A serverless JavaScript runtime with sub-millisecond cold starts, 500KB footprint, TypeScript support, and compile-time evaluation - all written from scratch in pure Zig.
Everyone knows map. But flatMap confuses people for years until it suddenly clicks. Here's the mental model that makes it obvious.
A Guide to build a compiler in Zig.
A Guide for Ai Agents, C Developers and Zig Beginners.
The "Payment Required" status code sat dormant since 1995, waiting for the right payment rails. Stablecoins and autonomous agents finally made it practical.
Everyone talks about AI writing code. Fewer ask who writes the spec. Turns out there's a way to treat specification as an engineering problem, not a prompting art.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Discover CIVILI and why their revival captures the authentic spirit of the 80s Yugoslavia's music scene
Building a pure TypeScript Mermaid renderer that works server-side - no browser, no DOM simulation, just functional patterns and smart type system usage.
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.
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.
Working on a project with the team of AI Agents... What can go wrong?
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.
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.
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.
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.
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.
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 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.
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 creates self-describing systems where servers guide client behavior through hypermedia controls, enabling API evolution without breaking existing integrations.
Companies adopt the vocabulary of product thinking while keeping the power structure of project shops. Here's why the transformation stops at the slides.
Real functional programming benefits in TypeScript without fp-ts or complex abstractions - just pure functions, explicit errors, and smart use of the type system.
While the identity community debated wallet distribution strategies, Apple, Google, and Microsoft shipped the infrastructure. The wallet problem got solved sideways.
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.
Multi-agent systems where different AI models critique each other's work. Sounds wasteful. Turns out it's the opposite.
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.
A practical guide to modernizing legacy monoliths using strangler fig, event sourcing, and data synchronization patterns that actually work in production.
When your organization grows, coupling debt kills velocity. Here's how to treat team structure like distributed systems architecture.