This is a submission for the OpenClaw Challenge.
I want to tell you about the moment I stopped understanding what software is.
It was a Tuesday evening. I was complaining into Telegram - half venting, half thinking out loud about how I kept losing track of articles I wanted to read later. I'd been dumping links into a notes file for months and never going back to them. "I wish something would just surface these for me based on what I'm working on," I typed, mostly to myself.
I didn't ask OpenClaw to do anything. I just said the thing. Twenty minutes later, while I was cooking, it sent me a message. It had built a skill. On its own. It had read my complaint, reasoned that what I needed was a periodic reading digest that cross-referenced my saved links against my recent Telegram conversations to infer context - and then it had written the skill, installed it, and scheduled it to run every morning at 8am.
I stood in my kitchen holding my phone, genuinely unsure what category of thing I had just witnessed. Because here's what it wasn't: it wasn't autocomplete. It wasn't a chatbot giving me a suggestion. It wasn't an API wrapper executing a predefined function. It was a system that heard a problem, reasoned about a solution, built the tool to implement that solution, and deployed it - without being asked.
I've been writing software for years. I know how much work that is when a human does it. That evening cracked something open in my thinking. And I haven't been able to look at software or how we build it - the same way since.
The Model We Were All Handed
If you've been in software for any amount of time, you inherited a mental model so deeply embedded you probably don't question it anymore. It goes like this: a problem exists, so someone builds an app for it. The app has a UI. The UI has menus, dashboards, settings, and buttons. You open it, navigate to the right screen, do the thing, close it, and open the next one.
We got very good at this. We built remarkable apps. Notion for notes. Linear for issues. Slack for messages. Zapier to connect the ones that don't talk to each other - which is most of them. Calendly so scheduling doesn't require six emails. Buffer to post what Notion drafted. Grammarly to fix what Buffer is about to send.
At peak "productivity," a developer today has roughly a dozen browser tabs open, eight active subscriptions, and spends a measurable chunk of their working day not doing work - but managing the infrastructure of doing work. We called this a stack. We optimised it. We wrote blog posts and YouTube videos and Twitter threads about it. I'm not sure any of us noticed the trap.
Three Things OpenClaw Showed Me
Running OpenClaw on Telegram over the past few weeks has been less like adopting a new tool and more like being handed a pair of glasses I didn't know I needed. Some things that used to be blurry are now very sharp.
1. Skills are the new apps
Every app you pay for is, at its core, a narrow capability wrapped in an interface. Todoist is "store and retrieve tasks with sorting logic." Buffer is "schedule content to post at a future time." Calendly is "find a mutually available slot and send a confirmation." These are not complex things. They are simple functions dressed in interfaces, priced monthly, and hosted on someone else's server.
OpenClaw skills are those capabilities, stripped of the wrapper. A skill is a Markdown file literally a (.md that describes a workflow, declares what tools it needs, and instructs the agent how to behave. No UI. No dashboard. No login. No vendor. When I needed something to pull my unread GitHub notifications and summarise them by priority every morning, I didn't evaluate three SaaS products or set up another Zapier flow. I described what I wanted in plain language. Within minutes, OpenClaw had the skill running. The "app" was created in the time it would have taken me to complete the onboarding of someone else's version.
The implication of this is uncomfortable to sit with: if a skill can replicate the core function of an app in minutes, then what we've been paying for was never the capability itself - it was the wrapper around the capability. The interface. The brand. The onboarding flow. The pricing page. OpenClaw removes the wrapper. What remains is just the thing itself.
2. Context is the new UI
Here's something that only becomes obvious once you've used a system with persistent memory: navigating a user interface is a workaround for the fact that the software doesn't know who you are.
Think about what you do every time you open a new app. You configure your preferences. You set your timezone. You explain your workflow through settings panels. You build up context slowly, through clicks and form fields - and then you do it again in the next app, and the one after that. The UI exists to compensate for the software's amnesia.
OpenClaw doesn't have amnesia. It knows I prefer concise summaries over verbose breakdowns because I told it once, weeks ago. It knows the difference between a Telegram message I need to act on now and one that can wait until tomorrow. It knows which projects are active, which deadlines are close, and what kind of interruptions I find useful versus annoying.
When I message it, I don't navigate anywhere. I don't select a module or click into a section. I just say what I need, in plain language, and it has all the context required to help me without asking me to repeat myself. I keep thinking about the enormous amount of design work that goes into navigation systems, information architecture, and onboarding flows. Work that exists entirely to bridge the gap between a user and a stateless system. What happens to that work when the system is no longer stateless? I don't have a comfortable answer.
3. The agent is quietly becoming the OS
This is the hardest shift to articulate, but I think it's the most significant. An operating system sits between you and a machine's raw capabilities, abstracting complexity into something usable. For decades, that abstraction has been graphical - files, folders, windows arranged spatially, because that's how human brains are wired to organise things.
OpenClaw doesn't organise things spatially. It organises them contextually. It knows which files are relevant to what I'm working on right now. It knows that when I say "the API project" I mean a specific repo with a specific set of concerns. It reads files, writes files, runs shell commands, manages my schedule, monitors my inbox - all the things an OS facilitates - but it does them in response to intent, not navigation.
I'm not claiming OpenClaw is an operating system in the technical sense. What I'm saying is that it increasingly feels like the layer I actually live in, and everything beneath it - the apps, the OS itself is starting to feel like infrastructure I don't directly touch. That Tuesday evening in my kitchen, when I watched it build itself a skill from a complaint, I glimpsed what this trajectory points toward: a computing experience where the distance between "I have a problem" and "the problem is handled" collapses almost entirely. Not because a better app was built for every problem, but because the act of building the app became instantaneous, automatic, and invisible.
The Part Nobody Wants to Say Out Loud
I want to be careful not to write the kind of AI piece that sounds embarrassing in two years. So let me say the uncomfortable parts plainly.
If skills replace apps, then a significant portion of SaaS is in deeper trouble than most people are admitting. Not because those products were built badly, but because their value was always more about the interface than the underlying capability. When capability becomes a Markdown file and the interface becomes a conversation, the monthly subscription loses its justification.
If context replaces UI, then some of what frontend developers and UX designers currently spend their careers on becomes less scarce not worthless, but worth less. The problems those disciplines were solving become less acute when the system already knows who you are. And if the agent becomes the ambient layer we operate through, then whoever controls the agent controls everything. Right now, OpenClaw is open source. Your context lives on your machine. Your skills are yours. But computing history is full of open things that became closed things once the economics got serious. I genuinely hope that doesn't happen here. I can't be certain it won't. These aren't arguments against what's happening. They're arguments for taking it seriously not as a productivity hack, but as a structural shift worth thinking carefully about.
What I Actually Believe
I've been learning to build software long enough to have developed a healthy scepticism of "this changes everything" claims. Most new tools change some things. A few change many things. Very rarely does something come along that makes you question the foundational assumptions underneath the tools themselves. OpenClaw does that for me not because of what it can do today, but because of what its existence reveals about what we've been doing all along.
We built apps as containers for capability because we had no better delivery mechanism. We built UIs as bridges to stateless machines because those machines couldn't remember us. We built Zapier and Make and n8n because our apps couldn't talk to each other. Every layer of complexity in the modern software stack turns out to be a solution to a problem that an agent with persistent memory and tool access simply doesn't have. The scaffolding wasn't the point. It was always a workaround.
And when OpenClaw quietly built itself a skill from a complaint I typed while thinking out loud when the distance between "I mentioned a problem" and "the problem was solved" was twenty minutes and required nothing from me - I understood that in a concrete, lived way for the first time. We were solving for the limitations of the tool, not for the actual problem. The actual problem was always just: I need this thing done. We might finally be close to solving that. Simply. Directly. Without a dashboard in sight.
I'm still figuring out what this means for how I build things. But I know I'm not going back to the old mental model. Once you see the scaffolding for what it is, you can't unsee it.
ClawCon Michigan
I couldn't make the trip to Michigan this year, but I'm thrilled to be joining the challenge remotely from Ghana! The energy around OpenClaw is amazing, and I can't wait to read the other submissions.
Top comments (2)
I'd love to hear from other developers on this: do you agree that context and memory will eventually replace traditional UI, or do you think graphical interfaces will always be the primary way we interact with software? Let me know your thoughts!