The art of minimalism: either I'm crazy, or this app is

I have an obsession, and I should say it upfront so you can judge everything after it: I believe AI should make software simpler. Not more impressive. Not more feature-packed. Simpler.

With ClarkCant I pushed that idea further than is probably reasonable. Minimal to the point of madness. Some days, using it, I catch myself thinking: either I'm crazy, or this app is crazy. In a good way, I hope.

This is an experiment. What follows are one-sided philosophies that live in my head, and I know it. Only the community can tell me whether they hold up. But I'll be honest with you: I have a lot of hope.

For a long time I was deeply into Japanese minimalism. I've been to Japan, I've worked with Japanese clients, and I have Japanese friends. What stayed with me isn't an aesthetic of empty rooms. It's the obsession itself. Love is not quite the right word for how I feel about it. Admire is closer.

I don't claim to understand that culture from the inside. I only know that once you've seen that kind of discipline up close, most software starts to look noisy. Every tab, toggle and badge on a screen is a decision somebody made, and now you're the one carrying it.

Here is my reading of it, and it's only mine. OpenAI's real achievement wasn't inventing AI. AI existed long before them. It wasn't even ChatGPT as a piece of technology. It was bringing the conversational experience to the whole world. You type, it answers. That's it. Annoyingly simple.

And now, in my opinion, they've walked into the very trap they once stepped around: complexity. Complicated as hell. ChatGPT absorbs Codex, then more surfaces show up, the things I've been calling Dots and Space, and the product starts to feel like a hotpot where everything gets thrown into the same pot. That's an observation from a user, not an insider's analysis.

I think they live a little in the future. They assume everyone understands what they understand. Real users don't think like that. Real users want to get one thing done and get back to their lives.

The promise was that everything would be one prompt away. Instead we learn something new every single day. Agents. Context engineering. Prompt engineering. Loops. Graph engineering. Skills. Hooks. Memory. A growing pile of weird techniques and jargon that, apparently, you need to master before the magic works.

I build this stuff for a living and even I feel tired. Something is wrong here, right? If the tool that was meant to remove the learning curve keeps adding a new one every week, we've lost the plot somewhere.

ClarkCant is built on that obsession. The north star in our DESIGN.md says the product must feel simpler than the system running underneath it, and that you only need to learn two things: one conversation, and one voice agent, which is the same Clark. Everything else (Pi sessions, Jev's routing, memory, nodes, the tool registry, workers, package generations, the policy engine) is infrastructure. It must not turn into a navigation model you have to learn.

The rule I keep coming back to sits in bold in that same file: don't make me think. Don't make the user understand the architecture to get work done.

Minimal doesn't mean starving, though. Our scope document puts it well: minimalism means reducing decision effort, not forcing every operation into words. A play button, a secure sign-in form, a date picker, a stop button are all fine. A session sidebar, a mandatory file tree and a permanent admin dashboard are not.

The trick is one line in the design doc: hidden is not the goal; summonable is. Nothing gets taken away. You can still sign in to providers, change the model, reopen old sessions. You just do it by asking, by voice, or with a slash command, and the answer comes back as a message in the conversation with a small interface inside it. Typing a command and saying the sentence end up as the same typed action.

A tiny example I like. The Orb, Clark's glowing signature, has a handful of styles. You can click the Plasma swatch in Settings, or you can just say switch the Orb to Plasma. Both are the same preference write, not two implementations. And Clark only tells you it's done once the Orb on your screen has actually re-read the choice and shows it. If that re-read fails, Clark says the choice is saved but not shown yet. That's the whole philosophy in one small feature: one action, many ways to reach it, and no pretending.

Honestly, the list of things ClarkCant doesn't have is the part I'm proudest of. No fixed sidebar for navigation. No session picker on the main screen. Widgets don't become a parallel dashboard. The header doesn't show a tool count, a node ID or engine internals. Settings isn't allowed to grow into an admin console.

Even inside Settings, a control only appears once the behaviour behind it exists. If a preference is declared but nothing reads it yet, it gets no switch, and we say why in the place you'd look for it. A switch that does nothing is a small lie.

The same thinking shapes approvals. By default Clark runs in Autonomous mode: you asked for the task, so it doesn't come back asking permission for every tool call. You can switch to Guarded, or Ask every time, whenever you like. The design doc is blunt here: security must not be used as a reason to add a duplicate confirmation after you've already said clearly what you want. What you get instead is visible activity, Stop, Undo where it's possible, and an audit log.

There are also things we refuse to fake, because simplicity built on small lies isn't simplicity. OAuth consent and OS permission dialogs still go through the platform's own screens. No button that looks usable but has no handler. No calling a cached number live. No claiming success just because a process stopped.

Even the inbox follows the rule. You can open it from the bell, or just ask Clark whether anything is waiting for you. Clark reads the same data the panel shows, and that question can't mark anything as read or approve anything behind your back.

Let me be straight with you. This might not work. Maybe people actually want the tabs and the dashboards, and I'm projecting my own taste onto everyone. Maybe power users will feel boxed in. Maybe a conversation-first app hits a wall I can't see yet.

But I keep thinking about how simple that first chat box felt, and how far we've drifted from it since. If AI is as capable as we all keep saying, the software around it should be getting quieter, not louder. ClarkCant is my attempt to test that, out loud. The community will give the real answer, and I'm genuinely curious what it is.