An interface is the meeting point between a person and a machine. For Claude, it is everything you use to talk to the AI and see what it produces.

The simple definition

An interface is the part of a system that you can see and touch. A light switch is the interface to a lamp. A steering wheel and pedals are the interface to a car. The Claude interface is the set of screens, tools, and settings that let you send instructions to Claude, share files with it, watch it work, and receive its answers.

It helps to separate two things that are easy to mix up. Claude is the AI itself, a family of language models. The interface is the surface wrapped around those models. Two people can use the same model through two different interfaces and have quite different experiences, just as two people can drink the same coffee from a street cart or from a cafe and enjoy a different visit.

What the interface includes

The interface is more than a chat window. It covers where you type, how conversations are saved, how you attach files, how you choose a model, what extra abilities you switch on, how finished work is shown to you, and how safely actions are approved. In the more advanced surfaces, it also covers how Claude works on its own for a long time while you step away and come back to check the result.

Why the interface matters

A good interface turns a powerful AI into something you can actually use. It decides how easily you can show Claude your documents, how clearly you can see what it is doing, how much you can control, and how safe your data stays. When people say an AI “feels smart” or “feels clumsy”, they are often describing the interface as much as the model.

The Claude interface started as a simple chat and grew into a place where real work gets finished.

When AI assistants first appeared, the interface was almost nothing: a text box and a reply. Over time, people wanted more. They wanted to upload files, keep their work organized, let the AI use tools, and get results they could actually use, such as a finished document instead of a long chat message. The interface slowly grew to meet those needs.

The direction is clear. The interface keeps moving from “ask and read” toward “delegate and review”. You describe the goal, Claude does the work with tools, and you inspect and approve the result. This shift is the reason that understanding permissions, tools, and memory is now as important as knowing how to write a good question.

Claude can be reached through several surfaces. A surface is simply one way of using it, and each one suits a different kind of person and job.

Under every conversation there is a stack of layers, and each layer has a clear job.

It is easier to understand Claude if you picture it as layers stacked from the screen you touch down to the models that do the thinking. You do not need to know the engineering details. You only need to know what each layer does, because most surprises in AI behavior can be explained by one of them.

flowchart TB
  A["Interface layer: Claude app, Claude Code, add-ons, Console and API"] --> B["Context layer: your message, files, history, project, memory"]
  B --> C["Model layer: Haiku, Sonnet, or Opus"]
  C  D["Tools layer: web search, connected apps, browser, private workspace"]
  C --> E["Output layer: chat reply, file, or artifact"]
  E --> A
    

Read the diagram from the top. Your message enters through the interface. The context layer gathers everything Claude should know for this request. The model layer does the reading and reasoning. When the model needs to look something up or do something, it reaches into the tools layer and gets results back. Finally, the output layer delivers the answer to you as a reply, a file, or an artifact.

The chat window looks simple, but each part of it has a purpose worth understanding.

The heart of the main Claude app is the conversation, a running thread of messages between you and Claude. Everything in that thread becomes part of what Claude can see when it writes its next reply. That is why a conversation can build on itself, and also why a very long conversation can eventually run out of room.

Why the thread has a limit

Claude can only hold a certain amount of text in view at once. This limit is called the context window, and it is measured in tokens, which are small pieces of text. Your messages, Claude’s replies, and any attached files all take up space in it. When a conversation grows very long, older parts may be shortened or left out. If you notice Claude forgetting something from early on, a fresh conversation with a short summary is often the cleanest fix.

Writing a request that works

The message box rewards clear requests. A good request names the goal, describes who the result is for, mentions any limits such as length or tone, and says what form the answer should take. For example, “a half-page summary for a busy manager, in plain words” gives Claude far more to work with than the single word “summarize”. If the first answer is not quite right, you do not need to start again. Reply with what to change, such as “shorter” or “more formal”, and Claude will adjust the same piece of work. Short, specific follow-ups are usually faster than long rewrites of your original request.

Inside the interface, you can usually pick among a few model sizes, each with a different balance of speed and depth.

