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. 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.