The Discuss-Then-Execute Workflow

The most important thing to understand about Claude Code is that it's not just an executor — it's a thinking partner with full access to your codebase.

The best results follow a two-phase pattern:

1. Discuss: Brainstorm the approach. Ask Claude to reason about trade-offs, challenge your assumptions, explore the codebase, and identify potential issues. It can read every file in your project, so it often spots things you'd miss.
2. Execute: Once you've aligned on a direction, let Claude implement. It writes code, runs tests, iterates on failures — all autonomously.

Skipping phase one is the most common mistake. If you jump straight to "build this feature," Claude picks an approach without the benefit of discussion. Sometimes it picks well. Often it doesn't — and you spend more time undoing than you saved.

Even experienced power users typically see around 85–90% of tasks fully achieved on the first attempt. That's remarkably effective — but it means roughly one in ten tasks needs course-correction. This is precisely why the discussion phase and verification loops exist: they catch the 10–15% before it costs you time.

Writing Effective Prompts

Good prompts dramatically improve output quality. A few principles:

• Be specific. Instead of "fix the bug", say "fix the login bug where users see a blank screen after entering wrong credentials — the issue is likely in src/auth/LoginForm.tsx." The more context upfront, the fewer wrong turns Claude takes.
• Reference files directly. Use @filename to point Claude at specific files. This is faster and more reliable than letting it search. Tab completion works.
• Provide external context. Paste URLs to GitHub issues, docs, or Stack Overflow answers directly. Claude will fetch and read them. You can also paste screenshots with Control-V (not Command-V on macOS).
• Break complex tasks into steps. Rather than "build a user profile system", try: "1. Create a database model for user profiles. 2. Add CRUD API endpoints. 3. Build a profile page component." Claude handles each step sequentially and can course-correct between them.
• State constraints explicitly. "Don't use external dependencies", "don't modify the existing API contract", "use our existing Button component from src/components/ui."
• Ask Claude to ask you questions. For ambiguous tasks: "Before you start, ask me any clarifying questions about the requirements." This is Claude acting as collaborator, not just executor.

Plan Mode

Plan Mode is probably the single most impactful habit. Always plan before you execute, especially for anything non-trivial.

Activate with Shift+Tab twice (or type /plan). This puts Claude in read-only mode — it can explore your codebase, search files, and fetch web content, but it can't modify anything.

Claude produces a structured implementation plan. Review it, challenge assumptions, suggest alternatives, and only exit plan mode (Shift+Tab again) to let it execute.

The Permission Mode Cycle

Shift+Tab cycles through three modes:

stateDiagram-v2
  Normal --> AutoAccept : Shift+Tab
  AutoAccept --> Plan : Shift+Tab
  Plan --> Normal : Shift+Tab

Most experienced users start in Plan Mode for new tasks, review the plan, then switch to auto-accept for execution. Normal mode is mainly useful when you're learning or want to watch each step closely.

Session Management

Two habits worth building:

• Use /clear aggressively. Every time you start something genuinely new, clear the conversation. Stale context causes mistakes and costs money.
• Use /compact when Claude has learned something valuable during a long session but the conversation has accumulated noise. It summarises the context while freeing up space.

A Typical Workflow

1. Start with /clear if beginning a new task.
2. Discuss the approach — describe what you want and ask Claude to think through the options.
3. Use Plan Mode (Shift+Tab twice) if the task is complex enough to warrant a structured plan.
4. Review and challenge — push back on anything that doesn't look right.
5. Switch to auto-accept and let Claude execute.
6. Commit frequently. Ask Claude to commit after each logical unit of work so you can revert if needed.

/clear

Add a dark mode toggle to the settings page. It should persist
the preference in localStorage and use our existing design tokens.
@src/components/Settings.tsx @src/styles/tokens.ts

Run the dev server and check for TypeScript errors. Then commit
this as "Add dark mode toggle with localStorage persistence".

Costs and Token Usage

Every interaction uses API tokens — and tokens cost money (on API billing) or count towards limits (on subscription). A few things to keep in mind:

• Long conversations cost more. Each message includes the full conversation history, so a 50-message session costs significantly more per message than a 5-message one.
• /clear saves money. Starting fresh for a new task avoids paying for irrelevant context.
• /compact is cheaper than continuing. Summarising removes noise while keeping value.
• Model choice matters. Use Sonnet for most work, Haiku for quick mechanical tasks, Opus when you need deep reasoning.

Key Takeaway

Claude Code's output quality is mostly about how you use it. Discuss before you execute. Plan before you implement. Manage your sessions well. These habits transform Claude from "sometimes helpful" to "genuinely productive."