Standardize Agent Rules with AGENTS.md

Create and test one AGENTS.md file that guides multiple coding agents.

Introduction

30 Second Summary

A small coding preference can turn into repeated cleanup when every assistant makes the same unwanted choice. Switching tools makes that repetition even harder to control.

In this project, you will prove that one AGENTS.md file can guide two coding agents by comparing their responses to the same request. You will also test the precedence of CLAUDE.md in Claude Code.

What You'll Build

You'll watch two coding agents apply the same house rules to the same request in your repo.

By the end of this project, you'll have:

  • A clear before-and-after comparison showing how an agent responds without repo instructions, then changes after reading AGENTS.md.
  • Shared coding rules that produce visible, repeatable choices across two agents.
  • A tested precedence result showing whether Claude Code follows CLAUDE.md or AGENTS.md when both files exist.
  • Secret Mission: An optional challenge to test your shared instructions in one more scenario.

Are there any prerequisites?

You'll need Git, a repo of your own, plus a coding agent that is already installed and signed in. This project adds no new charge beyond whatever you already pay for agent access.

Before We Start

Coding agents often look for different instruction files. A clean baseline lets you prove what changes after AGENTS.md appears.

This experiment depends on Claude Code version 2.1.277 or later. Checking the version first protects your test from a false negative.

You also need a test repository with no existing agent instructions. A second coding agent gives you a portability check against the same repository.

In this step, get ready to:
  • Confirm Claude Code is version 2.1.277 or later.
  • Select a test repository with no coding-agent instruction file.
  • Prepare a second coding agent that supports AGENTS.md.
Prepare Claude Code

Support for the fallback used in this project begins with Claude Code version 2.1.277. The version number determines which setup path you need.

  • Press Cmd+Space on macOS or the Windows key on Windows to open your search bar.
  • Type Terminal on macOS or PowerShell on Windows into the search bar.
  • Press Enter to open the terminal.
  • Check your Claude Code version by running this command:
claude --version

What does this command do?

The claude --version command prints the installed Claude Code version. Use that number to choose the matching path below.

✔️ I see version 2.1.277 or higher

You're set. This Claude Code installation includes the fallback behavior needed for the experiment.

ⓧ I see an older version

  • Update Claude Code by running this command:
claude update

What does this command do?

The claude update command requests the latest release available to your installation. The updated version becomes active when you next start Claude Code.

Before you check again, do you expect the printed version to meet the project's minimum?

  • Check the installed version again by running this command:
claude --version

What does this command do?

This check prints the version now available in your terminal. The result confirms whether the update reached 2.1.277 or later.

You should now see version 2.1.277 or higher.

ⓧ Command not found

Claude Code needs its official installer before the version check can work. Choose your operating system below.

macOS

  • Install Claude Code by running this command:
curl -fsSL https://claude.ai/install.sh | bash
What does this command do?

This command downloads the official native installer from Anthropic. The installer adds Claude Code to your machine.

  • Close the current terminal session.
  • Press Cmd+Space to open Spotlight.
  • Type Terminal into Spotlight.
  • Press Enter to start a new terminal session.
  • Confirm the installed version by running this command:
claude --version
What does this command do?

This command confirms that the new terminal can find Claude Code. It also prints the installed version.

You should see version 2.1.277 or higher.

Windows

  • Install Claude Code by running this command in PowerShell:
irm https://claude.ai/install.ps1 | iex
What does this command do?

This command downloads the official native installer from Anthropic. The installer adds Claude Code to your machine.

  • Close the current PowerShell session.
  • Press the Windows key to open search.
  • Type PowerShell into search.
  • Press Enter to start a new PowerShell session.
  • Confirm the installed version by running this command:
claude --version
What does this command do?

This command confirms that the new PowerShell session can find Claude Code. It also prints the installed version.

You should see version 2.1.277 or higher.

Linux

  • Install Claude Code by running this command:
curl -fsSL https://claude.ai/install.sh | bash
What does this command do?

This command downloads the official native installer from Anthropic. The installer adds Claude Code to your machine.

  • Close the current terminal session.
  • Open a new terminal from your application launcher.
  • Confirm the installed version by running this command:
claude --version
What does this command do?

This command confirms that the new terminal can find Claude Code. It also prints the installed version.

You should see version 2.1.277 or higher.

Still on an older version?

A package manager may control your Claude Code installation. Follow the official Claude Code setup guide for the update path that matches your installation method.

Ask for help with updating your Claude Code installation.

