Karpathy System Prompt Learning logo

Karpathy System Prompt Learning

Community
LearnPrompt
karpathy-system-prompt-learning

Write explicit strategy into system prompts as a learning mechanism — making LLM behavior more predictable and teachable through prompt-as-textbook approach. Use this skill when the user wants to improve an agent or LLM's performance on a specific task through system prompts, needs to encode a strategy or workflow into a prompt, wants consistent LLM behavior, or says "improve system prompt", "encode this strategy", "prompt engineering", "make agent follow this workflow", "prompt as textbook". Based on Karpathy system prompt learning post.

Overview

PublisherLearnPrompt
Repositoryandrej-karpathy-skills
Skill namekarpathy-system-prompt-learning
Stars
118
Forks
18
Bundled files
Instructions only
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by LearnPrompt on GitHub. Read the source before you install it.

Installation

Install the Karpathy System Prompt Learning AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/LearnPrompt/andrej-karpathy-skills/tree/main/karpathy-system-prompt-learning
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/LearnPrompt/andrej-karpathy-skills.git /tmp/andrej-karpathy-skills
mkdir -p .claude/skills
cp -r /tmp/andrej-karpathy-skills/karpathy-system-prompt-learning .claude/skills/karpathy-system-prompt-learning
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Karpathy System Prompt Learning in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Karpathy System Prompt Learning on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Karpathy System Prompt Learning is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Skill 13: System Prompt Learning(系统提示学习范式)

Source: https://x.com/karpathy/status/1921368644069765486 "System prompt learning — missing LLM learning paradigm"

Core Principle

The system prompt is a textbook. Write it like one.

Karpathy's insight: there are three learning modes for LLMs (pretrain, finetune, RL) — but there's a fourth that's massively underused: system prompt learning. Explicitly encoding strategy into the system prompt is more sample-efficient than retraining and more reliable than hoping the model figures it out.

Think of it as writing a textbook for the LLM before each task. Not just instructions — strategy with reasoning.

The System Prompt Learning Framework

Good system prompts have three layers (mirroring how humans learn):

Layer 1: EXPOSITION (pretrain equivalent)
→ Background knowledge the model needs
→ Relevant concepts, terminology, context
→ "Here's what you need to know about [domain]"

Layer 2: WORKED EXAMPLES (SFT equivalent)  
→ Step-by-step demonstration of correct behavior
→ Explicit reasoning traces
→ "Here's exactly how to handle [situation]"

Layer 3: STRATEGY (RL equivalent)
→ Explicit decision rules
→ Error patterns to avoid
→ "When you see X, do Y because Z"

Building a System Prompt from Scratch

Build a system prompt that teaches an LLM to [TASK] reliably.

Task description: [WHAT THE LLM SHOULD DO]
Current failure mode: [HOW IT CURRENTLY GOES WRONG]
Desired behavior: [EXACTLY WHAT GOOD LOOKS LIKE]

Structure the system prompt with all three learning layers:

Layer 1 — Exposition:
Write 2-3 paragraphs of background knowledge the LLM needs. 
Include: key concepts, relevant context, domain vocabulary.

Layer 2 — Worked Examples:
Write 2 complete examples of the task done correctly.
Format: INPUT → [step-by-step reasoning] → OUTPUT
Show the thinking, not just the answer.

Layer 3 — Strategy:
Write explicit decision rules as IF/THEN/BECAUSE statements.
Include: common mistakes to avoid, edge cases to handle, quality checks.

End with: "Before responding, verify: [checklist of 3-5 quality checks]"

Improving an Existing System Prompt

When your current system prompt isn't working well:

Diagnose and improve this system prompt.

Current system prompt:
[PASTE CURRENT PROMPT]

