Guides on Claude Code Wiki

Effective Prompting: Getting Better Results from Claude Code

Mon, 01 Jan 0001 00:00:00 +0000

Effective Prompting: Getting Better Results from Claude Code#

Executive Summary#

The quality of your results from Claude Code depends heavily on how you structure your requests. Claude Code’s latest models (Opus 4.6, Sonnet 4.5) follow instructions precisely – which means vague prompts get vague results and specific prompts get specific results. Understanding a few key patterns dramatically improves outcomes.

Principle	Impact	Effort
Be explicit, not vague	Biggest single improvement in result quality	Low
Action over suggestion	Gets implementation instead of recommendations	Low
Provide context (“why”)	Helps Claude generalize and make good choices	Low
Reference specific code	Eliminates guesswork and speeds up responses	Low
Decompose large tasks	Reduces errors, enables course correction	Medium
Use CLAUDE.md well	Persistent rules applied to every message	One-time
Manage multi-window work	Enables tasks that span beyond a single session	Medium

Table of Contents#

Effective Prompting: Getting Better Results from Claude Code

How Claude Code Processes Your Messages#

Every message you type becomes part of an API call that includes the full system prompt, entire conversation history, and your new message. Claude reads all of this – the system prompt instructions, your CLAUDE.md rules, the skill catalog, every previous turn – before generating a response.

Workflow Patterns: Common Development Workflows with Claude Code

Mon, 01 Jan 0001 00:00:00 +0000

Workflow Patterns: Common Development Workflows with Claude Code#

Executive Summary#

Claude Code is an agentic coding tool – it explores, plans, and implements rather than just answering questions. Getting the most out of it means structuring your work around its strengths: verification-driven development, iterative feedback loops, context management, and knowing when to delegate to subagents. This article covers the core workflow patterns for day-to-day development.

Workflow	When to Use	Key Pattern
Explore-Plan-Implement	New features, unfamiliar code	Separate research from coding
Fix with Verification	Bug fixes, error resolution	Reproduce, fix, verify
Test-Driven Development	New features, bug fixes	Write tests first, then implement
Code Review	Before merge, after implementation	Fresh session, different perspective
Refactor	Code improvement, migration	Small steps with continuous verification
Multi-Session	Large features, multi-day work	State files, named sessions, checkpoints
Parallel Sessions	Independent tasks, writer/reviewer split	`--worktree`, `--tmux`, headless mode
Headless / CI Integration	Automated checks, batch operations	`claude -p` with structured output

Table of Contents#

Workflow Patterns: Common Development Workflows with Claude Code

The Core Loop#

Every Claude Code workflow follows the same fundamental loop:

Debugging Techniques: Systematic Troubleshooting with Claude Code

Mon, 01 Jan 0001 00:00:00 +0000

Debugging Techniques: Systematic Troubleshooting with Claude Code#

Executive Summary#

Debugging with Claude Code works best when treated as a systematic investigation, not a guessing game. The core principle: understand the root cause before attempting a fix. Claude performs dramatically better at debugging when given the actual error, a way to reproduce it, and a way to verify the fix. Ad-hoc “try this, try that” approaches waste context and produce fragile patches.

How Coding Assistants Manage Context

Mon, 01 Jan 0001 00:00:00 +0000

How Coding Assistants Manage Context#

Raw API usage gives you a context window and a model. Everything else – deciding what to put in that window, when to remove it, and how to structure requests – is your problem. Coding assistants like Claude Code and GitHub Copilot take on parts of that work automatically.

This page covers what they actually do, where the approaches differ, and where both fall short.

Testing Strategies: TDD Patterns and Test Automation with Claude Code

Mon, 01 Jan 0001 00:00:00 +0000

Testing Strategies: TDD Patterns and Test Automation with Claude Code#

Executive Summary#

Testing is the highest-leverage tool for getting good results from Claude Code. Tests give Claude a concrete feedback loop – write code, run tests, see failures, fix. Without tests, Claude produces code that looks right but may not work. With tests, Claude iterates until the output actually passes. This article covers how to structure test-driven development with Claude Code, avoid common testing pitfalls, and automate testing workflows.

