Please structure the following information into a comprehensive guide for new users of Claude Code, emphasizing practical application and best practices. The guide should cover the following key areas, drawing directly from the provided text:

**I. Foundational Principles: Thinking Before Typing**
    *   Explain the critical importance of pre-computation and planning before interacting with Claude Code.
    *   Detail the "Plan Mode" (Shift + Tab twice) and its benefits.
    *   Provide actionable advice for users with limited software engineering experience to develop their thinking process, including learning and engaging in deep back-and-forth dialogues with LLMs for system design.
    *   Illustrate how this principle applies to various tasks (feature building, refactoring, debugging).
    *   Reinforce the consistent pattern: thinking first, then typing, yields superior results.

**II. CLAUDE.md: The Project's Onboarding Material**
    *   Define CLAUDE.md and its role in shaping Claude's project approach.
    *   Explain why it's crucial and how improper usage (too much, too little, or garbage) degrades performance.
    *   Provide specific, actionable guidelines for effective CLAUDE.md content:
        *   **Conciseness:** Adhere to instruction limits (mention system prompt usage).
        *   **Specificity:** Focus on project-specific details, not general knowledge.
        *   **Contextual "Why":** Emphasize providing reasons behind instructions for better implementation.
        *   **Constant Updates:** Explain the `#` key functionality and using it as a signal for updates.
    *   Contrast "bad" CLAUDE.md (documentation for new hires) with "good" CLAUDE.md (notes for amnesiac self).

**III. Navigating Context Window Limitations**
    *   Explain the concept of context window degradation, noting that quality diminishes well before 100% capacity (around 20-40% usage).
    *   Clarify that compaction (/compact) does not restore degraded quality.
    *   List and elaborate on strategies to manage context effectively:
        *   **Scoping Conversations:** One conversation per feature/task to prevent context bleed.
        *   **External Memory:** Utilizing files like SCRATCHPAD.md or plan.md for persistent context across sessions. Highlight top-level placement for hierarchical systems.
        *   **Copy-Paste Reset:** Describe the process of copying important information, compacting, clearing context, and pasting back critical elements.
        *   **Knowing When to Clear:** Advise on using `/clear` for off-track conversations or irrelevant accumulated context.
    *   Reinforce the mental model: Claude is stateless; treat every conversation as starting from scratch, dependent on explicit input.

**IV. The Paramountcy of Prompts**
    *   Assert that effective prompting is the most fundamental skill for AI code generation, often overlooked compared to learning frameworks.
    *   Define clear, specific prompting as superior to vague instructions.
    *   Provide concrete examples of effective prompting techniques:
        *   **Specificity:** Contrast broad requests ("build an auth system") with detailed ones ("Build email/password authentication using the existing User model, store sessions in Redis with 24-hour expiry, and add middleware that protects all routes under /api/protected").
        *   **Negative Constraints:** Instructing Claude on what *not* to do (e.g., avoid overengineering, unnecessary abstractions, excessive files). Emphasize cross-referencing outputs to prevent technical debt.
        *   **Contextual "Why":** Explain how providing reasons (e.g., "need this to be fast because it runs on every request") influences Claude's approach.
    *   Reiterate the core principle: "Bad Input == Bad Output." Blame prompting skills, not the model, for poor results.
    *   Identify key areas for improvement when consistently getting bad results: prompt writing, request structuring (breaking down tasks, agreeing on architecture), and context provision.

**V. Model Selection and Workflow Optimization**
    *   Differentiate between Claude models (Sonnet vs. Opus) based on speed, cost, and reasoning capabilities.
    *   Recommend a workflow: use Opus for planning/architecture, then Sonnet for implementation, noting potential API cost implications.
    *   Explain how CLAUDE.md ensures consistent constraints across model handoffs.

**VI. Exploring Advanced Features: MCP, Tools, and Configurations**
    *   Encourage experimentation with Claude's extensive features (MCP servers, Hooks, Custom slash commands, Settings.json, Skills, Plugins).
    *   **MCP (Model Context Protocol):** Explain its function for connecting to external services and the possibility of creating custom MCP servers.
    *   **Hooks:** Describe their use for automatic code execution before/after changes (e.g., Prettier, type checking) and their role in debt reduction and PR review security.
    *   **Custom Slash Commands:** Detail how to package repetitive prompts into commands for efficient execution of common tasks (debugging, reviewing, deploying).
    *   Advocate for utilizing all features, especially with higher-tier plans, and maintaining a mindset of re-testing due to rapid model improvements.

**VII. Strategies for When Claude Gets Stuck**
    *   Address common issues like looping or confidently incorrect implementations.
    *   Advise against simply pushing more instructions; instead, recommend changing the approach.
    *   Detail specific tactics:
        *   **Clear Conversation:** Use `/clear` to reset context.
        *   **Simplify Task:** Break down complex tasks into smaller, manageable pieces. Link this back to insufficient planning mode input.
        *   **Show, Don't Tell:** Provide minimal, clear examples of desired output.
        *   **Be Creative:** Reframe the problem from different angles.
    *   Emphasize recognizing loops early and the meta-skill of changing approach rather than persistent explanation.

**VIII. Building Systems with Claude Code**
    *   Shift focus from one-off tasks to building integrated systems.
    *   Highlight Claude Code's headless mode (`-p` flag) for scripting, piping output, and chaining with other tools.
    *   Provide examples of enterprise applications: automatic PR reviews, support ticket responses, logging, and documentation updates.
    *   Describe the "flywheel" effect: Claude mistakes -> log review -> CLAUDE.md/tooling improvement -> better Claude performance. Mention self-improving CLAUDE.md files.
    *   Stress that interactive use alone leaves value on the table; identify opportunities for automation.

**IX. TLDR: Key Takeaways**
    *   Condense the core principles into concise bullet points:
        *   Think before you type (planning > talking).
        *   CLAUDE.md is leverage (short, specific, why, update).
        *   Context degrades early (scope, external memory, reset, clear).
        *   Architecture is paramount (plan first).
        *   Input dictates output (prompting is key).
        *   Experiment with tools (MCP, hooks, commands; stay curious).
        *   Change approach when stuck (clear, simplify, show, reframe).
        *   Build systems, not one-shots (headless, automation, compounding improvements).
    *   Conclude by stating these principles determine whether one fights or flows with the tool when building with Claude.

**X. Call to Action**
    *   Include the provided URL for subscribing to the free weekly AI newsletter.

Ensure the tone remains practical, authoritative, and encouraging, reflecting the author's expertise and the goal of empowering beginners. Use clear headings and subheadings for readability.