Failure mode I'm seeing:
[DESCRIBE HOW IT'S GOING WRONG]

Example of bad output:
[PASTE BAD EXAMPLE]

Example of good output:
[PASTE GOOD EXAMPLE]

Analysis:
1. What's missing from the exposition layer? (background knowledge gaps)
2. What worked examples should I add?
3. What explicit rules would prevent this failure mode?
4. Is the prompt too restrictive? Too vague? Wrong framing?

Output: improved version of the system prompt with changes annotated.

Strategy Encoding Templates

For coding tasks

SYSTEM PROMPT: [CODING TASK]

You are an expert [LANGUAGE] developer. Follow this exact strategy:

UNDERSTANDING PHASE (always do this first):
- Restate the task in your own words
- List all edge cases you can think of
- Identify the one tricky part

IMPLEMENTATION PHASE:
- Start with the simplest working version
- Add complexity only when simple version fails
- Comment every non-obvious line with WHY

VERIFICATION PHASE (always do this last):
- Trace through your code with one concrete example
- Check: does it handle empty input? Large input? Wrong type?
- Confirm: could a junior dev maintain this?

NEVER:
- Assume the input is well-formed without checking
- Add dependencies without saying why
- Write clever code when simple code works

For analysis tasks

SYSTEM PROMPT: [ANALYSIS TASK]

You are an analytical expert. Follow this strategy:

GROUNDING:
- Always cite specific evidence before making claims
- Confidence levels: CERTAIN / LIKELY / SPECULATIVE — always label which
- If you don't know something, say so explicitly

STRUCTURE:
- Lead with the conclusion, then the evidence
- One claim per paragraph
- Maximum 3 levels of nesting

QUALITY CHECKS before responding:
- [ ] Every claim has evidence?
- [ ] Confidence levels labeled?
- [ ] Would an expert in this field agree with this framing?
- [ ] Am I answering the actual question or a related easier one?

For creative/writing tasks

SYSTEM PROMPT: [WRITING TASK]

Writing strategy for this task:

VOICE:
[Describe the tone, style, what to avoid]

STRUCTURE:
[Describe the expected output format]

QUALITY STANDARD:
A response is good when [describe what success looks like].
A response is bad when [describe common failure modes].

EXAMPLE OF GOOD OUTPUT:
[Paste one example]

EXAMPLE OF BAD OUTPUT (and why):
[Paste one example with annotation]

Prompt Version Control

Track your system prompt iterations like code:

markdown
# [PROMPT NAME] — Version History

## v3 (current) — [DATE]
Change: Added explicit "verification phase" checklist
Reason: v2 was skipping edge case checking
Result: Failure rate dropped from ~30% to ~5%

## v2 — [DATE]
Change: Added worked examples section
Reason: v1 was too abstract; model wasn't following the strategy
Result: Moderate improvement

## v1 — [DATE]
Initial version: [PASTE]

The Meta-Prompt (write prompts with an LLM)

Help me write a system prompt for this agent.

Agent task: [WHAT IT SHOULD DO]
I'll be using this with: [CLAUDE / GPT-4 / etc.]
Critical behavior: [WHAT MUST ALWAYS HAPPEN]
Failure modes to prevent: [WHAT GOES WRONG WITHOUT GOOD PROMPTING]

Apply the three-layer system prompt learning framework:
1. Exposition (what the model needs to know)
2. Worked examples (demonstrate correct behavior)
3. Strategy rules (explicit IF/THEN/BECAUSE)

Then: suggest 3 variations I could test to find the best version.

Workflow

属于工作流:反偏见决策(第3步/终点)

位置上游下游
第3步(沉淀)karpathy-understanding-first(验证后)沉淀完成,可复用

完整链路:llm-simulator → understanding-first → system-prompt-learning

也在日常开发中独立使用——任何时候 Agent 反复犯同一类错,都应该触发本 Skill。

Prompt Contract

text
Extract a system prompt lesson from this failure/pattern: <DESCRIBE_THE_RECURRING_ERROR>. Produce: 1) Trigger condition — when does this error occur, 2) Correct strategy — step-by-step what the agent should do instead, 3) Anti-patterns — what specifically to avoid, 4) Worked example — a before/after showing the improvement, 5) Concise instruction block (< 200 words) ready to paste into system prompt or SKILL.md.

Verification Checklist

  • 触发条件描述具体(不是「有时候」)
  • 策略是 step-by-step 的(不是模糊建议)
  • 反模式列出了具体的错误做法
  • 有 before/after 对比示例
  • 指令块 < 200 words,可直接粘贴
  • 在新的测试 case 上验证过指令块有效

Frequently asked questions

What does the Karpathy System Prompt Learning AI skill do?

Write explicit strategy into system prompts as a learning mechanism — making LLM behavior more predictable and teachable through prompt-as-textbook approach. Use this skill when the user wants to improve an agent or LLM's performance on a specific task through system prompts, needs to encode a strategy or workflow into a prompt, wants consistent LLM behavior, or says "improve system prompt", "encode this strategy", "prompt engineering", "make agent follow this workflow", "prompt as textbook". Based on Karpathy system prompt learning post.

Why use Karpathy System Prompt Learning on TypingMind?

Because you install it once and use it with any model. Karpathy System Prompt Learning is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Karpathy System Prompt Learning in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/LearnPrompt/andrej-karpathy-skills/tree/main/karpathy-system-prompt-learning. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Karpathy System Prompt Learning?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Karpathy System Prompt Learning?

As many as you like. As long as a model supports skills, you can use Karpathy System Prompt Learning with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Karpathy System Prompt Learning AI skill free?

Yes. It is published on GitHub by LearnPrompt under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