Throughout my career, I’ve seen many things change. I’ve gone from Borland to Visual Studio, from vi to Sublime Text, from Sublime to VS Code… And believe me, each change was a deliberate decision that cost me weeks of adaptation. But what’s happening now with AI tools is something completely different.

I’ve found myself using Copilot in the morning, trying Cursor in the afternoon, and checking out Claude Code before going to bed. And I’m not alone. Developers have gone from being faithful as dogs to our tools to being… well, promiscuous.

Two protocols, two philosophies

In recent months, two protocols have emerged that will change how we build AI systems: Agent2Agent Protocol (A2A) from Google and Model Context Protocol (MCP) from Anthropic. But here’s the thing: they don’t compete with each other.

In fact, after analyzing both for weeks, I’ve realized that understanding the difference between A2A and MCP is crucial for anyone building AI systems beyond simple chatbots.

The key lies in one question: Are you connecting an AI with tools, or are you coordinating multiple intelligences?

A few months ago, when Anthropic launched their MCP (Model Context Protocol), I knew we’d see interesting integrations between LLMs and databases. What I didn’t expect was to see something as polished and functional as ClickHouse’s AgentHouse so soon.

I’m planning to test this demo soon, but just reading about it, the idea of being able to ask a database questions like “What are the most popular GitHub repositories this month?” and getting not just an answer, but automatic visualizations, seems fascinating.

When working on large projects, it’s common to have test suites that can take several minutes to run. And when one of those tests fails early in the execution, it’s frustrating to wait for all the others to complete just to see the full results.

Jest includes a feature I’ve found very useful in development: the bail option, which allows stopping test execution after a certain number of failures. It’s one of those features that once you know and start using, you don’t understand how you lived without it.

In my years developing software, I’ve learned that the best tools are those that eliminate unnecessary friction. And LM Studio has just taken a huge step in that direction: it’s now completely free for enterprise use.

This may sound like “just another AI news item,” but for those of us who have been experimenting with local models for a while, this is an important paradigm shift.

The problem that existed before

Since its launch in May 2023, LM Studio was always free for personal use. But if you wanted to use it in your company, you had to contact them to obtain a commercial license. This created exactly the type of friction that kills team experimentation.

In my experience with mobile development, I’ve seen how apps become increasingly complex and projects grow uncontrollably. I remember perfectly that feeling of having thousands of lines of code and not being sure what was really being used and what wasn’t.

That’s why I was so struck by the tool that Sentry (formerly from Emerge Tools) just released as open source: Reaper. An SDK that does something that sounds simple but is tremendously useful: find dead code in your mobile applications.

A few years ago, many AI researchers (even the most reputable) predicted that prompt engineering would be a temporary skill that would quickly disappear. They were completely wrong. Not only has it not disappeared, but it has evolved into something much more sophisticated: Context Engineering.

And no, it’s not just another buzzword. It’s a natural evolution that reflects the real complexity of working with LLMs in production applications.

From prompt engineering to context engineering

The problem with the term “prompt engineering” is that many people confuse it with blind prompting - simply writing a question in ChatGPT and expecting a result. That’s not engineering, that’s using a tool.

Deno 2.4 has just been released, and I must admit it has pleasantly surprised me. Not only because of the number of new features, but because of one in particular that many of us thought would never return: deno bundle is back. And this time, it’s here to stay.

This release comes packed with improvements ranging from importing text files directly to stable observability with OpenTelemetry. Let’s explore what this release brings us.

I’ve seen how certain standards and tools become indispensable when working with data. And if there’s one thing we’ve learned over these years, it’s that JSON is everywhere: APIs, logs, configurations, NoSQL databases… The question is no longer whether you’ll work with JSON, but when you’ll face that 15-level nested structure that makes you sigh.

The Problem We’ve All Lived Through

How many times have you had to write something like this?

The first alpha version of PHP 8.5 has just been released, and I must confess it has me more excited than recent versions. It’s not just for the technical improvements (which are many), but because PHP 8.5 introduces features that will change the way we write code.

And when I say “change,” I mean the kind of changes that, once you use them, you can’t go back. Like when the null coalescing operator (??) appeared in PHP 7, or arrow functions in PHP 7.4.

Mozilla AI surprises again: AI agents that work just by opening an HTML

A few days ago I came across a Mozilla AI project that really caught my attention: WebAssembly Agents. And after 30 years watching the industry complicate life with dependencies, installations, and configurations, seeing something that works just by “opening an HTML” made me smile.

The problem it solves (and we all know it)

How many times have you tried to test an AI project and encountered this?

After many years working with systems of all kinds, I’ve seen how information retrieval has evolved from simple databases to today’s sophisticated systems. But what Baidu researchers have just proposed has particularly caught my attention, and I believe it marks a before and after in how we think about intelligent information retrieval.

The problem we all know (but don’t always admit)

If you’ve worked with RAG (Retrieval-Augmented Generation) systems, you know they work quite well for direct questions. But when you face queries that require multiple reasoning steps, comparing information from multiple sources, or handling contradictory data… that’s where it gets complicated. And a lot.