Select a clean test repository

Your Git repository is the control for this experiment. Existing instruction files would hide whether the fallback caused the agent's behavior to change.

  • Select a repository of your own that can accept a temporary small change.
  • Inspect the top level of that repository in Finder on macOS or File Explorer on Windows.
  • Confirm that CLAUDE.md is absent.
  • Confirm that AGENTS.md is absent.
  • Confirm that no other coding-agent instruction file is present.
  • Choose a different repository if an instruction file is present.
  • Record the full repository path here: full path to your test repository.
  • Switch your terminal to the test repository by running this command:
cd "[[TEST_REPO_PATH="full path to your test repository"]]"

What does this command do?

The cd command changes the terminal's current folder. Claude Code uses that folder for the session you start next.

  • Start Claude Code inside the test repository by running this command:
claude

What does this command do?

The claude command starts an interactive Claude Code session in the current repository. This gives the later tests a consistent starting point.

You should see Claude Code ready for a prompt inside your chosen test repository.

Claude Code opened in the wrong repository?

End the session before changing folders. Check that the saved path points to the repository folder itself.

Ask for help with opening the correct repository in Claude Code.

Prepare a second coding agent

The second agent is your portability check. Its official documentation must list support for repository-level AGENTS.md instructions.

  • Choose a second coding agent that you already have installed.
  • Confirm that you are signed in to the second agent.
  • Check the agent's official documentation for AGENTS.md support.
  • Open the same test repository through the agent's project or folder picker.
  • Leave the second agent pointed at full path to your test repository.

Before you compare the two agents, do you expect both of them to show the same clean repository?

  • Compare the repository path shown in Claude Code with full path to your test repository.
  • Compare the repository path shown in the second agent with full path to your test repository.
  • Recheck the repository's top-level files in Finder on macOS or File Explorer on Windows.

You should see both agents aimed at the same repository. The repository should contain no CLAUDE.md, AGENTS.md, or other coding-agent instruction file.

Your control is ready. Every later behavior change now has a fair comparison point.

✔️ Awesome, I've got everything!

Both agents can use the same clean test repository. Keep the repository free of instruction files until the baseline test is complete.

ⓧ I'd like to double check the full code

The test repository is available for the experiment. It initially contains no CLAUDE.md, AGENTS.md, or other coding-agent instruction file.

Your two-agent test bench is ready. Next, you will request a small change without repository instructions and capture the choices Claude Code makes on its own.

Verify Your Claude Code Version

The fallback test depends on behavior available from Claude Code version 2.1.277. An older release could make a valid AGENTS.md file look unsupported.

This step updates the CLI before the experiment begins. You will print the active version to prove the terminal is running a compatible release.

In this step, get ready to:
  • Update Claude Code to the latest release.
  • Print the active version to confirm it is 2.1.277 or later.
Update Claude Code

Native installations can download updates in the background. An explicit update applies the configured release channel immediately.

  • Update Claude Code from the terminal from earlier by running this command:
claude update

What does this command do?

The claude update command checks the configured release channel. It applies an available update without waiting for the next background check.

The terminal reports whether it installed a newer release or found your installation current. Your active command is ready for a version check.

Update Not Completing?

  • Check your network connection before running the update again.
  • Use the official Claude Code setup guide to find the upgrade path for your installation method.
  • Help me diagnose why my Claude Code update is failing.
Print the installed version

The claude --version command reads the release used by your active executable. This proves the update reached the installation your terminal runs.

Before you run the check, do you think the active version now clears the project's minimum?

  • Print the active Claude Code version by running this command:
claude --version

What does this command show?

The numeric value identifies your installed release. The (Claude Code) label confirms that the output belongs to the Claude Code CLI.

✔️ I see version 2.1.277 or later

That clears the version gate. Your AGENTS.md fallback experiment now has the release it needs.

ⓧ I see an older version

The active executable is still below the project requirement. Reinstalling the latest native release gives the terminal a fresh compatible binary.

  • Install the latest native release by running this command:
claude install latest

What does this command do?

The claude install latest command installs the newest native binary. This replaces a stale release with the current one.

Before you check again, do you expect your terminal to report a different version?

  • Print the version again by running this command:
claude --version

Why Check Again?

The second check reads the executable after reinstallation. It confirms the version your next Claude Code session uses.

You should now see version 2.1.277 or later.

Still Seeing the Older Version?

Your terminal may be resolving a different Claude Code installation. Use the official setup guide to identify the installation method before changing it.

