Vibe Coding in Practice: Agent Programming Tips from Boris Cherny and the Open Source Community

"This is easily the biggest change to my basic coding workflow in ~2 decades of programming and it happened over the course of a few weeks." — Andrej Karpathy

In early 2026, AI programming agents underwent a qualitative leap in capability. From Andrej Karpathy's viral tweet to Boris Cherny's internal dogfooding threads at Anthropic, to the collective practices of the open-source community, a new programming paradigm is emerging — Vibe Coding.

This article synthesizes first-hand practitioner experiences into a directly actionable workflow.

What Is Vibe Coding?

Vibe Coding is not "programming without thinking." Its core principles are:

• Describe intent in natural language, let the AI agent handle implementation
• Shift from imperative to declarative: don't give steps, give success criteria
• Human-AI collaboration: humans steer direction, review, and verify; agents execute and iterate

Karpathy described his own transformation:

From 80% manual coding + 20% AI assistance, to 80% agent coding + 20% manual edits.

Boris Cherny, the creator of Claude Code, now works like this:

"Claude do blah blah /go"

Boris Cherny's 6 Core Tips

On April 16, 2026, Boris shared the following tips after dogfooding Opus 4.7 for several weeks:

1. Auto Mode — No More Babysitting

The Problem: When an agent runs long tasks, you're constantly approving permission prompts.

The Solution: Enable Auto Mode.

• Permission prompts are routed to a model-based classifier for safety assessment
• Safe commands → auto-approved
• Risky commands → pause and ask

The Effect: Run multiple Claude sessions in parallel — while one is "cooking," switch to the next.

How to Enable:

• CLI: Shift+Tab to cycle Ask → Plan → Auto
• Desktop/VS Code: Select from dropdown

Availability: Opus 4.7 for Max, Teams, and Enterprise users

2. /fewer-permission-prompts Skill

What it does: Scans session history to find safe commands that repeatedly trigger permission prompts, then recommends adding them to your allowlist.

Use case: When not using Auto Mode, reduce permission friction.

3. Recaps — Memory Anchors for Long Sessions

What it does: Short summaries of what the agent did and what's next.

Example:

* Cogitated for 6m 27s
* recap: Fixing the post-submit transcript shift bug.
  The styling-flash part is shipped as PR #29869.
  Next: I need a screen recording of the remaining
  horizontal rewrap on `cc -c` to target that separate cause.

When to use: Returning to a long-running session after minutes or hours — instantly understand the current state.

Disable: /config

4. Focus Mode — Results Only

What it does: Hides all intermediate work, showing only final results.

Prerequisite: Trust that the model will run the right commands and make the right edits.

Toggle: /focus

5. Effort Level — Intelligence on Demand

Opus 4.7 uses adaptive thinking; tune via effort levels:

Set: /effort

Note: max applies only to the current session; other levels persist across sessions.

6. Give Claude a Way to Verify Its Work

This is the key to "2-3x improvement." Verification varies by task:

Boris's /go Skill Pipeline:

Claude do blah blah /go

/go executes:
1. End-to-end self-test (bash / browser / computer use)
2. Run /simplify to clean up code
3. Submit a PR

For long-running tasks, verification is critical — when you return, you know the code works.

Karpathy's Insight: From Imperative to Declarative

Andrej Karpathy's January 2026 share contained several key insights:

1. Give Success Criteria, Not Execution Steps

Don't: "First create file A, then write function B, then call C..."

Do: "Implement feature X, passing these tests..."

LLMs excel at looping until criteria are met. Let them find the path.

2. Write Tests First, Implementation Second

TDD (Test-Driven Development) is even more important with agents:

• Give the agent tests to pass
• Let it write code that passes
• You review whether tests cover critical scenarios

3. Leverage Agent "Stamina"

"They never get tired, never get demoralized, just keep trying."

An agent can iterate on a problem for 30 minutes where a human would have given up. This is the "feel the AGI" moment.

4. Speedup vs. Capability Expansion

LLM assistance isn't just about doing the same work faster — it's about:

