DEV Community: Syed Asif

Prompting Foundations for Developers — How to Talk to Claude So It Listens

Syed Asif — Thu, 28 May 2026 05:19:52 +0000

Introduction

You've installed Claude Code. You've sent a few prompts. But when you ask for something real — "write a login system" — the output feels generic, incomplete, or misses the point entirely.

The problem is almost always the prompt. That's fixable.

This chapter covers the exact structures and habits that turn vague requests into production-ready code: what Claude needs to know before it writes anything, how to trigger its reasoning instead of its pattern-matching, how to feed it multiple files without losing context, and how to lock in project-wide standards with CLAUDE.md.

What Claude Needs Before It Writes

Before Claude produces a single line, it resolves three things from your prompt:

What to build. "A login system" could mean a simple password check, a full OAuth flow, or a JWT-based API endpoint. Claude picks one. If you didn't specify, it guessed.
How it should behave. Should it block on errors or return structured error responses? Log failures? Validate inputs? Hash passwords? Silence on these means Claude chooses defaults — often the simplest ones.
What the result should look like. A single function? A module? A class with docstrings? Raw code or code with explanation?

Leave any of these unanswered and Claude fills the gap. The output won't be wrong exactly — it just won't be what you had in mind.

A useful mental check before sending: What, How, Format. Three seconds to answer those three questions will consistently improve what comes back.

Writing Prompts That Work

Weak vs. Strong

Weak:

"Write a function to handle user authentication."

Claude produces a bare-bones username/password check. No error handling, no hashing, no structure. Technically functional, not shippable.

Strong:

"Write a Python function using FastAPI that handles user authentication with JWT tokens. Verify credentials against the database, issue tokens that expire in 15 minutes, and return structured JSON responses. Include docstrings and a comment explaining each step."

Four additions: framework (FastAPI), language (Python), expected behavior (JWT, expiration, JSON responses), output format (docstrings, comments). Claude now knows what "done" looks like.

Chain-of-Thought Prompting

Claude reasons more carefully when you ask it to reason before it codes. This is chain-of-thought prompting — and it's worth knowing how it fits alongside Claude's newer capabilities.

Without it:

"Write a FastAPI endpoint that calculates factorial."

Claude often produces a recursive function with no input validation. It works for positive integers. It breaks on negatives and very large values.

With it:

"Before coding, outline your approach for a FastAPI endpoint that accepts a number and returns its factorial. Then write the full implementation with input validation, error handling, and comments."

Claude first lists its plan — input schema, recursion vs. iteration, edge cases (negative numbers, zero, large values), JSON output — then writes code that matches it. The result is safer and easier to debug.

One important nuance: Chain-of-thought prompting was the standard approach before Claude's extended thinking feature. Extended thinking (available on Sonnet 4.6 and Opus 4.6/4.7) gives Claude a separately-budgeted reasoning pass before generating output — you can inspect that reasoning trace in the API response. For complex coding tasks, extended thinking generally produces better results than manual chain-of-thought prompting. If you're on a plan that supports it, enable it for architecture decisions, complex debugging, and multi-step refactors. Manual chain-of-thought remains useful when extended thinking isn't available or when you need the reasoning to appear inline in Claude's response.

For either approach, Anthropic's docs note one consistent finding: always have Claude output its thinking. If the reasoning doesn't appear in the response, no reasoning step ran.

Multi-File Prompts

Real projects span multiple files. Claude handles them well — if you structure the input clearly.

Bad approach: Dump five files into a prompt with no labels. Claude loses track of which code belongs to which file and what the relationship between them is.

Good approach: Label each file with a clear header and state your goal upfront.

Claude, I'll share two FastAPI files. Analyze how validation is handled
across both and refactor them to remove redundancy.

## FILE: validators.py
[code here]

## FILE: main.py
[code here]

Provide the complete corrected code for both files.

Claude reads the structure, understands the relationship between modules, and refactors across both in one pass. The 1M-token context window on Sonnet 4.6 and Opus 4.6/4.7 means you can feed in large codebases this way — many files, full documentation, test suites.

CLAUDE.md: Project-Wide Standards

The blog's original framing of "system prompts" is accurate for API usage, but in Claude Code the standard mechanism is CLAUDE.md — a file you place in your project root (or in subdirectories for local rules). Claude reads it automatically at session start.