Help me find why my terminal still uses the older Claude Code version.

That version check removes the first source of false results. Next, you will capture how Claude Code handles a small change before any instruction file can influence it.

Record the Uninstructed Baseline

Claude Code version 2.1.277 or later is ready inside your test repository. The repository has no coding-agent instruction file.

This run creates an uninstructed baseline for Claude Code's default choices. You will record those choices so the next test has a fair comparison.

In this step, get ready to:
  • Define one small request that leaves implementation details open.
  • Run the request in the instruction-free repository.
  • Record the result plus the implementation choices you would change.
Define a fair request

A fair comparison changes one variable at a time. Reusing the same request later makes the instructions file the only new influence.

  • Limit the request to one observable change in the existing repository.
  • Leave naming decisions open to Claude Code.
  • Leave structure decisions open to Claude Code.
  • Leave formatting decisions open to Claude Code.
  • Record the exact wording here: your small change request.
Run the uninstructed request

Claude Code now has a request but no repository-level rules. Its response becomes the control result for every later comparison.

  • Open the test repository in Claude Code.
  • Confirm that AGENTS.md is absent from the repository file list.
  • Confirm that CLAUDE.md is absent from the repository file list.

Before you submit the request, which naming or structure choices do you think Claude Code will make?

  • Enter your small change request as your message to Claude Code.
  • Submit the request.
  • Approve the required repository edit if Claude Code asks for permission.
  • Wait for Claude Code to finish the change.
  • Inspect Claude Code's resulting output.
  • Review every changed file in the repository.

You should see a completed small change shaped by the agent's default choices. This is your uninstructed baseline.

No Repository Change?

  • Confirm that the request describes a concrete change to the existing repository.
  • Confirm that Claude Code can edit the test repository.

Help me turn this into a concrete repository change without adding implementation rules.

You now have a clean control result. Every later run can be compared with this exact output.

Capture the choices you would change

Useful baseline notes name the exact decisions you disagree with. Specific observations make the next comparison visible.

What Counts as an Implementation Choice?

  • Naming choices include the names used for files or code elements.
  • Structure choices include where the new code was placed.
  • Style choices include formatting or comment patterns.
  • Verification choices include tests the agent added or skipped.
  • Identify at least one implementation choice you would change.
  • Decide what you would prefer for each identified choice.

Before you lock in the record, could another person repeat this exact test from your evidence?

  • Check that the saved request matches the message you submitted.
  • Check that your evidence shows Claude Code's resulting output.
  • Check that your notes name at least one implementation choice you would change.
  • Check that AGENTS.md remains absent from the repository.
  • Check that CLAUDE.md remains absent from the repository.
  • Check that no other coding-agent instruction file was added.

You should have the exact request you submitted. You should also have Claude Code's resulting output.

Your notes should name at least one implementation choice you would change. The repository should still have no coding-agent instruction file.

That baseline gives you something real to challenge. Next up, you will write AGENTS.md with rules that target the choices you recorded.

Create Your AGENTS.md Rules

Your uninstructed Claude Code run gave you a baseline. It shows the implementation choices the agent makes when your repository provides no guidance.

Your preferences can only shape the output after you make them explicit. In this step, you will turn three unwanted choices into testable rules inside AGENTS.md.

In this step, get ready to:
  • Convert three baseline choices into direct coding rules.
  • Create AGENTS.md with exactly those three rules.
  • Test the original request against your new repository instructions.
Turn your baseline into three rules

A useful coding rule controls a choice you can see in the finished output. Specific wording gives you clear evidence when you repeat the request.

  • Return to the uninstructed baseline record from earlier.
  • Identify the three recorded implementation choices you most want to reverse.
  • Rewrite the first choice as a direct rule: your first coding rule.
  • Rewrite the second choice as a direct rule: your second coding rule.
  • Rewrite the third choice as a direct rule: your third coding rule.

What Makes a Rule Testable?

Each rule names one observable implementation choice. A reviewer should be able to inspect the new output to decide whether the agent followed it.

Keep each rule to one sentence. Use direct language that states the required result.

Create AGENTS.md

The repository instruction file becomes the shared source for your coding preferences. A three-line format keeps this test focused on the choices from your baseline.

Your File Shape

The file uses exactly three plain-text lines. Each line holds one rule.

  • your first coding rule.
  • your second coding rule.
  • your third coding rule.

No heading appears in the file. No list marker appears before a rule.

  • Return to Claude Code in the test repository from earlier.
  • Ask Claude Code to create AGENTS.md at the repository's top level using the file shape above.

