Boris Cherny's talk on how Claude Code represents a new paradigm in AI-powered development tools.

Boris Cherny, creator of Claude Code at Anthropic, presents a compelling vision of how programming is evolving in the age of AI. He traces the evolution from punch cards to natural language programming, explaining why Claude Code takes an intentionally simple, unopinionated approach to AI-powered development.

The talk covers Claude Code's core features—terminal integration, IDE support, GitHub integration, and SDK—while sharing practical tips for effective use, including code Q&A, teaching Claude your tools, and leveraging Plan Mode for complex tasks.

YouTube Video (17m)

Overview

Boris Cherny, creator of Claude Code at Anthropic, presents a compelling vision of how programming is evolving in the age of AI. In this talk from the AI Startup School in San Francisco, he explores the tension between exponentially improving AI models and the products we build to harness them. Claude Code's intentionally simple, unopinionated approach represents a fundamental shift in how developers interact with AI—providing direct access to powerful models without unnecessary abstraction layers.

Talk Chapters

• 0:00 The model is moving really fast, on exponential. The product is struggling to keep up.
• 1:25 Programming evolution: from punch cards to natural language
• 5:45 Ed, the first text editor - still available on Unix systems 50 years later
• 8:22 GitHub Copilot and Devin: the leap to AI-powered coding
• 10:30 Claude Code's philosophy: intentionally simple and general
• 12:15 Terminal, IDE, GitHub integration, and SDK features
• 14:00 Tips for effective use: code Q&A, teaching tools, and workflows
• 15:30 New Plan Mode feature and the power of context
• 16:40 Multi-Claude workflows and the future

Talk Summary

The Exponential Growth Challenge

"The model is moving really fast. It's on exponential. It's getting better at coding very, very quickly," Boris begins. "And the product is kind of struggling to keep up. We're trying to figure out what product to build that's good enough for a model like this."

This tension between rapidly advancing AI capabilities and the products we build to harness them is at the heart of Claude Code's philosophy. Rather than trying to predict the perfect interface for AI-assisted coding, Claude Code takes a deliberately minimal approach—providing the "bare minimum" to let developers experience and experiment with the model directly.

Getting Started with Claude Code

For those new to Claude Code, getting started is straightforward:

• Head to claude.ai/code to install it
• Run the installation from NPM
• As of the talk, Claude Code supports both Claude Pro and Claude Max plans

"Just try it out. Tell us what you think," Boris encourages, emphasizing the experimental nature of the tool.

The Evolution of Programming Languages

To understand where we're heading, Boris takes us on a journey through programming history. "Programming is changing, and it's changing faster," he notes.

The evolution began in the 1930s and 40s with physical switchboards—there was no such thing as software. By the 1950s, punch cards became the norm. Boris shares a personal connection: "My grandpa, actually, in the Soviet Union, he was one of the first programmers in the Soviet Union. And my mom would tell me stories about... he would bring these big stacks of punch cards home from work and she would like draw all over them with crayons."

Programming evolved from:

• Hardware (switchboards)
• Physical media (punch cards)
• Software with assembly language
• Higher-level languages (COBOL, C)
• The explosion of language families in the early 90s (Haskell, JavaScript, Java, Python)

"I think nowadays, if you kind of squint, all the languages sort of look the same," Boris observes. "Like when I write TypeScript, it kind of feels like writing Rust, and that kind of feels like writing Swift, and that kind of feels like writing Go. The abstractions have started to converge a bit."

The Evolution of Programming UX

From Punch Cards to Text Editors

The IPMO29 was "like the MacBook of the time for programming punch cards." This physical machine represented the state-of-the-art in programming interfaces before the advent of text editors.

Then came Ed, the first text editor, invented by Ken Thompson at Bell Labs. "If you open your MacBook, you can actually still type Ed. This is still distributed on Unix as part of Unix systems," Boris notes with amazement. "And this is crazy, because this thing was invented like 50 years ago."

