The First 30 Minutes with Claude Code: Why the Best Engineers Don’t Start by Writing Code
The First 30 Minutes with Claude Code: Why the Best Engineers Don’t Start by Writing Code
One of the biggest misconceptions about AI-assisted software development is that success comes from writing the perfect prompt.
It doesn’t.
During a recent workshop, Boris Cherny—the creator of Claude Code—shared a series of onboarding habits used internally at Anthropic. Surprisingly, almost none of them were about clever prompting. Instead, they focused on understanding the codebase, configuring the development environment, and giving the AI the context it needs to succeed. These recommendations closely align with Anthropic’s official Claude Code documentation and best practices.
The lesson is simple:
The quality of AI-generated software is determined far more by context than by prompts.
The Biggest Mistake New Users Make
Most developers install an AI coding assistant and immediately ask it to build a massive feature.
Something like:
“Build me this entire 3,000-line feature.”
Anthropic recommends the opposite.
Instead, spend time understanding the repository first.
Treat Claude like the senior engineer who just joined your team.
Ask questions.
Explore.
Learn.
Then build.
That simple shift dramatically improves both the quality of the implementation and your understanding of the system.
Anthropic’s Seven Practical Tips
1. Start with Codebase Q&A
Before changing a single line of code:
How does authentication work?
Where are API endpoints created?
What testing framework is used?
Why was this architecture chosen?
Claude Code is excellent at onboarding because it can answer repository-specific questions immediately.
The goal is understanding before implementation.
2. Learn How Claude Understands You
Prompting is less about magic words and more about learning how the model interprets requests.
Practice asking questions.
Experiment.
Notice where Claude needs additional context.
Over time you’ll naturally write clearer requests.
3. Teach Claude Your Company’s Tools
Claude becomes dramatically more valuable when connected to:
GitHub
Jira
Confluence
Figma
Internal APIs
Databases
MCP Servers
Instead of searching documentation manually, Claude can retrieve information directly from your enterprise systems using MCP integrations.
4. Match the Workflow to the Task
Not every task starts with coding.
Sometimes you need:
brainstorming
architecture
investigation
planning
implementation
iteration
Claude supports all of these workflows.
The best developers choose the workflow first.
5. Context Makes Claude Smarter
Every additional piece of useful context improves output.
Examples include:
architecture documents
coding standards
business rules
examples
test cases
design documents
Context consistently beats prompt engineering.
6. Curate That Context
Good teams deliberately organize information.
Decide:
what loads automatically
what stays personal
what is shared
what belongs in CLAUDE.md
what should live inside Skills
what should remain inside MCP servers
A well-organized repository produces consistently better AI results.
7. Check AI Configuration into Git
Anthropic recommends treating AI configuration exactly like source code.
Version control:
MCP configuration
permissions
slash commands
hooks
skills
Every engineer inherits the same AI environment.
That consistency reduces onboarding time dramatically.
According to Boris Cherny, this approach helped reduce onboarding from 2–3 weeks to roughly 2–3 days.
Anthropic’s Hidden Message
If you look carefully, these seven recommendations all point toward the same idea:
AI succeeds when the repository teaches the AI how your organization works.
The prompt becomes the smallest part of the system.
The repository becomes the operating manual.
How This Maps to Intent-Driven Engineering
Over the past year I’ve been developing and teaching an approach I call Intent-Driven Engineering.
What struck me while reviewing Anthropic’s guidance is how closely their recommendations align with an intent-first workflow.
The difference is that Intent-Driven Engineering extends the process one step further—capturing business intent before implementation begins.
Comparison
Anthropic Best Practice
Intent-Driven Engineering Extension
Start with repository Q&A
Explore the repository before spending implementation tokens
Learn effective prompting
Standardize requests with reusable Intent Files
Connect MCP servers
Enterprise Shared Services using approved MCP servers
Match workflow to task
Explore → Plan → Implement → Verify
Provide rich context
Feature.md + CLAUDE.md + architecture + standards
Curate repository context
Separate global, project, shared, and personal context
Version AI configuration
Treat AI configuration as enterprise infrastructure
(Not explicitly covered)
Capture business intent before any implementation begins
Don’t Spend Any Token Before It’s Time
One phrase has become central to my own thinking:
Don’t spend any token before it’s time.
Rather than jumping directly into implementation, successful AI-assisted development follows a disciplined progression:
Business Intent
↓
Repository Exploration
↓
Codebase Questions
↓
Architecture Understanding
↓
Intent File
↓
Planning
↓
Plan Review
↓
Implementation
↓
Verification
↓
Testing
↓
Pull Request
Each step reduces uncertainty.
Each step reduces wasted AI context.
Each step increases implementation quality.
The Real Competitive Advantage
Many organizations believe adopting AI means giving every developer access to a coding assistant.
Anthropic’s own practices suggest something different.
The organizations that move fastest aren’t the ones with the smartest prompts.
They’re the ones with:
well-structured repositories
reusable standards
MCP servers
shared skills
hooks
automated verification
consistent workflows
high-quality project context
The AI simply amplifies that foundation.
Final Thoughts
Anthropic’s onboarding philosophy reinforces a broader truth about enterprise AI development:
The future isn’t prompt engineering.
It’s context engineering.
It’s building repositories that teach AI how your organization works.
And when you combine that foundation with structured intent captured before implementation, AI-assisted development becomes not only faster—but repeatable, auditable, governed, and scalable across thousands of developers.
In other words:
Great software isn’t produced by better prompts. It’s produced by better context, better intent, and better operating models.
Comments