Beginner Experience with Vibe Coding - Claude Code on Desktop

Last December, while experimenting with Vibe Coding, I chose to use Claude Code on desktop and started by testing it on an old project. During my Vibe Coding practice, I didn't intervene much because I wanted to see what it was truly capable of. Furthermore, I only knew about Claude's 5-hour reset limit; I didn't realize there was a hidden Weekly Active Compute Hours limit (Anthropic mentioned in an August 2025 notice that Pro users have approximately 40-80 hours of Sonnet 4 compute per week). Because Vibe Coding consumes tokens much faster than expected, I not only ran out of my quota early, but because the weekly quota is calculated on a "7-day rolling" basis, I was locked out for several days. Combined with a temporary pause in my subscription to evaluate GitHub Copilot, this test was never actually completed.

Since I am currently unable to access the system to take screenshots, this article serves as a text-based record of that experience.

What is Claude Code on Desktop?

In the November 25, 2025 update, Claude Desktop added a Code tab, an interface that allows you to run Claude Code directly within the desktop application. Users don't need to open a terminal; they simply click the tab, install the dependencies, and can start using it immediately.

Operation Mechanism

After using it, I found its isolation logic quite unique. When a repository is selected, it does not modify the original files directly. Instead, it creates a folder with the same name as the project under the .claude-worktrees directory in the user's folder. It then generates a subfolder with a random name (containing a complete copy of the project) and creates a Git branch with a random name inside it.

All modifications occur within this isolated environment and branch. This design ensures the safety of the original project and enables the possibility of handling multiple tasks in parallel (each session corresponds to a different isolated environment).

Practical Experience

The Massive Difference in Context Understanding

When using AI assistance (like ChatGPT) in the early days, I was often limited by the input caps of the UI. Although long-text and file uploads were supported later, the precision still differs significantly from the context gained by Vibe Coding's direct reading of the entire project.

In the past, because I was lazy to code, I would often write out the logic and expected steps for Claude, ask it to generate the code, and then make adjustments. However, I frequently encountered output length limits that caused the code to be truncated. When I asked it to "continue generating," the subsequent code sometimes wouldn't connect properly (this was especially severe in early ChatGPT). When the logic I wanted to implement was too large, it was easy to spend a lot of time organizing the code because the details from multiple outputs wouldn't align.

In Vibe Coding mode, the AI can fully understand the project structure, and the generated code no longer suffers from truncation issues. This is the biggest difference in experience compared to traditional conversational AI.

Highly Rewarding Emotional Value

I have to say, Vibe Coding feels great to use. It's like an emotionally stable senior colleague with whom you can discuss things and who can help handle more tedious tasks. When I asked it to optimize code, it not only complied but also provided detailed explanations. At one point, when I wasted some quota and asked, "Am I asking for too much?", it replied: "This is what good engineering quality is all about." It provided plenty of emotional value.

Issues and Pitfalls Encountered

1. Conversation Sessions Cannot Be Resumed

This was the most serious problem I encountered. When there is no activity for too long, a 401 Unauthorized error appears when entering a message, meaning once the connection is lost, the old session is gone forever. Even worse, if you start a new session, it forces the creation of a brand new random isolated environment in .claude-worktrees. This prevented me from continuing my original work progress, resetting all context to zero, which I found to be the most frustrating point.

TIP

Regarding this issue, I later discovered an unofficial workaround. See: Solving the issue where Claude Code on desktop cannot resume conversation sessions

2. Logical Contradictions in Context Understanding

I have my own preferences for Commit Messages and Coding Style, so I wrote relevant documentation and asked it to read them, but the process did not go smoothly.

First, when a session was disconnected and reconnected, it often forgot the previous settings. I once asked if I needed to reference other Markdown files in CLAUDE.md, and it confidently told me, "No, I will read all Markdown files when loading." However, tests showed it didn't read them at all. When I questioned it, it changed its story, saying, "I only read CLAUDE.md when loading, but I read the Commit specification files only when writing commits."

Regardless of whether its mechanism is "read on load" or "read when writing commits," since the commits it eventually produced did not comply with the specifications, it meant both statements were hallucinations at the time. In the end, I had to obediently write the specifications explicitly into CLAUDE.md for it to finally listen.

The placement of specification files also sparked another thought. I originally preferred to manage specifications in a "modular" way—placing rule files in specific project directories and referencing them via links in CLAUDE.md to keep the configuration file concise, avoid overlap with README.md, and prevent inconsistency caused by every project having its own separate specifications.

