In the rapidly evolving landscape of artificial intelligence, a new consensus is beginning to emerge among the industry’s most prominent architects: the era of the "prompt engineer" may be drawing to a close. Boris Cherny, the creator and head of Claude Code at Anthropic, recently sat down with Y Combinator’s Diana Hu to dismantle the prevailing myths surrounding how users should interact with advanced AI agents.
Cherny’s core message is both provocative and liberating for the average user: stop obsessing over complex, multi-layered prompts and start treating your AI like a capable human colleague. According to Cherny, the true path to mastery lies not in linguistic gymnastics, but in empirical experimentation, task verification, and the ability to set clear, ambitious goals.
The Myth of the "Prompt Wizard"
For the past two years, the tech industry has been obsessed with the art of prompt engineering. Courses, Twitter threads, and LinkedIn influencers have flooded the market with "one weird trick" solutions—chains of thought, role-playing personas, and elaborate constraints—all designed to extract better performance from Large Language Models (LLMs).
However, Cherny argues that this approach is largely a relic of early, less capable models. As AI agents like Claude Code become more sophisticated, they no longer require the user to hold their hand through every step of a logic chain. "I think people tend to over-engineer," Cherny noted during the interview. "When we built systems in the past, that’s the way you had to do it. But trying to over-specify, and trying to get the model to do the task exactly the way that you would have done it, is just not the way the model works."
The implication is clear: by treating the model like a rigid computer program that requires precise syntax, users are actually stifling the AI’s ability to reason and execute complex tasks autonomously.
A Chronology of AI Interaction Evolution
To understand why prompt engineering is fading, one must look at the trajectory of AI development:
- The Early Phase (The "Chatbot" Era): Users interacted with simple text-in, text-out models. Success depended entirely on providing sufficient context and explicit instructions to prevent hallucinations.
- The "Prompt Engineering" Peak: As models grew, users realized they could "steer" models using structured frameworks. This led to the rise of job titles like "Prompt Engineer" and "Context Engineer."
- The Agentic Shift: We are now entering the era of the autonomous agent. Claude Code, for instance, has access to tools, file systems, and development environments. It is no longer just predicting the next word; it is executing workflows.
Cherny suggests that as we move into this third phase, the required skill set has fundamentally shifted. The "waves" of hype—from prompt engineering to context engineering—are indicative of an industry in transition, searching for the best way to leverage models that are becoming smarter than their users realize.
Supporting Evidence: The OpenCV and Swift Experiments
Cherny bolstered his argument with two striking anecdotes that highlight the latent, "hidden" capabilities of modern models.
The OpenCV Discovery
In an internal experiment at Anthropic, engineers granted Claude access to the OpenCV library—an open-source collection of thousands of real-time computer vision algorithms. Without being explicitly told how to use the complex library, the model was asked to perform visual tasks. The results were startling; the model not only navigated the library effectively but also began generating images and performing visual processing tasks that the team hadn’t specifically prompted it to do. This "model elicitation" proves that the model possesses a vast, unmapped landscape of capabilities that can be unlocked simply by giving it the right tools and the autonomy to explore them.
The Swift Transformation
In a more practical test, Cherny tasked the Claude Tag agent (an internal version of Claude working within Slack) with a heavy-duty programming assignment: rewrite the entire Claude desktop application from the Electron framework into Swift, Apple’s native language.
Rather than breaking the task down into a dozen microscopic, hyper-specific prompts, Cherny gave a simple, direct instruction: "Rewrite the Electron app in Swift. Run the Electron app in the Mac virtual machine, screenshot it, and then look pixel-by-pixel, compare it to the Swift version. Don’t stop until you’re done."
The model succeeded, but more impressively, it took the initiative to "live blog" its progress by posting screenshots of the build process into a dedicated Slack channel. This demonstrated a level of proactive communication and self-verification that no amount of prompt engineering could have forced.
The Vital Importance of Verification
If prompt engineering is not the key to success, what is? Cherny points to a single, often overlooked pillar: Verification.
"The skill nowadays is less about prompt engineering and more about figuring out how do you give Claude a hard task that seems a little bit too hard? And then how do you make it possible for Claude to verify its work along the way?" Cherny explained.
In the programming example, the verification was built into the task: comparing the Swift output to the Electron screenshot. By providing the agent with the tools to check its own work—and the freedom to "fail" and iterate—the user creates a feedback loop that is far more efficient than trying to predict every potential error in a prompt.
Implications: The New "Expert" User
For those looking to ascend to the "top 1% of Claude users," Cherny’s advice is counter-intuitive: stop reading the influencers.
The Empirical Approach
"You have to approach it empirically," Cherny says. "You have to give it a task that’s too hard. You have to give it the tools to verify the work, like you would if you were doing the task. You have to see where it struggles, and then you have to fix that."
This is a shift from prescriptive interaction (telling the model exactly what to do) to collaborative interaction (treating the model as a peer).
The "Coworker" Mindset
The ultimate goal, according to Cherny, is to unlearn the "engineer-to-computer" relationship. For decades, developers have been trained to treat machines as deterministic engines that only do exactly what is written in the code. Because modern AI is probabilistic and intelligent, this mindset is a liability.
"It’s a journey to kind of figure out how do you treat this thing like you would a coworker," Cherny noted. "I think that’s the level of intelligence that it’s at now."
Summary of Key Takeaways
- Stop Over-Specifying: Long, complex prompts are often self-defeating. They restrict the model’s ability to leverage its internal logic.
- Prioritize Verification: Your primary job is not to dictate the "how," but to provide the "check." Give the model a way to verify its results (e.g., unit tests, visual comparison, or file validation).
- Embrace the "Too Hard" Task: Modern models have latent capabilities that only surface when they are challenged. If a task seems slightly beyond the model’s reach, that is the perfect environment to test its potential.
- Adopt an Empirical Mindset: Treat your interaction with AI as an experiment. If it fails, observe why it failed, provide the missing context or tool, and try again.
- Ignore the Hype: The landscape changes too fast for "one-size-fits-all" prompting tips to remain relevant. Direct, clear, and goal-oriented communication remains the gold standard.
As we move forward, the divide between the average user and the "power user" will likely be defined by their ability to delegate. Those who can effectively act as project managers for their AI agents—setting high-level goals and building robust verification loops—will achieve significantly more than those still stuck in the cycle of trying to engineer the "perfect" prompt.