A CLAUDE.md might contain:

# Project Standards

- Language: Python 3.12, FastAPI 0.115
- Always include docstrings on public functions
- Use Pydantic v2 models for request/response schemas
- Never use eval() or exec()
- All database queries go through the repository layer — no raw SQL in route handlers
- Secrets come from environment variables only

Claude automatically merges multiple CLAUDE.md files based on directory structure — global rules in the root, local overrides in subdirectories. This mirrors how senior engineers think: project-wide conventions plus file-specific constraints.

For API usage, system prompts work the same way — set them once, and every request in the session inherits the standards.

On security guardrails specifically: treat prompts like logs. Assume they can be inspected. Don't put secrets or credentials in prompts. Lock down tool permissions to what Claude needs for the task. For anything touching authentication or access control, keep a human in the review loop.

Best Practices

For Beginners

Run the What, How, Format check before every prompt.
Paste actual error messages when debugging. Claude diagnoses errors well when it sees the full stack trace, not a paraphrase of it.
Ask Claude to explain its reasoning: "Why did you choose an iterative approach over recursion?" The answer teaches you how it's modeling the problem.

For Experienced Developers

Commit a CLAUDE.md to every project. Keep it short and explicit — specific rules outperform long documentation.
Label files clearly in multi-file prompts. State the goal at the top, then paste the files.
Use extended thinking for complex tasks. Set effort to xhigh for coding and agentic work — Anthropic's own docs recommend this as the default for most development use cases.
For very long autonomous runs, use sub-agents: "You just wrote the payment processor. Now use a sub-agent to run a security review on that code." This keeps the main conversation focused while the review runs in a separate context.

Common Prompting Errors

Problem	Likely Cause	Fix
Generic output	Prompt missing framework, format, or behavior constraints	Add specific language, library, and output requirements
Output cuts off	Hitting max token limit	Ask for output in sections, or summarize then expand
Claude ignores part of the prompt	Too many instructions at once	Break into sequential prompts
Wrong imports or syntax	Missing version context	Specify library versions: "FastAPI 0.115, Pydantic v2"
Claude contradicts earlier decisions	Context drift	Re-anchor: "We're still using FastAPI 0.115 with PostgreSQL"

Prompts as Dialogue

The developers who get the most out of Claude treat prompting as a conversation, not a one-shot command. Start broad enough to test Claude's interpretation of the problem. Refine based on what comes back. Ask it to defend its choices.

Each iteration improves the output. Over time you develop a sense for when to be specific and when to leave room for Claude to interpret — when a tight spec produces better code and when a looser framing surfaces a better architecture. Anthropic's own best practices guide puts it plainly: sometimes a vague prompt is exactly right, because you want to see how Claude interprets the problem before constraining it.

Conclusion

Prompting is a skill with a short learning curve and a long ceiling. The foundations: answer What, How, Format before you send anything; use chain-of-thought or extended thinking for tasks that require reasoning; label multi-file inputs clearly; store project standards in CLAUDE.md so you don't repeat yourself every session.

Try this: Take a piece of code you wrote recently. Write a weak prompt — just "improve this function." Then write a strong one using the three questions. Compare what Claude returns. The difference will be obvious, and you won't go back to vague prompts.

Acknowledgment: Based on official Anthropic documentation and community research. Technical details reflect the state of Claude Code as of May 2026.

How Claude Code Thinks: Inside Your AI Coding Assistant

Syed Asif — Thu, 28 May 2026 04:50:14 +0000

Introduction

You've set up Claude Code and sent your first prompt. Now the question is: how does it actually understand what you wrote?

This guide covers what happens under the hood — how Claude reads code, what tokens and context mean in practice, and why it sometimes drops details from earlier in a conversation. Understanding these mechanics will change how you prompt.

How Claude Reads Code

Claude doesn't execute your code. It processes text. Three stages build its understanding:

1. Parsing and context formation. Claude breaks your prompt into tokens and maps relationships between them — which function calls which, where a variable appears, how control flow branches. The output is a structural model of your code.

2. Reasoning and pattern matching. Claude compares that model against patterns from training. A sorting function that resembles merge sort gets treated like merge sort. That match drives what Claude predicts you need next.