The Claude family has three main sizes. Haiku is the small and fast one, good for quick and simple work. Sonnet is the balanced all-rounder, strong enough for most everyday tasks. Opus is the largest, kept for hard problems where depth matters most. As of November 2026, the latest versions of all three are numbered 5.5. Above them, a newer Mythos class of models exists, but its most powerful members are not open to the general public.

In the Claude apps, the model in use can be changed in the middle of a conversation. That means you can start a brainstorm on a fast model and then switch to a stronger one when the thinking gets difficult. The conversation stays in place and the new model reads the earlier messages. A note of caution: an earlier reply may say something about which model wrote it or what that model knew, and that remains true of the model that wrote it, not necessarily of the one you are using now.

The interface lets you add abilities to Claude, much like adding apps to a phone.

Out of the box, Claude answers from what it learned during training. But the world changes, and your own information lives elsewhere. So the interface offers optional abilities that give Claude fresh knowledge or personal context. Which ones you see depends on your plan, your device, and your organization.

You stay in control

Switches such as web search and memory are meant to be your choice. You can use them when helpful and turn them off when you want a more private or more focused conversation. If you want Claude to stop using memory or past chats altogether, that is controlled in Settings, not by Claude itself. Claude can leave a topic alone for the rest of a chat if you ask, but the setting is what truly turns the feature off.

Not every answer belongs in a chat message. Some results are things you want to keep, edit, and share.

A short answer, such as an explanation or a quick opinion, is perfect in the chat. But a report, a slide deck, a spreadsheet, or a small interactive tool is different. You will read it more than once, change it, and probably send it to someone. For work like this, the interface can place the result in a separate space beside the conversation. This space holds what is called an artifact.

What artifacts can be

Depending on your account, artifacts can include documents, slide decks, spreadsheets, designs such as posters or app screens, whiteboards for diagrams and brainstorms, task lists, dashboards, and small web pages or calculators. Each kind opens in a suitable editor, so you can fix a heading or change a number yourself instead of asking Claude to redo everything.

Private first, shared by choice

A published artifact is a page with its own link. It starts out private, so only you can see it. If you want others to see it, you decide when to share. This design means that finished work is easy to keep and polish, while sharing stays a deliberate step. If a topic is sensitive, you can tell Claude to keep the result as a plain file instead of a shareable page.

Claude does not know you or your work until you show it. Projects and memory are the tools that carry that knowledge forward.

Projects: a shared workspace

A project is a named space that gathers related conversations, files, and instructions in one place. If you are writing a book, running a campaign, or studying for an exam, a project lets you store the reference material once and have Claude see it every time you chat inside that project. This saves you from pasting the same background into every new conversation.

Memory: lasting facts about you

Memory is a separate idea. It lets Claude keep a small set of lasting details between conversations, such as your role, your preferred style, or an ongoing project. It is meant to feel natural: Claude uses a remembered detail only when it truly improves the answer, and it does not announce that it is using memory. Memory is designed to avoid keeping highly sensitive information, such as government ID numbers or card numbers, and you can choose whether memory is on at all.

How projects and memory relate

Each project has its own memory setting. It can be connected, which lets chats in the project draw on your general memory and lets ordinary chats see the project’s memory. Or it can be kept separate, so the project’s memory stays inside the project and is not available anywhere else. This setting lives on the project’s own page, and it is useful when you want a clear wall between, say, a work project and personal chats.

Deciding what goes where

A useful rule of thumb is to match the tool to how long the information stays useful. Something needed only for today’s question belongs in the conversation. Reference material for a whole piece of work, such as a style guide or a set of research papers, belongs in a project. A lasting fact about how you like to work belongs in memory. Keeping these apart prevents clutter: your project stays tidy, your memory stays short and meaningful, and each conversation stays focused on its own task.

Three ideas let Claude reach beyond the chat window: connecting to your apps, adding bundles of abilities, and learning repeatable ways of working.

Connectors: plugging Claude into your apps

