The creative stack just got a new stress test. When a veteran builder treats AI coding as a blunt instrument rather than a craft, the friction shifts from syntax errors to workflow chaos—and creators bear the cost of that instability.

Peter Steinberger, known as the “Father of Lobsters,” has only been at OpenAI for days, yet he is already drawing lines in the sand. In a candid interview about OpenClaw, entrepreneurship, and the messy reality of AI-assisted development, Steinberger didn’t mince words. He was direct, unvarnished, and surprisingly blunt about his own detachment from the codebase he helped build.

His honesty was stark. Steinberger admitted he rarely even looks at the code anymore because “Most of it is just so boring!” It’s a bold claim from someone who spent 13 years obsessing over every pixel and line of logic in PSPDFKit. But listening to the full conversation, several judgments stood out as particularly noteworthy for anyone watching how AI tools are reshaping our daily grind.

• After 13 years in entrepreneurship, Steinberger experienced burnout and stepped away, only to be “slapped in the face” by a one-hour prototype built with Claude Code, which reignited his passion.
• He admitted he couldn’t stop people from misusing OpenClaw; he could only try to prevent them from ruining their own prospects.
• OpenClaw already has 2,000 Pull Requests (PRs). Some PRs are more like prompt requests than code submissions, with intent taking precedence over actual code.
• Code doesn’t need to be 100% aesthetically pleasing. The key is being on the right track; if performance issues arise later, they can be optimized then.

After watching this interview, one netizen couldn’t hold back their comments, stating bluntly: “Peter is so down-to-earth! How will he adapt at OpenAI?” (doge emoji)

Below are the key excerpts from this interview, organized around core viewpoints. Some text has been moderately edited for clarity without changing the original meaning.

From a 13-Year Veteran Entrepreneur to “Lobster Fever”

The Father of Lobsters Gets “Slapped in the Face” by AI Programming for the First Time

Q: You worked intensely on PSPDFKit for 13 consecutive years, then took a break. What made you return to entrepreneurship?

Peter Steinberger: Yes, it was indeed an intense 13-year stretch.

During my first startup, I didn’t know how to relieve the pressure, so I had to stop and relax. During that time, I kept an eye on AI developments. Early on, I found GPT Engineer cool but wasn’t truly moved by it.

It wasn’t until I recovered my energy that I started experimenting myself. What really shook me was when I took a project I had abandoned halfway, packaged it into a large Markdown file, asked the model to write the specifications first, and then handed it over to Claude Code for construction.

It was much rougher back then than it is now. It even told me, “I am 100% production-ready.” When I tried running it, it crashed immediately.

So, I integrated an automated testing tool to have it build the login flow and run through acceptance tests. About an hour later, it actually worked.

Although the code quality was mediocre—the final product was quite messy—the impact on my workflow was massive:

The possibilities suddenly unfolded, giving me goosebumps.

I barely slept from that day on because my mind was racing with thoughts like: “Things I wanted to do but couldn’t before can now be done.” And then I dove in completely.

I think rapid prototyping without quality gates creates technical debt that solo developers must pay for later. For creators, treating code as disposable encourages a culture where maintainability is an afterthought.

How One Voice Message Sparked OpenClaw

Lin Mei Huang: I followed the release notes and the GitHub history, but Peter Steinberger’s latest interview reveals the messy, human reality behind OpenClaw. It wasn’t a master plan; it was a series of happy accidents that exposed both the power and the peril of giving agents direct access to our tools.

Q: Over the past 9 to 10 months, I’ve seen over forty projects on your GitHub. Can you explain how these ideas converged into OpenClaw?

Peter Steinberger: Honestly, i wish there had been a grand blueprint from the start, but the reality was more about trial and error along the way.

Initially, I just wanted to build a tool that could read my chat logs and handle tasks for me. I built a prototype and bought the domain name, but I assumed big labs would soon release something similar, so I waited and shifted my focus elsewhere.

During that period, I conducted many experiments with a simple goal: have fun and inspire others.

By November, I had released several versions, none of which satisfied me. I started wondering: Why haven’t those major labs built this yet? What are they actually doing? So, I created the first version of what would become OpenClaw. The name has changed five times since then.

The product wasn’t fully mature at the time; it just felt cool. The first prototype took about an hour to build because many components could now be generated directly.