• Coding small tools that weren't worth the effort before
• Tackling code previously beyond your knowledge/skill level

Open Source Community Best Practices

1. CLAUDE.md / CODEX.md — Project Context Files

Place a markdown file in the repo root containing:

• Project architecture overview
• Coding standards
• Common pitfalls
• Testing strategy

The agent loads this automatically each session, reducing repetitive context.

Key Principles (from Karpathy):

• Think Before Coding: Make the agent think before acting
• Simplicity First: Avoid over-engineering
• Surgical Changes: Precise edits without collateral damage
• Goal-Driven Execution: Target outcomes, not steps

2. Plan Mode — Plan Before Executing

For complex tasks, have the agent:

1. Analyze requirements
2. List implementation steps
3. Identify risks
4. Confirm before executing

Boris noted: "Things get better in plan mode."

3. Skills System

Encapsulate repetitive workflows as reusable skills:

/epic      → Plan large features
/run-epic  → Execute planned phases
/go        → Test + simplify + PR
/simplify  → Code cleanup

4. Parallel Agent Workflows

Multiple agents handling different tasks simultaneously:

• Agent A: Implement feature
• Agent B: Write tests
• Agent C: Review code

Auto Mode makes this practical.

Common Pitfalls and Countermeasures

❌ Pitfall 1: Agent Over-Engineering

Agents love to implement in 1000 lines what could be 100.

Countermeasure: Actively ask for simplification. "Can this be done more simply?" — they usually can clean it up immediately.

❌ Pitfall 2: Unverified Assumptions

Agents make wrong assumptions and keep going without clarification.

Countermeasures:

• List common assumptions in CLAUDE.md
• Require the agent to pause and ask when uncertain
• Add confirmation steps at critical decision points

❌ Pitfall 3: Dead Code Accumulation

Agents often leave unused variables, functions, and imports behind.

Countermeasure: Periodically run /simplify or request "clean up all unused code."

❌ Pitfall 4: Modifying Unrelated Code

Agents sometimes change code unrelated to the task (comments, formatting, etc.).

Countermeasures:

• Explicitly request: "Only modify code directly related to the task"
• Use Focus Mode to watch the final diff

❌ Pitfall 5: Brain Atrophy

Over-reliance on agents can lead to:

• Abandoning your own design judgment
• Accepting the agent's default solutions
• Declining creative capacity

Countermeasures:

• Maintain control of design direction
• Actively challenge the agent's approach
• Regularly hand-write critical code to stay sharp

Recommended Workflow

Daily Development Flow

1. Launch Claude Code, load project context
2. Describe requirements in natural language (declarative)
3. Enter Plan Mode, let the agent analyze and list steps
4. Review the plan, confirm or adjust
5. Switch to Auto Mode, let the agent execute
6. Check progress with Recaps
7. Verify with /go (test + simplify + PR)
8. Human review of final diff

Long Task Management

1. Break large tasks into subtasks
2. One Claude session per subtask
3. Use Recaps to maintain context continuity
4. Save progress regularly (commit)
5. Use /focus to reduce information noise

Tool Selection Guide

Final Thoughts

Vibe Coding doesn't make programmers obsolete — it upgrades them from "typists" to "architects."

As Boris Cherny put it:

"Engineers are more important than ever — AI is transforming the profession, not replacing it."

The key shifts:

• From writing code → describing intent
• From execution steps → defining success criteria
• From solo coding → directing agent teams

In 2026, this workflow is moving from early adopters to mainstream engineers. Starting now is the right time.

References

1. Boris Cherny's Tips (2026-04-16) — Opus 4.7 dogfooding experience
2. Andrej Karpathy's Tweet Thread (2026-01-26) — "A few random notes from Claude coding"
3. Anthropic Postmortem (2026-04-23) — Claude Code quality incident analysis
4. Karpathy's CLAUDE.md — 100K+ Stars project context template
5. Open Source Community Skills — /epic, /go, /simplify workflows

This article is continuously updated. If you have practices to share, contributions are welcome.