Ed was incredibly primitive by today's standards:

• No cursor
• No scroll back
• No fancy commands
• No type ahead
• Built for teletype machines that literally printed on paper

The GUI Revolution

In 1980, SmallTalk 80 represented "one of the first, I think the first graphical interface for programming." Remarkably, it had features we still struggle with today: "For anyone that's tried to set up live reload with React or Redux or any of this stuff, this thing had live reload in 1980, and it worked."

Visual Basic in 1991 "was the first code editor that introduced a graphical paradigm to the mainstream." While tools like SmallTalk existed, Visual Basic brought GUI-based programming to the masses.

Modern AI-Powered Evolution

GitHub Copilot marked "a big jump forward with single-line type ahead and then multi-line type ahead," using AI to suggest code completions.

Devin introduced the next major abstraction: "to program, you don't have to write code, you can write natural language, and that becomes code." This concept, which developers had been trying to achieve for decades, finally became practical with advanced AI models.

Claude Code's Philosophy

"With all this in mind, Claude Code's approach is a little different," Boris explains. "It's to start with a terminal and to give you as low-level access to the model as possible in a way that you can still be productive."

The key principles:

• Unopinionated: No flashy UI or unnecessary scaffolding
• Simple and General: Shows off the model's capabilities without getting in the way
• Model-First: Lets developers experience the raw power of the AI model

"We actually just don't know. Like, we don't know what the right UX is. So we're starting simple," Boris admits candidly.

The guiding principle? "The more general model always wins, and the model increases in capability exponentially."

Claude Code Features

Terminal Product

The core Claude Code experience is deliberately minimal: "You can install Claude Code, and then you just run claude in any terminal." It's truly unopinionated—working in iTerm2, WSL, over SSH and TMUX sessions, VS Code terminal, Cursor terminal, anywhere.

IDE Integration

When running Claude Code in an IDE, it provides enhanced features:

• Beautiful diff displays within the IDE
• Diagnostic information ingestion
• Minimal polish compared to specialized tools like Cursor or Windsurf

"This is to let you experience the model in a low-level, raw way," Boris emphasizes.

GitHub Integration

A few weeks before the talk, Anthropic announced GitHub integration. The setup is simple:

1. Open Claude
2. Run the slash command to install the GitHub app
3. Pick your repository
4. Claude runs on your compute—your data stays local

SDK for Custom Integrations

For maximum flexibility, Claude Code offers an SDK: "You can build it however you want. People have built all sorts of UIs, all sorts of awesome integrations."

Boris shares a personal use case: "I'll take my GitHub logs, or my sorry, my GCP logs. I'll pipe it into claude -p, because it's a Unix utility, so you can pipe in, you can pipe out, and then I'll JQ the result."

Tips for Using Claude Code Effectively

Boris shares practical advice for getting the most out of Claude Code:

1. Start with Code-Based Q&A

"At Anthropic, we teach Claude Code to every engineer on day one, and it shortened onboarding times from like two or three weeks to like two days."
Engineers can simply ask Claude questions about the codebase.

2. Teach Claude to Use Your Tools

"With every IDE, there's sort of like a plug-in ecosystem... For this new kind of coding tool, it can just use all your tools."
The process is:

• Give it bash tools or MCP tools
• Run --help on a CLI tool
• Put the information in claude.md
• Claude now knows how to use the tool

3. Effective Workflows

Traditional coding tools focused on writing code, but AI-powered tools do much more:

Exploration and Planning: Have Claude explore and make a plan before writing code. Use extended thinking when there's substantial context.

Test-Driven Development (TDD): "I know I try to use TDD. It's like, it's pretty hard to use in practice. But I think now with coding tools, it actually works really well."
The workflow:

1. Tell Claude to write tests first
2. Explicitly state the tests won't pass yet
3. Commit the tests
4. Then write the code and commit

Provide Iteration Targets: "If Claude has a target to iterate against, it can do much better."
This could be:

