🎛️ Claude Code Setup Cookbook

(Optimized for Multi-Phase SDLC + Token Economy + Shared Rules)

This cookbook is structured into logical operational blocks covering:

• IDE & Environment Setup
• Project Artefact Discipline
• Prompt and Model Configuration
• System-wide Rules & Guardrails
• Workflow Templates
• Token Efficiency Practices
• Monitoring, Validation & Testing

---

🧰 1. Environment Setup — Universal Foundations

🔹 Standard Project Structure
Enforce this on every project:

/src
/tests
/doc_internal
README.md
ARCHITECTURE.md
OPERATIONAL_RULES.md
.gitignore
CLAUDE.md
COPILOT_RULES.md

This separates internal reference from public code, reduces accidental context leaks, and keeps project config tidy. (YouTube)

🔹 Editor Integrations
Use Claude Code CLI inside terminal plus editor extensions:

• VS Code (via “Claude Code” or local LLM extensions)
• Cursor (with custom rules)
• JetBrains (IntelliJ/PyCharm)
• Dedicated shell workflow (CLI with aliases)

Tip: set up editor commands or macros that generate 2–3 boilerplate files when a project is created.

---

📁 2. Artefact Discipline — Canonicals You Always Create

Every new project must have:

🔸 .gitignore (your base template)

__pycache__/
*.pyc
.env
.venv/
dist/
build/
.eggs/
*.egg-info/

# Internal docs
doc_internal/
DOC_INTERNAL/
.clinerules
.coverage

🔸 doc_internal/ Rules

This folder contains non-public artefacts (which should not be re-sent to the LLM automatically unless explicitly needed):

• ARCHITECTURE.md — formal architecture document
• OPERATIONAL_RULES.md — specific coding rules
• CONTEXT.md — summaries intended for Claude
• HISTORY.md — timestamped log of prior sessions
• CLAUDE.md — Claude Code manifest & default rules

This structure avoids accidental repetition of full context in prompts, saving tokens over time. (YouTube)

---

📜 3. Model Selection & Prompt Modules

Claude Code (Opus 4.5+) supports model selection and prompt scaffolding. Use prompt modules — reusable sections — and use prompt caching where supported:

Model and effort are real settings.json keys (~/.claude/settings.json globally, .claude/settings.json per project); /model and /effort change them for the current session:

{
  "model": "opus",
  "effortLevel": "medium"
}

Reusable context is loaded by reference, not re-pasted. CLAUDE.md imports a file with an @ line, so the session summary in doc_internal/CONTEXT.md is read once per session:

@doc_internal/CONTEXT.md

Prompt caching needs no keys: the API caches the stable prefix of each request (the system prompt, CLAUDE.md and its imports, the rules) automatically. What you control is the cache lifetime, below.

Effort Levels

• Low — exploratory research (cheap, less reasoning)
• Medium — design reasoning + nuanced tasks
• High — full architectural work, agentic execution
• Extra-high (xhigh) — complex multi-file reasoning, deep architectural analysis (Opus 4.7+ only; other models fall back to high). Set with /effort xhigh or "effortLevel": "xhigh" in settings.

This lets you trade token cost vs reasoning depth. (Wikipedia)

Prompt Caching — Extended TTL

By default, Claude Code uses a 5-minute prompt cache TTL. For long multi-phase sessions (30+ minutes with the same context), enable the 1-hour TTL:

export ENABLE_PROMPT_CACHING_1H=1

Or persist in settings.json via "env": {"ENABLE_PROMPT_CACHING_1H": "1"}. The 5-minute default is fine for short tasks.

---

🧠 4. Universal Engineering Rules (Enforce Across Copilots)

These should live in OPERATIONAL_RULES.md and be enforced by Claude Code / your local Copilot workflows:

🔹 General Best Practices

1. Follow SOLID, Clean Architecture, Pragmatic Programmer principles.
2. Use linting and formatting (Prettier/ESLint for JS, Black/Flake8 for Python, Checkstyle/SonarLint for Java).
3. No hard-coded structured data (JSON/XML inside code). Use config files.
4. API design must be modular, testable, and versioned.
5. Every production feature must have automated tests (unit + integration).

These rules should be explicitly codified and referenced by your agent workflows. (YouTube)

🔹 CLI & Agent Safety Rules

In CLAUDE.md or agent config:

RULE: ask_before_execute
RULE: safety_sanitize_output
RULE: no_silent_code_changes

Meaning: never make silent changes; always request confirmation before edits, and sanitize outputs for security & compliance.

---

📦 5. Workflow Patterns (Consistent Across Sessions)

