I had a personal project in mind for years, but it was big enough that I would never seriously jump into it by myself. I decided to start it in December 2025 with a simple idea: test myself on the full ecosystem of applied AI, all in. In this experiment, I could lead, I could design, I could talk to the AI, but I could never touch a line of code. The goal was to see if, with the available tech, I could build a professional product end to end, fully functional, usable by anyone, with enough quality. But I could only use tier-one accounts of each AI provider and any open-source tool I wanted.
SPOILER: After 10 months of "vibe coding", here it is: Tape Music Suite.
I started seeing the real power of LLMs for coding around that point, maybe even before. In August 2025, I was already delegating part of my AWS architecture management to a Cursor chat, when the concept of agents wasn't even around. I was already delegating clearly defined pieces of code to be built with ease, yet deeply reviewing everything, because many times the potential destruction of user experience with the code generated was high. Even when the code was correct, the impact on the product was destructive and nonsense. How much the entire software landscape has changed in a year. So fucking crazy.
I always thought of software development as market-hyped digital piping work. (I'm a former architect.) So it's been hilarious to see the evolution of the space over the year and how commoditized it has become. Digital piping in the end.
Good luck, junior developers. Good luck, senior developers. Good luck to everyone who just executes in the digital world. Welcome to the deep thinkers, researchers, product designers, and deeply empathetic people. This is our age now. If you also have technical expertise, you are a digital product god. Barriers have fallen forever. There is no excuse now not to bring your personal point of view of something.
But weekend vibe-coded points of view are boring as fuck. The product user flows are just complete nonsense, user experiences break all the way through, design is boring, products are boring. The fact that you can spend $200 on a few Claude prompts does not make it an interesting or valuable project or product. Put some effort into it. You can clearly see it everywhere: Claude website here, ChatGPT website there, 3D website here, 3D website there... boring.
Another thing I see happening is that, in companies, execution people are now in depression mode, forgetting how to think. Now they have a tool that produces "their work", which was thought up by another person and will be validated by another person who will take final responsibility for launching it to the public. The destruction loop is deep and impossible to stop. Everyone is seeing their seat in danger, and only profiles with deep craft and thought integrated into their minds will remain.
In the product arena, I feel we are entering the age of fluid, highly customized, highly personal user interfaces, highly customized product experiences, and underlying protocols connecting those experiences behind the scenes. Sometimes with agentic tooling, sometimes just a customized experience on top of those protocols. In any case, those experiences need deeply thought-out user-interface protocols to work properly.
The UI atomic design concept is not needed anymore. We are shifting toward a higher-level concept I called "Atomic Product Protocols".
That distinction became very concrete while building Tape Music Suite. I had to create a full local knowledge architecture so I could jump from model to model fast and easy, and internalise a context tree intelligent and efficient enough for each model to reach the task context and files they may need. Everything is local now. I ended up with a clear way for each conversation, where every model is managed as if it was my team junior engineer, my team junior legal partner, my team front-end developer, my team architecture maintainer. The code could be correct and still have a destructive impact on the product. The tools can do a lot, but I still need to understand the whole thing.
I think I integrated every role in a tech company except for three: Product Manager, Technical Product Manager and Product Designer. The rest of the tech-company software stack is handled by AI, better than a human, only if it's led correctly by those three. It does not go faster on paper. It is definitely cheaper. It needs care and a deep organisational model, nothing weird if you've ever led Product. I treated all my agents with a Product backlog, prioritisation, everything should be validated through exchange, written down, clearly tested, evaluated, republished, refactored to fit tests. Results did not fit expectations so many times, as it would happen with a human software engineer but without the human problems with it.
Refactor this logic completely. Rethink this component. Rethink the request again from zero. Jump into Figma and redesign the UI again. Rebuild. It starts to match product needs, starts to match expectations, refine. Okay, ready to test with users. Launch on a testers group. Testers complain about stuff. Have the model read tester complaints and error logs, infer the problems, I validate, relaunch the fixes. It does not work again in other areas. Refactor the whole fucking thing again, discover another flaw, refactor... Same... Product... problems, as always. One unique thing: faster cycles, cheaper software development, not a single engineer needed. Zero.
When I mention protocols, I'm referring to anything that requires a set of actions with a specific logical relationship to human usability, something that can be parameterized into clear digital product steps for the many. In payments, it's the payment flow of a user or company and the checks and balances of those flows. In identity, it's the deep process and steps of validating identity data over a specific flow. For example, buying a flight is the clear process of human decision-making to choose which flight you want, not the user interface offering possibilities for the user to decide, but the logic of will.
I want to go to Paris, from Madrid -> this day -> happy to take early flights -> this is my budget -> give me options aligned with it -> select an option, done. My credentials are already in the conversation between my agent and the flight agent, validated. My agent asks me if my credentials can be shared securely with the airline. Click, sent. The payment appears on my personal payments validation app for a final OK, guess, it is not a bank app. ;)
No interface needed aside from a minimal one, built on the fly on my device, fluid, based on modules and the selection process. No airline website that sucks at every step, no entering my card details into a field, no endless scrolling through a selection process.
A clear validation product protocol for that specific case.
I feel the internet will slowly take shape around defining and clarifying the checks and balances of those Atomic Product Protocols for everything. In the same way we've consolidated clear user experiences on the web with the browser as the main channel, the new channel will be an agentic, fluid, modular protocol interactor. We'll need clear agentic product protocols with clear steps for our personal agents, running wherever they're running. Local LLM, Claude, ChatGPT, DeepSeek, it doesn't matter. The protocols will be the same.
And I feel the two areas with the most impact for developing those protocols are, first, identity. Identity validation and verification are the deepest bottlenecks to anything. And then payments: sovereign, neutral, easy payments associated to an identity and a jurisdiction.
And this is where I think companies will need support in the future. What is a good company knowledge base? What is a good quality agent orchestration schema? What are good checks and balances? Is the Product Manager's expertise broad enough to take responsibility for their agents' work? Do the Product Manager and Product Designer work agile enough together to understand product needs and user needs, so they can wisely delegate specific features or tasks?
I feel this is where product design goes from here. The screen is only one surface; the product logic behind it is what lets agents take action with the right checks and balances. Everything else will slowly become a modular protocol.