From vibe coding to agentic engineering: the repo that summarizes everything
Mike Codeur
We moved from vibe coding to agentic engineering.
If you don't really see the difference between the two, this article is for you. And the video that goes with it too.
Right now, a repo just exploded on GitHub. First in trending. Publicly shared by Boris Cherny, the creator of Claude Code at Anthropic. It's called claude-code-best-practice and it's probably the most comprehensive recap of the new development paradigm we've been living for the last 6 months.
Vibe coding vs agentic engineering: what's the real difference
Vibe coding is that practice we all did at the start: you open Claude Code, you throw a prompt like "add me this feature", you wait, you accept the diff, and you pray it works in prod.
That's not a workflow. That's AI-assisted gambling.
Agentic engineering is the next step. You don't ask an agent to code anymore. You build a production system around one or several agents. You structure, you frame, you verify, you delegate.
This shift, many devs haven't seen yet. They still use Claude Code as a clever chatbot. The repo of the week shows you exactly what the new way of working looks like.
What's inside the repo
The repo gathers all the building blocks you find in real agentic workflows today. Not one angle, not one tool. The complete recap.
| Block | What it's for |
|---|---|
| Custom commands | Encapsulate your repetitive workflows in invocable commands |
| Skills | Give Claude specialized contextual competencies |
| Subagents | Delegate in parallel to multiple specialized agents |
| Hooks | Automate actions around Claude (pre/post commit, audit, etc.) |
| Rules | Frame an agent without limiting it, persistent rules per project |
| MCP | Connect your stack to Claude (DB, API, internal tools) |
| Cross-model workflow | Combine Claude Code + Codex on the right steps |
Each block has its role. And it's the assembly that makes the difference.
Commands and skills that structure your workflow
A dev who moves to agentic mode doesn't type the same prompt 50 times. They encapsulate it in a custom command.
Typical example: /ultraplan that forces Claude to produce a 4-phase testable implementation plan before coding. Or /ultrareview that runs a complete diff review by a dedicated agent.
Skills play a complementary role. A skill is contextual knowledge activated by keywords. You don't explain every time how your internal API works or your naming conventions: you write a skill once, and Claude activates it when the context calls for it.
Subagents: parallel delegation
The classic mistake is asking a single agent to do everything.
A clean workflow splits the work:
- one subagent exploring the repo
- one subagent coding the feature
- one subagent writing the tests
- one subagent reviewing everything
Each subagent runs in parallel in its own context. No pollution. No context explosion. Your main agent becomes an orchestrator.
Hooks and rules: framing without limiting
Hooks turn Claude into an integral part of your pipeline. Pre-commit to validate the diff, post-push to notify, audit before merge. Everything you did by hand enters the system.
Rules persist the architecture decisions you make. You no longer explain at every session that API routes must return typed JSON, that you use Drizzle ORM, that your components are RSC by default. It's in the rules once and for all.
MCP: connecting your stack to Claude
MCP (Model Context Protocol) is what transforms Claude from an isolated tool into an integrated agent.
You can connect it to your database, your internal API, Notion, GitHub, any tool that exposes an MCP server. And then, Claude no longer just generates code: it queries your real state, looks at your real data, calls your real services.
It's the difference between an assistant that guesses and an agent that knows.
Cross-model workflow: Claude + Codex
The part that changes the way of working the most is probably this one.
Claude Code is excellent at exploring a repo, understanding the architecture, proposing a plan. Codex can be very good at challenging that plan, reviewing coldly, finding the holes.
So instead of:
Claude, code me everything.
You switch to:
- Claude → research
- Claude → plan
- Codex → challenge the plan
- Claude → implement phase by phase
- Codex → review the diff
- You → ship
This loop completely changes the quality of the result. And it's not a fad: it's exactly what AI teams in companies are doing today.
The Research, Plan, Execute, Review, Ship method
When you group all this, you always find the same structure:
- Research - the agent explores and understands the terrain
- Plan - the agent proposes a plan before coding
- Execute - the agent implements phase by phase
- Review - a second agent challenges the diff
- Ship - you validate and deploy
This is what we see in every company trying to make AI truly productive in a dev team. Not "I launch a prompt and pray".
What it changes for you in 2026
If you still use Claude Code as a clever chatbot, you're falling behind without realizing it. The dev job doesn't disappear. It changes nature.
Your job in 2026 is no longer to write each line of code. It's to pilot the system that writes them. To define the agents, their roles, their guardrails, their orchestration. To make AI produce correctly.
The claude-code-best-practice repo is the best starting point I've seen to make this shift. Not a marketing course. Not an inspiring Twitter thread. A concrete, structured repo that shows how it's done.
To go further
I made a complete one-hour training on YouTube that dissects each building block of the repo, with demos and concrete workflows.
If you have to watch only one of my videos from the last 6 months, this is the one.
And if you want to keep following this kind of content every week, I publish The Agentic Dev, the newsletter that goes out every Tuesday on AI workflows for devs.