Planning phase — use Opus (or your highest-capability model) with high effort. This is where architectural mistakes happen, and they’re expensive to fix later. You want Claude to think deeply about component boundaries, data models, API contracts, and auth flows. The token cost during planning is tiny compared to the cost of rebuilding after a bad architectural decision.

Building phase — use Sonnet with medium effort for the bulk of implementation. Most implementation work (writing React components, API routes, Prisma models, tests) is well-defined once the plan exists. Sonnet handles this efficiently at lower cost and faster speed. Switch to Opus only when you hit something genuinely complex mid-build — a tricky state machine, a concurrency issue, a subtle security concern.

Quick tasks (renaming, formatting, simple config changes, generating boilerplate) — Haiku with low effort. Fast, cheap, good enough.

The principle is simple: pay for intelligence where mistakes are costly, use speed where the path is clear.

Below are repeatable workflows you can share across different Copilots and LLM models:

---

🛠️ A) Research & Planning Workflow

Start with:

@mode research
@model Opus 4.5
@effort medium

Then use a structured prompt template:

Task: Summarize current domain knowledge for PROJECT_X.
Input: document references, URLs, code repo path
Constraints:
- Return structured topics
- Produce taxonomy of concepts
- Output as JSON with sections: summary, key entities, risks, unknowns

Save the result into doc_internal/CONTEXT.md for reference — and avoid re-pasting long summaries. (YouTube)

---

🧾 B) Incremental System Design Workflow

Prompt skeleton:

Task: Generate draft architecture
Input: design goals + constraints
Output:
- 3 architectural options ranked
- tradeoffs
- risks & mitigation
- integration points

Store this as ARCHITECTURE.md. Use version tags (v0.1, v0.2) so Claude can reference instead of re-regenerating.

---

🧪 C) Code Generation/Execution Workflow

Switch to:

@mode execution
@model Opus 4.5
@effort high

Use a diff-only pattern:

Before:
<existing files>

Task: Make changes for feature X
Response format: diff (unified), tests added, summary

By only returning diffs, you avoid large code rewrites and reduce token costs.

---

💰 6. Token Efficiency Practices

📌 Prompt Caching — cache static headers like System Prompt and Global Rules so they aren’t re-sent each time.
📌 Chunk context manually — load only relevant parts rather than whole ARCHITECTURE.md. (YouTube)
📌 Compact context periodically — use built-in /compact or explicit summarization to reduce token window.
📌 Session per task — finish a task, flush the context before starting another to avoid uncontrolled growth. (YouTube)

---

🧪 7. Test & Validation Integration

Inject automated validation steps at key points:

Trigger: code_write
Follow-up: run linters + test suite
Output: failures + suggested fixes

Claude Code’s agent frameworks increasingly support test runs and integrations (even GitHub Actions). (YouTube)

---

📊 8. Versioning & Shared Rules

Together with CLAUDE.md, maintain:

• COPILOT_RULES.md — shared conventions for Copilots
• AGENT_MANIFEST.md — mappings of agent behaviors (refactorer, architect, reviewer)
• DEPLOY_PIPELINE.md — CI/CD rules (SonarQube, code coverage)

This lets you treat Copilot/Claude workflows like real engineering assets — checked in, versioned, audited.

Reflecting current research, “agentic coding manifests” like Claude.md files play the same role as traditional build pipelines, and having well-structured manifests is critical in real development workflows. (arXiv)

---

📈 9. Shared Config Templates (Cross-Copilot)

Here are reusable templates you can apply whether you’re using Claude Code, GitHub Copilot, Cursor, or local LLM workflows:

🔹 Error Patterns File

[ERROR_PATTERNS]
missing_input_validation
missing_tests
error_prone_regex
…

🔹 SAFE_GUARD.md

RULE: no silent code changes
RULE: require test coverage >= 80%
RULE: lint errors must be zero before merge

🔹 CODE_STYLE.yaml

indentation: spaces
line_length: 100
naming_conventions: camelCase /*adjust per language*/

All AI copilots can be coerced to follow these by embedding them into prompts once and caching.

---

🧠 Closing

What you want is not just better prompts, it’s a shared engineering contract — files, templates, rules, versioned artifacts, and workflows that all agents respect. This turns Claude Code / Copilot / Cursor / local LLMs into repeatable, programmable teammates rather than unpredictable assistants.

If you want, I can generate executable CLI templates (shell scripts) that initialize this entire repo structure and include pre-built templates oriented to your SDLC. Just let me know your preferred language ecosystem (Python + Node + Java?) and I’ll produce them.