A connector links Claude to one of your own apps, such as a calendar, a document store, a project tracker, or email. Once connected, Claude can read information from that app and, with your permission, put results into it. Connectors are built on the open standard introduced in late 2024, which means many different apps can be connected in a consistent way.

Skills: packaged know-how

A skill is a folder of instructions that teaches Claude to do a certain kind of task well, such as building a spreadsheet, making a slide deck, or following your company’s way of writing a report. Skills are loaded when they are needed, so Claude can bring the right know-how to the right job. Teams can add their own skills, which makes good practice repeatable.

Plugins: bundles for a role

A plugin is a package that can bring together skills, commands, and connections for a particular kind of work, such as a sales process or a legal review. An organization can offer plugins that match the way its teams already work, so people start with a helper that already understands their routine.

Some work cannot be done by reading and writing alone. It needs clicking through websites and using apps, and the interface has doors for that too.

Many tasks live on websites: filling in a form, checking an order, comparing products, or reading a page that needs a sign-in. For these, Claude can act in a web browser. There are two main ways. Claude in Chrome is an extension that works inside your own Chrome browser, using the sign-ins you already have. The built-in browser is a pane inside the Claude desktop app. It is separate from your Chrome and has its own sign-ins. You can usually choose which one Claude prefers in your settings.

Computer use for desktop apps

Computer use lets Claude see and operate apps on your own computer, through the Claude desktop app. It works by taking screenshots and then clicking, typing, and scrolling, much as a person would. It is meant for ordinary desktop programs and for jobs that cross several apps. Websites are handled by the browser tools instead, because they are better suited to the job.

Permissions come first

Browsing tools are powerful, so they come with guardrails. Claude needs your approval to act on a site, it treats text it finds on web pages as information rather than as orders, and it asks before it does anything with real consequences, such as sending a message, publishing content, or making a purchase. Some things Claude leaves entirely for you to do yourself, such as typing passwords or payment details into a form, or solving a human-check puzzle.

Claude Code is a different kind of interface. Instead of a chat about code, it is a helper that works directly inside your project.

Writing software involves many small steps: reading files, making changes, running tests, and fixing what breaks. Claude Code is built to do those steps for you. It is an agentic tool, which means it can plan a job, take actions, look at the results, and carry on until the work is done. Engineers can use it from the terminal, and also on the web, on the desktop, and on mobile.

What makes it different from a chat

In a plain chat, you copy code in and out by hand. With Claude Code, the tool can read your project files, search through them, edit them, and run commands such as tests. That removes a lot of copying and lets it understand the whole project instead of one pasted snippet. Because it can change real files, it asks before taking risky steps, and you can decide how much it should ask.

Developers who want to build their own AI-powered products use the Claude API instead of the chat interface.

An API, short for application programming interface, is a way for one program to talk to another. With the Claude API, a developer’s program sends a request containing instructions and information, and Claude sends back a reply. The developer decides what the product looks like, and Claude supplies the intelligence behind it. The Claude Console is the website where developers manage their access and settings. Some cloud platforms, such as Amazon Bedrock and Google Cloud Vertex AI, also offer Claude to their customers.

What a developer controls

Unlike the Claude app, the API leaves almost everything to the developer. They choose the model, write the instructions, decide what to remember between requests, and design how answers appear to their users. This freedom is powerful, but it also means the developer takes on the work of managing context, cost, and safety.

Follow one request from your keyboard to the finished result, and you will see how every piece of the interface plays its part.

sequenceDiagram
  participant U as You
  participant I as Interface
  participant C as Claude model
  participant T as Tools
  U->>I: Send a message or a file
  I->>C: Message plus history, project, and memory
  C->>T: Ask to search, read, or run something
  T-->>C: Return the results
  C-->>I: Draft reply, file, or artifact
  I-->>U: Show the result and the progress
    

The picture shows a loop in the middle. Claude can ask a tool for help, receive the results, think again, and ask for something else, before it produces its draft. On a simple question this loop does not happen at all. On a long task, it may run many times, which is why bigger jobs take longer and use more of your allowance.