3. Generation and justification. Claude writes its response token by token, checking for coherence and safety at each step. The comments you see — "This variable is unused," "This may fail on empty lists" — come from this stage, not from running the code.

Claude is probabilistic. Two similar prompts may produce different answers. That's reasoning, not a bug.

Tokens and Context Windows

A token is a small chunk of text. Claude averages 4 characters per token, or about 1.5 tokens per word in English. For code that number rises — brackets, operators, and keywords don't map cleanly to natural language tokens.

Practical scale:

print("Hello") is 3–4 tokens
A typical function is 50–200 tokens
1,000 tokens is roughly 750 words of English prose

The context window is Claude's working memory for a session. It holds your prompts, Claude's responses, uploaded files, and tool outputs — all from the same token budget. Current models as of May 2026:

Model	Context	Best For
Claude Haiku 4.5	200K	Quick fixes, low-latency tasks
Claude Sonnet 4.6	1M	General coding, refactoring, multi-file work
Claude Opus 4.6 / 4.7	1M	Deep analysis, full-stack architecture, large codebases

The 1M window on Sonnet 4.6 and Opus 4.6 went live at standard pricing in March 2026. The older Claude 3 series is deprecated. Claude 3 Haiku is fully retired — requests to it now return errors.

When a session fills up, Claude drops the oldest tokens first. Recent messages stay. That's why early details can go missing in long conversations.

One more thing worth knowing: research has documented a "lost in the middle" effect — attention quality drops for content buried in the center of a very large context. Put your most important constraints, framework choices, and goals at the top of a session.

The Request-Response Lifecycle

Four stages happen every time you send a prompt.

Stage 1 — Tokenization. Claude converts your input to token IDs. It processes your message together with conversation history, loaded files, system prompts, and any command outputs. Longer sessions accumulate tokens faster because the input compounds.

Stage 2 — Context assimilation. Claude merges the new prompt with history and runs self-attention, weighting which parts matter most. Constitutional AI constraints apply here — unsafe requests get flagged before generation starts.

Stage 3 — Generation. Claude produces output token by token. It checks coherence and safety continuously. You'll often see Claude frame its approach before writing code — that framing is the alignment step.

Stage 4 — Memory update. Claude adds the response to its in-session context. That's why "now optimize the async performance" works — Claude knows which code you mean. Close the session and that context is gone.

Memory and Conversation State

Within a Session

Claude holds everything in the active context window. As it fills, the oldest tokens drop. Re-anchoring every few turns keeps Claude oriented:

"We're still on the FastAPI e-commerce API with JWT auth and PostgreSQL. Now add order history."

Across Sessions

By default, Claude Code starts each session from scratch. Stateless architecture is simpler to reason about and easier to scale — this is intentional, not an oversight.

Anthropic rolled out auto-memory for Claude Code in early 2026. Claude now builds and maintains a MEMORY.md file during sessions, storing key decisions and context that load automatically next time. The feature is on a gradual rollout; your account may need it enabled.

The manual alternative: keep a .claude/ directory with a context.md or decisions/ folder. Claude reads these at session start.

A session_notes.txt with key decisions and code snippets also works well. Paste it in at the top of each new session if auto-memory isn't available yet.

API vs. IDE

Claude Web and IDE integrations maintain context within the open session automatically. The Claude API is stateless by default — you send conversation history with each request to maintain continuity. More work, but also more control.

Which Model to Use

Model	Context	Use When
Haiku 4.5	200K	Repetitive tasks, test generation, quick completions
Sonnet 4.6	1M	Everyday coding — best cost-to-capability ratio
Opus 4.6 / 4.7	1M	Legacy refactors, complex multi-file reasoning, long-context analysis

Use Haiku for "add a docstring to every function." Use Sonnet for most development work. Bring in Opus when you need to untangle something genuinely complex — a legacy monolith, an architecture decision with many constraints, a long document to reason over. Using Opus for a typo fix costs you money and time.

Best Practices

For Beginners

Start small. Token awareness develops naturally as you work.
If Claude loses track of earlier context, restate your goal explicitly.
The web interface handles context management for you.

For Power Users

