Thoughts on programming, creativity, and building great products.
What I found after analyzing a large enterprise microfrontend platform — and why organizational complexity now matters more than technical complexity
A new engineering role is emerging at the intersection of frontend, backend, and AI—one focused not on building AI itself, but on making it genuinely useful inside real software.
AI's greatest contribution isn't writing code—it's removing the friction that prevents developers from doing their best work.
Why scaling parallel work with AI and teams increases coordination costs and turns attention into the real bottleneck
How to keep runtime validation, type safety, and manual UX aligned when JSON Schemas come from backend contracts
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.
Why most agent systems overspend tokens, and a practical pipeline template to make them cheaper, faster, and more reliable.
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.
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.
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
A deep dive into how tools like GitHub Copilot inside Visual Studio Code gather context, reason about structure, and navigate your repository
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.
Why productivity gains come from workflow integration rather than perfect tools, and what agent-based development reveals about the future of software engineering
The shift from writing code to expressing intent, and how spec-driven workflows with AI agents improve velocity, accuracy, and reliability
Why AI makes junior hiring more important, not less—and how organizations that maintain talent pipelines will outlast those optimizing for short-term efficiency.
How Sweden reversed course on digital classrooms after discovering that screens don't replace centuries of embodied learning
Understanding the core idea behind GPT models through a simple, accessible example without heavy tools or libraries
Exploring how algorithms work by thinking of them as layered machines, from intent to mathematical operations, using metaphors to grasp complex concepts
Beyond the hype: what AI can actually do for software development today, and what still needs human engineers
Boundaries and setups for testing
Evolutionary systems target the right audience
Problem solved or not
Tradeoffs are hidden in the details
What's the practical plan to intent driven development?
A future where maintenance of dependencies shares control
How computation changed over the decades and the essential technologies shaping software development in 2024
Best practices for test automation: strategies, tools, and approaches to building reliable automated test suites
The decline of Visual Basic and what it meant for accessible programming: lessons from a tool that democratized software development
How web tech factors in, and where things might go next: grounded in recent developments and concrete trade-offs in modern UI frameworks
A common React anti-pattern that disables memoization and how to identify it
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
The truth behind microfrontends: lessons learned from real-world implementations
Framing thoughts for the new digital era: the importance of question formulation in an age of generative AI
Do we truly understand what is there before jumping on the wagon?
How to manage state effectively: understanding derived state and avoiding common useEffect pitfalls
Can reactivity be embedded in the web better than web-components? Exploring native reactivity patterns
Are governments protecting our jobs? The real risk of AI adoption without proper oversight and policy frameworks
Encouraging leaders to care about the craft of software and embrace AI responsibly
What's shaping the web this year: generative UI, platform design evolution, and the shift from creation to orchestration
That doesn't mean your app is
Tools like redux taught frontend Devs to normalize their structures, but are we maybe reinventing the wheel?
A critique of the current state of the job market and hiring practices in tech
🧠 The hardest part about building with AI isn't getting it to work— it's getting it to improve without destroying
The new technologies allow for better understanding of our data through semantic search and vector embeddings
An analysis on building smarter, not sooner: why AI-first isn't always the right approach and when to start with a solid foundation
Why language isn't just words: how biased patterns in training data become embedded in AI models through mathematical representations
One lesson learned from using LLMs: the browser can stream and build out-of-order results for better user experience
Object-Oriented Systems, not Classes
What makes Bun so efficient? A comparison of Node.js and Bun runtime performance
An indication to split, but what concerns?
How to make our app logic more resilient to changes by thinking in systems
How LLMs actually changed software engineering (not someday—today): the impact of transformer architecture on modern development
Why managing multiple releases in parallel creates delivery drag and how focusing on one release track improves engineering flow and productivity
How AI is commoditizing repetitive professional work and transforming traditional expertise into quality assurance roles
The subtle risks of ignoring the steps of the ladder: why speed-to-prototype tools can't replace human thinking and careful requirement analysis
What makes you less productive the most?
Leveraging LLM integration as an enhancer, not the core: sustainable AI product design
How new patterns are reshaping information technology and search paradigms
Was Star Trek far off? How modern UI design is catching up with futuristic visions
Exploring the parallels between React and game development, focusing on rendering efficiency, state management, modularity, and design patterns.
Exploring how AI influences software development craftsmanship and how seniority is being redefined in the modern tech era.
Guidance on progressing toward a senior software engineer role, emphasizing meaningful experience, problem-solving, and critical thinking.
Discussion on high cohesion in software development, its importance in modular design, and practical applications in UI/UX and full-stack development.
An overview of the P vs NP problem, circuit complexity, AI, quantum computing, and ethical implications.
Is the current generation the right model to pursuit AGI?
Exploration of COBOL's history, relevance in modern development, and AI-assisted code transformation.
How design-led thinking can transform business success, bridging the gap between business goals and customer needs through user-centric innovation.
Guide on selecting the appropriate Git merging strategy
Using the actor model for scalable and modular UI state management
Measuring software development with useful metrics
Adopt a functional programming mindset for more predictable, testable, and maintainable JavaScript code
Complete guide to implementing undo/redo in Redux — patterns, tradeoffs, and when to use client vs server history
Practical functional programming patterns: compose, pipe, map, filter, reduce, and more
Why composition often beats inheritance for flexible, maintainable JavaScript code
Understanding the differences between var, let, and const for modern JavaScript development
Complete guide to JavaScript Map and Set data structures — methods, properties, and practical usage patterns
Complete guide to JavaScript Promise methods — then, catch, finally, and all static methods with practical examples
Deep dive into destructuring, rest/spread, closures, modules, Map/Set, event loop, and compilers
Essential principles and practices for writing maintainable, readable, and robust code
Master the art of writing clear, maintainable conditional logic in JavaScript
Understanding why grid-gap causes overflow with percentage-based columns and how to fix it using fr units, minmax(), and calc()
Reusable logic patterns with custom React hooks for cleaner, more maintainable components
Understanding state, entities, normalization, serialization, and data modeling patterns in JavaScript applications
Leverage React's built-in dependency injection patterns for more testable, maintainable code
Extract complex conditional expressions into named functions for clearer, more maintainable code
Use object destructuring for cleaner, more flexible function signatures with multiple parameters
Team engineering standards covering clean code, SOLID, DRY, functional programming, dependency injection, and anti-patterns to avoid
Complete guide to error handling in Node.js — try-catch, callbacks, promises, async/await, and uncaught exception handling
Curated reading list covering programming, architecture, UI design, and agile methodology
Complete guide to floating-point arithmetic, precision issues, and best practices in JavaScript
Overview of upcoming JavaScript features — pipeline operator, pattern matching, records & tuples, and the TC39 proposal process
Understanding and applying idempotence for more reliable and predictable systems
Complete guide to Immer for immutable state management — produce, patches, snapshots, and undo/redo patterns
Decouple components by inverting control flow - a fundamental pattern for flexible, testable code
Master modern asynchronous JavaScript with async/await syntax
Handle async errors with promises, async/await, and modern error handling patterns
Complete guide to JavaScript fundamentals — primitives, type coercion, equality, functions, scope, hoisting, prototypes, and classes
Complete guide to essential design patterns in JavaScript — practical implementations with real-world examples
Understand how JavaScript handles asynchronous code with the event loop, call stack, and task queue
Execute multiple promises in parallel and handle their results efficiently
Handle multiple promises that may fail without stopping execution
Get the first result from multiple competing promises
Practical JavaScript shortcuts — ternary operators, short-circuit evaluation, destructuring, arrow functions, and modern syntax for cleaner code
Master try/catch/finally for robust error handling in synchronous JavaScript code
Understanding the difference between isLoading and isFetching, and how to design better loading UX with skeletons and stale data
Clear naming conventions for callback functions that make your code self-documenting
Complete guide to Node.js development — setup, file system, streams, events, and best practices
The fundamental principles that form the foundation of clean, maintainable code
Understanding and eliminating unnecessary middleman objects that add complexity without value
Understanding and writing pure functions for predictable, testable code
Comprehensive guide to React development — component patterns, hooks, performance optimization, and code organization
Complete guide to Redux — store, actions, reducers, middleware, normalized state, and modern best practices
Complete guide to Redux Toolkit — createSlice, createAsyncThunk, RTK Query, and migration from traditional Redux
Understanding serial execution — happens-before relationships, atomicity, and coordination patterns for async operations
Complete guide to serialization and deserialization in JavaScript — JSON, dates, custom objects, and common pitfalls
Deep dive into JavaScript Symbols — creation, usage patterns, well-known symbols, and practical applications
Understanding transducers — composable, efficient data transformations that work across different data structures
Master TypeScript's powerful type system with advanced type features and patterns
Create dynamic, flexible types that adapt based on type conditions
Narrow union types with custom type predicates for safer, more expressive code
Practical TypeScript tips — ReturnType, discriminated unions, mapped types, readonly, exhaustiveness checks, and predicate type guards
Essential built-in utility types that make working with TypeScript more efficient
Exploring CSS quirks — grid-gap overflow, hidden dependencies, stacking contexts, and other unexpected behaviors
Exploring JavaScript's most surprising behaviors — push returns length, floating-point quirks, and other unexpected language features
Complete guide to Zustand — store creation, subscriptions, middleware, and comparison with Redux and Context API
Techniques and strategies for lazy loading images, components, and modules in React to improve performance and user experience.
Guide on handling SSL/HTTPS in React/Next.js apps deployed on Heroku, including redirect issues and middleware solutions.
Or how to be the next hero of the day at work!
Bonus: how to reset state selectively