12 Core Claude Code Patterns to Transform Vibe Coding into Agent Engineering

After repeatedly seeing Claude delete a branch, the author realized the core issue was the way the model was used: each session started from scratch with no structure, constraints, or reusable configuration, relying solely on prompts that were tweaked when problems arose.

1. CLAUDE.md May Hurt More Than Help

Most users treat CLAUDE.md as a massive configuration file, believing longer is better. The author’s file was ~500 lines, but Claude consistently ignored the latter part. Experiments showed that about 60 lines is optimal, with 200 lines as an absolute limit; beyond that, later rules are silently downgraded because Claude’s attention is limited.

The solution is not to delete rules but to make them appear only when relevant, using conditional blocks such as <important if="language=go"> which are visible to Claude only when processing Go files.

my-service/
├── CLAUDE.md          # root: generic rules (~30 lines)
├── api/
│   └── CLAUDE.md      # REST conventions, error codes
├── internal/
│   └── CLAUDE.md      # package naming, interface patterns
└── cmd/
    └── CLAUDE.md      # flag parsing, logger init

In internal/CLAUDE.md the author adds conditional rules:

<important if="language=go">
- Avoid bare goroutine; use errgroup or WaitGroup.
- Channels with capacity > 0 need inline comments.
- Context must be first parameter named <code>ctx</code>.
</important>

This keeps the total line count manageable and ensures each rule activates only when truly applicable.

2. Stop Treating Claude Code as a Chat Window

Instead of re‑declaring all rules in every prompt, the author configures Claude Code as an orchestration system using the .claude/ directory, which supports three configuration types: commands/: reusable workflow shortcuts stored as slash commands. agents/: dedicated sub‑agents with clearly limited tool permissions. skills/: knowledge modules that can be transplanted across projects.

For code review, the author created .claude/agents/reviewer.md with only Read permission, preventing any file modifications or shell execution. The agent’s physical inability to modify files makes the “read‑only” constraint enforceable without relying on prompt wording.

3. Treat Context as a Consumable Resource

Skills inherit the main agent’s context by default, which can bloat subsequent tasks. The author’s code‑quality analysis skill reads 40 files, causing later tasks to carry that heavy context, slowing responses.

Adding context: fork to the skill’s frontmatter runs it in an isolated sub‑agent; after execution the context is discarded, leaving only a clean summary for the main agent.

4. Hooks Run Outside Claude’s Main Reasoning Loop

The rarely configured hook points PreToolUse, PostToolUse, and Stop execute outside the token‑consuming reasoning cycle, so they add automation without interrupting tasks.

Auto‑format on write : a PostToolUse hook runs gofmt after every Go file write, removing the need to ask Claude to format.

Protected dangerous operations : a /careful mode activates a PreToolUse hook that intercepts irreversible actions (file deletion, force pushes) and requires explicit confirmation.

Completion verification : described in pattern 11, a Stop hook can trigger test suites to ensure a task truly finished.

5. Reduce Permission Prompts by 84%

Claude Code’s default behavior asks for approval before each shell command. Using /sandbox runs commands in an isolated environment with limited system access, dramatically lowering the approval threshold and cutting permission prompts by 84% while keeping safety for typical coding tasks.

6. Run Multiple Claudes Simultaneously

Boris Cherny describes launching Claude with claude -w inside a Git worktree, then using tmux panes to run dozens of independent Claude instances, each with its own context, branch, and task. This parallelism turns a single‑threaded “vibe coding” workflow into a true multi‑agent engineering process.

7. ultrathink Is Not a Gimmick

Inserting the keyword ultrathink anywhere in a task description triggers a higher‑investment reasoning mode without changing configuration or model. The author used it to design a service‑splitting plan, uncovering two constraints (cross‑service transaction boundaries and monitoring rollout cost) that the normal mode missed.

8. Local Automation That CI Can’t Achieve

A loop command such as /loop 30m /code-review runs a code‑review workflow every 30 minutes (up to 1 hour interval, lasting up to 3 days). Unlike CI/CD, which only sees post‑merge diffs, this loop observes the live development state, automatically drafting PR summaries and marking issues even when the developer is away.

9. Ask Questions Without Interrupting Tasks

During a long refactor, the /btw command queues a side question, allowing Claude to continue the current task and address the query at a natural pause, avoiding costly context loss.

10. Make Skills Worth Writing

Core contributor Thariq advises that the highest signal‑to‑noise part of any skill is the “Gotchas” section, which records real‑world failure modes rather than generic usage examples. Updating Gotchas after each failure turns them into preventive measures.

11. Ensure “Complete” Really Means Complete

Claude may claim a task is finished, but the author found missing error handling in generated code. Connecting a Stop hook to a verification script that runs tests, checks file existence, and validates API responses forces Claude to fix issues before signalling completion.

12. A Flag That Makes the SDK Ten Times Faster

When using the Agent SDK programmatically, adding the --bare flag skips the initial context discovery (locating CLAUDE.md, loading config, checking environment). This reduces startup time up to tenfold. In a daily analysis pipeline of ~300 files, runtime dropped from ~40 minutes to 18 minutes.

Common Thread of the 12 Patterns

After reviewing all 69 tips, the author concludes that the gap between “vibe coding” and “agent engineering” is not new tools but a different way of using the same tools. Vibe coding is passive, relying on prompt wording; agent engineering moves constraints into configuration files, enforces hard permissions, automates context cleanup, and yields stability that prompt engineering cannot achieve.

All the capabilities—agents, skills, hooks, worktrees, loops—are built into Claude Code and are simply under‑used.

The repository shanraisshan/claude-code-best-practice remains actively maintained and is worth reading from start to finish.