Front-load key facts. Your framework, language, and hard constraints belong at the top of the session, not buried in message 15.
Re-anchor every few turns. "Still on the FastAPI project, PostgreSQL backend" keeps Claude from drifting as context accumulates.
Segment sessions by topic. Start a new session when you switch from backend to frontend work.
Build explicit context for the API. Send prior messages in each request, or use the MEMORY.md / .claude/ pattern to persist decisions.

Common Mistakes

Assuming Claude remembers yesterday. It doesn't by default. Save summaries or enable auto-memory.
Pasting 50,000-line files wholesale. Large undifferentiated inputs dilute attention. Start with the relevant files and expand from there.
Reaching for Opus by default. Sonnet 4.6 handles most development tasks well and costs significantly less.
Referencing retired models. Claude 3 Haiku returns errors now. Claude 3 Sonnet and Opus are deprecated. Use the 4.x series.

Conclusion

Claude Code is a reasoning engine with a finite but large working memory. You now understand how it reads code, how tokens accumulate across a session, the four stages it runs on every request, and how to manage context across sessions and model choices.

Try this: Open a fresh session and build a small API across several turns. After a few exchanges, change the subject entirely, then bring Claude back to the original task. Watching how it re-anchors — or loses the thread — makes the mechanics concrete.

Acknowledgment: Based on official Anthropic documentation and community research. Technical details reflect the state of Claude Code as of May 2026.

Getting Started with Claude Code: Your First AI Coding Partner

Syed Asif — Thu, 28 May 2026 04:44:35 +0000

Introduction

Claude Code is a pair programmer that never gets tired, explains every suggestion, and reads your entire project at once. But it's not a chat interface with a coding plugin. It's an agentic CLI that runs in your terminal, reads and writes files, manages Git, and reasons across your full codebase.

This guide covers what sets Claude Code apart, how to install it, and how to run your first prompt. By the end you'll know how to treat it as a collaborator rather than an autocomplete.

Core Concepts

What Claude Code Actually Is

Claude Code is Anthropic's official command-line interface for AI-assisted development. It runs in your terminal and can:

Read and write files directly in your project
Execute commands
Manage Git workflows — branches, commits, pull requests
Reason across up to 1 million tokens of codebase context
Connect to external services via MCP (Model Context Protocol)
Surface its reasoning in plain English before acting

It runs on Sonnet 4.6 by default for Pro users, Opus 4.6 on Max plans. Before taking any file-altering action, it asks for confirmation and shows its plan — that's the Constitutional AI framework in practice.

How Claude Code Compares

Feature	Claude Code	Typical autocomplete tools
Type	Agentic CLI	IDE plugin or chat interface
Focus	Multi-file reasoning and agentic tasks	Predicting the next line
Context	Up to 1M tokens	Current file or limited window
Actions	Reads/writes files, runs commands, manages Git	Suggests code you paste manually
Safety	Confirms before file changes	Basic filtering

Claude Code handles large-scale refactoring, cross-file bug fixes, and infrastructure tasks end to end. It's a different category from autocomplete.

Installation and Your First Prompt

Step 1 — Choose Your Access Method

Three ways to use Claude Code:

Claude Web (claude.ai) — No installation. Good for experimenting with prompts.
Claude Code CLI — The core tool. Runs from any terminal, works over SSH, scriptable in CI/CD pipelines.
IDE Extension — A VS Code extension (also works in Cursor, Windsurf, and Kiro) that surfaces inline diffs and accept/reject controls without leaving your editor.

Installing the CLI

To install Claude Code, use one of the following methods:

macOS, Linux, WSL:

curl -fsSL https://claude.ai/install.sh | bash

Or install Node.js 18+ first, then:

npm install -g @anthropic-ai/claude-code

Run claude in your terminal and complete the OAuth flow to authenticate. Verify with:

claude doctor

Install with Linux package managers

For Debian and Ubuntu. To use the rolling channel, change both stable occurrences in the deb line: the URL path and the suite name.

sudo install -d -m 0755 /etc/apt/keyrings
sudo curl -fsSL https://downloads.claude.ai/keys/claude-code.asc \
  -o /etc/apt/keyrings/claude-code.asc
echo "deb [signed-by=/etc/apt/keyrings/claude-code.asc] https://downloads.claude.ai/claude-code/apt/stable stable main" \
  | sudo tee /etc/apt/sources.list.d/claude-code.list