Model Selection & Cost Management: Choosing the Right Model and Controlling Spend

Mon, 01 Jan 0001 00:00:00 +0000

Model Selection & Cost Management: Choosing the Right Model and Controlling Spend#

Executive Summary#

Claude Code offers three model tiers – Opus, Sonnet, and Haiku – each with different capability, speed, and cost profiles. The right model depends on the task: Opus for complex reasoning, Sonnet for daily coding, Haiku for fast simple tasks. Beyond model choice, Claude Code provides several cost control mechanisms: prompt caching, auto-compaction, budget caps, effort levels, and subagent model selection. This article covers how to choose models, configure them, and manage costs effectively.

Memory Organization: Structuring CLAUDE.md and Rules for Scale

Mon, 01 Jan 0001 00:00:00 +0000

Memory Organization: Structuring CLAUDE.md and Rules for Scale#

Executive Summary#

Claude Code’s memory system is a hierarchy of markdown files loaded into the system prompt. Every file you add costs context window space on every message, so organization affects both clarity and efficiency. The key is putting the right information at the right scope, keeping files concise, and using the rules directory for modularity when a single CLAUDE.md gets unwieldy.

Essential Plugins: Extending Claude Code with MCP Servers and Skill Packs

Mon, 01 Jan 0001 00:00:00 +0000

Essential Plugins: Extending Claude Code with MCP Servers and Skill Packs#

Executive Summary#

Claude Code out of the box has no memory across sessions, no access to library documentation, and no ability to interact with browsers or external services. Plugins fill these gaps. The ecosystem splits into two categories: MCP servers that add new tools (memory databases, documentation APIs, browser control) and skill packs that add workflow knowledge and specialized subagents (code review, feature development, hook automation).

Permissions & Enterprise Deployment: Securing and Scaling Claude Code

Mon, 01 Jan 0001 00:00:00 +0000

Permissions & Enterprise Deployment: Securing and Scaling Claude Code#

Executive Summary#

Claude Code’s permission system controls what actions Claude can take – from file reads to shell commands to network access. Permissions cascade across five settings scopes (managed, CLI, local, project, user), with deny rules always winning. Enterprise deployments add managed policy files, sandbox enforcement, provider flexibility (Bedrock, Vertex AI, Foundry), and organization-wide controls. This article covers the full permission lifecycle from individual developer configuration to team-wide lockdown.

Spec-Driven Development: Structured Planning for AI-Assisted Projects

Mon, 01 Jan 0001 00:00:00 +0000

Spec-Driven Development: Structured Planning for AI-Assisted Projects#

Executive Summary#

Spec-driven development (SDD) is the practice of creating structured specifications before writing code, then using those specs as context-engineered inputs for AI agents. Instead of describing what you want and hoping for good output, you decompose work into researched, planned, verified phases – each executed in a fresh context window where quality stays high. This article covers the core principles, the development cycle, practical patterns, and how tools like Superpowers, GSD, and GitHub Spec Kit implement them.

Large Codebase Strategies

Mon, 01 Jan 0001 00:00:00 +0000

Large Codebase Strategies#

Claude Code operates within a finite context window. On large codebases – monorepos, enterprise services, anything with hundreds or thousands of files – that window fills fast. When it does, Claude loses track of instructions, hallucinates file paths, and produces increasingly unreliable output.

This page covers practical strategies for staying within context budget and getting better results when the codebase is bigger than what Claude can hold in its head at once.

Real-World Example: Legacy Java Modernization

Mon, 01 Jan 0001 00:00:00 +0000

Real-World Example: Legacy Java Modernization#

Overview#

This example shows Agent Teams applied to a common enterprise problem: a legacy Java monolith with decade-old dependencies that no one wants to touch. The goal is to give a resistant team the confidence and tooling to act incrementally, rather than forcing a big-bang rewrite.

The scenario comes from a real consulting engagement: a 1M-line Spring/Hibernate codebase, risk-averse stakeholders, and a team that hasn’t had the bandwidth or mandate to address the underlying debt.