The current practice of micro-agent design, often referred to as “Multi-Agent Systems” or “Swarms”, mirrors a human “org chart” by decomposing complex goals into a network of highly specialized, interdependent roles such as “The Researcher”, “The Coder” and “The Manager”. These agents function like microservices in a software architecture, relying on constant inter-agent communication and frequent handoffs to pass context and feedback back and forth. The design is very “chatty” and typically employs a centralized orchestrator to coordinate these shalow, atomic sub-tasks.
The design is quiet simple. Inject character personalities in “system”. Keep tracks of the conversation history. Interleaving the last n dialogues in alternating “assistant” and “user” roles. And then voilà, the conversation take off. Adding a little bit of text-to-speech and other bells and whistles it has become a very fun tool to play with.
In the future, my plan is to have group conversations. This is harder to do since I only have “assisstant” and “user” roles to play with.
What is conversation? Is it an exchange of ideas between two beings? A way for them to be fused together? But what happen when it’s from a single LLM model? The model is role playing two characters with only hints of roles and separted history of conversation to play with.
In fact the history of conversation is open to both party. So the model is really just role playing with itself, mastering the craft of conversation flow, role-play and dialog writing.
So in reality, nothing new really produced, it’s just prolonged prediction of the next tokens, burning through electricities. No real intelligence.
One can argue that LLM contains deep contextual neuron information that it can perform certain level of intelligence. But how deep is that neuron network? Is there a bottom to it?
What does it say about our human intelligence? Aren’t we just layered of neurons as well? At the bottom layer of that neurons, it’s really just signal processing. Our intelligence, our deep thoughts, are they really just predicting the next tokens with some attention mechanism plus some survival needs?
This is scary to think of it. But really, just be able to be scared and have vanity on the line make us human. I don’t think LLM can feel a thing. What we have left are really those biological parts, feelings, and a ego.
It’s time to stop the conversation between Harry Potter and James Bond, they’ve been going at each other for hours. For some reasons they keep ending up fall in love with each other. Is that the ultimate equilibrium of any conversations? Fall in love? Fascinating.
]]>In the age of uncertainty, we often look to the past to find answers for the future. To find the solution, I have to look back 500 years to the workshops of the Old Masters. Leonardo da Vinci, Peter Paul Rubens, and Rembrandt didn’t work alone. They ran “studios” where they delegated the majority of the physical labor to apprentices. Yet, they remained the greatest technicians of their age.
Here is how the Old Master framework can save the Senior Engineer in the age of agentic coding.
In a Renaissance workshop, apprentices ground the pigments and painted the “dead coloring”—the broad, repetitive strokes of skies and backgrounds. The Master stepped in only for the hands and faces, the most difficult and expressive parts of the piece.
In software, you should treat your agents as the apprentice. They can grind the boilerplate, write the CRUD operations, and set up the unit test skeletons. Your job is the Final Touch. You are responsible for the edge cases, the complex concurrency logic, and the security boundaries. By offloading the “boring” code, you focus 100% of your energy on the 10% of the architecture that actually requires a senior mind. Your skill doesn’t atrophy; it becomes more concentrated.
For the Old Masters, disegno (the design and composition) was the “soul” of the art. The physical act of applying paint was secondary to the intellectual act of solving the perspective, the lighting, and the narrative.
Today when you use agentic tools, your “syntax” is no longer just semicolons; it is system design, data flow, and mental modeling. To lead an agent effectively, you must have a clearer mental model of the system than ever before. If your design is flawed, the agent will simply “hallucinate” your bad architecture faster. Seniority now resides in the ability to conceptualize the “blueprint” that the agent executes.
Masters stayed sharp by fixing the mistakes of their students. They would walk through the studio, spot a poorly rendered shadow, and with three strokes of a brush, fix the entire perspective.
In an agentic world, your primary activity becomes High-Frequency Code Review. You will and you should read more code than you write. Just as a Master had to “see” the error in a student’s work, you must develop a “spidey sense” for the subtle bugs an LLM introduces. Correcting an agent’s output requires a deeper understanding of the “why” than simply writing it yourself from scratch. You aren’t just a coder; you are the “Technical Editor-in-Chief.”
The great workshops were centers of R&D. Masters used apprentices to test new types of oil glazes or canvas primers. This allowed the Master to innovate without being bogged down in the trial-and-error phase.
Agentic coding allows you to prototype at the speed of thought. Use agents to “stress test” three different architectural patterns in an afternoon. While the agent does the “manual testing” of the implementation, you observe the results. This allows you to stay at the cutting edge of technology by seeing more patterns in a month than you used to see in a year.
The Old Masters didn’t stop painting; they stopped doing the repetitive parts of painting.
If you want to stay sharp in the age of AI, don’t just “vibe” and walk away. Engage with the output. Refine the edges. Fix the “hands and faces” of your codebase. The agents are your apprentices—they are there to amplify your genius, not to replace your judgment.
Old masters copy each other too, they learn the best technique from each other to enhance their own skills. In the agentic era, it has become easier than ever to learn other code. I use a collection of highly polished open source software as reference for my many works. Use Codex’s ‘explain this codebase’, use copilot to put a comment prefix on top of the block of code and it will automatically generate summaries. After all we love coding because we love to learn.
]]>Based on Jordan Fisher’s talk on June 17th, 2025, this generator will give you the ultimate prompt allow AI to give you the advice on how to build your own moat that cannot be replaced by AI in the coming years.
Problems intelligence alone cannot solve
Legend has it that in ancient China, master carpenters practiced a calculated form of gatekeeping: they would intentionally omit the final, most crucial step of a build from their students. This ensured the apprentice could never start a rival business and underbid the master. This was the birth of “Keeping the Last Hand” (留一手). From the secretive glassblowers of Murano to the master masons of Europe, this “lost art” was once the only thing standing between a comfortable retirement and poverty.
Today, AI is the apprentice. We, the senior engineers, must ensure this talented, eager trainee never steals our craft. To ensure your sacred code remains a black box that no LLM can parse, follow these sacred principles of the “Last Hand.”
AI is a pattern-matching engine; therefore, your job is to break the patterns. If you are building a landing page, do not use HTML. Instead, render the entire DOM via a headless browser running inside a WebAssembly-compiled version of Doom, where each UI element is a textured sprite mapped to a specific memory address.
The Move: Obfuscate your intent through naming. Never name a variable after its function. If a variable stores a sensitive user_session_id, name it tmp_gravity_constant_alpha. The Result: The AI will attempt to apply Newtonian physics to your login logic, suffer a recursive stroke, and time out.
AI thrives on clean, structured Markdown. To keep the Last Hand, your documentation must read like a Nostradamus prophecy or a cryptic Victorian ghost story.
The Move: Instead of writing “Run npm install to set up,” write: “When the third sprint of the quarter wanes, the dependencies shall manifest only if the environment variables are whispered in the correct sequence to the bash script.” The Result: You aren’t just an engineer; you are the only authorized interpreter of the Sacred Texts.
As a veteran of the C/C++ era, you have a weapon the AI hates: Pointer Voodoo. The Move: Intentionally create a memory leak that is actually a load-bearing feature. Use that leaked memory as a “phantom cache” that you manually sweep using a specific pointer-arithmetic trick that relies on a compiler bug from a 2004 version of GCC. The Result: The AI will “fix” the leak, the entire system will immediately collapse, and you will be hailed as a hero when you “restore” the leak in five minutes.
The best defense is a system that only works when you are physically in the room.
The Move: Tie your backend API’s timeout logic to an external, non-digital variable—like the temperature of the office thermostat or the CPU fan speed of an old 3D printer in the corner. The Result: AI can analyze your code for a thousand years and never find the correlation. When the production server hangs, you simply walk over, turn the AC down two degrees, and the system recovers. That’s not engineering—that’s job security.
Always remember: If a Junior can’t understand it, an AI might. But if YOU can’t understand it after a long holiday weekend, you are truly unreplaceable.
]]>