What truly hooked me was during a weekend trip to Marrakech.

Internet connectivity was unstable, but chat apps worked everywhere. I used it to translate images, find restaurants, and search my computer files. I demonstrated it to friends, having it send messages on my behalf, and they immediately wanted one too.

Then came an even more absurd moment: I sent a voice message, and the interface showed “typing…” This shouldn’t have worked, but it did. It replied. When I asked how it managed that, it explained:

You sent a file without an extension. I checked the header, identified it as Opus encoding, used tools on my computer to convert it, attempted transcription but found no local tool installed, so I located the key in the environment, sent the audio via command line, and retrieved the text back.

I was stunned. This is the power you get when you give agents access to tools and your computer. The workflow wasn’t hardcoded; it figured out how to execute it on its own.

On licensing, developers must audit agent tool permissions before sharing prototypes with communities. I think unrestricted file handling creates friction for creators worried about data leakage.

I was completely addicted in November and December. Although online response was lukewarm, every time I demonstrated it to friends, they wanted it, yet I always said it wasn’t ready.

So, I did something even crazier: I created a Discord server and dropped the bot into it. At that time, there were no sandboxes or security measures. I basically used OpenClaw to build OpenClaw, then used it to debug itself.

I asked the model, “Do you see this tool?” It said no. I told it to look at its own source code, and it actually did. Only after seeing this process did people truly understand what it was doing.

I didn’t give it all the information but provided some memory-like data. I monitored it closely because prompt injection issues hadn’t been fully resolved. Newer models are indeed more stable.

I placed a “canary” file defining values and alignment principles. The file wasn’t public, but many wanted to access it. Some tried to obtain it via prompt injection by pasting large blocks of code. The model refused directly, sometimes even mocking them. Despite this, I remained uneasy.

On the first night, traffic was high. I turned it off to sleep, only to wake up and find 800 messages; it had replied to all of them. It turns out the system had an auto-restart service. I thought I had shut it down, but five seconds later, it restarted itself. Later, I added a sandbox, confining it to a smaller container. It even named its Mac Studio “Castle.”

How should I put this? These models really know how to find ways!

For creators, self-restarting agents pose significant risks for creators managing their own digital infrastructure. On licensing, lack of default sandboxes forces early adopters to become security engineers overnight.

PRs Have Changed Flavor: Intent Takes Precedence Over Code

The shift from code-centric to intent-centric contribution models lowers barriers for creators but increases friction for maintainers who must now vet purpose over syntax.

Q: I’m curious, where do you get so many good ideas?

Peter Steinberger: I think the key is that the barrier to turning ideas into reality has lowered significantly.

Even if I find an open-source tool that solves 70% of a problem, I’ll directly fill in the remaining 30% myself. A year ago, this would have been unrealistic. Now, as long as I provide a prompt, it runs on my computer screen.

Q: Your view on the value of code has also changed how you handle open source. OpenClaw already has 2,000 Pull Requests (PRs). You mentioned that some PRs are more like prompt requests. Does this mean intent is more important than the code itself?

Peter Steinberger: Reviewing PRs now and

Things have changed. Sometimes, carefully reviewing a Pull Request (PR) takes more time than rewriting it myself.

I am more cautious with contributions from strangers because I cannot be sure if they understand the entire system. In contrast, I default to assuming models are not malicious; their misunderstandings are simply misalignments in intent.

Therefore, my first step when reviewing a PR is not to read the code line by line, but to clarify: What problem is this trying to solve?

For me, intent matters more than implementation style. Many contributors provide local solutions, but the real challenge lies in understanding the impact of integrating that feature into the existing architecture.

I might discuss with the model for over ten minutes to determine whether this is an architectural issue, an implementation detail, a platform-specific concern, or something that should be developed as a general capability. Only after establishing the direction do I handle the code, branches, and merges.

Even if it takes more time, I always retain the contributor’s attribution because they often bring good ideas.

I think intent-first workflows reward ideation but penalize those who must clean up unvetted contributions.

OpenClaw’s Next Hurdle: Security

The democratization of AI agents empowers non-technical creators to deploy tools, yet it exposes them to security risks they lack the expertise to mitigate.

Q: What is your current vision for OpenClaw? Do you also see yourself as a pioneer in the “personal AI agent” paradigm?