Good. Your repository now has one instruction file containing your own coding decisions.

  • Ask Claude Code to display the complete contents of AGENTS.md.

You should see exactly three lines. Each line should match the rule you captured above.

  • Ask Claude Code to list every coding-agent instruction file at the repository's top level.

You should see AGENTS.md as the only instruction file. CLAUDE.md should be absent.

✔️ Awesome, I've got everything!

Your repository now contains the three rules needed for a controlled before-and-after test.

ⓧ I'd like to double check the full code

Compare your complete AGENTS.md file with this three-line reference.

[[RULE_ONE="your first coding rule"]]
[[RULE_TWO="your second coding rule"]]
[[RULE_THREE="your third coding rule"]]

How to Compare the File

Each saved value occupies its own line. The file contains no other text.

Your repository should still contain no CLAUDE.md file.

File Has Extra Content?

  • Ask Claude Code to remove every heading or list marker from AGENTS.md.
  • Ask Claude Code to remove any rule you did not author.
  • Confirm that AGENTS.md sits at the test repository's top level.

Ask for help with correcting the instruction file.

Repeat the same request

The original request now becomes a controlled test. The request stays constant while repository guidance becomes the only changed condition.

  • Return to the uninstructed baseline record.
  • Locate the exact small change request you sent during the baseline run.

Before you send it again, which rule do you expect to leave the clearest trace in the output?

  • Enter the exact original request in Claude Code.
  • Submit the request.

You should see Claude Code produce an updated result that follows all three rules in AGENTS.md.

There it is. The same request now reflects the coding choices you deliberately placed in the repository.

  • Create a test record containing the repeated small change request.

Your instructed test record should now begin with the same request shown in the baseline.

  • Add Claude Code's new output to the same test record.
  • Compare the instructed output with the uninstructed baseline record.

You should find three specific differences. Each difference should map directly to one rule in AGENTS.md.

Output Still Looks the Same?

  • Confirm that AGENTS.md is inside the same repository Claude Code is using.
  • Tighten any rule that leaves room for multiple implementation choices.
  • Submit the exact baseline request once more after correcting the file.

Ask for help if you need to trace why the rules were ignored.

Your shared rules now work in Claude Code. Next, you will send the same request to your second AGENTS.md-compatible agent to test whether the instructions travel with the repository.

Test a Second Coding Agent

Your Claude Code test proved that AGENTS.md can change how one agent works. The larger payoff comes from carrying those repository rules across tools.

A second coding agent now receives the same small change request. The request stays the same. The repository stays the same.

In this step, get ready to:
  • Point the second agent at the existing test repository.
  • Send the exact small change request from your earlier test.
  • Compare how both agents follow your three repository rules.
Prepare a fair second-agent test

A fair comparison changes one thing at a time. Here, only the agent changes.

Agent interfaces expose repository access in different places, so this part can feel a little fiddly. The important outcome is that the second agent works inside the same test repository.

  • Switch to your second agent that supports AGENTS.md.
  • Point the second agent at the existing test repository.
  • Approve access to the test repository if the agent requests permission.
  • Confirm the repository view lists AGENTS.md.
  • Confirm CLAUDE.md remains absent.
  • Keep AGENTS.md unchanged during this test.
  • Return to your uninstructed baseline record.
  • Copy the exact small change request from that record.

Before you submit the request, do you think the second agent will make the same three rule-aligned choices as Claude Code?

  • Paste the copied request into the second agent.
  • Submit the request.

You should see the second agent produce output that follows all three rules in AGENTS.md.

That is the portability payoff. Your repository rules now shape two agents without a duplicate instructions file.

Second agent ignoring the rules?

  • Check that the second agent is working inside the folder containing AGENTS.md.
  • Confirm the agent supports repository instructions from AGENTS.md.
  • Start a fresh conversation in the second agent to remove instructions carried over from an earlier request.

Help me diagnose why my second coding agent is not following the three rules in AGENTS.md.

Build the comparison record

Rule adherence is the useful measure. Different wording or code structure can still pass when both outputs obey the three written rules.

  • Return to the note or document that holds your earlier test records.
  • Add a Second-agent comparison section beside the Claude Code test record.

Your record now has a dedicated place for evidence from the second agent.

  • Paste the second agent's output into the new section.
  • Record the exact small change request above that output.

The comparison record now pairs the second agent's result with the same request used for Claude Code.

  • Add one comparison entry for each of the three rules in AGENTS.md.
  • Record Claude Code's adherence result under each entry.