sudo apt update
sudo apt install claude-code

Verify the GPG key fingerprint before trusting it: gpg --show-keys /etc/apt/keyrings/claude-code.asc should report 31DD DE24 DDFA B679 F42D 7BD2 BAA9 29FF 1A7E CACE.

To upgrade later, run sudo apt update && sudo apt upgrade claude-code.

Setting Up in VS Code

Open the Extensions view (Ctrl+Shift+X on Windows/Linux, Cmd+Shift+X on Mac), search for Claude Code, and click Install. Sign in with your Anthropic account on first launch.

The extension also installs the first time you run claude from VS Code's integrated terminal. It works identically in Cursor, Windsurf, and other VS Code forks.

Once installed, click the Spark icon in the sidebar. You get real-time inline diffs, plan review before Claude touches any files, @-mention support for specific files and line ranges, and conversation history across tabs.

Setting Up in Cursor

Run Claude Code from Cursor's integrated terminal for heavy agentic tasks. Use Cursor's Composer for interactive editing. The two tools operate at different speeds and task scales — they complement each other.

Setting Up in Zed

Since Zed 1.0, Claude Code is native to Zed's Agent Panel via ACP (Agent Client Protocol). No separate installation. Zed is built in Rust with GPU-accelerated rendering.

Pick your entry point: VS Code if you're already there. Cursor for deep project-wide IDE features alongside agentic work. Zed for raw performance.

Step 2 — Your First Prompt

Open your chosen interface and send this:

"Hello Claude! Please write a Python program that prints 'Hello, Claude!' and then explains, in a comment, what each line of the code does."

Claude responds:

# Assign the string 'Hello, Claude!' to the variable 'message'
message = 'Hello, Claude!'

# Use the print() function to display the value of 'message' in the console
print(message)

It explained each line without being asked. That's the default behavior — Claude assumes you want to understand the code, not just copy it.

Now push further:

"Rewrite it in JavaScript and explain the differences."

Claude produces a JavaScript version and explains that const replaces Python's implicit assignment and console.log() replaces print():

// Assign the string 'Hello, Claude!' to the variable 'message' using const
const message = "Hello, Claude!";

// Use console.log() to display the value in the console
console.log(message);

Step 3 — Iterate

"Update the Python version to ask for my name, greet me personally, and show the current time."

Claude adds input(), imports datetime, and returns a runnable script:

import datetime

# Ask the user for their name
name = input("What is your name? ")

# Greet the user by name
print(f"Hello, {name}!")

# Display the current system time
current_time = datetime.datetime.now().strftime("%H:%M:%S")
print(f"The current time is {current_time}.")

Each follow-up request revises Claude's reasoning and output. Treat it as a conversation, not a one-shot query.

Best Practices

For Beginners

Start with the web interface — no setup, immediate feedback.
Ask Claude to explain every decision. The reasoning is often more useful than the code.
Make small, specific requests. Vague prompts produce vague output.

For Experienced Developers

Install the CLI and IDE extension. You'll cut context switching significantly.
Use chain-of-thought prompts: ask Claude to "think step by step" before writing code on complex problems.
Put your full codebase in context. Claude reads 1M tokens — use it on large files and documentation.
Describe Git tasks in plain language. Claude Code creates branches, writes commit messages, and opens pull requests.

Common Mistakes

Vague bug reports produce vague fixes. Instead of "fix this bug," say: "The function should return X but returns Y. Here's the code and the error."
Ignoring Claude's explanations wastes the tool's main advantage. Read the reasoning.
Single-prompt expectations don't match how Claude works best. Iterate.
Using Claude Code for line completions is like using a chainsaw to slice bread. Save it for multi-file, multi-step tasks.

Conclusion

Claude Code is an agentic CLI that reads your codebase, executes commands, manages your Git workflow, and explains every decision. You now know:

What it is and how it differs from autocomplete tools
How to install the CLI and configure VS Code, Cursor, or Zed
How to run and iterate on your first prompt

Next step: Install the CLI, send that first "Hello, Claude!" prompt, then try something harder — ask it to refactor a real file, add error handling, or commit a change. The scope of what it can do autonomously becomes clear quickly.

Acknowledgment: Based on official Anthropic documentation and community research. Technical details reflect the state of Claude Code as of May 2026.