AI Isn't Replacing Coding. It's Replacing the Friction Around It.
AI's greatest contribution isn't writing code—it's removing the friction that prevents developers from doing their best work.
Blog
Thoughts on programming, creativity, and building great products.
The Orchestration Tax
Why scaling parallel work with AI and teams increases coordination costs and turns attention into the real bottleneck
Runtime Form Validation with Backend JSON Schemas: A Practical Architecture
How to keep runtime validation, type safety, and manual UX aligned when JSON Schemas come from backend contracts
What's Your Backup Plan When AI Gets Too Expensive?
Everyone is debating whether AI will replace engineers. Fewer people are talking about what happens when AI becomes too expensive, too restricted, or simply disappears from your workflow.
Building Token-Efficient AI Agents in the Real World
Why most agent systems overspend tokens, and a practical pipeline template to make them cheaper, faster, and more reliable.
Digitalisation Failed Us (And Why Automation Is Still Broken)
For over 50 years we've been trying to digitalise society. Instead of removing friction, we built thousands of disconnected digital islands. Here's why — and what actually works.
Development Is Accelerating Faster Than Ever — Are We Ready?
AI-assisted development is compressing the distance between idea and implementation. The real challenge is learning how to move faster without losing the thoughtfulness that good engineering requires.
What Much of Node.js Has Been Missing
How pointer compression — a V8 optimization Chrome has used since 2020 — is finally coming to Node.js, and what it means for memory, cost, and scaling
How Coding Agents Actually Understand Your Codebase
A deep dive into how tools like GitHub Copilot inside Visual Studio Code gather context, reason about structure, and navigate your repository
Frontend Architecture Is Not Missing. You're Just Looking at the Wrong Boundary.
Modern frontend hasn't abandoned separation of concerns—it has adapted it to a medium where ephemeral state, lifecycle, and reactivity are first-class concerns.
Automation Over Perfection: What OpenClaw-style Tools Teach Us About Real Development Workflows
Why productivity gains come from workflow integration rather than perfect tools, and what agent-based development reveals about the future of software engineering
From Code to Intent: How Agents Are Reshaping Development
The shift from writing code to expressing intent, and how spec-driven workflows with AI agents improve velocity, accuracy, and reliability
Hire Juniors and Train Them Well
Why AI makes junior hiring more important, not less—and how organizations that maintain talent pipelines will outlast those optimizing for short-term efficiency.
Sweden's Education U-Turn: From Digital-First to Fundamentals-First
How Sweden reversed course on digital classrooms after discovering that screens don't replace centuries of embodied learning
How GPT Works: A Tiny, Stripped-Down Example
Understanding the core idea behind GPT models through a simple, accessible example without heavy tools or libraries
Understanding Algorithms Through Layers and Metaphors
Exploring how algorithms work by thinking of them as layered machines, from intent to mathematical operations, using metaphors to grasp complex concepts
The Real State of AI Coding in 2026
Beyond the hype: what AI can actually do for software development today, and what still needs human engineers
About Testing and Confidence
Boundaries and setups for testing
Open Source After Dependencies (Part V): Adding Guardrails Without Losing the Point
Evolutionary systems target the right audience
Open Source After Dependencies (Part III): Where This Breaks, Who Pushes Back, and What a Minimal Path Forward Looks Like
Problem solved or not
Open Source After Dependencies (Part IV): Package Managers, Governance, and a Realistic Migration Path
Tradeoffs are hidden in the details
Open Source After Dependencies (Part II): Design Spaces, Incentives, and What Comes Next
What's the practical plan to intent driven development?
Open Source After Dependencies: Rethinking Freedom in an LLM-Native World
A future where maintenance of dependencies shares control
From ENIAC to AI
How computation changed over the decades and the essential technologies shaping software development in 2024
Testing Automation
Best practices for test automation: strategies, tools, and approaches to building reliable automated test suites
What We Lost When Visual Basic Faded Away
The decline of Visual Basic and what it meant for accessible programming: lessons from a tool that democratized software development
Why I Think Windows UI Feels Slower — And Why It Isn’t Just My Imagination
How web tech factors in, and where things might go next: grounded in recent developments and concrete trade-offs in modern UI frameworks
How I Caught a Silent Performance Killer in Code Review
A common React anti-pattern that disables memoization and how to identify it
Monorepo as a Platform: PNPM/Yarn Workspace with Git Submodules and Automation
How I built a repeatable, automatable monorepo platform using pnpm/yarn workspaces, Git submodules, and a suite of small CLI utilities to clone, bootstrap, add dependencies, initialize repos, link hosts, and run commands reliably
Rebuilding Frontends From Raw Experience
The truth behind microfrontends: lessons learned from real-world implementations
Why “asking the right questions” feels like the most human skill in the AI era
Framing thoughts for the new digital era: the importance of question formulation in an age of generative AI
Trends in Software Development
Do we truly understand what is there before jumping on the wagon?
Stop Blaming useEffect: React’s Real State Problem
How to manage state effectively: understanding derived state and avoiding common useEffect pitfalls
A Vision for the Next Web
Can reactivity be embedded in the web better than web-components? Exploring native reactivity patterns
AI Disruption Is Not the Threat — The Absence of Guardrails Is
Are governments protecting our jobs? The real risk of AI adoption without proper oversight and policy frameworks
AI Is Shaping Our Craft
Encouraging leaders to care about the craft of software and embrace AI responsibly
Web Review 2025
What's shaping the web this year: generative UI, platform design evolution, and the shift from creation to orchestration
REST Is Stateless
That doesn't mean your app is
Data Management in Frontend
Tools like redux taught frontend Devs to normalize their structures, but are we maybe reinventing the wheel?
Senior Software Engineer Role
A critique of the current state of the job market and hiring practices in tech
Working with LLMs
🧠 The hardest part about building with AI isn't getting it to work— it's getting it to improve without destroying
Searches, Indexing, and Language
The new technologies allow for better understanding of our data through semantic search and vector embeddings
Is AI the Future of Software—or Just the Enhancer?
An analysis on building smarter, not sooner: why AI-first isn't always the right approach and when to start with a solid foundation
AI, Bias, and Vectors
Why language isn't just words: how biased patterns in training data become embedded in AI models through mathematical representations
Streaming Is About to Be the Standard
One lesson learned from using LLMs: the browser can stream and build out-of-order results for better user experience
True OOP
Object-Oriented Systems, not Classes
Node.js Has Tough Competition
What makes Bun so efficient? A comparison of Node.js and Bun runtime performance
Software Development Patterns: Separation of Concerns
An indication to split, but what concerns?
Build Systems, Not Features
How to make our app logic more resilient to changes by thinking in systems
What if Transformers Were Never Invented?
How LLMs actually changed software engineering (not someday—today): the impact of transformer architecture on modern development
Parallel Releases Are Killing Your Velocity
Why managing multiple releases in parallel creates delivery drag and how focusing on one release track improves engineering flow and productivity
AI Is a Commodity
How AI is commoditizing repetitive professional work and transforming traditional expertise into quality assurance roles
Vibe Coding Offers Fast Prototypes
The subtle risks of ignoring the steps of the ladder: why speed-to-prototype tools can't replace human thinking and careful requirement analysis
Technical Debt or Communication Lack?
What makes you less productive the most?
Building a Product That Lasts
Leveraging LLM integration as an enhancer, not the core: sustainable AI product design
Searching for What We Need Has Changed
How new patterns are reshaping information technology and search paradigms
User Interfaces Are Shifting to Science Fiction
Was Star Trek far off? How modern UI design is catching up with futuristic visions
Comparing Rendering and State Management in React and Game Development
Exploring the parallels between React and game development, focusing on rendering efficiency, state management, modularity, and design patterns.
Insights into Craftsmanship, AI, and Seniority in the Modern Era
Exploring how AI influences software development craftsmanship and how seniority is being redefined in the modern tech era.
Senior Software Engineer Track: Insights and Suggestions
Guidance on progressing toward a senior software engineer role, emphasizing meaningful experience, problem-solving, and critical thinking.
Principles of software development: High Cohesion
Discussion on high cohesion in software development, its importance in modular design, and practical applications in UI/UX and full-stack development.
Computational Complexity: the P Vs NP problem
An overview of the P vs NP problem, circuit complexity, AI, quantum computing, and ethical implications.
Is General Intelligence (AGI) at the Horizon?
Is the current generation the right model to pursuit AGI?
Your Next Modern Job Might be COBOL Development
Exploration of COBOL's history, relevance in modern development, and AI-assisted code transformation.
Make Your Business Shine With Design-Centric Thinking
How design-led thinking can transform business success, bridging the gap between business goals and customer needs through user-centric innovation.
Git - Choosing the Right Git Merging Strategy: A Practical Guide
Guide on selecting the appropriate Git merging strategy
Elevating State Management: Embracing the Actor Model in UI Development
Using the actor model for scalable and modular UI state management
Quality Gates and Feedback Loops
Measuring software development with useful metrics
Functional Programming Mindset: A JavaScript Guide
Adopt a functional programming mindset for more predictable, testable, and maintainable JavaScript code
Redux Undo/Redo: Client-Side State History
Complete guide to implementing undo/redo in Redux — patterns, tradeoffs, and when to use client vs server history
Functional Programming Techniques in JavaScript
Practical functional programming patterns: compose, pipe, map, filter, reduce, and more
Inheritance vs Composition in JavaScript
Why composition often beats inheritance for flexible, maintainable JavaScript code
JavaScript Variable Declarations: var, let, and const
Understanding the differences between var, let, and const for modern JavaScript development
JavaScript Map and Set Reference
Complete guide to JavaScript Map and Set data structures — methods, properties, and practical usage patterns
JavaScript Promise Methods Reference
Complete guide to JavaScript Promise methods — then, catch, finally, and all static methods with practical examples
Advanced JavaScript Concepts
Deep dive into destructuring, rest/spread, closures, modules, Map/Set, event loop, and compilers
Clean Code Principles: A Comprehensive Guide
Essential principles and practices for writing maintainable, readable, and robust code
Conditional Branching Patterns in JavaScript
Master the art of writing clear, maintainable conditional logic in JavaScript
Why Does CSS Grid-Gap Cause an Overflow?
Understanding why grid-gap causes overflow with percentage-based columns and how to fix it using fr units, minmax(), and calc()
Custom React Hooks Patterns
Reusable logic patterns with custom React hooks for cleaner, more maintainable components
Data Modeling and State Management
Understanding state, entities, normalization, serialization, and data modeling patterns in JavaScript applications
Dependency Injection in React
Leverage React's built-in dependency injection patterns for more testable, maintainable code
Descriptive Conditionals: Making Code Self-Documenting
Extract complex conditional expressions into named functions for clearer, more maintainable code
Destructuring Object Parameters in Functions
Use object destructuring for cleaner, more flexible function signatures with multiple parameters
Engineering Guidelines: Patterns, Principles, and Philosophy
Team engineering standards covering clean code, SOLID, DRY, functional programming, dependency injection, and anti-patterns to avoid
Error Handling in Node.js: Synchronous and Asynchronous Patterns
Complete guide to error handling in Node.js — try-catch, callbacks, promises, async/await, and uncaught exception handling
Essential Books for Software Developers
Curated reading list covering programming, architecture, UI design, and agile methodology
Floating-Point Numbers in JavaScript
Complete guide to floating-point arithmetic, precision issues, and best practices in JavaScript
Future JavaScript Proposals: What's Coming Next
Overview of upcoming JavaScript features — pipeline operator, pattern matching, records & tuples, and the TC39 proposal process
Idempotence in Programming
Understanding and applying idempotence for more reliable and predictable systems
Immer: Immutable State Made Simple
Complete guide to Immer for immutable state management — produce, patches, snapshots, and undo/redo patterns
Inversion of Control Pattern
Decouple components by inverting control flow - a fundamental pattern for flexible, testable code
JavaScript Async/Await: A Complete Guide
Master modern asynchronous JavaScript with async/await syntax
Asynchronous Error Handling in JavaScript
Handle async errors with promises, async/await, and modern error handling patterns
JavaScript Basics: Primitives, Types, Functions, and Scope
Complete guide to JavaScript fundamentals — primitives, type coercion, equality, functions, scope, hoisting, prototypes, and classes
JavaScript Design Patterns: Strategy, Factory, Adapter, Singleton, and CQRS
Complete guide to essential design patterns in JavaScript — practical implementations with real-world examples
JavaScript Event Loop and Async Programming
Understand how JavaScript handles asynchronous code with the event loop, call stack, and task queue
JavaScript Promise.all() Method
Execute multiple promises in parallel and handle their results efficiently
JavaScript Promise.allSettled() Method
Handle multiple promises that may fail without stopping execution
JavaScript Promise.race() Method
Get the first result from multiple competing promises
JavaScript Quick Tips and Shorthand Techniques
Practical JavaScript shortcuts — ternary operators, short-circuit evaluation, destructuring, arrow functions, and modern syntax for cleaner code
Synchronous Error Handling in JavaScript
Master try/catch/finally for robust error handling in synchronous JavaScript code
Loading States in React: isLoading vs isFetching
Understanding the difference between isLoading and isFetching, and how to design better loading UX with skeletons and stale data
Naming Callback Functions: Best Practices
Clear naming conventions for callback functions that make your code self-documenting
Node.js: Server-Side JavaScript Essentials
Complete guide to Node.js development — setup, file system, streams, events, and best practices
Pillars of Clean Code
The fundamental principles that form the foundation of clean, maintainable code
The Proliferation of Code Anti-Pattern
Understanding and eliminating unnecessary middleman objects that add complexity without value
Pure Functions in Functional Programming
Understanding and writing pure functions for predictable, testable code
React Best Practices: Components, Hooks, and Performance
Comprehensive guide to React development — component patterns, hooks, performance optimization, and code organization
Redux Fundamentals: State Management for JavaScript Apps
Complete guide to Redux — store, actions, reducers, middleware, normalized state, and modern best practices
Redux Toolkit: Modern Redux Development
Complete guide to Redux Toolkit — createSlice, createAsyncThunk, RTK Query, and migration from traditional Redux
Serial Execution in JavaScript: Sequential, Non-Overlapping Operations
Understanding serial execution — happens-before relationships, atomicity, and coordination patterns for async operations
Serialization in JavaScript: JSON and Beyond
Complete guide to serialization and deserialization in JavaScript — JSON, dates, custom objects, and common pitfalls
JavaScript Symbols: The Complete Guide
Deep dive into JavaScript Symbols — creation, usage patterns, well-known symbols, and practical applications
Transducers in JavaScript: Composable Data Transformations
Understanding transducers — composable, efficient data transformations that work across different data structures
TypeScript Advanced Types Guide
Master TypeScript's powerful type system with advanced type features and patterns
TypeScript Conditional Types
Create dynamic, flexible types that adapt based on type conditions
TypeScript Predicate Type Guards
Narrow union types with custom type predicates for safer, more expressive code
TypeScript Tips and Best Practices
Practical TypeScript tips — ReturnType, discriminated unions, mapped types, readonly, exhaustiveness checks, and predicate type guards
TypeScript Utility Types
Essential built-in utility types that make working with TypeScript more efficient
Weird CSS: Surprising Behaviors and Hidden Dependencies
Exploring CSS quirks — grid-gap overflow, hidden dependencies, stacking contexts, and other unexpected behaviors
Weird JavaScript: Surprising Behaviors and Quirks
Exploring JavaScript's most surprising behaviors — push returns length, floating-point quirks, and other unexpected language features
Zustand: Lightweight State Management for React
Complete guide to Zustand — store creation, subscriptions, middleware, and comparison with Redux and Context API
React - Lazy loading images, background images, components and modules
Techniques and strategies for lazy loading images, components, and modules in React to improve performance and user experience.
Next JS - How to handle SSL on Heroku — The Good, the Bad and the Ugly
Guide on handling SSL/HTTPS in React/Next.js apps deployed on Heroku, including redirect issues and middleware solutions.
Redux - Centralize Data Fetching and Error actions
Or how to be the next hero of the day at work!
Redux - Resetting State with a Root Reducer
Bonus: how to reset state selectively