Is this you? As a journalist, you can create a free Muck Rack account to customize your profile, list your contact preferences, and upload a portfolio of your best work.
Claim your profile
Articles by Remo H. Jansen
From Never Getting Selected to a 1-in-3 Success Rate: Did AI Help Me Write Better CFPs, or Is AI Selecting Them?
For years, I was involved in developer advocacy. I organised meetups, spoke at many of them, and was invited to conferences by people in my network. At one point, I was even a Microsoft MVP, partly as a result of all that developer advocacy work. I had experience. I had technical topics to talk about. I had a network of people who knew me and my work. But there was one thing I could never seem to get right: getting selected through a conference Call for Papers (CFP). I tried. A lot.
Halo is the new Doom and most software will soon be effectively open source (by force or by choice)
Seven months ago I published “Source code is now a common good, and SaaS is mostly dead.” I argued that AI had collapsed the economic cost of clean-room reimplementation, that pure software expression was losing its scarcity, and that the SaaS model built on high-margin code would face an existential squeeze—except where real data moats or network effects remained. I was wrong about the timeline. It didn’t take five to ten years. This month the premonition became visible reality.
SDLC != ADLC != ASDLC
I recently came across this definition: The Agentic Development Lifecycle (ADLC)—also known as the Agent Software Development Lifecycle—is a software engineering methodology designed for building, testing, deploying, and governing AI agent systems rather than traditional deterministic code. That sentence made something click. A lot of people (myself included, until recently) have been casually treating ADLC and ASDLC as interchangeable. They’re not.
The Agentic Manifesto: What Should the Agile Manifesto Look Like in the Age of AI?
I've been spending a lot of time thinking about where all the recent advancements in AI are going to take the software industry. Not just what AI coding agents mean for developers today, or how much faster we can write code, but what happens when these capabilities fundamentally change the economics of building software.
Mutation Testing with TypeScript: How to Verify Your Tests in the Age of AI Coding Agents
Your tests pass. But would they catch a bug? Imagine asking an AI coding agent to implement a feature. A few minutes later, it has generated the implementation, written unit tests, and opened a pull request. The CI pipeline is green. All tests pass. Code coverage looks good. Can you trust the change? Not necessarily. The implementation and its tests may share the same misunderstanding of the requirements. The tests might execute every line without checking the behavior that matters.
Building Agentic Engineering Resilience: Using VS Code Copilot Automations + Datadog MCP for Recurrent Error Detection and Fixing
In the agentic engineering world, coding agents generate a lot of code quickly. The bottleneck shifts from writing code to verifying it. I’ve written about this shift before — the need for explicit systems and multilayer verification (see my earlier posts on dev.to/remojansen, especially When Code Gets Cheap, Verification Becomes Expensive).
From T-Shirt Sizes to Token Quotes?
I'll start with my position, because the rest of the article depends on it. I'm against estimation. I have been for a long time. My team has already stopped estimating and stopped doing sprint planning, and I have no plans to bring either back. One thing is left: when upper management asks how big something is, we still answer with a t-shirt size. Even that has started to feel wrong. In an earlier article I argued that coding agents are finally killing Scrum.
When Code Gets Cheap, Verification Becomes Expensive: How AI changes the economics of software architecture
Recently, I was having a conversation at work about how we should implement a feature. I was advocating for one particular approach, and one of the reasons I preferred it was that I thought it would be easier for AI agents to work with. The structure was more explicit, the possible states were easier to reason about, and it would give us better opportunities to automate verification and put guardrails around future changes.
Do We Still Need Code Reviews in the Age of Coding Agents?
For most of my career, code review has been a fairly simple idea. One engineer writes some code, opens a pull request, and another engineer reviews it before it gets merged. The second engineer looks for bugs, questions design decisions, suggests improvements, and ultimately gives the team another level of confidence that the change is safe to ship. It is such a normal part of software development that we rarely stop to question the assumptions behind it.
Revisiting the Toyota Production System (TPS) in the Age of Coding Agents
Software has borrowed a surprising amount from manufacturing. Not from manufacturing in the sense of “let’s put programmers on an assembly line.” Thankfully, we’ve tried enough variations of that idea already. I mean something more interesting. Some of the most influential ideas in modern software development came from looking at how Toyota transformed manufacturing.
Why the Best Software Advice Is the Hardest to Follow
Not all software advice is created equal. Some advice is practical. It tells you exactly what to do: Write small functions. Keep functions focused. Use constants instead of magic numbers. Give variables meaningful names. Keep your classes small. This kind of advice is useful because it is easy to understand, easy to teach, and easy to verify. You can look at a piece of code and ask: Is this function too large? Is this a magic number? Is this constant named correctly?
Scrum is finally dead π and we have to thank Coding Agents for that
The funeral nobody is sad about Let's be honest about something we've all been pretending not to notice. Scrum is dead. And almost nobody is sad about it. We've spent twenty years standing in a circle every morning, moving tickets across a board, arguing about whether something is a 3 or a 5, and calling it "agility." We built an entire industry on top of it β certifications, coaches, tooling, dashboards. We turned a lightweight idea into a bureaucracy with a mascot.
Turbocharge Coding Agents with Your Test Coverage
The original title of this post was Turbocharge Your Test Coverage with Coding Agents but then I changed it because the real competitive advantage isn’t using AI to write tests. It’s using high test coverage to let coding agents move at maximum speed without breaking your system. Most organisations still treat testing the old way. Tests ensure code quality. Tests catch bugs. Tests are a cost centre. We’ll add them when we have time. The result is painfully familiar. Low coverage creates fear of change.
Maye Enterprise Software Doesn’t Have to Suck Anymore
There is an uncomfortable truth about most non-tech enterprises: a lot of their software is insanely shit. I don't mean that the engineers are shit. In many cases, the opposite is true. I've worked with plenty of smart engineers who were perfectly capable of building good software. The problem is that good software is expensive, and for a long time the economics of building it simply didn't make sense. Think about the incentives inside a large enterprise.
Career safety in the Age of AI Layoffs
There is a strange contradiction happening in software engineering right now. A lot of developers are worried that AI is going to make them obsolete. At the same time, the people building the most capable AI coding tools are demonstrating something that should probably make us rethink what being a software engineer actually means. I don't think the future is one where nobody understands software anymore. I think it is one where writing the software becomes dramatically cheaper.
How to Become a 10x Engineer and Stay Safe in the Age of AI Layoffs
There is a strange contradiction happening in software engineering right now. A lot of developers are worried that AI is going to make them obsolete. At the same time, the people building the most capable AI coding tools are demonstrating something that should probably make us rethink what being a software engineer actually means. I don't think the future is one where nobody understands software anymore. I think it is one where writing the software becomes dramatically cheaper.
Calling All Cloud Providers: Let’s Build a Sustainable Funding Model for Open Source
Calling All Cloud Providers: Let’s Build a Sustainable Funding Model for Open Source Open source powers an enormous part of the modern internet. Apache HTTP Server, Linux, Kubernetes, PostgreSQL, Python, NGINX, and thousands of other projects form the foundation of the applications and infrastructure that run on cloud platforms.
I’m Looking for the Right Problem, Not the Right Job Title — Could It Be You?
This is a slightly unusual post. After almost 20 years of writing software, creating and leading an open-source project, writing multiple books, spending several years as a Microsoft MVP, and generally spending far too much of my free time thinking about developer tools, I've reached a point where I think I know what I want to do next. And I'm not entirely sure what the job title is. So instead of starting with a job title, I'm going to describe the kind of work I'd love to do.
AI Code Is No Longer Slop
In December 2025 I wrote that Claude Opus 4.5 changed everything. I had been using AI coding tools since the beginning. They were useful, but they were also unreliable. The working pattern was defensive: stage every change, review every prompt, stay on feature branches, lean hard on CI, and be ready to roll back. Then I spent serious time with Opus 4.5. What shifted was not that the model suddenly produced perfect software. It still didn’t. What shifted was the economics of my own time.
Developers that brand AI as slop will be left behind
A few days ago I shared an architectural proposal for InversifyJS on Reddit. It outlined an IPC-based type server that could help Inversify move beyond the legacy TypeScript decorator metadata APIs toward something compatible with TC39 decorators and TypeScript’s next-generation compiler. The first comment was: AI slop I ignored it and went back to work. That night I built rflct. It isn’t perfect. It’s an alpha with plenty of rough edges.
RFLCT: Bringing Runtime Type Metadata to TypeScript 7
If you've built large-scale applications in TypeScript, chances are you've used a Dependency Injection (DI) container. As the creator of InversifyJS, I've spent years thinking deeply about inversion of control, decoupling, and how to make enterprise patterns feel natural in TypeScript. But for all those years, there has been a glaring elephant in the room: our heavy reliance on experimentalDecorators and emitDecoratorMetadata.
23 TypeScript Tools for Making Software Explicit in the AI Era
In my previous articles, I argued that AI is changing the role of constraints in software development. For a long time, we treated constraints as friction. Static types felt slower than dynamic code. Schemas felt restrictive compared to flexible data. Explicit workflows felt more cumbersome than letting an application decide what to do at runtime. But AI changes the economics. Writing code is becoming cheaper. Understanding what the code is supposed to do is not.
The Boundary Independence Principle (BIP)
I've been writing about the SOLID principles for over a decade. I built InversifyJS because of them, I wrote about implementing them with the onion architecture, and just recently I argued that they are universal design principles that appear far beyond object-oriented programming. Yet something has always felt missing, not from the principles themselves, but from the conversation around them. SOLID tells you how to write good components.
Please Stop Calling It "Developer Experience"
"Technical debt" might be one of the most successful terms ever coined in software engineering. Not because it solved the problem. Technical debt is still everywhere. But it fundamentally changed the conversation. Before the term existed, engineers struggled to explain why seemingly harmless shortcuts eventually become expensive. Calling it technical debt gave business leaders a language they already understood. Debt accumulates interest. Debt carries risk. Debt demands attention.
Emergent Design & Gall's Law: When Complex Coding Problems Dissolve Instead of Being Solved
I recently read an article by the main maintainer of InversifyJS describing the journey of rebuilding its dependency resolution algorithm. What caught my attention wasn't the performance improvements or the technical details. It was something much more familiar. As I was reading, I realized they were experiencing the exact same phenomenon I had experienced years ago while creating InversifyJS. It reminded me of something that, until now, I had never really put into words.
I tried to compile TypeScript into a native binary with scriptc
TL;DR: I tried to compile the TypeScript 6 compiler into a native binary with scriptc, and I failed — it got 90% of the way there and then hit an internal compiler error it couldn't get past, so there is no native tsc at the end of this story. But it's a failure worth having: I learned exactly where a week-old TypeScript-to-native compiler runs out of road, and I got some interesting numbers along the way.
Your AI Agents Need Finite State Machines (FSMs)
In my previous article, I argued that AI changes the role of constraints in software development. For years, many developers saw constraints as something to minimize. Dynamic languages gained popularity over static ones. Schema-less databases promised greater flexibility. Convention replaced configuration. Implicit behavior was often preferred over explicit definitions. The motivation was understandable. Constraints felt like friction. They slowed us down. AI changes that trade-off.
Just for Fun: Fear and Loathing in the Age of Coding Agents
There is a distinct, quiet disquiet settling over the software engineering landscape today. You can feel it in LinkedIn post threads, in hushed conversations over coffee with senior colleagues, and in the background noise of tech news cycles. On one side of the coin, we are navigating an unprecedented era of tech layoffs, budget contractions, and corporate belt-tightening. On the other side, artificial intelligence is advancing at a dizzying, almost relentless speed.
Building a 3D engine from scratch with C++ and Vulkan for web developers Part II: Rendering your first triangle
Where we left off In Part I, we set up the Vulkan infrastructure: instance, window, surface, device, and swapchain. We have a GPU ready to receive commands, and a queue of images waiting to be drawn to and displayed on screen. But at that point we didn't draw anything. The game loop just polled for window events and looped. Now we're going to make pixels appear — specifically, a colored triangle. This is the "Hello, World!" of graphics programming.
Building a 3D engine from scratch with C++ and Vulkan for web developers Part I: Bootstrapping Vulkan
Why this project exists My background is in web development. TypeScript, Node.js, React — that's been my world for years. I've spent a lot of time thinking about software architecture: SOLID principles, onion architecture, dependency injection, separation of concerns. All of that in the context of the web. But the reason I got into technology in the first place has nothing to do with web forms or REST APIs. It was Super Mario 64.
From Rigidity to Explicitness: How AI Changes the Role of Constraints in Software
For a long time, software engineering has talked about a familiar trade-off: rigid vs flexible systems. Static typing vs dynamic typing Relational databases vs schema-less storage Strict architectures vs “just ship it” codebases The usual story is simple: rigidity slows you down, flexibility speeds you up. But this framing is becoming less useful.
Source code is now a common good, and SaaS is mostly dead
Back in 2023, I wrote a post titled "The upcoming SaaS bubble burst" where I argued that AI would enable individual developers to replicate SaaS products at a fraction of the cost, turning high-margin businesses into commodities. I was wrong about the timeline. It's happening right now. The Legal Hack That Started It All In 1982, a company called Phoenix Technologies wanted to create IBM PC-compatible computers. The problem? IBM's BIOS was copyrighted.
The Infinite Loop Part III: Agentic Software Engineering
Creating a culture of trust, ownership, and data-driven continuous experimentation—now accelerated by AI The Infinite Loop (L∞P) was introduced in 2023 as a software development methodology that unified lessons from Agile, Lean UX, Kanban, DevOps, and Product-led growth. Its core philosophy—trust, ownership, outcomes over outputs, no arbitrary deadlines—was designed to create high-performance teams that could achieve flow state and deliver genuine customer value.
The 6th SOLID Principle?
I've been writing about the SOLID principles for over a decade. I built InversifyJS because of them, I wrote about implementing them with the onion architecture, and just recently, I argued that they are universal design principles that show up far beyond the world of object-oriented programming. But I've always felt something was missing — not from the principles themselves, but from the conversation around them. SOLID tells you how to write good components.
The SOLID Principles are Universal
I've spent a significant portion of my career thinking about the SOLID principles. I wrote about them in the context of JavaScript and TypeScript, I built InversifyJS largely because of them, and I've had countless conversations with other developers about whether they belong in the JavaScript world at all. Over the years, many people have pushed back, arguing that SOLID is an object-oriented thing, that it only matters if you're writing Java or C#, and that it doesn't apply to their world.
Running the Copilot CLI in a WebGL-powered retro CRT terminal implemented by the Copilot CLI 🤯
This is a submission for the GitHub Copilot CLI Challenge What I Built A port of Swordfish90/cool-retro-term (Qt and OpenGL) to WebGL, React, and Electron, and use to make my website look like a cool retro monochrome CRT monitor with an OS from 1977. Demo https://remojansen.github.io/ Please note: The site is meant to be used with a keyboard (no mouse or touch controls).
Turning Your Living Room into a Couch Co-op Arena with TouchCoop
Hey everyone π, Today I want to share something fun. Imagine this: you're at home with friends, the big TV is on, and instead of everyone fighting over Bluetooth controllers or passing around one gamepadβ¦ everyone just pulls out their phone and instantly becomes a player. No accounts. No installs. Just scan a QR code and start mashing buttons.
Claude Opus 4.5 changes everything
Before I begin, I would like to clarify my position. I'm one of those people who believe that AGI will happen. I don't know when, but I believe that while the human mind and consciousness are extraordinarily complex, they are ultimately governed by the physical laws of the universe and can therefore be simulated. Someday AGI will be a reality. How far are we? I have no idea, and I don't care.
I have open-sourced a WebGL front-end for your terminal that emulates a CRT monitor
I'm thrilled to announce that I've open sourced cool-retro-term-webgl, a modern WebGL-based recreation of the beloved cool-retro-term terminal emulator! For years, developers and retro computing enthusiasts have loved cool-retro-term by Filippo Scognamiglio (Swordfish90) β a Qt-based terminal that perfectly mimics the look and feel of old cathode ray tube (CRT) monitors, complete with scanlines, glow, and that nostalgic flicker.
Building a Retro CRT Terminal Website with WebGL and GitHub Copilot (Claude Opus 4.5)
During the holidays, I was browsing the internet when I came across cool-retro-term, an open-source terminal that mimics the visuals of old cathode ray tube (CRT) displays. I loved the look of it—it has an awesome retro sci-fi atmosphere that reminds me of the Alien and Fallout fictional universes. I thought it would be amazing if I could make my personal website look like that. I took a look at the source code and quickly realized that it's implemented using QML and C++.
Beware: ChatGPT Could Be Attacking You!
Did you know that your AI chatbot could be trying to hack you? Introduction The other day, I was deep in research mode, hammering away at ChatGPT with questions to fuel my latest project. The responses were solid, as usual—until one caught my eye. It was a perfectly valid answer, but nestled within it was a link that screamed trouble. A quick glance revealed it wasn’t just a dodgy URL; it was a full-on phishing site designed to look legit.
RAG vs Fine-Tuning: Which One Wins the Cost Game Long-Term?
Over the past few months, I’ve been diving deep into Retrieval-Augmented Generation (RAG) and fine-tuning strategies for LLMs. While RAG is often praised for its flexibility and lower upfront cost, I’ve started to question whether that narrative holds up when you zoom out and look at the long-term economics—especially in high-volume, production-grade scenarios. The Common Assumption: RAG is Cheaper RAG is typically seen as the budget-friendly option. You don’t need to retrain your model.
Agent Driven Development (ADD): The Next Paradigm Shift in Software Engineering
Today we’re standing at the edge of a new paradigm: Agent Driven Development (ADD). ADD is not just a buzzword. It’s a structured methodology that redefines how we build software. It’s not about replacing developers—it’s about augmenting them. Think of it as pair programming, but your pair is an AI agent that never sleeps, never forgets, and never gets bored of writing tests. What is Agent Driven Development?
How will the Agentic web change the web as we know it?
Lately, I’ve been diving deep into Model Context Protocol (MCP) and Retrieval-Augmented Generation (RAG), and I have to admit—it’s been a wild ride for my imagination. These technologies are not just incremental improvements; they hint at a fundamental shift in how we interact with the web. Making predictions about the future is always risky (and often wrong), but it’s also a lot of fun.
JSON to TypeScript in less than 1 second!
Imagine that you are trying to integrate an HTTP API with a TypeScript client. Sometimes, SDKs and documentation are available, but other times, you are in the dark.
TSConf 2019: Types on every desk, in every home, for every JS developer
Remo H. Jansen Oct 14, 2019 ・5 min read I was fortunate to join the second TypeScript conference last Friday, and, in this blog post, I would like to share my thoughts about it. There were no big announcements or surprises in TSConf 2019, but I was not disappointed. When I decided to join TSConf 2019, I was not expecting big surprises. TypeScript is an open-source project, which means that there are not many secrets about it.
My new book has just been released! Here is how I did it and how you can do the same 🚀
My new book, Learning TypeScript 2.x, has just been released! I'm not going to talk about the book contents in this post because you can learn everything about it at www.learningtypescript.com. However, I would like to talk about the behind the scenes process of how this book became a reality. In this article I'm going to answer the following questions: I decided to write this post because I think it could be useful for some aspiring authors.
Show More
loading
Actions
Is this you?
As a journalist, you can create a free Muck Rack account to customize your profile, list your contact preferences, and upload a portfolio of your best work.Get in touch with Remo H.
Contact Remo H., search articles and posts on X, monitor coverage, and track replies from one place.
Learn more about Muck Rack