Coding Without an IDE: A Glimpse into the Future with Anthropic's Boris Cherny

Picture your typical coding session. You fire up VS Code, WebStorm, or your favorite JetBrains IDE. The familiar colors, the comforting hum of your extensions, the powerful IntelliSense predicting your every move—it's a digital workshop, perfectly tooled for your craft. For most developers, the Integrated Development Environment (IDE) isn't just a tool; it's home. Now, what if one of the brightest minds in AI development told you he hadn't opened one in a month?

That's exactly what Boris Cherny, the brilliant engineer who created Claude Code at Anthropic, recently revealed. The statement sent ripples through the developer community, sparking a mixture of disbelief, curiosity, and a touch of existential dread. Is this a quirky experiment by an outlier, or are we witnessing the dawn of a new era in software development?

In this post, we’ll dive deep into Cherny's "no-IDE" month, explore the seismic shift it represents, and unpack what it means for the future of your own coding workflow.

Who is Boris Cherny and What is Claude Code?

To understand the weight of this statement, you need to understand who said it. Boris Cherny isn't just any developer. He's a seasoned software engineer with a rich history at places like Facebook (Meta) and a reputation for deep thinking on programming languages and systems. At Anthropic, an AI safety and research company, he is the creator of Claude Code, a sophisticated AI model designed to understand, write, and reason about code.

Unlike early-generation code assistants that primarily focused on autocompletion, Claude Code is part of a new wave of AI partners. It's designed for a conversational approach to programming, capable of tackling complex tasks, refactoring entire codebases, and explaining intricate logic. Cherny isn't just a user of AI tools; he is building the very foundation of them. When he changes his workflow, it's not just a personal preference—it's a data point from the future.

A Month in the Wilderness: What Does "No IDE" Really Mean?

When Cherny announced he hadn't used an IDE for a month, he wasn't suggesting a return to writing C in Notepad and compiling from a raw command line. The reality is far more futuristic. His workflow has evolved beyond the traditional "write-compile-debug" loop that IDEs are built to optimize.

Instead, he has embraced what can be called "Conversational Development."

His new "IDE" is a combination of a simple text editor (like Zed or Sublime Text), a terminal, and, most importantly, a direct line to his AI collaborator, Claude. The process looks less like typing code and more like directing an incredibly competent junior developer.

The New AI-Driven Workflow

Imagine this scenario:

• The Prompt as the Starting Point: Instead of creating a new file and typing `function...`, Cherny might start with a high-level prompt to Claude: "Scaffold a new React component for a user profile page. It should fetch data from `/api/user/{id}`, display the user's name, email, and avatar. Use TypeScript and handle loading and error states gracefully."
• AI as the Implementer: Claude generates the initial code—the component structure, the API call, the state management, and the JSX. This saves minutes, or even hours, of writing boilerplate code.
• The Developer as the Architect and Reviewer: Cherny's role shifts. He reviews the generated code, much like a senior developer conducting a code review. He might then issue follow-up commands: "Refactor the data fetching into a separate custom hook." or "Add a skeleton loader to improve the perceived performance." or "Can you write some unit tests for this component using Jest and React Testing Library?"
• The Terminal for Integration: He uses the command line to run tests, commit code to version control, and deploy changes. The core "thinking" and "writing" of code is happening in conversation with the AI.

In this model, the developer's primary skill is no longer just syntax fluency but the ability to articulate requirements clearly, review code critically, and guide the AI toward the desired outcome. The cognitive load shifts from "How do I write this?" to "What do I want to build?"

Is the IDE Truly Dead? (Spoiler: Not Yet)

So, should you uninstall VS Code and throw your JetBrains license in the digital bin? Absolutely not. Cherny's experience is a glimpse into a possible future, but it's crucial to add context.

IDEs still offer immense, irreplaceable value:

• Integrated Debugging: The ability to set breakpoints, step through code execution, and inspect variables in real-time is a superpower that conversational AI has yet to replicate seamlessly.
• Project-Wide Refactoring: Tools like "Rename Symbol" or "Find Usages" across an entire massive codebase are still faster and more reliable in a modern IDE.
• Discovery and Learning: For developers learning a new framework or library, the autocompletion and inline documentation of an IDE are invaluable learning aids.
• Complex System Navigation: Navigating a sprawling monolithic enterprise application with thousands of files is often more manageable with the structured project views and "Go to Definition" features of an IDE.

What Cherny's experiment signals isn't the death of the IDE, but a fundamental evolution of its role. The IDE is no longer the sole center of the developer universe. For many, the future is hybrid. Tools like GitHub Copilot, Tabnine, and JetBrains' AI Assistant are already bringing conversational AI inside the IDE. The IDE is becoming a "cockpit" where the developer pilots the coding process, using AI as a powerful co-pilot.

Practical Tips: How to Start Using AI Like Boris Cherny

You don't have to abandon your favorite tools to start benefiting from this new paradigm. The key is to start thinking of AI as a collaborator. Here are some practical ways to integrate an AI-assisted workflow today:

1. Delegate the Boilerplate

Next time you need to write a common function—reading a file, making an API call, setting up a basic server—don't write it from scratch. Ask an AI assistant.
Prompt Example: "Write a Python script using the `requests` library to fetch JSON data from `https://api.example.com/posts` and print the title of each post."

2. Use it as a Super-Powered Search Engine

Instead of searching Stack Overflow for an obscure error message or a specific syntax, paste it directly into your AI chat.
Prompt Example: "I'm getting the error 'TypeError: cannot read properties of undefined' in my JavaScript code. Here's the function causing it: [paste code]. What are the likely causes and how can I fix it?"

3. Accelerate Your Learning

When you encounter a piece of code you don't understand, ask the AI to break it down for you.
Prompt Example: "Explain this line of Rust code to me like I'm a Python developer: `let new_vec: Vec<&str> = my_vec.iter().map(|s| s.as_str()).collect();`"

4. Brainstorm and Prototype

Use AI to quickly sketch out ideas. It's an incredibly fast way to see if a concept is viable without investing hours in setup.
Prompt Example: "Give me a basic HTML, CSS, and JavaScript structure for a to-do list application. I need an input field, an 'Add' button, and a list where I can check off and delete items."

Conclusion: The Evolving Role of the Developer

Boris Cherny's month without an IDE is more than just a tech headline; it's a profound statement about the future of our craft. It shows us that the core work of a developer is evolving from being a meticulous "coder" to a visionary "architect." Our value is shifting from writing perfect syntax to defining clear problems, guiding intelligent systems, and integrating complex components.

The IDE isn't dead, but it is changing. It must adapt to a world where code is often generated, not just written. For us developers, the takeaway is clear: the future belongs to those who learn to collaborate effectively with AI. Start experimenting, start delegating, and start having conversations with your code. The next great leap in productivity and creativity is waiting.