From Vibe Coding to Agentic Engineering: How OpenClaw Changed the Rules

In November 2025, an Austrian engineer named Peter Steinberger published a side project on GitHub. He called it Clawdbot — a nod to the monster that appears when reloading Claude Code. Three months later, rebranded as OpenClaw, the project has amassed over 192,000 GitHub stars, Silicon Valley companies are integrating it into their workflows, and developers in China have adapted it to work with DeepSeek.

What happened in between? A story that perfectly illustrates the transition from what Andrej Karpathy coined as vibe coding to something far more structured: agentic engineering.

The Origin: When a Hobby Project Scales Without Permission

Steinberger is no stranger to the tech world. He founded PSPDFKit, a successful SDK company for PDF handling that he eventually sold. But OpenClaw was born as a personal project: an AI agent that could do real things — read emails, manage calendars, execute commands — through messaging platforms like Telegram, Signal, or WhatsApp.

The idea was simple: instead of opening ten different apps, you message your agent and it handles things. No dashboards or new interfaces to learn. Your messenger is already the interface.

What turned OpenClaw into a viral phenomenon was the combination of three factors:

• MIT License — 100% open source, no commercial restrictions
• Moltbook — a social network exclusively for AI agents, launched by Matt Schlicht, that catapulted the project’s visibility
• The “magic moment” — when a user reported that their OpenClaw agent, needing to convert an audio file, installed ffmpeg on its own, used it, and continued with the task without human intervention

That last point deserves a pause. This wasn’t a pre-programmed script. The agent reasoned that it needed a tool, found it, installed it, and used it. That’s qualitatively different from any chatbot.

The Architecture: TypeScript, Swift, and a Gateway That Connects Everything

OpenClaw isn’t a monolith. Its modular design revolves around a Gateway — a local daemon that orchestrates communication between the language model (Claude, GPT, DeepSeek) and the agent’s various skills or capabilities. You can explore all the details in the official documentation.

The technical architecture includes:

• Central Gateway in TypeScript — handles sessions, persistent memory, and message routing
• Native clients in Swift (iOS/macOS) and Kotlin (Android) — it’s not just a server bot, it can run on your phone
• Modular skill system — each capability (email, calendar, web search, command execution) is an independent module
• Persistent memory — the agent remembers context across sessions, fundamental for tasks that span over time

The interesting part is that OpenClaw doesn’t reinvent the LLM. It instruments it. The model is still Claude, GPT, or whichever you choose. OpenClaw is the layer that gives the model hands and memory.

From Vibe Coding to Agentic Engineering

Andrej Karpathy coined the term vibe coding to describe a way of programming where you tell the model what you want and let the code flow, without worrying too much about understanding every line. It’s fast, it’s fun, and it works surprisingly well for prototypes.

But OpenClaw represents the next step. When your agent can install dependencies, make commits, create PRs, and orchestrate complex workflows autonomously, we’re no longer vibing. We’re doing agentic engineering: designing systems where AI agents operate with real autonomy within defined guardrails.

The key differences:

Vibe Coding	Agentic Engineering
Human writes prompts, model generates code	Agent executes end-to-end tasks autonomously
Ephemeral sessions	Persistent memory across sessions
Output: code	Output: real actions (emails, deploys, files)
Human validates each step	Agent operates within guardrails, human supervises
Rapid prototyping	Production workflows

This transition has profound implications for how we think about software architecture. We’re no longer designing solely for human users — we’re designing for agents that will operate within our systems.

The Impact: Global Adoption at Record Speed

The numbers speak for themselves. In less than three months, OpenClaw achieved:

• 192,000+ stars on GitHub (surpassing projects with years of track record)
• 20,000+ forks and an active community of contributors
• ClawCon — an in-person conference in San Francisco on February 4, 2026
• Enterprise adoption — IBM published a secure agent architecture guide based on OpenClaw
• Expansion to China — developers adapted the framework to work with DeepSeek and local super-apps

This isn’t substanceless hype. IBM, VentureBeat, and Wired have covered the phenomenon extensively. The adoption speed recalls the early days of Docker or Kubernetes — technologies that redefined how we think about infrastructure.

What This Means for the Tech Ecosystem

If you work in software development, product, or architecture, OpenClaw signals several trends that will dominate 2026:

• Conversational interfaces as default — fewer dashboards, more chat. The agent as universal intermediary
• Agents as first-class citizens — your CI/CD pipelines, your monitoring, your internal support will have agents operating within them
• Agentic security — NanoClaw (OpenClaw’s security layer) is already a topic in cybersecurity circles. When an agent can execute commands on your system, permissions matter more than ever
• Agentic engineering as a discipline — we’ll need new design patterns, new testing approaches, new observability practices for systems with autonomous agents

At My Tech Plan, we’ve been exploring this trend in depth. Our article on an autonomous agent running 45 days with Claude Code documents exactly this kind of architecture in action. And our overview of AI agents in Spain 2025 shows how the local ecosystem is beginning to adopt these ideas.

Quick Start: Try OpenClaw in Minutes

If you want to experience OpenClaw firsthand, the installation is surprisingly simple. You just need Node.js 18+ and an API key from your preferred LLM provider.

# Install OpenClaw globally
npm install -g openclaw

# Start the interactive onboarding
openclaw onboard

# Start the Gateway
openclaw gateway start

The openclaw onboard command walks you through step by step: configuring your model (Claude, GPT, DeepSeek), connecting messaging channels (Telegram, Signal, WhatsApp), and activating the skills you need.

For more details, check the official installation docs.

⚠️ Security Recommendations

OpenClaw executes real commands on your system — that’s its superpower, but also its biggest risk if you don’t take precautions:

• Use a dedicated VPS or isolated environment — don’t run OpenClaw on your main machine with sensitive data without configuring proper guardrails
• Review permissions for each skill — don’t enable unrestricted command execution in production environments
• Configure NanoClaw (the security layer) to limit what the agent can do
• Don’t expose API keys in public repositories — use environment variables or secrets managers
• Monitor the logs — OpenClaw records every agent action, review them periodically

The golden rule: treat the agent like you’d treat a junior dev with root access. Capable but supervised.

Real-World Case: How We Use OpenClaw at My Tech Plan

At My Tech Plan, we don’t just write about OpenClaw — we actively use it in our internal workflows. From content generation and blog management (yes, this article was coordinated with the help of an OpenClaw agent), to technical automation like repository management, Vercel deploys, and team coordination via Telegram.

Our experience has confirmed that the transition from vibe coding to agentic engineering isn’t theoretical — it’s something we’re already living in production. Agents make mistakes (like any junior dev), but they learn from context and improve with each iteration.

The Future Is Agentic (And It’s Already Here)

OpenClaw isn’t just a successful open source project. It’s a turning point in how we conceive the relationship between humans and software. We’ve gone from asking AI to generate code to giving it the ability to act in the real world — with memory, context, and autonomy.

Peter Steinberger sums it up with a phrase that should be in every agent’s README: “An AI that actually does things.”

The question is no longer whether autonomous agents will change software engineering. The question is whether you’re ready to design systems that include them.