{"id":323461,"date":"2026-05-15T23:46:12","date_gmt":"2026-05-15T20:46:12","guid":{"rendered":"https:\/\/ceotudent.com\/andrej-karpathy-claude-md-file-2026-guide"},"modified":"2026-05-17T07:37:18","modified_gmt":"2026-05-17T04:37:18","slug":"andrej-karpathy-claude-md-file-2026-guide","status":"publish","type":"post","link":"https:\/\/ceotudent.com\/en\/andrej-karpathy-claude-md-file-2026-guide","title":{"rendered":"What Is Andrej Karpathy&#8217;s CLAUDE.md File? The New Memory of AI-Era Software Development (2026 Guide)"},"content":{"rendered":"<blockquote>\n<p><strong>Short answer:<\/strong> <strong>CLAUDE.md<\/strong> is the persistent context file that Anthropic&rsquo;s developer tool <strong>Claude Code<\/strong> reads at the start of every session. By 2026 it supports <strong>four scopes<\/strong> (managed \/ project \/ user \/ local) and an <strong>imports syntax<\/strong> (<code>@path\/to\/file<\/code>) for pulling in other files. The <strong>auto memory<\/strong> introduced in v2.1.59 lets Claude accumulate knowledge into a <code>MEMORY.md<\/code> on its own; together the two give the project a <strong>two-layer memory<\/strong>. Between November 2025 and January 2026, Andrej Karpathy moved <strong>80% of his coding routine to agent-driven coding<\/strong>, calling it <em>&ldquo;the biggest workflow shift in roughly 20 years of programming.&rdquo;<\/em> In <strong>April 2026<\/strong> he published the <a href=\"https:\/\/gist.github.com\/karpathy\/442a6bf555914893e9891c11519de94f\" rel=\"noopener\">idea file<\/a> gist and redefined CLAUDE.md as the <strong>schema spine of a personal knowledge architecture<\/strong> made of <code>raw\/<\/code> (sources), <code>wiki\/<\/code> (LLM-maintained knowledge base) and <code>CLAUDE.md<\/code> (schema). This guide unpacks every one of those innovations and what an effective CLAUDE.md looks like in 2026.<\/p>\n<\/blockquote>\n<p>In this era of AI-fused software development, <strong>what you tell the AI and how you tell it<\/strong> decides how much real productivity you get back. Since March 2026, Anthropic&rsquo;s official documentation moved to its new home (<code>code.claude.com\/docs\/en\/memory<\/code>) and CLAUDE.md remains Claude Code&rsquo;s most critical concept, while complementary layers \u2014 <strong>auto memory<\/strong>, <strong>path-scoped rules<\/strong>, <strong>imports<\/strong>, <strong>subagent memory<\/strong> \u2014 formed around it. Karpathy&rsquo;s posts over the last six months pushed this mechanism beyond a plain config file and into <strong>the central knowledge architecture of AI-era software<\/strong>.<\/p>\n<hr>\n<div id=\"ez-toc-container\" class=\"ez-toc-v2_0_84 counter-hierarchy ez-toc-counter ez-toc-grey ez-toc-container-direction\">\n<div class=\"ez-toc-title-container\">\n<p class=\"ez-toc-title\" style=\"cursor:inherit\">Table of Contents<\/p>\n<span class=\"ez-toc-title-toggle\"><a href=\"#\" class=\"ez-toc-pull-right ez-toc-btn ez-toc-btn-xs ez-toc-btn-default ez-toc-toggle\" aria-label=\"Toggle Table of Content\"><span class=\"ez-toc-js-icon-con\"><span class=\"\"><span class=\"eztoc-hide\" style=\"display:none;\">Toggle<\/span><span class=\"ez-toc-icon-toggle-span\"><svg style=\"fill: #999;color:#999\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\" class=\"list-377408\" width=\"20px\" height=\"20px\" viewBox=\"0 0 24 24\" fill=\"none\"><path d=\"M6 6H4v2h2V6zm14 0H8v2h12V6zM4 11h2v2H4v-2zm16 0H8v2h12v-2zM4 16h2v2H4v-2zm16 0H8v2h12v-2z\" fill=\"currentColor\"><\/path><\/svg><svg style=\"fill: #999;color:#999\" class=\"arrow-unsorted-368013\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"10px\" height=\"10px\" viewBox=\"0 0 24 24\" version=\"1.2\" baseProfile=\"tiny\"><path d=\"M18.2 9.3l-6.2-6.3-6.2 6.3c-.2.2-.3.4-.3.7s.1.5.3.7c.2.2.4.3.7.3h11c.3 0 .5-.1.7-.3.2-.2.3-.5.3-.7s-.1-.5-.3-.7zM5.8 14.7l6.2 6.3 6.2-6.3c.2-.2.3-.5.3-.7s-.1-.5-.3-.7c-.2-.2-.4-.3-.7-.3h-11c-.3 0-.5.1-.7.3-.2.2-.3.5-.3.7s.1.5.3.7z\"\/><\/svg><\/span><\/span><\/span><\/a><\/span><\/div>\n<nav><ul class='ez-toc-list ez-toc-list-level-1 ' ><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-1\" href=\"https:\/\/ceotudent.com\/en\/andrej-karpathy-claude-md-file-2026-guide\/#Andrej-Karpathy-From-Software-20-to-the-Idea-File\" >Andrej Karpathy: From Software 2.0 to the Idea File<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-2\" href=\"https:\/\/ceotudent.com\/en\/andrej-karpathy-claude-md-file-2026-guide\/#What-Is-CLAUDEmd-and-How-Does-It-Fit-With-Auto-Memory\" >What Is CLAUDE.md and How Does It Fit With Auto Memory?<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-3\" href=\"https:\/\/ceotudent.com\/en\/andrej-karpathy-claude-md-file-2026-guide\/#2026-New-Features-Imports-clauderules-AGENTSmd-Interop\" >2026 New Features: Imports, .claude\/rules\/, AGENTS.md Interop<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-4\" href=\"https:\/\/ceotudent.com\/en\/andrej-karpathy-claude-md-file-2026-guide\/#Karpathys-Idea-File-Approach-April-2026\" >Karpathy&rsquo;s Idea File Approach (April 2026)<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-5\" href=\"https:\/\/ceotudent.com\/en\/andrej-karpathy-claude-md-file-2026-guide\/#How-to-Write-an-Effective-CLAUDEmd-2026-Standards\" >How to Write an Effective CLAUDE.md (2026 Standards)<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-6\" href=\"https:\/\/ceotudent.com\/en\/andrej-karpathy-claude-md-file-2026-guide\/#CLAUDEmd-vs-Cursor-Rules-vs-ChatGPT-Custom-Instructions\" >CLAUDE.md vs Cursor Rules vs ChatGPT Custom Instructions<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-7\" href=\"https:\/\/ceotudent.com\/en\/andrej-karpathy-claude-md-file-2026-guide\/#Practical-Tips-for-Turkish-Developers\" >Practical Tips for Turkish Developers<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-8\" href=\"https:\/\/ceotudent.com\/en\/andrej-karpathy-claude-md-file-2026-guide\/#Frequently-Asked-Questions-About-CLAUDEmd\" >Frequently Asked Questions About CLAUDE.md<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-9\" href=\"https:\/\/ceotudent.com\/en\/andrej-karpathy-claude-md-file-2026-guide\/#Conclusion-CLAUDEmd-the-New-Memory-of-AI-Era-Software\" >Conclusion: CLAUDE.md, the New Memory of AI-Era Software<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-10\" href=\"https:\/\/ceotudent.com\/en\/andrej-karpathy-claude-md-file-2026-guide\/#Sources\" >Sources<\/a><\/li><\/ul><\/nav><\/div>\n<h2><span class=\"ez-toc-section\" id=\"Andrej-Karpathy-From-Software-20-to-the-Idea-File\"><\/span>Andrej Karpathy: From Software 2.0 to the Idea File<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><strong>Andrej Karpathy<\/strong> (b. October 23, 1986, Bratislava) is one of modern AI&rsquo;s ten most influential engineers. He completed his computer science PhD at Stanford under Fei-Fei Li in 2016. Three stops shape the spine of his career: he was a <strong>founding researcher at OpenAI<\/strong> (2015\u20132017), then <strong>Tesla&rsquo;s Director of AI<\/strong> (2017\u20132022) running the Autopilot Vision team, briefly rejoined OpenAI in 2023, and in <strong>2024 founded Eureka Labs<\/strong>. His YouTube channel \u2014 home to the marathon <em>&ldquo;Let&rsquo;s build GPT from scratch&rdquo;<\/em> lectures \u2014 has crossed 2 million subscribers.<\/p>\n<p>Reading Karpathy as a pure technical researcher misses the point. He is also the designer of AI&rsquo;s creative vocabulary. In <strong>Software 2.0<\/strong> (2017) he argued that programs are increasingly &ldquo;written&rdquo; not by developers but by neural networks learning weights. Provocative in 2017, the sector&rsquo;s shared reality in 2026. <strong>Vibe coding<\/strong> \u2014 building software by chatting with AI rather than typing it directly \u2014 is the term he popularised in early 2025. <strong>Agentic coding<\/strong> describes long-horizon task automation with autonomous models like Claude Code, Codex CLI, Aider and Cline.<\/p>\n<p>The most recent break came between <strong>November 2025 and January 2026<\/strong>. In that window Karpathy moved <strong>80% of his routine from manual coding to agent-driven coding<\/strong> and called it <em>&ldquo;the biggest workflow shift in roughly 20 years of programming.&rdquo;<\/em> Claude Code and its memory file \u2014 CLAUDE.md \u2014 sat at the centre of that shift. In <strong>April 2026<\/strong> he pushed the topic a step further with the &ldquo;idea file&rdquo; concept: a new personal knowledge architecture based on <strong>sharing ideas, not code<\/strong>. In his words: <em>&ldquo;You just share the idea, then the other person&rsquo;s agent customizes &amp; builds it for your specific needs.&rdquo;<\/em><\/p>\n<p><iframe src=\"https:\/\/www.youtube.com\/embed\/LCEmiRjPEtQ?start=13&#038;rel=0\" title=\"Andrej Karpathy \u2014 Software Is Changing (Again), YC AI Startup School 2024\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe><\/p>\n<blockquote>\n<p>\ud83d\udcfa The starting point for this article is Karpathy&rsquo;s keynote <em>&ldquo;Software Is Changing (Again)&rdquo;<\/em> at <strong>Y Combinator AI Startup School 2024<\/strong>. Vibe coding and agentic coding are summarised most clearly in that talk.<\/p>\n<\/blockquote>\n<hr>\n<h2><span class=\"ez-toc-section\" id=\"What-Is-CLAUDEmd-and-How-Does-It-Fit-With-Auto-Memory\"><\/span>What Is CLAUDE.md and How Does It Fit With Auto Memory?<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>CLAUDE.md is the persistent instruction file you write and edit; Claude Code reads it at the start of every session. Anthropic&rsquo;s docs put it plainly: <em>&ldquo;Instructions you write to give Claude persistent context.&rdquo;<\/em> In 2026 a second memory layer was added: <strong>auto memory<\/strong>. The split between them: you write CLAUDE.md (rules, architecture); Claude writes auto memory (insights it has inferred from your past corrections and preferences). Auto memory shipped with Claude Code v2.1.59 and persists at <code>~\/.claude\/projects\/&lt;project&gt;\/memory\/MEMORY.md<\/code>. At the start of each chat, the first 200 lines (or 25KB) of MEMORY.md get injected into context.<\/p>\n<table>\n<thead>\n<tr>\n<th>Feature<\/th>\n<th><strong>CLAUDE.md<\/strong><\/th>\n<th><strong>Auto memory<\/strong><\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Author<\/td>\n<td>You<\/td>\n<td>Claude<\/td>\n<\/tr>\n<tr>\n<td>Content type<\/td>\n<td>Instructions and rules<\/td>\n<td>Inferred learnings and patterns<\/td>\n<\/tr>\n<tr>\n<td>Scope<\/td>\n<td>Project, user or organisation<\/td>\n<td>Per worktree<\/td>\n<\/tr>\n<tr>\n<td>Loading<\/td>\n<td>Fully each session<\/td>\n<td>First 200 lines \/ 25KB each session<\/td>\n<\/tr>\n<tr>\n<td>Main use<\/td>\n<td>Code standards, architecture, workflow<\/td>\n<td>Build commands, debug findings, preferences<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>CLAUDE.md itself gained a richer structure in 2026. <strong>Four scopes<\/strong> are supported: organisation-wide <strong>managed policy<\/strong> files distributed by IT\/DevOps (macOS at <code>\/Library\/Application Support\/ClaudeCode\/CLAUDE.md<\/code>, Linux at <code>\/etc\/claude-code\/CLAUDE.md<\/code>, Windows at <code>C:Program FilesClaudeCodeCLAUDE.md<\/code>); team-specific <strong>project<\/strong> files (<code>.\/CLAUDE.md<\/code> or <code>.\/.claude\/CLAUDE.md<\/code>); <strong>user<\/strong> files covering all your projects (<code>~\/.claude\/CLAUDE.md<\/code>); and <strong>local<\/strong> files for project-only personal notes that go into <code>.gitignore<\/code> (<code>.\/CLAUDE.local.md<\/code>). More specific scopes override broader ones.<\/p>\n<p>Loading mechanics widened too. Starting from the working directory, Claude walks <strong>upward to the filesystem root<\/strong> scanning every directory for <code>CLAUDE.md<\/code> and <code>CLAUDE.local.md<\/code>; all matches are pulled into context. CLAUDE.md files in subdirectories are not loaded at launch \u2014 they load <strong>on-demand<\/strong> when Claude reads a file in that directory. If you bring in extra directories with <code>--add-dir<\/code>, set the <code>CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1<\/code> environment variable to load their CLAUDE.md files too. After a compaction (<code>\/compact<\/code>) the project-root CLAUDE.md is reloaded automatically; nested files come back with the next relevant read.<\/p>\n<hr>\n<h2><span class=\"ez-toc-section\" id=\"2026-New-Features-Imports-clauderules-AGENTSmd-Interop\"><\/span>2026 New Features: Imports, .claude\/rules\/, AGENTS.md Interop<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>To stop CLAUDE.md from ballooning into one giant file, Anthropic standardised the <strong><code>@path\/to\/import<\/code><\/strong> syntax. It pulls other markdown files into CLAUDE.md; relative and absolute paths both work; recursion is allowed up to <strong>5 hops deep<\/strong>. Typical usage:<\/p>\n<pre><code class=\"language-markdown\">See @README for project overview and @package.json for available npm commands.\n\n# Additional Instructions\n- git workflow @docs\/git-instructions.md\n- personal preferences @~\/.claude\/my-project-instructions.md\n<\/code><\/pre>\n<p>The second major addition is the <strong><code>.claude\/rules\/<\/code><\/strong> folder and its <strong>path-scoped rules<\/strong>. Instead of cramming every instruction into one CLAUDE.md, split rules into topic-specific markdown files with YAML frontmatter that activates them only when Claude touches matching paths:<\/p>\n<pre><code class=\"language-markdown\">---\npaths:\n  - &quot;src\/api\/**\/*.ts&quot;\n  - &quot;lib\/**\/*.{ts,tsx}&quot;\n---\n\n# API Development Rules\n- All API endpoints must include input validation\n- Use the standard error response format\n- Include OpenAPI documentation comments\n<\/code><\/pre>\n<p>Rules files with no path frontmatter load every time; ones with it activate only when Claude is working in matching files. This is critical for monorepos where different teams maintain their own rule sets. The <strong><code>claudeMdExcludes<\/code><\/strong> setting also lets you selectively disable ancestor-directory CLAUDE.md files.<\/p>\n<p>The third addition is <strong>AGENTS.md interoperability<\/strong>. Cursor, Codex, Aider and other agents read AGENTS.md; Claude Code only reads CLAUDE.md. The standard way to resolve the conflict now:<\/p>\n<pre><code class=\"language-markdown\">@AGENTS.md\n\n## Claude Code\nUse plan mode for changes under `src\/billing\/`.\n<\/code><\/pre>\n<p>Same instruction set shared across all your agent tools; the short Claude-specific section adds the extras. On the slash-command side: <strong><code>\/init<\/code><\/strong> drafts the file, <strong><code>\/memory<\/code><\/strong> lists currently loaded files and lets you edit them, and the <strong><code>InstructionsLoaded<\/code> hook<\/strong> lets you debug what loaded when. Setting <code>CLAUDE_CODE_NEW_INIT=1<\/code> turns <code>\/init<\/code> into an interactive multi-phase flow: a subagent inspects the repo, asks you about gaps, and proposes a reviewable file before writing.<\/p>\n<hr>\n<h2><span class=\"ez-toc-section\" id=\"Karpathys-Idea-File-Approach-April-2026\"><\/span>Karpathy&rsquo;s Idea File Approach (April 2026)<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>On 3 April 2026, Karpathy proposed a new sharing format on X and then in a GitHub gist: the <em>&ldquo;idea file&rdquo;<\/em>. Classic open source is built on sharing code; an idea file shares the idea, and the other side&rsquo;s agent <strong>rebuilds it for their environment<\/strong>. The reasoning was simple: in 2026 \u2014 with agent models strong enough \u2014 copying <strong>intent<\/strong> is more efficient than copying code pixel-by-pixel.<\/p>\n<p>The concrete shape is a three-layer structure. Layer one is the <code>raw\/<\/code> folder: papers, articles, images, datasets land here. The LLM <strong>reads but never modifies<\/strong> this folder \u2014 sources are immutable and verifiable. Layer two is the <code>wiki\/<\/code> folder: LLM-produced summary pages, concept pages and entity pages live here, cross-referenced and <strong>growing cumulatively<\/strong> instead of being re-derived per query. Layer three is the <code>CLAUDE.md<\/code> file (alternatively <code>AGENTS.md<\/code> or <code>OPENCODE.md<\/code>), which defines the <strong>schema<\/strong> of the whole system and how it&rsquo;s maintained.<\/p>\n<p>The system runs three operations. <strong>Ingest:<\/strong> when a new source lands in <code>raw\/<\/code>, the LLM reads it and simultaneously updates 10\u201315 wiki pages, keeps an index and an activity log. <strong>Query:<\/strong> questions go through the structure; valuable answers get filed back as new pages so knowledge compounds. <strong>Lint:<\/strong> periodic health checks surface contradictions, orphan pages, missing concepts and suggested reviews. Karpathy ties this to <strong>Vannevar Bush&rsquo;s 1945 Memex concept<\/strong>; Bush&rsquo;s unsolved &ldquo;who maintains it?&rdquo; question is finally answered by LLMs.<\/p>\n<p>This architecture diverges from classic RAG (Retrieval-Augmented Generation) on one core point. RAG goes back to sources and synthesises on every query; the idea file approach <strong>compiles knowledge once and keeps it fresh<\/strong>, rather than re-deriving each time. In Karpathy&rsquo;s words: <em>&ldquo;The knowledge is compiled once and then kept current, not re-derived on every query.&rdquo;<\/em> CLAUDE.md is the schema file that turns a generic chatbot into a <strong>disciplined wiki maintainer<\/strong>.<\/p>\n<hr>\n<h2><span class=\"ez-toc-section\" id=\"How-to-Write-an-Effective-CLAUDEmd-2026-Standards\"><\/span>How to Write an Effective CLAUDE.md (2026 Standards)<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>Four principles from Anthropic&rsquo;s own docs form the core of effective CLAUDE.md writing. <strong>Size:<\/strong> keep the file under 200 lines; longer files consume more context and reduce adherence. If instructions grow, split via path-scoped rules or imports. <strong>Structure:<\/strong> instructions grouped under markdown headings and bullets are far more scannable than loose paragraphs; Claude reads like a human. <strong>Specificity:<\/strong> write verifiable, concrete instructions. <em>&ldquo;Format code properly&rdquo;<\/em> \u2192 <em>&ldquo;Use 2-space indentation&rdquo;<\/em>; <em>&ldquo;Test your changes&rdquo;<\/em> \u2192 <em>&ldquo;Run <code>npm test<\/code> before committing&rdquo;<\/em>; <em>&ldquo;Keep files organised&rdquo;<\/em> \u2192 <em>&ldquo;API handlers live in <code>src\/api\/handlers\/<\/code>&ldquo;<\/em>. <strong>Consistency:<\/strong> when instructions conflict, Claude picks one at random; review and refresh CLAUDE.md and nested CLAUDE.md files periodically.<\/p>\n<p>When should something go into CLAUDE.md? Anthropic&rsquo;s guidance is blunt: <em>&ldquo;Treat CLAUDE.md as the place you write down what you&rsquo;d otherwise re-explain.&rdquo;<\/em> If Claude makes the same mistake twice, if a convention caught in code review is something Claude also needs to know, if you find yourself writing the same correction you wrote last session, or if a new teammate would need a piece of context to be productive \u2014 all of those are CLAUDE.md entries. Multi-step procedures or rules that apply to only a corner of the codebase belong in a <strong>skill<\/strong> or a <strong>path-scoped rule<\/strong>, not in CLAUDE.md itself.<\/p>\n<p>The template below is the minimum functional starting point for a 2026 CLAUDE.md. Copy it directly into your project:<\/p>\n<pre><code class=\"language-markdown\"># Project Name\n\n## What this is\nOne-paragraph summary of what the project does and why it exists.\n\n## Tech stack\n- Language: Python 3.12 \/ TypeScript 5.4\n- Framework: FastAPI \/ Next.js 15\n- DB: PostgreSQL 16\n- Tests: pytest + httpx \/ vitest\n\n## Commands\n- Install: `uv sync` \/ `pnpm install`\n- Run dev: `uv run uvicorn app.main:app --reload` \/ `pnpm dev`\n- Test: `uv run pytest -x` \/ `pnpm test`\n- Lint: `uv run ruff check .` \/ `pnpm lint`\n- Typecheck: `uv run mypy app\/` \/ `pnpm typecheck`\n\n## Conventions\n- Type hints everywhere\n- Public functions: docstrings (Google style)\n- Tests live in `tests\/` matching `app\/` structure\n- No global state \u2014 pass dependencies explicitly\n\n## Don't\n- No emoji in code or commits\n- No `print()` for debug \u2014 use `logger.debug()`\n- No new dependencies without justifying in PR description\n- Don't write code comments that just restate what code does\n\n## Common pitfalls\n- DB migrations: run `alembic upgrade head` after pulling\n- The `vendor\/` folder is git-tracked but not editable\n- `pytest` requires `.env.test` (copy from `.env.test.example`)\n\n## Architecture in 3 lines\n- Request \u2192 middleware (auth) \u2192 router \u2192 service \u2192 repository \u2192 DB\n- Async I\/O end-to-end with `asyncpg`\n- Background jobs in `app\/jobs\/` use `arq` (not Celery)\n\n## Imports\n@README.md\n@docs\/architecture.md\n@AGENTS.md\n<\/code><\/pre>\n<p>Two extra pieces of advice from Karpathy&rsquo;s practice: first, the <em>&ldquo;AI is a junior dev with infinite enthusiasm&rdquo;<\/em> analogy \u2014 the AI agent is like a talented but amnesiac junior developer who needs the morning briefing each day; CLAUDE.md is that briefing in writing. Second, the <em>&ldquo;living memory&rdquo;<\/em> principle: the file shouldn&rsquo;t be a write-once-and-forget README \u2014 it should grow with every new mistake the AI makes.<\/p>\n<hr>\n<h2><span class=\"ez-toc-section\" id=\"CLAUDEmd-vs-Cursor-Rules-vs-ChatGPT-Custom-Instructions\"><\/span>CLAUDE.md vs Cursor Rules vs ChatGPT Custom Instructions<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>The three main AI coding tools store developer context in different ways. As of 2026 <strong>Claude Code&rsquo;s CLAUDE.md system<\/strong> is the richest and most hierarchical \u2014 managed\/project\/user\/local + path-scoped rules + auto memory + imports. <strong>Cursor<\/strong> offers a similar structure with markdown + YAML frontmatter inside <code>.cursor\/rules\/<\/code>, but lacks a user-level shared scope. <strong>ChatGPT Custom Instructions<\/strong> is tied to your OpenAI account, stored in the cloud, and consists of two free-text fields \u2014 no project context support.<\/p>\n<table>\n<thead>\n<tr>\n<th>Dimension<\/th>\n<th>CLAUDE.md (Claude Code)<\/th>\n<th>Cursor Rules<\/th>\n<th>ChatGPT Custom Instructions<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Location<\/td>\n<td>Repo + user + managed (org)<\/td>\n<td><code>.cursor\/rules\/*.md<\/code><\/td>\n<td>OpenAI account (cloud)<\/td>\n<\/tr>\n<tr>\n<td>Hierarchy<\/td>\n<td>4 scopes + nested + auto memory<\/td>\n<td>Project only<\/td>\n<td>User only<\/td>\n<\/tr>\n<tr>\n<td>Format<\/td>\n<td>Markdown + YAML frontmatter (rules)<\/td>\n<td>Markdown + YAML frontmatter<\/td>\n<td>Plain text (2 fields)<\/td>\n<\/tr>\n<tr>\n<td>Imports<\/td>\n<td><code>@path<\/code> 5-hop recursive<\/td>\n<td>Limited<\/td>\n<td>None<\/td>\n<\/tr>\n<tr>\n<td>Path-scoped rules<\/td>\n<td>\u2705 <code>.claude\/rules\/<\/code> + paths glob<\/td>\n<td>Partial<\/td>\n<td>\u274c<\/td>\n<\/tr>\n<tr>\n<td>Auto memory<\/td>\n<td>\u2705 v2.1.59+<\/td>\n<td>\u274c<\/td>\n<td>\u274c<\/td>\n<\/tr>\n<tr>\n<td>AGENTS.md interop<\/td>\n<td>\u2705 <code>@AGENTS.md<\/code> import<\/td>\n<td>\u274c<\/td>\n<td>\u274c<\/td>\n<\/tr>\n<tr>\n<td>Version control<\/td>\n<td>Yes (in Git)<\/td>\n<td>Yes (in Git)<\/td>\n<td>No (cloud-only)<\/td>\n<\/tr>\n<tr>\n<td>Team sharing<\/td>\n<td>Yes<\/td>\n<td>Yes<\/td>\n<td>No<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>The practical takeaway: if you use all tools in the same project, write <strong>CLAUDE.md as the master source<\/strong>, import AGENTS.md from it, and copy 1:1 into <code>.cursor\/rules\/<\/code> for Cursor. Put <strong>personal preferences only<\/strong> into ChatGPT Custom Instructions (e.g. &ldquo;Reply in English, code comments in English&rdquo;) \u2014 project details don&rsquo;t belong there because they apply to every project in your account.<\/p>\n<hr>\n<h2><span class=\"ez-toc-section\" id=\"Practical-Tips-for-Turkish-Developers\"><\/span>Practical Tips for Turkish Developers<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>CLAUDE.md adoption spread quickly across Turkey&rsquo;s developer community from late 2025. You see it in side projects opened on GitHub by Insider, Trendyol, Hepsiburada, Getir and others. The shared rule across those projects is <strong>language consistency<\/strong>: code comments, error messages and docstrings should be in English; user-facing documentation can be in Turkish; PR descriptions are bilingual. A single line in CLAUDE.md does it: <em>&ldquo;Code comments, docstrings, error messages: English. Documentation in <code>docs\/<\/code>: Turkish. PR descriptions: bilingual.&rdquo;<\/em><\/p>\n<p>The second issue you encounter in Turkish projects is <strong>encoding and locale<\/strong>. UTF-8 file encoding (no BOM), <code>utf8mb4_unicode_ci<\/code> database collation, and explicit <code>tr_TR.UTF-8<\/code> for locale-sensitive sort tests are standard practice. Without that small note the classic <em>&ldquo;i \/ \u0130 \/ \u0131 \/ I&rdquo;<\/em> trap keeps producing bad results. The third critical block is <strong>regulation and local business rules<\/strong>: KVKK compliance (don&rsquo;t log TC ID numbers), e-fatura inside the <code>eFatura.NS<\/code> namespace, TL pricing format adhering to <code>f\"{amount:,.2f} \u20ba\"<\/code> \u2014 none of which the AI can infer on its own.<\/p>\n<p>A final tip: <strong>version CLAUDE.md with your team<\/strong>. Keep it on <code>main<\/code> and review every change in PR. A rule one developer adds becomes the team&rsquo;s instant standard because the AI always reads the latest version. This is the foundation of the recent shift in Turkish engineering teams toward <strong>codifying technical standards together with the AI<\/strong>.<\/p>\n<hr>\n<h2><span class=\"ez-toc-section\" id=\"Frequently-Asked-Questions-About-CLAUDEmd\"><\/span>Frequently Asked Questions About CLAUDE.md<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<h3>Are CLAUDE.md and auto memory the same thing?<\/h3>\n<p>No. CLAUDE.md is the file you write that explains rules and architecture. Auto memory is what Claude keeps on its own at <code>~\/.claude\/projects\/&lt;project&gt;\/memory\/MEMORY.md<\/code> \u2014 inferred preferences from past corrections. The two load together; neither replaces the other. Auto memory is available in Claude Code v2.1.59+.<\/p>\n<h3>What happens if <code>~\/.claude\/CLAUDE.md<\/code> and <code>.\/CLAUDE.md<\/code> conflict?<\/h3>\n<p>Both load and contents merge. For directly conflicting rules, the <strong>project level (.\/CLAUDE.md) wins<\/strong> because it&rsquo;s more specific. Use the user level for &ldquo;things I want in every project,&rdquo; the project level for &ldquo;rules unique to this project.&rdquo;<\/p>\n<h3>How do <code>@path<\/code> imports work?<\/h3>\n<p>Writing <code>@README.md<\/code> or <code>@~\/.claude\/preferences.md<\/code> makes Claude pull that file into context. Both relative and absolute paths are supported. Max recursion is 5 hops \u2014 an imported file can import another, which can import another, but the 6th level is rejected. The first external import shows an approval dialog; declining it dismisses the dialog permanently.<\/p>\n<h3>What&rsquo;s the difference between <code>.claude\/rules\/<\/code> and CLAUDE.md?<\/h3>\n<p>CLAUDE.md always loads; files under <code>.claude\/rules\/<\/code> with a <code>paths<\/code> frontmatter load only when Claude is processing a matching file. In big projects, the rules folder slices instructions by topic\/path and <strong>reduces context spend<\/strong>. Rules files without a <code>paths<\/code> frontmatter carry the same priority as CLAUDE.md.<\/p>\n<h3>How do skills, plugins and subagents relate to CLAUDE.md?<\/h3>\n<p>Skills are heavier modules invoked on demand, not loaded each session. Plugins package MCP servers, slash commands and skill bundles for distribution. Subagents can keep their own auto memory (<code>enable-persistent-memory<\/code>). CLAUDE.md sits as the base context layer underneath all of these; task-specific flows move into skills.<\/p>\n<h3>Did Karpathy&rsquo;s &ldquo;idea file&rdquo; concept redefine CLAUDE.md?<\/h3>\n<p>Not directly, but it widened its scope. Classic CLAUDE.md holds rules and commands. In Karpathy&rsquo;s April 2026 proposal, CLAUDE.md additionally plays the role of <strong>the schema file<\/strong> governing <code>raw\/<\/code> (sources) and <code>wiki\/<\/code> (LLM-compiled knowledge). That moves CLAUDE.md from a command list into the <strong>centre of the knowledge management system<\/strong>.<\/p>\n<h3>Where do you follow Karpathy?<\/h3>\n<p>Four main channels: <strong>YouTube<\/strong> (<a href=\"https:\/\/www.youtube.com\/@AndrejKarpathy\" rel=\"noopener\">@AndrejKarpathy<\/a>) for marathon lectures, <strong>X \/ Twitter<\/strong> (<a href=\"https:\/\/x.com\/karpathy\">@karpathy<\/a>) for daily observations, <strong>GitHub<\/strong> (<a href=\"https:\/\/github.com\/karpathy\" rel=\"noopener\">github.com\/karpathy<\/a>) for open-source projects like <code>nanogpt<\/code>, <code>nanochat<\/code>, <code>makemore<\/code>, <code>micrograd<\/code>, <code>llm.c<\/code>, and <strong>Eureka Labs<\/strong> (<a href=\"https:\/\/eurekalabs.ai\" rel=\"noopener\">eurekalabs.ai<\/a>) for AI-education platform announcements. The <strong>idea file gist<\/strong> is directly at <a href=\"https:\/\/gist.github.com\/karpathy\/442a6bf555914893e9891c11519de94f\" rel=\"noopener\">gist.github.com\/karpathy\/442a6bf555914893e9891c11519de94f<\/a>.<\/p>\n<hr>\n<h2><span class=\"ez-toc-section\" id=\"Conclusion-CLAUDEmd-the-New-Memory-of-AI-Era-Software\"><\/span>Conclusion: CLAUDE.md, the New Memory of AI-Era Software<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>CLAUDE.md is a simple-looking convention that is reshaping the nature of software development. By 2026 it&rsquo;s no longer <strong>a single file<\/strong> but a system encompassing <strong>four scopes, imports, path-scoped rules, auto memory and idea-file architecture<\/strong>. As Karpathy points out: software&rsquo;s new currency isn&rsquo;t just code; it&rsquo;s the context you give the AI. Keeping that context persistent, continuously updated and team-shared has become the new baseline configuration for modern software teams.<\/p>\n<p>The practical plan is simple. <strong>Day one<\/strong>: start Claude Code in any open project of yours and run <code>\/init<\/code> (ideally with <code>CLAUDE_CODE_NEW_INIT=1<\/code>). <strong>Day two<\/strong>: edit the generated draft against the template in this guide. <strong>Week one<\/strong>: every time the AI makes a mistake, add a one-liner to CLAUDE.md before fixing it. <strong>Week two<\/strong>: share with your team and bring it into PR review. <strong>A month later<\/strong>: if the file is approaching 200 lines, split via <code>.claude\/rules\/<\/code> and start using <code>@path<\/code> imports. <strong>Three months later<\/strong>: consider Karpathy&rsquo;s idea-file architecture with <code>raw\/<\/code> and <code>wiki\/<\/code> layers.<\/p>\n<p>The recommendation is clear: treat CLAUDE.md with the same seriousness as <code>README.md<\/code>. Every line you&rsquo;ve added in a month is a mistake the AI hasn&rsquo;t made in a month. This investment compounds \u2014 the return grows as the weeks pass.<\/p>\n<hr>\n<h2><span class=\"ez-toc-section\" id=\"Sources\"><\/span>Sources<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<ul>\n<li><strong>Anthropic.<\/strong> <em>Claude Code Documentation \u2014 How Claude remembers your project<\/em>. code.claude.com\/docs\/en\/memory (accessed 2026-05-01)<\/li>\n<li><strong>Anthropic.<\/strong> <em>Claude Code: Skills, Plugins, Hooks, Subagents documentation<\/em>. code.claude.com\/docs\/en<\/li>\n<li><strong>Karpathy, Andrej.<\/strong> <em>Idea file<\/em> \u2014 GitHub gist, April 2026. gist.github.com\/karpathy\/442a6bf555914893e9891c11519de94f<\/li>\n<li><strong>Karpathy, Andrej.<\/strong> <em>X (Twitter) posts<\/em>, <a href=\"https:\/\/x.com\/karpathy\">@karpathy<\/a> \u2014 3 April 2026 idea-file tweet and follow-up discussions.<\/li>\n<li><strong>Karpathy, Andrej.<\/strong> <em>Software Is Changing (Again)<\/em> \u2014 keynote, <strong>Y Combinator AI Startup School<\/strong>, 2024. YouTube: youtube.com\/watch?v=LCEmiRjPEtQ<\/li>\n<li><strong>Karpathy, Andrej.<\/strong> <em>Software 2.0<\/em>. Medium, November 2017. karpathy.medium.com\/software-2-0-a64152b37c35<\/li>\n<li><strong>Karpathy, Andrej.<\/strong> <a href=\"https:\/\/github.com\/karpathy\" rel=\"noopener\">github.com\/karpathy<\/a> \u2014 CLAUDE.md and AGENTS.md examples in <code>nanogpt<\/code>, <code>nanochat<\/code>, <code>makemore<\/code>, <code>micrograd<\/code>, <code>llm.c<\/code>.<\/li>\n<li><strong>Antigravity Codes.<\/strong> <em>Karpathy&rsquo;s LLM Wiki: The Complete Guide to His Idea File<\/em>. antigravity.codes\/blog\/karpathy-llm-wiki-idea-file<\/li>\n<li><strong>MCP Directory.<\/strong> <em>Claude Code Best Practices: A Developer&rsquo;s Guide (2026)<\/em>. mcp.directory\/blog\/claude-code-best-practices<\/li>\n<\/ul>\n<hr>\n<blockquote>\n<p><strong>Related reading:<\/strong> <a href=\"\/en\/what-is-generation-alpha-2026-guide\">What Is Generation Alpha? 2026 Guide<\/a> \u00b7 <a href=\"\/en\/60-business-ideas-2026\">60 Business Ideas 2026: A List Built for the AI Era<\/a> \u00b7 <a href=\"\/en\/best-video-call-apps-2026\">Best Video Call Apps 2026<\/a> \u00b7 <a href=\"\/en\/how-to-build-a-daily-plan\">How to Build a Daily Plan<\/a><\/p>\n<\/blockquote>\n","protected":false},"excerpt":{"rendered":"<p>Anthropic Claude Code&#8217;s project memory CLAUDE.md became a comprehensive memory layer in 2026 with four scopes (managed \/ project \/ user \/ local), @path imports syntax, auto memory (v2.1.59+), path-scoped rules via `.claude\/rules\/`, and AGENTS.md interoperability. Andrej Karpathy then redefined CLAUDE.md in April 2026 with his `idea file` concept as the core schema of a 3-layer knowledge architecture (raw \/ wiki \/ schema). This guide covers all those innovations and the 2026 standards for writing an effective CLAUDE.md.<\/p>\n","protected":false},"author":1,"featured_media":324011,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4456,9],"tags":[],"class_list":["post-323461","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-dijital","category-teknoloji"],"_links":{"self":[{"href":"https:\/\/ceotudent.com\/en\/wp-json\/wp\/v2\/posts\/323461","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ceotudent.com\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ceotudent.com\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ceotudent.com\/en\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/ceotudent.com\/en\/wp-json\/wp\/v2\/comments?post=323461"}],"version-history":[{"count":0,"href":"https:\/\/ceotudent.com\/en\/wp-json\/wp\/v2\/posts\/323461\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ceotudent.com\/en\/wp-json\/wp\/v2\/media\/324011"}],"wp:attachment":[{"href":"https:\/\/ceotudent.com\/en\/wp-json\/wp\/v2\/media?parent=323461"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ceotudent.com\/en\/wp-json\/wp\/v2\/categories?post=323461"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ceotudent.com\/en\/wp-json\/wp\/v2\/tags?post=323461"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}