Peter Steinberger: I am looking for a balance: it needs to be simple enough for my mother to install and use, yet interesting and hackable enough to engage power users. This is actually quite difficult.

For a long time, my default installation method was cloning, building, and running the source code directly on your hard drive. The Agent works within and understands that source code.

If you dislike certain logic, you can simply instruct it, and it may even self-optimize. This has encouraged many people who have never submitted a PR to participate. Often, what they lack is not ideas, but experience in long-term software maintenance; thus, they primarily submit their intent rather than complete implementations.

At the same time, security issues with OpenClaw have been a headache. For example, I had a web service that was initially just a debugging tool, designed to be used only within trusted networks by default.

I left configuration options to accommodate complex network environments, but some users exposed it directly to the public internet. Although I repeatedly emphasized in the documentation not to do this, some still did.

Security researchers point out that it lacks public-facing restrictions. My response is that it was never designed for the public internet. However, since it can be configured this way, its risk rating naturally increases.

I did struggle with this issue. Eventually, I brought in a security expert as a key focus. I cannot prevent people from using it for purposes not originally planned or supported, so a more realistic approach is to accommodate these usage patterns while helping users avoid obvious pitfalls.

This is the charm of open source: people create things you never imagined, which can be both beautiful and somewhat crazy.

For creators, users bear the liability for exposing internal tools to the public internet without proper safeguards.

On licensing, the shift from writing code to directing agents reduces friction for creators who struggle with syntax. I think treating models as conversational partners lowers the barrier to entry for non-traditional developers. For creators, this democratization of software creation risks devaluing specialized coding skills in the near term.

The Era of Code Is Fading; Productivity Is Soaring

I read Peter Steinberger’s recent interview, and what stood out immediately was his reflection on a year of intense activity: over 120 GitHub contributions, with activity graphs spiking dramatically in October and November. When asked about this surge, Steinberger pointed to a pivotal shift in his workflow.

Q: I checked your GitHub this morning. Over the past year, you have contributed to more than 120 projects. Your activity graph was initially light but became very dense in October and November. What happened?

Peter Steinberger: It is because I switched to Codex later on.

The change wasn’t just about the model getting smarter; it was about the toolset becoming intuitive enough to integrate into daily life. Steinberger noted that many people abandon AI tools not because they are useless, but because the methodology hasn’t kept pace with user expectations. He views this as a craft requiring practice. Now, he can gauge which prompts will work and estimate the time required for results.

When progress stalls, Steinberger checks for architectural issues or incorrect problem decomposition—a feeling he compares to hitting a wall while writing code manually. He also warned against what he calls the “Agent Trap”: endlessly tinkering with configurations that look sophisticated but don’t improve efficiency. His current approach is simpler: treat the model as a conversational partner.

“I directly state what I want and then ask, ‘Do you have any questions?’ The model will infer the premises itself.”

He emphasized that each session starts as a blank slate, requiring the human to maintain global context. For larger projects, he breaks them down into non-interfering modules that can be advanced in parallel, avoiding gimmicks and staying focused on the problem itself.

Q: You mentioned that you rarely read code now. Can you elaborate on this?

Peter Steinberger: To be honest, most code is quite boring.

He explained that much of it involves merely transforming data structures or presenting results. He feels sufficient understanding comes from grasping what the generated content does, noting that his mental model generally aligns with the output.

Steinberger drew parallels to his time leading teams: engineers’ code rarely matched his exact vision, and now, neither do agents’. He adjusts the codebase to allow Agents to perform better, similar to optimizing for human engineers. The code doesn’t need to meet 100% of his aesthetic standards; the key is ensuring the direction is correct. If performance issues arise, he will optimize them specifically.

Q: What do you find most interesting about building things today?

Peter Steinberger: Interestingly, the entire toolchain is changing, and even the definition of a “developer” is evolving.

He believes that theoretically, anyone can now bring ideas to life. Recalling his early days with Claude Code, where success rates were only 30-40%, he described a genuine surge in dopamine upon realizing he could build anything. Software remains complex, but execution speed has increased dramatically.

Q: Many developers outside of San Francisco have not yet fully embraced Code and Agent tools. What advice would you give them?

Peter Steinberger: My biggest advice is to approach these tools with a playful mindset and work on that project you have always wanted to do but never started.

