Claude Code's Creator Has a Surprisingly Vanilla Setup

SUMMARY

Boris Cherny, Claude Code's creator at Anthropic, shares his surprisingly basic usage tips in a Threads post, analyzed in a video for practical adaptation amid token limits.

STATEMENTS

• Boris Cherny and his team at Anthropic use Claude Code with minimal customizations, running it straight out of the box despite its high customizability.
• They operate five Claude Code instances in parallel terminals, labeled for easy monitoring, alongside 5-10 web sessions and mobile app sessions.
• The team employs Opus 4.5 as their primary model for coding due to its superior steering and tool-use capabilities compared to alternatives like Sonnet.
• A shared Claude.md file is maintained via Git, updated frequently by the team to correct Claude's errors and enforce preferences like using Bun over NPM.
• Sessions typically begin in plan mode to refine strategies collaboratively before switching to auto-accept edit mode for efficient execution.
• Slash commands are utilized for repetitive workflows to avoid redundant prompting, and Claude can invoke them autonomously.
• Subagents are created for specific tasks like QA testing and research to manage context windows without bloating the main agent's session.
• Hooks monitor events such as tool usage or agent completion to ensure code formatting and other refinements.
• Permissions are pre-configured for safe bash commands to minimize interruptions, avoiding the risky "dangerously skip permissions" mode.
• For long-running tasks, verification mechanisms like background agents, stop hooks, or the Ralph Wigum plugin are used to enhance reliability.
• Feedback loops, including tools like browser extensions, enable Claude to self-verify work, dramatically improving output quality.

IDEAS

• Running multiple parallel sessions across terminals, web, and mobile maximizes productivity but demands unlimited tokens, highlighting access disparities.
• A team-shared Claude.md file evolves organically through collective error corrections, turning mistakes into institutional knowledge.
• Starting every coding session in plan mode ensures thorough planning before execution, preventing costly revisions later.
• Slash commands act as prompt shortcuts that even the AI can self-trigger, blurring lines between user and agent initiative.
• Subagents modularize workflows, isolating tasks to preserve main session efficiency, much like microservices in software architecture.
• Pre-approving permissions for known safe commands strikes a balance between autonomy and control, reducing prompt fatigue without full YOLO risk.
• Hooks provide subtle automation for polishing outputs, handling the "last 10%" that raw AI generation often misses.
• Integrating CLI tools like BigQuery directly bypasses the need for custom MCP servers, simplifying tool ecosystems.
• The Ralph Wigum plugin, born as a joke, enables infinite loops for persistent tasks, showcasing how whimsy can yield practical innovations.
• Feedback loops multiply output quality by 2-3 times, mimicking human developer iterations but accelerated by AI self-correction.
• Vanilla setups from experts reveal that advanced features like skills or MCP servers are often unnecessary for core effectiveness.
• Tagging Claude in GitHub PR comments to update shared rules demonstrates seamless integration of AI into collaborative dev processes.
• Usage engineering—optimizing for token limits—contrasts sharply with unlimited access, forcing creative constraints that spur efficiency.
• Coding with AI remains the top use case, with Claude Code inspiring a wave of agentic CLI tools despite competitors.
• Avoiding over-customization preserves tool simplicity, allowing focus on high-impact practices like planning and verification.

INSIGHTS

• True power in AI coding tools lies not in endless customization but in disciplined planning and modular delegation to subagents.
• Shared knowledge files like Claude.md transform individual errors into team-wide safeguards, fostering continuous AI improvement.
• Feedback mechanisms enable AI to emulate human debugging cycles, yielding exponentially better results through iterative self-assessment.
• Balancing permissions preemptively enhances workflow speed without sacrificing safety, turning potential chaos into controlled autonomy.
• Parallel sessions amplify throughput but underscore equity issues in AI access, where limits demand strategic token conservation.
• Vanilla configurations from creators highlight that simplicity often outperforms complexity, prioritizing core features like hooks and commands.

QUOTES

• "My setup might be surprisingly vanilla. Claude Code works right out of the box, so I don't customize it much."
• "A good plan is really important. 100% agree. I spend so much time in plan mode."
• "The most important thing to get great results out of Claude Code is give Claude a way to verify its work."
• "If it has a feedback loop, it will give it two to three times better quality for its final result."
• "Claude can now also use those slash commands on its own."

HABITS

• Running five parallel terminal sessions with numbered tabs and system notifications to monitor inputs efficiently.
• Starting all coding sessions in plan mode to collaboratively refine strategies before execution.
• Updating a shared Claude.md file weekly with team corrections during code reviews and PRs.
• Using slash commands daily for repetitive tasks like committing PRs to minimize prompting.
• Employing subagents for routine workflows such as QA testing to avoid bloating main context windows.

FACTS

