Over the past months, AI has taken on a relevance in my work that I no longer want to be without. I had tried all kinds of tools, including various IDE plugins and standalone AI editors, and yet—until less than half a year ago—I used no agents at all in my daily work. Not because those tools couldn’t already have been used sensibly, but because of how I personally approach such things.
Agentic Coding Is Not Vibe Coding
To this day, agents are often lumped together with vibe coding. The two terms are used as synonyms, yet there is a decisive difference—at least as soon as production code is involved. Vibe coding is the only reason the idea that we would soon no longer need developers could ever take hold. What I practice with these tools is agentic coding: I leave the tedious typing to the agent, but never the architecture or the algorithms. The payoff is maintainable systems I understand at any moment.
The Model Matters Less Than How You Use It
Creating software is enormous fun for me. Not just the outcome, but the whole how of it. That’s why it mattered to me to understand the how of agents as well: how they are even able to do their work, so that I can deploy them deliberately. Lately it has become clear to me that the model alone is often not what decides a good result—it’s the way you employ your agent. That covers clear instructions, but also meaningful additions such as MCP servers—though, as with all of my work, keeping the setup minimal matters enormously to me.
A Hype I’ve Seen Before
Right now I’m still watching a hype much like the one I saw during the first migrations to the cloud. Back then, everyone regarded the cloud as simply better across the board. Applications were neither perfectly prepared for that world, nor had the consequences been sufficiently assessed. Many people lived through the result: enormous costs and little control. From then on, people often stopped even trying to understand how such a service is actually operated. One very well-known move out of the cloud came from 37signals.
A Prompt Is Not an Abstraction
Working with AI is still in a finding phase. What makes it harder is that the understanding around it is getting even blurrier. It goes so far that agents are seen as the logical evolutionary step of higher-level programming languages. We still have a long way to go.
AI builds its solutions on probabilities. A prompt is not an abstraction of a programming language, even if classic vibe coding would like it to be. In the end, AI is nothing more than a generator with a certain probability. That means—if you don’t want to lose control—you have to understand the output completely. With a compiler, you can rely on what it guarantees; with a probability distribution, you cannot.
More Productive, Not on a Higher Level
AI tools have increased my productivity enormously, and I don’t want to be without them. But it pays to keep the logical classification in mind: a prompt is not simply the next level above a programming language. It’s a different kind of tool altogether.
The Evolution of Programming Tools
I’ve lived through this evolution of programming tools firsthand—from the plain text editor to the agent. Each stage added a deeper layer between me and the machine:
- Pure text editor—the blank page.
- Concept: a raw buffer of characters with no awareness of language at all.
- Value: complete freedom to write—nothing is prescribed, and nothing is hidden.
- Lexical analysis (syntax highlighting)—the first glance of a parser.
- Concept: a tokenizer recognizes keywords, strings, and comments.
- Value: structure becomes visible at a glance, so fewer slips go unnoticed.
- Deterministic autocompletion—the index knows your symbols.
- Concept: symbol tables propose what could syntactically come next.
- Value: less typing and more consistency—but always on your terms, never with an opinion.
- Semantic analysis (IntelliSense & LSP)—the editor understands types.
- Concept: a language server resolves types, references, and signatures.
- Value: navigation and refactoring across a real model of the code, not just its text.
- Probabilistic line and block completion—the model guesses ahead.
- Concept: a language model predicts plausible tokens from context.
- Value: real speed on boilerplate—but suggestions arrive as likelihood, not as truth.
- Context-aware assistants (chat and inline edit)—conversation enters the loop.
- Concept: the model reasons across a larger prompt and your open files.
- Value: a partner for questions and rewrites, while the judgment stays with you.
- Agentic coding (autonomous systems)—the tool acts on its own.
- Concept: a model plans and executes multi-step tasks through tools.
- Value: whole work packages get executed—provided you define architecture and constraints and review the result.
It’s Not Magic
The hype around AI tools is enormous. And the fact that you often need so little to solve a problem demands at least a minimum of understanding of what is going on in this space. But that’s exactly when it gets exciting again: when you realize that none of it is magic and that it still runs purely on logic.
Further Exploration
- AI in Software Development: Tool, Not Replacement—why AI is a tool, not a replacement
- Using AI as a Pair Programming Partner in Development—how I collaborate with AI day to day
- The Two Faces of Abstraction: Power vs. Hidden Dependency—why a prompt is not an abstraction
- Beyond the Cloud Hype: Building Resilient Systems—the cloud parallel, revisited
- Beyond the Tool Trap: Rediscovering Real Innovation—on swapping tools without understanding them
- A Year of Recalibration: Rethinking the Tools I Use Every Day—where AI sits in my current stack
- The Evolution of Computer Science: From Mysticism to Pragmatism—why the fundamentals still decide