~12 minutes to read.

I use three versions of the same AI. The model and intelligence are the same, yet the products feel so different that choosing the interface matters more than choosing the model.

At one end, polished and opinionated software makes decisions legible and guides you through them. The learning curve is gentle because the designers have traded some flexibility for clarity. At the other, flexible software exposes the machinery and leaves the decisions to you. It is harder to learn because control has displaced clarity.

This is a philosophy axis rather than a quality ranking. Excellent software exists at both ends; the difference is what its designers assumed should matter.

Three versions of Claude

Claude Web sits at the polished end. Open a browser, type a question and get an answer. It has a beautiful interface, conversation history and an Artifacts panel for code and documents. Anyone can use it within 30 seconds.

In return, you cannot point it at your files, build workflows or chain sessions together. Each conversation starts from zero unless you paste the context yourself, and its memory is a black box you do not control.

Claude Cowork sits in the middle. It gives Claude access to a folder, so you can ask it to organise files or make a report from notes and watch it plan and execute the job. The GUI and hand-holding remain, along with Anthropic’s guardrails. Cowork decides what the plan and file structure look like, which is often useful but still a decision made for you.

Claude Code occupies the powerful end. It is a terminal prompt with no GUI, able to read and write any file on the system. You supply the context system, commands and workflows, so the ceiling is set by your imagination and willingness to configure it.

Nobody becomes productive in Claude Code within 30 seconds. You need to understand file systems and Markdown, perhaps some shell scripting, and I spent dozens of hours building my system before the return appeared. The underlying model is the same; the product changes where the decisions live.

The same choice appears everywhere

Apple makes the trackpad, window-management and file-system decisions, then hides much of the machinery behind a coherent interface. People love it until they need something Apple did not anticipate. Linux exposes everything and assumes you will work it out; the first week is miserable and the next decade can feel like liberation.

Notion gives you pleasant databases, toggles and templates, but your data stays on its servers, in its format and behind its API. An export produces Markdown files that do not quite work elsewhere. Plain text in a folder is uglier and has no toggles, though it works in every editor that has existed and every editor likely to follow. No .md file will send you a shutdown email.

Lightroom is obvious: the sliders make sense, the presets look good and Adobe’s ecosystem is integrated. darktable gives you a scene-referred pipeline, parametric masks and a module system that only begins to make sense after 40 hours, at which point it can make more sense than Lightroom ever did.

WordPress asks you to install it, choose a theme and write. Hugo asks you to learn Go templates, configure TOML and set up a build pipeline first. WordPress powers 40% of the web because it works; Hugo powers this blog because I wanted a 3ms page load and zero attack surface.

Calling this a beginner-to-expert scale misses the point. Experts often choose polished tools, while beginners can waste months inside powerful ones they should have avoided. The useful question is where the leverage sits.

Polished software optimises for what 80% of users want 80% of the time, making the common case effortless. Powerful software exposes primitives for the specific case, which matters when your work falls outside that 80% or the remaining 20% holds all of the value.

A professional photographer may prefer Lightroom because client management, rather than editing, is the bottleneck. A hobbyist may choose darktable because editing is the point and they want to understand every pixel. Skill does not choose the tool; the source of leverage does.

The interface changes the thought

Polished software carries a cost that is absent from the pricing page: your thinking adapts to its interface. Notion’s field types become the categories you think in. When Apple hides the terminal, shell scripts disappear from the space of obvious solutions. A chat interface makes every problem look like a conversation, including problems better solved by pointing an AI at a folder.

I noticed this after moving from Claude Web to Claude Code. On the web, I carefully crafted prompts and tried to fit complex tasks into one conversation. In Claude Code I began building persistent context files, modular commands and workflows spanning several sessions. The terminal did more than permit different actions; it changed how I thought about AI assistance. The web interface had been a ceiling I could not see.

Power has a bill

Configuration is work. Every hour spent on infrastructure is unavailable for the task itself, and I have put dozens of hours into context files, session management, custom commands and deployment scripts.

The decisions also return to you. Folder structures, file names and workflow design all become forks where you can be wrong. A polished product removes those forks, which is a feature rather than a limitation.

Maintenance compounds as well. Notion maintains its infrastructure; the plain-text system you built is yours to update and debug. Flexibility also enables the powerful-software user’s characteristic procrastination: optimising the note system instead of taking notes, building a deployment pipeline instead of dragging files to Squarespace, or configuring the terminal instead of writing code. The work feels productive because it often is, just not necessarily towards the thing that mattered. I know this trap and still walk into it.

Why polish trails the frontier

A polished interface necessarily arrives after the capability it presents. Design, user testing, edge-case handling and documentation take time, so the primitive exists before the UI around it.

Claude Code received tool use, extended thinking and multi-file editing as those capabilities shipped. Claude Web received them weeks or months later inside panels and toggles that needed to be designed and tested. Cowork launched with guardrails based on the use cases Anthropic understood at launch, before users had discovered the next set.

Linux can use new file systems, kernel features and hardware drivers when they are released; macOS supports them when Apple chooses to. Plain text can absorb a new tool or convention immediately, while Notion waits for a product and design team to ship it. The polished product interprets a capability through yesterday’s UI; the powerful one exposes the primitive and lets the user reinterpret it as soon as something new becomes possible.

At the frontier, support becomes binary. Cowork can organise files, but it cannot build a persistent context system that compounds across months of sessions because its view of AI use does not include a personal intelligence system on the local file system. Apple runs consumer applications beautifully but is not a platform for a self-hosted NAS with ZFS snapshots and encrypted Backblaze backups. These are design worldviews rather than missing checkboxes, and polish cannot compensate when the required capability is outside them.

The gap is widest where the work is new. Once a use case is understood, the polished tool catches up and its interface becomes an advantage. During rapid capability growth, as with AI now, the polished version from six months ago may lack entire paradigms that the exposed primitives have already made possible.

Which cost compounds?

Polished software can compound its cost in the wrong direction. Continued use makes its ceiling familiar and trains your thinking around the constraints, so switching later requires unlearning habits built over years.

Powerful software front-loads the expense. Setup is costly and the learning curve can be brutal, but a working system compounds positively as each customisation enables the next. My setup took dozens of hours; now sessions begin with rich context, state persists across weeks, and the AI knows my projects, preferences and priorities without another explanation. Claude Web’s architecture cannot provide that compounding.

The time horizon decides whether this matters. For a week, the polished version wins. Over years, the arithmetic changes.

I give core tools, which I expect to use daily for years, the powerful treatment: my text editor, notes, AI assistant and operating system. Peripheral tools such as my calendar, email client and photo backup stay polished because I need them to work more than I need to bend them.

Then I ask whether my use is in the common 80% or the valuable 20%, and how long I expect to keep the tool. A vanilla use case deserves the polished product. An unusual one will eventually fight its opinions. For daily use, the break-even point is usually around two to three months.

Most people should choose polished software because the investment in power is not justified by how they use the tool. I sometimes choose power for the worse reason that building systems feels like productivity. This spectrum is not a ladder to climb; it is a dial, and the honest setting depends on what the tool is for.