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
Blog
Thoughts on programming, creativity, and building great products.
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
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