You now have three Claude Code results aligned with the exact rules they test.

  • Record the second agent's adherence result under each entry.
  • Note any output differences that do not affect rule adherence.

Before you make your final judgment, do you expect both agents to pass all three rule checks?

  • Reread the three exact rules in AGENTS.md.
  • Check that every rule has an adherence result for both agents.
  • Check that the record includes the shared request and the second agent's output.

You should see the same request, the second agent's output, and three rule-by-rule results for both agents in the comparison record. Both outputs should obey your three rules even when their wording or implementation details differ.

You have proved that one AGENTS.md can guide two coding agents. Your rules now travel with the repository.

Your shared instructions file has passed its cross-agent test. Next, you'll introduce a competing repository instruction and discover which file takes precedence.

Verify Instruction File Precedence

Your shared AGENTS.md has already steered two coding agents from one set of repository rules. The last uncertainty is precedence.

A deliberate conflict between AGENTS.md and CLAUDE.md gives you a controlled test. The repeated request reveals which file Claude Code follows.

The built-in mod source provides a second form of evidence. Reading its lookup behavior turns your observation into a verified explanation.

In this step, get ready to:
  • Create a temporary CLAUDE.md containing one rule that conflicts with an existing rule in AGENTS.md.
  • Repeat the same change request to identify which instruction file Claude Code follows.
  • Inspect the built-in mod source to locate the instruction-file lookup behavior.
Create a conflicting CLAUDE.md

Precedence becomes visible when two instruction files require different observable choices. A single conflict keeps the test focused.

  • Choose one rule in AGENTS.md that produces an obvious difference in the agent's output.
  • Create CLAUDE.md beside AGENTS.md with the same editing method you used earlier. Give the new file exactly one rule that requires the opposite choice.
  • Confirm the repository file list shows AGENTS.md beside CLAUDE.md.

Your repository now contains a controlled conflict. Either file can reveal itself through the next generated change.

✔️ Both instruction files are ready

Your original three rules remain in AGENTS.md. Your temporary CLAUDE.md contains one visibly different rule.

ⓧ I'd like to double check the files

  • Confirm AGENTS.md still contains exactly the three rules from your earlier test.
  • Confirm CLAUDE.md contains exactly one rule.
  • Confirm the CLAUDE.md rule requires a different visible choice from one rule in AGENTS.md.
  • Confirm both files sit in the same test repository.
Run the controlled precedence test

The small change request stays constant during this test. The new instruction-file conflict is the only changed condition.

  • Start a fresh Claude Code conversation from the test repository using the same method as your earlier test.

Before you repeat the request, which file do you think Claude Code uses when both instruction files are present?

  • Submit the exact small change request from your earlier tests.

You should see the visible choice required by CLAUDE.md. This identifies CLAUDE.md as the active project instruction file under the default fallback mode.

What did the test prove?

The default claude-md-or-agents-md mode treats AGENTS.md as a fallback. A project-owned CLAUDE.md causes the built-in mod to stand down.

Your conflicting rule makes that decision visible in the generated output. Repeating the same request keeps the comparison fair.

  • Compare the rerun output with the conflicting rules in both files.
  • Record CLAUDE.md as the followed file in your precedence investigation record.

You have a clean behavioral result. Claude Code used the project-specific instruction file while both files were present.

Seeing mixed or unclear output?

  • Rewrite the conflict as a binary formatting or naming choice that appears in the generated change.
  • Start another fresh conversation so the next request receives newly built instruction context.
  • Use /config to check the Project instructions setting.
  • Select claude-md-or-agents-md for the default fallback behavior tested here.

Ask for help with the exact conflict you created: help me determine why my Claude Code precedence test produced an unclear result

Locate the lookup in the built-in mod

Behavioral evidence tells you what happened. The source shows where Claude Code makes the fallback decision.

The lookup is easy to miss because the mod divides its explanation from its implementation. You will trace the documented mode into the registration module.

Before you inspect the source, where do you expect the fallback check to look for CLAUDE.md?

  • Open the official built-in agents-md mod overview.
  • Find the What it hooks section to identify the event responsible for instruction-file selection.
  • Open the official registration module at mods/agents-md/hooks/register.ts.
  • Press Cmd+F (macOS) or Ctrl+F (Windows) to search the source.
  • Search for isClaudeProject.
  • Read the surrounding prompt.context handler to locate the fallback branch.

Where does the lookup happen?