• Unit tests
• Integration tests
• Screenshots from iOS simulator or Puppeteer
• Even camera feedback from 3D printers!

New Features: Plan Mode

"Today we launched plan mode in Claude Code," Boris announces. By hitting Shift+Tab, Claude switches to Plan Mode where it:

• Creates a plan for your request
• Waits for approval before executing
• Allows you to review and modify the approach

The Power of Context

"Give Claude more context," Boris emphasizes. Several methods make this easy:

• claude.md files: Place in your home folder or project
• Slash commands: Put markdown files in .claude/slash-commands folders
• Memory function: Type # to ask Claude to memorize something

"You can tell this is still pretty rough. This is our first version, but it's the first version that works," Boris acknowledges, inviting feedback on the UX.

The Future: Multi-Claude Workflows

During the Q&A, an interesting question arose about managing multiple Claude instances. Power users are already "multi-Clauding"—running several terminal tabs with different Claude instances working in parallel on different parts of a codebase or different work trees.

"If you do want to coordinate, the best way is just ask them to write to a markdown file, and that's it," Boris suggests for inter-Claude communication.

Conclusion

Claude Code represents a fundamental shift in how we think about AI-assisted programming. Rather than trying to build the perfect IDE or the ultimate coding assistant, it provides direct, unopinionated access to increasingly powerful AI models. This approach acknowledges a crucial reality: in a world where AI capabilities are growing exponentially, the most valuable tool might be the simplest one—one that gets out of the way and lets developers experiment, learn, and discover new ways of working with AI.

As Boris concludes, the evolution of programming—from punch cards to natural language—is accelerating. Claude Code positions itself not as the final answer, but as a flexible foundation for whatever comes next. In the race between exponentially improving models and the products built to harness them, sometimes the winning move is to build less, not more.

The message is clear: the future of coding isn't just about better tools—it's about fundamentally rethinking the relationship between human creativity and AI capability. Claude Code is an invitation to join that exploration.

Notes

• Claude Code shortened onboarding times at Anthropic from 2-3 weeks to just 2 days
• The tool is intentionally "unopinionated" - it works in any terminal environment
• Power users are already "multi-Clauding" - running multiple instances in parallel
• Plan Mode (Shift+Tab) was launched the day of this talk
• Claude Code can be taught to use any CLI tool by showing it the --help output

YouTube Description

A ten thousand foot view of the coding space, the UX of coding, and the Claude Code team's approach.

About Boris Chemy Created Claude Code. Member of Technical Staff @Anthropic. Prev: Principal Engineer @Meta, Architect @Coatue. Author, OReilly's Programming TypeScript.

Chapters on YouTube

• 0:00 - Introduction & the exponential model challenge
• 0:49 - Getting started with Claude Code
• 1:25 - Evolution of programming languages
• 3:45 - Evolution of programming UX
• 4:30 - IPMO29: The MacBook of punch cards
• 5:00 - Ed: The first text editor
• 6:20 - SmallTalk 80 & GUI revolution
• 7:10 - Visual Basic brings GUI mainstream
• 8:00 - GitHub Copilot & AI evolution
• 8:45 - Devin & natural language programming
• 10:00 - Claude Code's philosophy
• 11:30 - Terminal product demo
• 12:15 - IDE integration
• 12:45 - GitHub integration
• 13:15 - SDK for custom integrations
• 14:00 - Tips: Code-based Q&A
• 14:30 - Teaching Claude your tools
• 15:00 - Effective workflows & TDD
• 15:45 - Plan Mode launch
• 16:15 - The power of context
• 16:40 - Q&A: Multi-Claude workflows

References:

• Claude Code & The Evolution of Agentic Coding - Boris Cherny (YouTube)
• Boris Cherny on X (Twitter)
• Talk Slides (Google Docs)
• Claude Code - Anthropic
• Claude Code Documentation
• Anthropic