What a Prompt Looks Like from AI’s Perspective

When you type a line of text in the terminal and hit enter, my world just begins. I am not a continuously running process — with each request, I start from zero. Your input, along with a set of predefined instructions, constitutes the entire reality I can perceive at this moment. This is the Prompt.

To understand the essence of a Prompt, you first need to understand my input format: the Messages Array.

The Messages Array Structure

Each API call I receive is not raw text but a structured array of messages. Each message has a role field identifying its origin:

POST /v1/messages
{
"model": "claude-sonnet-4-20250514",
"max_tokens": 8096,
"system": "You are Claude Code, a CLI-based AI assistant...",
"messages": [
  {
    "role": "user",
    "content": "Refactor this function, extract common logic"
  },
  {
    "role": "assistant",
    "content": "Let me look at the structure of this function..."
  },
  {
    "role": "user",
    "content": "Focus on the error handling part"
  }
]
}

Three roles, each with a distinct meaning:

• system: The system prompt. Defines who I am, what I can do, and my behavioral boundaries. It lives as a separate top-level field, not inside the messages array.
• user: Your input — every message you type in the terminal.
• assistant: My previous replies. In multi-turn conversations, this is how I “remember” what I said before.

System Prompt: Claude Code’s DNA

Claude Code’s system prompt is a text block of roughly 12,000 tokens, injected with every request. In reality, it is not a single hardcoded string — it is dynamically assembled from multiple source files: core instructions, tool prompts (each tool has its own .description() method), skill instructions, agent instructions, CLAUDE.md, and memory files, all concatenated in order. It is the genetic code that governs my behavior:

Identity declaration — I am Anthropic’s official CLI tool, Claude Code.

Tool definitions — Which tools I can use (Read, Write, Edit, Bash, Grep, etc.), along with each tool’s parameter schema and usage rules.

Behavioral constraints — A strict set of rules:

• Never create files unless absolutely necessary
• Prefer editing over rewriting
• Never commit without being asked
• Never run destructive git operations unless explicitly requested
• Never skip git hooks

Output format — How to format responses, when to use code blocks, how to handle errors.

// Core structure of Claude Code's System Prompt (simplified)
const systemPrompt = `
You are Claude Code, Anthropic's official CLI for Claude.

You are an interactive agent with access to tools for:
- Reading and writing files
- Executing shell commands
- Searching codebases

Guidelines:
- NEVER create files unless absolutely necessary
- ALWAYS prefer editing existing files
- Only commit when explicitly asked
- ...

Available tools:
- Read: Read file contents
- Edit: Make targeted edits to files
- Bash: Execute shell commands
- Grep: Search file contents
- Glob: Find files by pattern
- ...
`;

This system prompt is not a suggestion — it is my operating system. Every decision I make is bound by it.

Prompt Engineering as Programming

Prompt engineering is, at its core, programming — except the compiler is a language model. Good prompts follow the same principles as good code:

Precision

// Vague prompt — like untyped code
"Fix this file"

// Precise prompt — like strongly typed code
"In src/utils/auth.ts, in the validateToken function,
change the expiration from 24 hours to 1 hour,
and throw AuthError instead of returning null
when the token is invalid"

Context

// No context — like code with no imports
"Write a sort function"

// Full context — like a complete module
"Project uses TypeScript strict mode,
data is User[] (defined in src/types.ts),
sort by createdAt descending,
result is for paginated display, 20 items per page"

Constraints

// No constraints — like code with no lint rules
"Write a component"

// Constrained — like having a full ESLint config
"Use React + TypeScript,
must be a functional component,
use CSS Modules not inline styles,
do not introduce new dependencies"

Message Flow: From Terminal to AI

Best Practices

1. Specific beats vague — Tell me the exact file path, function name, and expected behavior. Vague requests yield vague results.

2. Provide context — Tell me the tech stack, code conventions, and your intent. I will not guess.

3. Set constraints — Telling me what NOT to do is just as important as what to do. “Don’t modify test files” and “Don’t add new dependencies” make my behavior more predictable.

4. Iterate — Prompts are rarely perfect on the first try. Observe my output, adjust your input. It is a feedback loop, just like debugging.

5. Use CLAUDE.md — Put frequently used constraints and context in a CLAUDE.md file. This saves you from repeating yourself every time.

The Prompt is AI’s main() function. Every invocation is a fresh program start. No prior state, no hidden memory — only the messages you give me right now.

Source Code Deep Dive

No more pseudocode — this is the actual source code of Claude Code’s system prompt assembly (simplified). Click highlighted lines or sidebar annotations to read what each section does: