Unpacking Agentic Coding: Real-World Evidence, Success Strategies, and Lingering Doubts

The discussion around agentic coding reveals a nuanced picture: while not a magic bullet for fully autonomous development, it offers significant productivity gains for many when approached with specific strategies and a disciplined workflow.

The "Does It Work?" Debate

Initial skepticism, often stemming from over-hyped claims and poor early experiences with models like Codex, quickly gives way to a more pragmatic view. Many experienced developers report positive results, shifting from a mindset of expecting AI to "do the job" to using it as a powerful assistant. The definition of "works" also varies; for some, it's about income generation and speed, while for others, it's about maintaining high code quality and architectural integrity.

Key Strategies for Success

Successful users consistently emphasize the following:

• Human in the Loop: The most prevalent theme is that agentic coding requires constant human supervision. Developers act as technical leads, delegating tasks, reviewing plans, inspecting generated code, and providing immediate feedback. This iterative dialogue is critical for guiding the AI effectively.
• Clear and Detailed Specifications: Agents thrive on explicit instructions. Crafting comprehensive SPEC.md files, AGENTS.md or CLAUDE.md for project-wide guidelines (coding style, design patterns, testing standards), and asking the agent to clarify requirements or generate a detailed plan before coding are common practices. This upfront investment in precise communication prevents much of the "spaghetti code" and "subtle mistakes" observed by the original poster.
• Small, Well-Defined Tasks: Breaking down large problems into smaller, atomic units is crucial. Agents excel at generating boilerplate code, migrating codebases (e.g., Python 2 to 3, old Node.js versions), creating infrastructure-as-code (Terraform, Ansible), writing tests, generating documentation, or producing small utilities. Attempting to build complex greenfield applications from scratch autonomously often leads to frustration.
• Rigorous Testing: Test-Driven Development (TDD) is frequently recommended. Have the AI generate tests first, then implement the code to pass those tests. These tests serve as a critical "spec" and guardrail. Human review of the tests themselves is paramount to ensure they genuinely validate behavior and not just pass trivially (e.g., expect(true).to.be(true)).
• Leverage Existing Context and Conventions: Agents perform significantly better within existing codebases that have established patterns and comprehensive documentation. They can follow examples and adhere to a project's style more reliably than when operating in a vacuum.
• Strategic Model and Tooling Choice: Claude Code, particularly with Opus 4.5, is widely favored over older models like Codex for agentic workflows due to better long-term focus and adherence to instructions. IDE integrations like Cursor, along with Multi-Context Platform (MCP) tools, enhance the agent's ability to access and understand the codebase.
• Willingness to Iterate and Discard: Treat AI-generated code as a disposable first draft. If an agent goes off track or produces suboptimal code, it's often more efficient to revert, refine the prompt/plan, and try again rather than attempting to painstakingly fix it. The goal is rapid iteration to validate ideas.
• Language Considerations: Statically typed languages like C# and Go, or dynamic languages with strict type checking (e.g., TypeScript with aggressive linters), tend to yield better results due to their inherent clarity and ability to catch errors early.

The Evolving Role of the Developer

Agentic coding redefines the developer's role. Many feel they transition from direct coders to "managers of robots" or "product designers with high technical skills." The mental shift involves focusing on higher-level architectural decisions, strategic planning, and sophisticated debugging, while offloading the tedious "typing" and boilerplate generation to the AI.

This shift has reignited a "love of programming" for many seasoned engineers, freeing them from repetitive tasks and allowing them to tackle more complex, interesting problems. However, it also raises concerns about job displacement, the accelerating accumulation of technical debt, and the need for developers to continuously adapt their skill sets.

Challenges and Criticisms

Despite the enthusiasm, significant challenges remain. Agents struggle with high-level architectural design and often introduce subtle bugs or duplication if not meticulously guided. The lack of persistent memory and "learning" across sessions means developers often have to re-teach principles, leading to calls for shared memory layers for agents (e.g., "Memco"). There's also skepticism about the accuracy of reported speedups, with some studies suggesting AI might sometimes increase completion time due to the overhead of guidance and correction.

The debate over code quality continues. While some argue that customers only care about functionality, others emphasize that maintainable, well-architected code is crucial for long-term project success. The push to "validate behavior over architecture" is seen as risky without strong human oversight and robust, human-reviewed tests.

Ultimately, agentic coding is a powerful new tool. Its effectiveness depends less on the AI's "magic" and more on the human's skill in wielding it, requiring constant learning, adaptation, and a deep understanding of software engineering principles.