However, after discussing this with Gemini, I learned that such AI editors (like GitHub Copilot) usually only default to reading specific configuration files (like CLAUDE.md or .github/copilot-instructions.md). The "links" inside are just plain text paths to the AI and do not automatically read the content of those files into the context.

Therefore, the strategy must be adjusted. While building a "central specification library" as the single source of truth is still necessary, the application method has shifted from "referencing files" to "direct insertion": when starting a new project, I select appropriate modules (e.g., Git specs, Vue specs) from the central library and "copy-paste" the content directly into the CLAUDE.md file itself. Although this sacrifices conciseness, it ensures the AI reads the specifications 100% while maintaining consistency across projects.

Best Practices for CLAUDE.md Configuration

According to the Determine memory type documentation, it is recommended to manage context in layers:

• Global Settings: ~/.claude/CLAUDE.md. All sessions on the computer will read this setting.
• Project Settings: CLAUDE.md or .claude/CLAUDE.md (recommended) in the project root. This is the primary setting for the project; it is recommended to store it in a .claude folder to keep the root directory clean.
• Modular Rules: .claude/rules/*.md. The "modular" management mentioned earlier, splitting different specifications (e.g., git.md, vue.md) so Claude can read them as needed.
• Local Override: ./CLAUDE.local.md. Project-specific local rules; be sure to include it in .gitignore to avoid accidental commits.

Additionally, according to Claude Code: Best practices for agentic coding, we can define rules specific to certain subdirectories (e.g., backend/CLAUDE.md). Claude Code has an intelligent reading mechanism; when the agent interacts with files in that directory, it will automatically read and apply these local contexts, achieving more precise specification control.

3. Hallucinations and Incorrect Information

In addition to the file-reading mechanism mentioned above, it also hallucinates when providing suggestions. For example, when I asked where to put the specification files, it suggested putting them in the .github folder. But as everyone knows, .github is usually for GitHub Actions or Issue Templates, not a standard place for documentation. This shows that developers still need to exercise judgment when relying on AI suggestions.

4. Clumsiness and Conflicts in Git Operations

When performing Git operations, Claude Code sometimes appears "too clever for its own good":

• Taking the long way around and hindering progress: For tasks that could be easily solved with git rebase -i, it might take a roundabout way using other methods. When the result isn't as expected, it automatically reverts and tries other methods. While the spirit is commendable, this mechanism doesn't always succeed and sometimes makes the Git graph even messier.
• The Pitfall of the Snapshot Mechanism: This is a common issue with all AI editors. It takes snapshots of files. If you manually intervene after it fails (e.g., manually resolving a Git conflict), it might ignore your changes and overwrite them with its old snapshot.

WARNING

If you want it to perform Git operations, it is safer to provide the Commit Hash directly rather than vaguely describing "modify that commit."

5. Performance Lag

When operating the Desktop version, there is noticeable lag in the interface. Sometimes, because there was no response, I accidentally pressed Enter multiple times, resulting in it sending multiple messages. Since it outputs a large amount of text every time a message is sent, it's easy to miss this. This not only causes operational chaos but can also lead to unnecessary quota consumption.

Conclusion

Although the experience was forced to end due to quota issues, and there is still much room for improvement in Git operations and session management, this experience truly showed me the potential for a shift in development models.

AI tools are evolving extremely fast. Early on, Vibe Coding was just a vague concept; before you know it, it has gradually matured. Of course, I don't think all work is suitable for Claude Code. While I still believe Claude is the most suitable model for coding at this stage, every tool has its best use case, and the future development model should be "Multi-Model collaboration."

For example, if applied to Claude Code, the division of labor might look like this:

• Commit Message: Leave it to other free or cheaper AIs; don't waste Claude's quota.
• Complex Git Operations (Rebase): To avoid breaking the graph, I feel more comfortable doing these dangerous operations manually.
• Claude Code: For discussions or development tasks that require deep understanding of the project.
• Gemini / Other models: If it's just a general technical question or doesn't involve a large amount of project context, I would ask Gemini instead. Don't ask Claude; if you use a Pro subscription, Claude Chat and Claude Code share the same quota.

However, I still need time to explore how to find the best AI tool combination for myself based on the strengths and costs (Q.Q) of each model.

---

Change Log

• 2026-01-06 Initial document creation.
• 2026-01-07 Added official CLAUDE.md configuration best practices and explanation of the context inheritance mechanism.