In July 2026, a thought-provoking article by Salvatore Sanfilippo (antirez), the creator of Redis, sparked a crucial conversation in the developer community. The piece, titled "Control the Ideas, Not the Code," argues that as AI tools like large language models (LLMs) become more capable of generating and maintaining code, the true value of a software developer shifts from writing every line to owning the core concepts and architectural decisions. This isn't just a philosophical shift—it's a practical reality that many teams are already navigating.
The Core Thesis: Why Ideas Matter More Than Syntax
Sanfilippo's central argument is that in an era where AI can produce functional code from a well-defined prompt, the bottleneck is no longer the act of coding itself. Instead, it's the ability to think clearly about what the code should do. He describes his own experience with a side project where he used an LLM to generate most of the codebase. The challenge wasn't debugging syntax errors—it was articulating the right logic, ensuring the architecture was sound, and making design choices that the AI couldn't infer on its own.
This aligns with a broader trend: leading companies like GitHub, GitLab, and JetBrains have all integrated AI coding assistants that handle boilerplate, tests, and even refactoring. According to a 2025 survey by Stack Overflow, over 70% of professional developers now use AI tools regularly. But the same survey noted that the most significant productivity gains come from developers who deeply understand their domain, not just those who write code fast.
Practical Implications for Developers and Teams
1. Shift from Code Review to Logic Review
Traditionally, code reviews focus on style, edge cases, and potential bugs. In an AI-assisted workflow, the AI handles much of that. The human reviewer's job becomes about verifying the logic: "Did the AI implement the correct algorithm? Is the business rule applied correctly?" This requires a stronger grasp of the problem domain than ever before.
2. Architecture as a Competitive Advantage
Sanfilippo warns that if a developer cedes architectural decisions to an AI, they risk creating systems that work but are brittle or unmaintainable. For example, an AI might generate a monolithic function for a task that should be split into microservices, or it might choose a database schema that works for a prototype but fails under load. The developer must control the high-level structure—the ideas—while letting the AI fill in the details.
3. Prompt Engineering as a Core Skill
This isn't about writing magic prompts. It's about learning to decompose a complex feature into discrete, testable units that an AI can generate. Sanfilippo's article describes how he writes a high-level plan first, then uses the AI to implement each step. This is similar to how software architects have always worked, but now the implementation phase is accelerated.
Real-World Case Studies from the Article
Sanfilippo shares a concrete example from his own work: he built a Redis-compatible data structure library where the AI wrote about 80% of the code. His role was to define the API contract, the memory layout, and the concurrency model. When the AI produced incorrect behavior under edge cases, he didn't fix the code line-by-line—he refined the prompt with clearer constraints. This approach reduced development time by roughly 60% compared to writing from scratch.
Another case mentioned in the article involves a startup that used an LLM to generate their entire backend. The initial code worked, but they hit a performance wall because the AI had chosen suboptimal data structures. The founders had to rewrite the core from scratch, learning the hard lesson that AI can't substitute for deep technical judgment.
How to Implement This Mindset
| Old Approach | New Approach |
|---|---|
| Write every function yourself | Describe the function's purpose and let AI generate it |
| Review code for syntax errors | Review code for logical correctness and alignment with business goals |
| Own the implementation details | Own the architecture and trade-offs |
| Learn new languages by syntax | Learn new paradigms and concepts, let AI handle syntax |
For teams wanting to adopt this model, the article suggests starting with small, non-critical modules. Define the interface and expected behavior in a prompt, then test the AI's output rigorously. Over time, you build a library of reliable patterns.
The Role of Education and Tools
This shift also impacts how we teach programming. Instead of focusing on memorizing syntax, curricula should emphasize problem decomposition, system design, and critical evaluation of generated code. Tools like ASI Biont's platform are already exploring this by offering courses that teach how to guide AI effectively, rather than just writing code manually. For example, if you're integrating with a service like Telegram, you can define the message flow and let AI handle the API calls—ASI Biont поддерживает подключение к Telegram через API — подробнее на asibiont.com/courses.
Conclusion
Sanfilippo's article is a timely reminder that technology doesn't make human expertise obsolete—it refines what expertise means. In 2026, controlling the ideas means you can build faster, iterate smarter, and focus on what truly differentiates your product. The code is just the medium; the idea is the message. Developers who embrace this will not only stay relevant but lead the next wave of innovation.
Comments