The prompt.context handler checks the project walk through Names.CLAUDE_NAMES. The result is stored in isClaudeProject.

In fallback mode, a project Claude file makes found use NONE. The Names.AGENTS_NAMES walk supplies fallback files when the project check is false.

  • Add mods/agents-md/hooks/register.ts to your precedence investigation record as the lookup source.
  • Record that the default claude-md-or-agents-md mode yields to a project-owned CLAUDE.md.

Before your final check, do you expect the rerun evidence to agree with the source branch you just inspected?

  • Compare the visible choice in the rerun with the rule stored in CLAUDE.md.
  • Confirm your precedence investigation record names the followed file plus the source location.

That closes the loop. Your observed result matches the built-in lookup behavior.

✔️ My evidence agrees

Your rerun follows CLAUDE.md. Your source inspection explains why AGENTS.md stays in its fallback role.

ⓧ I'd like to double check the full state

  • Confirm AGENTS.md still contains exactly three learner-authored rules.
  • Confirm CLAUDE.md contains exactly one different rule.
  • Confirm the precedence investigation record identifies CLAUDE.md as the followed file.
  • Confirm the precedence investigation record names mods/agents-md/hooks/register.ts as the source location.

Secret mission

Audit Cross-Agent Instruction Conflicts

Two agents can read the same repository instructions yet resolve overlapping files differently. Run a read-only conflict audit to turn that uncertainty into a reusable policy for your team.

Clean Up Your Resources

Clean Up Your Resources

Your files create no ongoing cost, so this project adds nothing beyond the coding-agent access you already use. Decide whether to keep the precedence test, leave its files untouched for later, or remove the temporary duplicate.

Resources you used:

  • Temporary CLAUDE.md in the test repository for the instruction-file precedence test.

What Stays in the Repository?

The AGENTS.md file is the finished project artifact. Keep it as the repository's shared instruction file.

The test repository existed before this project. Cleanup leaves it untouched.

Keep everything running

No action needed. Choose this if you want to keep comparing instruction-file behavior in the test repository.

  • Keep AGENTS.md as the shared repository instruction file.
  • Keep CLAUDE.md while you continue precedence testing with Claude Code.
  • Preserve the uninstructed baseline record for future comparisons.
  • Retain the two-agent comparison record.
  • Retain the precedence investigation record.

Pause - I'll come back to this later

There is no background service to pause. Choose this if you want to stop testing while keeping every file for later.

  • Leave the test repository unchanged.
  • Keep AGENTS.md beside CLAUDE.md for another precedence test.
  • Retain your records so the next test can use the same request.

Delete - I don't want to use this again

Remove the temporary precedence file. Your test repository stays in place.

macOS

  • Switch back to the terminal from earlier.
  • Return to the test repository used for the precedence test.
  • Remove the temporary precedence file by running this command:
rm CLAUDE.md
What Does This Command Do?

This command removes CLAUDE.md from the current folder. It leaves AGENTS.md in place.

  • Check the test repository's file list.

You should still see AGENTS.md. The temporary CLAUDE.md file should be gone.

Your repository now has one shared source for its coding rules.

Is the Temporary File Still There?

Confirm that the terminal points to the test repository before running the command again. Help me remove CLAUDE.md without deleting AGENTS.md.

Windows

  • Switch back to the terminal from earlier.
  • Return to the test repository used for the precedence test.
  • Remove the temporary precedence file by running this command:
Remove-Item .\CLAUDE.md
What Does This Command Do?

This command removes CLAUDE.md from the current folder. It leaves AGENTS.md in place.

  • Check the test repository's file list.

You should still see AGENTS.md. The temporary CLAUDE.md file should be gone.

Your repository now has one shared source for its coding rules.

Is the Temporary File Still There?

Confirm that the terminal points to the test repository before running the command again. Help me remove CLAUDE.md without deleting AGENTS.md.

Nice Work!

Nice Work!

You did it! You proved that AGENTS.md can carry your coding rules between agents.

You've learned how to:

  • Built a controlled baseline after verifying Claude Code version 2.1.277 or later. Repeated the same request after adding three observable rules to AGENTS.md. The side-by-side outputs showed your rules taking effect.
  • Tested a second coding agent with the same request. Compared its rule adherence with Claude Code.
  • Investigated instruction-file precedence with CLAUDE.md beside AGENTS.md. Located the lookup behavior in Claude Code's built-in mod source.
  • Completed the optional Secret Mission to extend your instruction-file workflow.

Ready to quiz yourself?