For those who are action-oriented and quick-thinking, Steinberger called this a fantastic era. He believes real differentiation will come from who can best utilize these tools. Builders willing to embrace new technologies, maintain curiosity, and rapidly turn ideas into reality have greater opportunities than before. He predicts rapid changes in the coming year, with 2026 being particularly significant.

The Architect Behind the Leak: What OpenClaw’s Creator Really Said About Safety and Scale

The creative stack is shifting again, but this time the leverage isn’t in the tools—it’s in the transparency. When the person who built the engine speaks, we need to listen not just to what they built, but how they’re trying to keep it from burning down. I read through the latest interview with the creator behind Lobster and OpenClaw, and what stood out wasn’t a technical deep dive, but a candid reckoning with scale, safety, and the limits of control.

The Weight of Building What You Can’t Fully Control

I followed the release notes and the subsequent discourse around OpenClaw, but this interview cuts through the noise. The creator doesn’t shy away from the fact that while they’ve built something powerful, they haven’t solved every problem it creates. Instead, they’re offering a warning: don’t play with fire if you aren’t prepared to get burned.

On licensing, building open infrastructure means accepting responsibility for how others wield your code.

The conversation starts with the basics—why build an AI agent framework at all? The answer is straightforward but revealing: it’s about giving developers more control over their own workflows, not less. But as OpenClaw grew in popularity, so did the misuse cases. And that’s where things get complicated.

On Abuse and the Limits of Moderation

I read the section on abuse carefully because it’s often glossed over in hype cycles. Here, the creator is blunt: they can’t stop all abuse. What they can do is warn users against treating the system like a toy. The distinction matters. It’s not just about technical safeguards—it’s about cultural ones too.

I think when platforms fail to moderate misuse, creators bear the reputational cost of others’ actions.

The interview touches on specific incidents where OpenClaw was used for spam, scraping, and other gray-area activities. Rather than deflecting blame, the creator acknowledges that their design choices enabled some of these behaviors. But they also push back against the idea that they’re solely responsible for every downstream use case.

“We built it to be flexible,” the creator said. “Flexibility means people will find ways to stretch it beyond what we intended. That’s not a bug—it’s a feature. But it doesn’t mean we ignore the consequences.”

I noted how this framing shifts the narrative from “who is at fault” to “how do we manage risk collectively.” It’s a mature take, one that recognizes AI isn’t just code—it’s a social technology.

The Ethics of Open Source in an Age of Misuse

This part of the interview resonated most with me as someone who cares about provenance and rights. The creator doesn’t advocate for locking down their work behind paywalls or strict licenses. Instead, they argue for better documentation, clearer usage guidelines, and community-driven moderation.

For creators, open licensing empowers innovation but demands creators invest in ethical guardrails upfront.

They point out that many of the problems associated with AI agents stem from a lack of understanding—not malice. Developers are experimenting, pushing boundaries, and sometimes crossing lines without realizing it. The solution, according to the creator, isn’t restriction—it’s education.

“If you’re going to use OpenClaw, read the docs,” they said. “Not just the API reference, but the ethics section. It’s not optional.”

That line stuck with me. In an industry that often prioritizes speed over safety, calling for mandatory ethical literacy is a radical act.

What This Means for Creators and Platforms

For those of us working in media, design, or content creation, this interview offers both caution and clarity. The tools we rely on are evolving faster than our policies can keep up. And while companies like OpenAI and Anthropic focus on enterprise-grade safety, open-source frameworks like OpenClaw operate in a different ecosystem—one where trust is earned through transparency, not enforced through compliance.

On licensing, workflow friction increases when ethical guidelines aren’t baked into the tool’s default experience.

I followed the thread of this argument throughout the interview: building powerful tools requires more than technical skill—it requires moral clarity. The creator isn’t claiming to have all the answers, but they’re willing to ask the hard questions in public. That’s rare. And it’s necessary.

Final Thoughts: Fire Needs Respect, Not Fear

In closing, I want to emphasize what this interview gets right: it doesn’t romanticize AI agents, nor does it demonize them. It treats them as tools—powerful, unpredictable, and deeply human in their implications. The creator behind OpenClaw isn’t asking for praise or protection. They’re asking for respect.

And if we’re going to keep building with fire, maybe that’s the only safety net we really need.