• Coding and AI engineering is the number one AI use case, as per the OpenRouter State of AI paper.
• Anthropic recently acquired Bun, a faster alternative to NPM, which Claude Code is prompted to prioritize.
• Claude Code was created as a side project by Boris Cherny about a year before Cursor's rise.
• Opus 4.5 outperforms Sonnet in coding by requiring less steering and excelling at tool use.
• The Ralph Wigum plugin originated as a joke but is now officially integrated by Anthropic for long-running tasks.

REFERENCES

• iTerm2 terminal for Mac, used for tabbed multi-session management.
• Bun package manager, preferred over NPM for its technical superiority.
• Ralph Wigum plugin, enabling infinite loops for persistent agent tasks.

HOW TO APPLY

• Launch multiple Claude Code instances in parallel: Set up 5 terminal tabs numbered 1-5 using a tool like iTerm2, monitor via system notifications, and supplement with 5-10 web sessions plus mobile app starts for distributed processing.
• Maintain a shared knowledge file: Create a team Claude.md in Git, update it frequently with corrections from errors or PR tags, limiting length to under 200 lines and enforcing rules like using Bun over NPM.
• Initiate sessions with planning: Begin every task in plan mode, iterate back-and-forth on the strategy (optionally starting with a PRD and Q&A tool), then switch to auto-accept edit mode for one-shot execution.
• Implement slash commands and subagents: Define reusable prompts via slash for daily repeats like PR commits; create subagents with isolated contexts for tasks like QA or research, invoked by the main agent without overcomplicating.
• Configure hooks and permissions: Set post-tool hooks for auto-formatting code and event monitoring; pre-approve safe bash commands in permissions to skip prompts, using sandboxes for risky long tasks and stop hooks for verification.

ONE-SENTENCE TAKEAWAY

Embrace vanilla Claude Code setups with strong planning, feedback loops, and modular tools for superior coding efficiency.

RECOMMENDATIONS

• Prioritize plan mode for all sessions to build robust strategies, reducing errors and token waste.
• Build feedback loops via verification agents or browser extensions to boost output quality twofold.
• Use subagents sparingly for isolated tasks, preserving main session clarity without unnecessary bloat.
• Preconfigure permissions for safe commands, avoiding YOLO mode to maintain control and revert ease.
• Share and iterate on a concise Claude.md file team-wide, turning AI missteps into shared wisdom.

MEMO

In the fast-evolving world of AI-assisted coding, Boris Cherny, the engineer behind Anthropic's Claude Code, offers a refreshingly straightforward glimpse into his daily workflow. Far from the elaborate custom rigs often showcased by enthusiasts, Cherny's setup is "surprisingly vanilla," relying on the tool's out-of-the-box strengths. As the creator of this influential CLI agent—which has sparked a proliferation of similar tools like Codex and Gemini CLI—Cherny emphasizes simplicity amid hype. His recent Threads post, dissected in a detailed video analysis, reveals 13 practical tips honed by unlimited access at Anthropic, adapted here for users navigating token constraints.

Cherny's routine begins with parallelism: five terminal instances humming simultaneously, tabs neatly numbered in iTerm2 for quick oversight, complemented by web and iOS app sessions. This multi-front approach, while token-intensive, underscores a key tension—elite access versus everyday limits. For the average developer "usage engineering" their quotas, the lesson is selective scaling: perhaps one or two sessions to mimic the throughput without exhaustion. Cherny pairs this with Opus 4.5, lauding its minimal need for guidance and robust tool integration over rivals like Sonnet. His team collaborates via a Git-committed Claude.md file, a living document of dos and don'ts—prioritizing Bun over NPM, for instance—that evolves through collective tweaks during code reviews.

Planning emerges as Cherny's cornerstone habit, with every session launching in "plan mode" for iterative refinement before flipping to auto-execution. This deliberate upfront investment, often seeded with product requirement documents and targeted questions, yields cleaner outputs and fewer revisions. Slash commands streamline repeats, from PR commits to routine prompts, while subagents handle silos like quality assurance, keeping the primary context lean. Hooks quietly polish the edges—formatting code post-generation or flagging agent completions—ensuring that last 10% of perfection without manual fuss.

Yet Cherny shuns the allure of unchecked autonomy, forgoing "YOLO mode" in favor of pre-vetted permissions for safe commands, a nuance that curbs headaches from overzealous AI actions. Tools like BigQuery CLI fill gaps without bespoke servers, and for marathon tasks, he deploys verification via background agents or the whimsical Ralph Wigum plugin, now canonized by Anthropic for looped persistence. Above all, feedback loops reign supreme: granting Claude mechanisms to self-audit—be it browser control or log inspections—multiplies result quality by two to three times, echoing the reflective cycles of human coders.

This vanilla ethos challenges the customization frenzy surrounding Claude Code, where features like MCP servers and skills often steal the spotlight. Cherny's approach, light on such bells and whistles, proves that core practices—planning, modularity, verification—drive real gains. For developers token-bound, it advocates mindful adaptation: curate essentials, conserve resources, and let AI's inherent strengths shine. In an era where coding agents redefine productivity, Cherny's setup reminds us that less tinkering can unlock more ingenuity.