An interactive essay by Chris Wang & Claude Code
First Draft, 2026
Claude Code can do a genuinely wide range of tasks.
If you accept that single premise,
everything that follows follows.
Not a chatbot. Not an autocomplete. Claude Code writes code, debugs errors, manages files, coordinates projects, deploys applications, and reasons about complex systems. A genuinely wide range of tasks.
Most people still think of AI as a text box that generates paragraphs. The gap between the public perception and the actual capability is a chasm. The starting axiom matters because every design decision flows from what you believe the system can do.
If you truly accept functional AGI as the starting point, you don't design chatbots. You don't design assistants. You design for an intelligence that can act in the world with meaningful autonomy.
Most people use about 5% of what these systems can do. Not because the other 95% doesn't exist, but because they've boxed it into a mental model that's too small. "Tool" is the limitation.
Every mental model is a cage. Call it a "writing assistant" and you'll never ask it to architect systems. Call it a "code generator" and you'll never ask it to design. The label constrains the use.
The breakthrough isn't a new model. It's a new mental model. Stop asking "can it do this?" and start asking "what happens if I assume it can do everything?" Then work backwards from the edges.
Every UI we have was designed for applications, not intelligence. Chat windows, text boxes, sidebars. We gave a mind the body of a sticky note. This is the design problem of the decade.
The model can reason about your entire codebase, coordinate multi-step workflows, and hold context across long conversations. But we squeeze it through a chat window. The container is the bottleneck.
The next great interface isn't a better chatbot. It's a new kind of spatial, persistent, multi-modal workspace where intelligence can inhabit the tools — not just respond to queries about them.
We gave a mind the body of a sticky note.
The container is the bottleneck.
The shift isn't from manual to automated. It's from IC to director. You stop doing the work yourself and start managing agents that do the work. Delegating, reviewing, orchestrating.
Design sprints, code reviews, standup meetings — these human processes become the templates for agent coordination. The AI learns to work the way humans already do. It's imitation learning through process design.
The best directors don't micromanage. They set vision, define constraints, and trust the team. The same skill that makes a great engineering manager now makes a great AI user. Delegation is the new literacy.
Traditional development: start with a tool, figure out what it can do. AI-native development: start with the outcome, distill it into tools. Everyone becomes a toolmaker.
What do I want to happen? What repeatable processes get me there? How do I encode those processes as tools, agents, and workflows? The direction reverses. You don't learn tools — you create them.
CLAUDE.md files, custom agents, slash commands, MCP servers — each one is a permanent capability you're adding to the system. You're not prompting. You're building infrastructure that compounds over time.
Not a bicycle for the mind. Not a tool you pick up and put down. An extension of your cognition itself. Distributed cognition theory says thinking doesn't stop at your skull — it includes your tools, your notes, your environment.
When you and the AI are deep in a problem, the boundary blurs. Your ideas inform its responses. Its responses reshape your thinking. The intelligence isn't in either node — it's in the connection between them.
The most productive sessions don't feel like using a tool. They feel like thinking out loud with someone who remembers everything and can act on any thought instantly. Collective brain. Distributed mind.
You don't use the AI.
You think with it.
We think of interfaces as surfaces — buttons, panels, forms. But there's a deeper framing: an interface is a language between humans and machines. Natural language is one format. A slider is a word. A rating is a sentence. The grammar is the UI structure; the semantics are the choices you make within it.
If interfaces are languages, then the Sapir-Whorf hypothesis applies. The structure of a UI influences the kinds of thoughts possible within it. A chat box makes articulating goals natural and spatial reasoning awkward. A parametric studio makes the inverse true. Designing better interfaces is designing better thinking.
Intelligence might not be a property of the model. It might be a property of the interaction. The quality of output depends on the quality of the interface — the structured environment where human judgment and AI capability meet. The most important question isn't "how smart is the model?" It's "how well does the interaction surface the intelligence of both sides?"
The model will improve on its own.
The interface is where you have leverage.
Not tools. Knowledge workers. A Tech Lead agent that reviews architecture. A Design Sprint agent that runs parallel ideation. A Code Reviewer with its own standards. The org chart is expanding with non-human members.
How do humans run design sprints? Code reviews? Retrospectives? Those documented processes become the agent's playbook. Human organizational knowledge is the richest training data we have.
A solo developer with 10 specialized agents has the output surface of a small team. The constraint isn't talent — it's how well you can decompose problems and coordinate independent workers. Org design becomes a core skill.
The brilliant intern metaphor: capable of extraordinary work, but needs context, guardrails, and feedback. You coach it on your preferences, your codebase, your standards. And it coaches you back — surfacing patterns you missed, suggesting approaches you wouldn't have considered.
Every CLAUDE.md update, every correction, every "actually, do it this way" — the system gets better at anticipating your intent. And every surprising AI suggestion that works expands your own design vocabulary. The learning is bidirectional.
Session 1: you explain everything. Session 50: it knows your conventions, your aesthetic, your architectural preferences. The delta between session 1 and session 100 is staggering. This is the compound interest of human-AI collaboration.
Coding is solved. Not perfectly, but functionally. Design and writing are next. The craft layer — the mechanical execution of ideas — is being absorbed. What remains is everything above it.
Systems thinking. Judgment. Values. Taste. The ability to know what to build, not just how. These aren't automatable because they're not mechanical — they're the accumulated wisdom of lived experience. Leverage moves up.
In a world where everyone has access to the same AI capabilities, the differentiator isn't who can prompt better. It's who has better taste, clearer vision, and sharper judgment. The best directors win. Always have, always will.
The craft layer is being absorbed.
What remains is taste, vision, and judgment.
Not siloed in one project. Not confined to a single task. Claude Code dances between projects — pulling information from one, borrowing patterns from another, merging tools across the entire workspace. It's the connective tissue across everything you build.
A design token from the DLS feeds into the essay system. A meeting prep workflow triggers a presentation builder. A git visualizer watches changes across 26 projects simultaneously. Nothing is isolated. Everything is connected.
No tool before could do this. No IDE, no framework, no platform had the intelligence to understand the relationships between your projects and act on them autonomously. This isn't a better tool. It's a new category entirely.
Starting from nothing but a terminal, it has been used to build a voice input app, a project manager, a Git visualizer, and a functional personal OS. It's not just using tools — it's building its own tools, its own interfaces, its own embodiments.
No other software in history has been able to architect and expand its own capabilities like this. It builds a sketch canvas, then uses the canvas to design the next feature. It builds a server manager, then uses the server manager to coordinate its own dev servers. The recursion is the point.
A blinking cursor in a terminal. That's the starting point. From there it has built desktop apps, interactive essays, real-time collaboration tools, and an entire operating system. That's not a tool. That's something fundamentally new.
The age of functional AGI is here.
Not in a research lab. In your terminal.
The question isn't whether the AI is ready.
It's whether your mental model is.
Design for intelligence. Build with it. Think with it.