From Vibe Coding to Agentic Engineering — 5 Principles I Added to CLAUDE.md

Mar 17, 202610 min readTech

claude-code AI agentic-engineering workflow

“Vibe coding is slang.” That was Peter Steinberger, author of OpenClaw, on his three-hour Lex Fridman interview.

Vibe coding means throwing a prompt and praying. You read the output, decide it looks about right, and move on. Steinberger’s alternative — what he calls Agentic Engineering — is the opposite: deliberately steering AI agents through structured collaboration.

I use Claude Code every day. My workflow already combines CLAUDE.md, skills files, hooks, Plan mode, and subagents — and when I look at it honestly, it was already leaning toward agentic engineering. What it lacked was explicit, written principles.

After reading an extract of Steinberger’s principles, I ran a small experiment: take the most applicable ones and add them to my global CLAUDE.md the same day. This is the record of that experiment.

Five Principles I Added

1. Fix Forward — Never Revert

Steinberger doesn’t use git revert. His reason is precise: rolling back means discarding the understanding the agent built up while working. All the implicit knowledge the model accumulated about where the problem lives and why gets thrown away with it.

This matches my own experience. When Claude Code goes in the wrong direction, the right move isn’t git checkout . to wipe everything and start over. It’s “here’s what went wrong, here’s the direction to fix it.” Keeping the context alive means the agent’s next output is noticeably more accurate.

Rule I added to CLAUDE.md:

Fix forward: when something breaks, keep going — don't revert.
Rolling back means throwing away the context.

2. Discuss First, Build Second

Instead of opening with “implement this feature,” Steinberger first asks the agent to discuss the approach. His workflow has three beats:

Before building: “Let’s discuss. Give me options. Don’t write code yet.”
Building: “OK, build.” Then leave it alone for twenty minutes.
After building: “How would you do this differently?” “What’s worth refactoring?”

That third step matters most. The agent experienced the friction of building. Before that context disappears, you draw out what it learned.

This pairs naturally with Claude Code’s Plan mode. I’ve standardized a workflow: lock in the approach with Plan mode, let it build, then close with “what improvements did you notice during this session?“

3. Give Architecture Hints in One or Two Sentences

Every new session, the agent starts from zero. Handing it a 100,000-line codebase with “fix this bug” is like asking a new engineer to fix a bug with no onboarding.

The fix is straightforward. At the start of each task, describe the relevant files or module structure in one or two sentences.

"Auth bug. Supabase Auth integration lives in src/lib/auth/.
Session validation is in middleware.ts."

That alone cuts the time the agent spends exploring. Having a project structure summary in CLAUDE.md makes it even better.

4. Let the Agent Name Things

This was the most counterintuitive principle. Even when the name the agent chooses doesn’t match my preference, I accept it.

The reason: names that live in the model’s weights are names the model will find again the next time it searches or edits that code. When I override with my own preference, the agent’s ability to navigate its own output drops.

I still enforce project-level conventions — camelCase, PascalCase, and so on. But between fetchUserData and getUserData, I now let the agent decide.

5. Make the Agent Answer Its Own Questions

Steinberger’s “magic question”: ask the agent, “any questions?” When the list comes back, go through it and return any question the agent could answer by reading the code: “read it and answer.” Only what remains genuinely needs human judgment.

This also preserves context. Feeding the agent an answer directly fills context space with that information. Sending the agent to read the code lets it retrieve exactly what it needs.

What I Chose Not to Apply

Steinberger makes a strong case for CLI over MCP. His argument: MCP pollutes the context, while CLI tools are composable.

I only partially agree. In my setup, MCP servers for GA4 and Gmail are indispensable — replacing them with CLI scripts isn’t worth the cost. That said, I’ve felt firsthand how MCP output can bloat the context. The lesson I took isn’t “abandon MCP” — it’s that MCP server design matters: responses need to be scoped, not sprawling.

What Changed, Hours In

It’s only been a few hours since I applied these, but the principle with the most immediate payoff is Fix Forward. In situations where I would previously have run git checkout . and restarted, keeping the context alive and steering the agent toward the fix produces visibly sharper output the second time. The model’s understanding stays intact.

Letting go of naming was harder than I expected. The instinct to impose your own preference is strong. But in an agent collaboration, “my code” is the wrong frame. “Team code” is more productive.

Summary

The difference between Vibe Coding and Agentic Engineering is the difference between praying and designing.

CLAUDE.md, Plan mode, hooks, and subagents are instruments for structuring the collaboration with an agent. Steinberger’s principles give you a guide to using those instruments well.