The CLI Is the Interface: Why the IDE Debate Is About the Wrong Thing

I keep watching the same debate run through every developer community: which IDE is best? Cursor versus Windsurf versus Lovable. Which one has the better autocomplete, which one integrates more cleanly with Claude, which one feels right.

I’m not in that debate — and that’s not because I don’t have an opinion. It’s because the debate is about the wrong thing.

The IDE debate is the kind of conversation that happens when people have confused the apron for the kitchen. Cursor has better autocomplete. Windsurf feels smoother. Lovable is friendlier to non-developers. None of it matters if you’re still clicking through dashboards to do work that a terminal command handles in four seconds.

Everything I build runs from the command line. Claude Code lives in the terminal. The entire pipeline — client sites, ecommerce properties, domain intelligence, email deliverability, supplier stock feeds, payment diagnostics — lives in the terminal.

Visual Studio Code is open on the left monitor and it’s a viewer. The work happens on the right.

This isn’t a preference. It’s physics.

The Scaling Killer

With one client, using the dashboard is fine. You log into their Stripe, poke around, and it takes ten minutes.

Imagine you have a client whose payments keep failing at checkout. The card is declining on a specific product variant, and everything else is going through. You need to pull the payment intent, check the metadata, and confirm whether it’s a card issue or a product configuration issue.

So you open the Stripe dashboard and log in. The client then gets a security code sent to their phone, which means they have to be available to read it back while you type it in. There’s a ten-minute session window. The client is in a meeting, so you start again.

The dashboard is a beautiful lie. It has buttons, colours, a navigation menu that someone spent three weeks in Figma designing. It makes work look like work. What it doesn’t tell you is that it requires your client to be sitting by their phone at precisely the moment you need to diagnose their payment failure — which is almost never when they’re sitting by their phone.

The API key for the same client’s Stripe account is in the environment file. It authenticated once, six months ago, when I set up the integration. Since then it has never asked me to be available at the same time as the client. It has never expired mid-diagnosis. It has never needed a phone to be nearby.

Now multiply that by every client on the books. Multiply by Stripe, Brevo, Google Search Console, their hosting, and their domain registrar. Every platform that requires a browser login and a 2FA handshake is a dependency on the client being available, present, and not in a meeting.

That dependency compounds into hours every week — not dramatically, but insidiously. The five-minute job that takes twenty-five because someone’s phone is in their coat pocket.

The consultancy running twenty clients through browser dashboards isn’t just slower than the one using API keys in a terminal. It’s structurally slower. The friction is baked into the architecture.

The Accumulation Argument

Six months ago, “wire up the Namecheap API” would have been twenty minutes of clarification. Which endpoints? What auth method? What do you need it to do — availability checks, registration, DNS management, portfolio sync? Walk me through the use case.

On 10 March 2026, I typed one sentence and the Namecheap integration shipped — availability checking, domain registration, DNS record management, portfolio sync with the database. Full integration. One sentence.

Not because Claude Code got smarter overnight. Because 8 months of sessions, corrections, and commits built a substrate that already knew the conventions, the patterns, the way the codebase is organised, and what I reach for when I wire up a new API. The situated intelligence had context that no browser session could accumulate.

That same session saw OVO affiliate links wired into Energy Pages, the Beehive restock API integrated so that live supplier stock feeds directly into the product database, the Shopify CLI installed and the theme pulled for a client migration, and the domain database cleaned up.

Six pieces of infrastructure, no browser dashboards, no 2FA handshakes, one session.

The speed isn’t from skipping dashboards — though that helps. It’s from every session building on every previous session. The CLI is the interface because it’s the only interface that remembers.

The One-Time Cost

Some CLIs require a browser step to set up. Shopify CLI needs a one-time OAuth login before it can pull themes or push bulk updates, and that’s fine. The distinction that matters isn’t whether a browser is ever involved — it’s whether the friction is one-time or per-session.

One-time setup pays for itself on the first use. Per-session friction compounds into hours every week.

For one theme change, using the Shopify dashboard is fine. For a client migration — 130 redirects, bulk product updates, metafield rewrites, theme customisations — the API does in thirty minutes what the dashboard does across three afternoons. The one-time OAuth cost was eight minutes, four months ago, and it hasn’t been paid since.

The same principle applies to Brevo for email deliverability. When a client’s emails are landing in spam, you could log into the dashboard, navigate through three menus to find the sending logs, filter by date, export, and start reading.

Instead, I ran one command and got back the full sending history, bounce categories, and reputation scores. The authentication cost was a single afternoon when I built the email diagnostic tool, and every diagnosis since has taken thirty seconds.

DataForSEO replaced SEMrush the same way. Not because DataForSEO’s interface is better — it doesn’t have one. It’s pure API, which is the point. I wrote the wrapper once, and now keyword research, ranking data, and competitor analysis all run from the terminal, inside the same session context as everything else.

The SEMrush dashboard was a separate world I visited. The DataForSEO integration is part of the pipeline.

SEMrush will also, for an additional monthly fee, remove their branding from the reports you send to clients.

What the Terminal Knows

Visual Studio Code is excellent and I have it open all day. It shows me the file tree, the syntax highlighting, the diff view. When I want to read what exists, I read it there.

The terminal knows, because the terminal is where the work happened.

The tools that run there — Claude Code, the Django management commands, the API integrations — share the same session context and they compound on each other. The diagnosis from yesterday informs the fix today. The integration built last month handles the requirement that arrived this morning.

The Consultancy Comparison

There are two ways to run a consultancy at scale.

The first way is browser dashboards for everything. You log in, authenticate, work, and log out. Each client is a separate set of credentials, a separate 2FA dependency, a separate context to reload every time you need to do something. The knowledge lives in the consultant’s head, every new platform is a new dashboard to learn, and every diagnosis starts from scratch.

Some agencies have job titles for this — account coordinator, operations manager, and project manager. The role exists to log into things, read back codes, wait for dashboards to load, and open tickets when platforms misbehave.

The second way is API keys for everything that supports them. One-time setup, authenticated once, usable forever. Integrations that know the client’s context because they were built to know it. Every new integration is built once and used indefinitely.

The architecture I’ve built handles thirty clients with no team — not the hours worked, not the hustle, not some exceptional capacity for multitasking. The tools authenticate once and work every time.

The terminal compounds. The browser resets.

The consultancy that manages twenty clients through browser dashboards is structurally slower than the one using API keys in a terminal. Not a preference. Physics.

Read more about the system:

• Teaching Claude Code Taste
• The Atomic Commit: Why Your Git History Is Business Intelligence
• The Tier System: How I Stopped My Context File From Killing My AI’s Judgement
• The Split Brain: What Neuroscience Can Teach You About Running Two Different Reasoning Models
• Anyone Can Use AI. The Art Is Situating It.
• Ingeniculture: Why the Room Matters More Than the Model

If you want this kind of thinking applied to your business — here’s how I work with clients, or get in touch.