A few simple questions will usually tell you which door to use.

flowchart TD
  A["What do you need?"] --> B{"Is it a conversation or a quick task?"}
  B -->|Yes| C["Claude app on web, desktop, or mobile"]
  B -->|No| D{"Is it about code?"}
  D -->|Yes| E["Claude Code"]
  D -->|No| F{"Are you building a product?"}
  F -->|Yes| G["Claude Console and API"]
  F -->|No| H{"Is the work inside another app?"}
  H -->|Yes| I["Add-ons: Chrome, Microsoft 365, Google Workspace, Slack"]
  H -->|No| J["Claude app with connectors and finished-work outputs"]
    

The diagram starts with the shape of your task. Quick questions and conversations belong in the Claude app. Software work belongs in Claude Code. If you are making a product for other people, the API is the right door. If the work happens inside another tool, an add-on brings Claude to you. And for bigger jobs that need to produce documents or use your apps, the Claude app with connectors is the usual home.

The more Claude can do, the more important it is to know who is in charge. The answer is always you.

When Claude only chats, the risks are small. When Claude can read your files, browse the web, and act in your apps, the stakes rise. That is why the interface is built around a few simple principles: you give the instructions, everything else is treated as information, and anything with real-world consequences needs your approval.

flowchart TD
  A["Claude reads a page, file, or email"] --> B["It is treated as data, not as instructions"]
  B --> C{"Does the next step have side effects?"}
  C -->|No| D["Claude continues: reading, searching, drafting"]
  C -->|Yes| E["Claude asks you first: send, buy, publish, accept, delete"]
  E -->|You approve| F["Claude performs the action"]
  E -->|You decline| G["Claude stops and offers an alternative"]
  C -->|Sensitive: passwords or moving money| H["Claude leaves it for you to do yourself"]
    

The diagram shows three paths. Harmless steps, such as reading and drafting, can go ahead freely. Steps with side effects, such as sending a message or making a purchase, pause for your yes or no. The most sensitive steps, such as typing a password or moving money, are not done by Claude at all.

Shared responsibility

Security is a partnership. The interface provides guardrails, such as approval requests and private-by-default sharing, but it cannot read your mind. You decide which apps to connect, which files to share, and which approvals to grant. Organizations add another layer, because administrators can set company-wide rules about which capabilities are available. A healthy habit is to ask yourself three questions before approving anything: what exactly will happen, who could see it, and can it be undone? If you cannot answer all three, it is wise to pause and ask Claude to explain.

Everything you do with Claude uses some allowance. Knowing what uses it helps you plan your work and avoid surprises.

The main unit behind the scenes is the token, a small piece of text that Claude reads or writes. Your messages, attached files, Claude’s replies, and any tool results all count. Plans in the Claude apps have usage limits, and API customers pay by the token. The exact limits and prices depend on your plan and change over time, so check the help center and the pricing pages rather than relying on old numbers.

Keeping track of progress and results

For longer jobs, the interface shows a task list, so you can see what is done, what is in progress, and what is left. It is the main way a person who stepped away can catch up quickly. At the end, a good result comes with a short summary, the finished file, and a note of anything that needs your attention, such as a fact to double-check.

What teams and developers watch

Why some jobs take longer

A quick question is answered in seconds, but a large task can take much longer, and that is normal. Claude may need to read many pages, call several tools, build a file, and then check its own work. Each of those steps takes time and tokens. When you ask for a big piece of work, it helps to say clearly what you need first, so that the effort goes into the right result. If you only need a rough outline, say so, and Claude can finish far sooner than if it builds a polished final version.

Every powerful interface gives you something and asks for something in return.

Handing work to Claude

Memory, connectors, and context

A handful of habits will make every surface of Claude work better for you.

Habits that pay off

Mistakes to avoid

These typical situations show how different people combine the doors into Claude. They are illustrations, not claims about any one person or company.

Quick answers to the questions people ask most about the Claude interface.