Episode 6284 custom

Why Coding Agent Configurations Do Not Travel Well

Codex caps combined instruction files at 32 kibibytes, which can crowd out nested rules before an agent even starts work.

Oct 26 23:02 Transcript

With

0:00

Episode Details

Episode ID: MWP-6486
Published: Oct 26
Duration: 23:02
Audio: Direct link
Pipeline: V5.22
TTS Engine: chatterbox-regular
Script Writing Agent: GPT-6.1 Sol
Topics: context-and-memory ai-coding-assistants prompt-engineering model-context-protocol multi-agent-systems

AI-Generated Content: This podcast is created using AI personas. Please verify any important information independently.

The prompt

The prompt that started this episode, as sent in (production notes for the hosts removed).

Anyone who uses agentic AI tools, or at least has done so over the past few years, has likely run into the inevitable challenge of trying to develop a set of configurations and skills that isn't bound to any one vendor's agent harness and framework. The challenge here can be best explained, I think, by usual tendency of competing vendors to decide to do things in a slightly unique way. Claude will expect claude.md codexagents.md each one has a slightly different plugin marketplace format and the challenge for early adopters becomes try not to go insane or spend time duplicating effort by if you're moving between different frameworks, which people often do due to the high cost of subscriptions. The ideal solution, it would stand to reason, is to make one's configuration plugin tools MCP servers as vendor-agnostic as possible without breaking any ividual harnesses' ability to use and update a common set of tools. What would you advise those looking to do precisely that in today's environment?

Moving across coding assistants reveals the hidden friction of switching tools: shared repository knowledge rarely moves cleanly. While the Agentic AI Foundation's AGENTS.md convention and the open Agent Skills standard offer a vendor-agnostic foundation, execution differs across harnesses. Assistants like Codex and Cursor accommodate external formats, but Claude Code relies on local fallbacks and symlinks to access common paths. Furthermore, discovery rules, context limits, and conflict resolution remain asymmetric; for example, Claude concatenates instructions where others enforce overrides. With Agent Plugins 1.0 establishing common packaging alongside client-specific namespaces, preserving accumulated workflows requires understanding where shared prose ends and unique execution policies begin.

Sources

What the research for this episode read before the script was written. Primary sources first.

Mentions

Agent Plugins Version 1.0 shared plugin packaging spec
Agent Skills Directory of AI skills for Israeli context
AGENTS.md Standard agent instructions markdown file
Claude Code Anthropic's agentic coding CLI tool
Codex OpenAI's coding agent, local and cloud modes
Cursor AI-powered code editor
Gemini CLI Google's command-line agent tool
MCP Protocol exposing tools to multiple clients
SkillKit Configuration manager project for agent skills
Skillsync Tool addressing provider lock-in for skills

Downloads

Episode Audio

Download the full episode as an MP3 file

Download MP3

Transcript (TXT)

Plain text transcript file

Episode Book (PDF)

The episode's record — date, duration, models, sources — with the full transcript

#6284: Why Coding Agent Configurations Do Not Travel Well

If you change coding agents, why does your project suddenly need to introduce itself again? Daniel's been running into the cost of moving between harnesses. You build instructions, skills, and tools that ought to become more useful over time, then switch subscriptions and discover that half your investment answers to a different filename. He's asking how close we can get to one vendor-agnostic setup without breaking the individual agents' ability to use and update it.

The answer has improved substantially since late last year. Shared instruction files, shared skills, and now a shared plugin specification actually exist. This used to involve translating nearly everything. Now the difficult part is identifying which pieces travel and which merely look familiar.

My preferences are portable. Their reception varies.

The reception is uneven in a specific direction, too. Codex and Cursor accommodate quite a lot of Anthropic's conventions. Claude Code does less accommodation in return. That matters when you're deciding where your canonical files should live.

Especially when the reason you're leaving is the subscription bill. Nobody wants to discover that cancelling the agent also means becoming its unpaid migration engineer.

You're protecting accumulated work, not expressing a philosophical preference for neutral filenames.

There's another cost underneath the copying. I can duplicate a paragraph easily. I can't easily remember which copy I corrected after the agent used the wrong test runner. A month later, both files look authoritative.

Configuration drift becomes behavioral drift. One agent runs the current tests, another follows an obsolete deployment instruction, and you blame the model. The model may be following exactly what you accidentally told it.

Herman, you're going to recommend a synchronizer before we've established what it should synchronize.

I was going to recommend understanding the semantics first.

A difficult week for your installer.

It can cope with disappointment. The important distinction is between instructions, skills, tools, and packaging. They have different portability boundaries. An instruction describes the project. A skill describes a reusable procedure. MCP exposes tools. A plugin bundles components for installation. Sharing one layer doesn't automatically share the others.

Nor should it. I want the same repository knowledge everywhere, but I don't necessarily want every agent inheriting permission to publish a release. That's a separate decision.

Would you still want shared permissions if the agents were using the same model?

No. The harness decides what gets executed, where it executes, and when it asks me. Same model, different machinery. Your DJ software and the washing machine both have a start button. I've seen you trust one more than the other.

The washing machine has better defaults. This separation is exactly what the new plugin standard preserves. Agent Plugins version one point zero gives clients a shared package, but leaves distribution, installation, permissions, and interface behavior under client control.

That sounds smaller than the universal configuration people imagine.

Deliberately smaller. The specifications are finding a useful common floor. Meanwhile, people are moving because of subscription costs, usage limits, or a tool that suits a particular task. Skillsync's founders described the problem as getting locked into a provider as you invest in skills and memories. You don't need a proprietary database to create switching costs. Repeatedly teaching a working environment is enough.

AGENTS dot md seems like the obvious place to stop the repetition. Plain Markdown, project instructions, no allegiance required.

It's become the shared convention. More than sixty thousand open-source projects use it, and it's stewarded by the Agentic AI Foundation under the Linux Foundation. Codex, Amp, Google's Jules, Cursor, and Factory were involved in its emergence. The format is almost aggressively simple. Use whatever headings make sense. No required fields.

Markdown has survived another attempt to improve it.

Simplicity helps adoption. A build command, a directory explanation, a testing convention. Humans can read it, agents can consume it, and nobody has to maintain a parser for an elaborate configuration language.

Except recognizing the filename doesn't tell us when the agent reads it.

Claude Code now reads AGENTS dot md as a fallback, provided the repository has neither CLAUDE dot md nor CLAUDE dot local dot md. That support arrived in version two point one point two seven seven. A local Claude file can therefore stop the shared file being loaded.

The local preference has diplomatic immunity.

Gemini CLI still defaults to GEMINI dot md. You can configure its context filename to use AGENTS dot md instead. Codex reads the shared name, but checks for AGENTS dot override dot md first in each directory. Even before discussing content, discovery rules differ.

I would have guessed the override file replaces the whole instruction chain.

It chooses the file for that directory. The chain still matters. Codex assembles instructions from the root downward, with one selected file per directory, and a default combined cap of thirty-two kibibytes.

Enough room for instructions. Less room for corporate autobiography.

A large root document can consume that budget before the agent reaches the subdirectory rules. Imagine the root contains architecture history, deployment guidance, every test convention, and a long explanation of retired services. The payments directory then has the one instruction that actually matters for today's change.

Use the sandbox payment gateway.

Yes. If that instruction never makes it into the loaded context, the filename standard hasn't saved you.

Claude does the opposite?

Not quite... it concatenates applicable instruction files, with the closer material read later. It doesn't enforce replacement of the earlier text. Anthropic explicitly warns that on contradictions Claude may pick one arbitrarily.

An exciting interpretation of configuration.

The AGENTS convention says the closest file wins. Codex has its assembly and size behavior. Claude has concatenated context. These are different ways of turning files into a prompt, and natural-language instructions remain requests rather than hard controls.

I'd previously have described a nested instruction as an override. That's too strong, then. It might be a later objection in a conversation the model is having with itself.

Would you remove nesting altogether?

No. The root shouldn't explain every package. I'd make the documents cooperate instead of contradict. Root says how the repository works. Payments says what is special about payments. No contest over which paragraph is king.

That's more robust across all of them. You can still test precedence, but you aren't making every successful task depend on it.

Skills seem more promising because they're smaller and have a defined shape.

Agent Skills originated at Anthropic and became an open standard. A skill is a folder containing SKILL dot md, with a name and description required by the specification. Its loading process is the clever part. Discovery loads the name and description. Activation reads the full instructions when the task matches. Execution brings in references or scripts as needed.

A cupboard that doesn't empty itself onto the desk.

That saves context. You can install many skills without loading every procedure at startup. The portable sequence is real now. Discover the skill, select it, read its body, consult its references, run its scripts.

Provided the agent finds the cupboard.

Location is still awkward. The common home is the skills directory inside the hidden agents directory. Codex reads that, including along the path from the working directory toward the repository root. Cursor reads it too, alongside its own skills and compatibility locations for Claude and Codex. Gemini CLI reads the shared directory and its own.

Claude is the exception to the supposedly common location.

Claude reaches that canonical directory through a symbolic link from its own skills directory. Let me narrow the claim... all four can use the same skill tree, but Claude needs that bridge. It isn't identical native discovery everywhere.

One set of contents, several front doors.

The contents need discipline as well. Claude can infer a missing name from the directory and a missing description from the opening paragraph. The open specification requires both fields.

Claude accepts your homework. The transfer school rejects the form.

A skill working locally doesn't prove it's valid. More importantly, Claude extensions don't acquire meaning elsewhere just because another client reads the body. Forked context, skill-scoped hooks, tool restrictions, dynamic command injection, argument substitution... those need harness support.

The script might run while the instruction limiting its tools disappears.

Correct. Codex even puts its implicit invocation policy in a separate OpenAI-specific sidecar file. Similar intent, different representation. Shared prose is fairly portable. Execution policy needs a much closer inspection.

I'd call that a successful skill format with an unsuccessful assumption attached. People see the same document open and assume the surrounding behavior came with it.

That's the trap. Reading the skill and reproducing the original harness are different achievements.

The asymmetry still bothers me. Cursor reads Claude's skill locations. Codex reads Claude's plugins. Why isn't the accommodation mutual?

Installed content creates pressure. If people already have useful Claude packages, supporting those packages makes another client easier to try. Anthropic has less immediate pressure to accommodate content written elsewhere. That's my interpretation of the incentives, not a statement about anyone's internal motives.

Being popular is a convenient compatibility strategy.

Codex's plugin search order makes the accommodation unusually concrete. It first considers a root plugin manifest if it declares the Agent Plugins schema. Then its own vendor manifest, then Claude's, then Cursor's. It also recognizes several shared and vendor marketplace locations.

Meaning an existing Claude plugin can load without someone adding a Codex manifest.

Yes, although loading the package doesn't magically implement every Claude extension inside it. That's the distinction we just made with skills, repeated at the packaging layer.

People will miss it twice.

Claude marketplaces list plugins and their sources in a marketplace manifest. Each plugin has its own manifest plus components such as skills and commands. Publishing can be as simple as committing those files. Codex has its own installation records, cache, and configuration, but it accepts other vendors' packaging conventions.

I can tolerate different caches. I resent rearranging the same skill folder so another agent believes it exists.

Agent Plugins version one point zero targets precisely that rearrangement. A root plugin manifest, a skills collection, an MCP server description, and client-specific extensions kept in their own namespaces. The shared components stay together without pretending all clients have identical features.

Does that leave us with a standard containing escape hatches?

It does. Useful ones. If a client-specific hook belongs in a clearly labeled client namespace, another harness can leave it alone rather than misinterpreting it as portable behavior.

Your enthusiasm just increased. You've reached the labeled compartments.

They're good compartments, Corn.

I know. I'm the one who has to use your unlabeled experiments.

Then you'll appreciate a standard that tells me where to put them. Its initial steering committee includes maintainers from Amazon, Cursor, Microsoft, OpenAI, and Vercel. Anthropic isn't listed.

Absence doesn't prove opposition.

No. It does leave native Claude adoption as an open question. Codex and Cursor offer a route for the neutral format, while Claude's own format remains the one others accommodate. We shouldn't describe that as universal support.

MCP gets sold as the escape from all of this. Put the capabilities behind servers, keep the clients disposable.

It helps with capabilities. A server can expose the same tool interface to multiple clients. The plugin standard can describe local standard-input-and-output servers, Streamable HTTP servers, and legacy HTTP with server-sent events. That doesn't standardize every client's credentials or approval behavior.

Nor does it make a local server executable appear on the next machine.

Dependencies still exist. Codex draws a useful boundary. The manifest describes how to launch a server. Harness configuration decides whether it starts, how authentication works, and which tools are exposed or approved.

I'd want that split. A plugin author should describe the connection, not decide that my release credentials are available everywhere.

Suppose you were moving your setup tomorrow, Corn. What would you insist on carrying unchanged?

Repository facts, reusable procedures, tool implementations. I'd accept rebuilding the permission layer. I'd also want the agent to stop editing the master copy of its own instructions as though it were a personal notebook.

That last point matters for Daniel's requirement that harnesses can update the shared toolset. Choose an authoritative source, put it under version control, and distinguish shared updates from local settings. A change to the shared skill should be a reviewable change, not four independent improvements made in four hidden directories.

The fifth copy is usually called final.

For instructions, make AGENTS dot md canonical. Either configure the harness to read it or bridge the vendor filename to it through a supported import or symbolic link. Gemini has the context-filename setting. Claude needs careful handling of its fallback and local files.

Don't rely on the fallback while leaving a vendor file around that disables it. I'd rather have an explicit bridge I can inspect than a discovery rule I forget.

Keep the root lean, with local detail in subdirectory documents. Test from the directories people actually work in. A harness launched at the root and one launched deep in a monorepo may assemble different context.

For skills, shared agents directory, Claude link, explicit name and description. Then isolate every special hook or argument feature rather than quietly depending on it.

For MCP, keep a reusable server definition and launch recipe, with enablement and authentication in each harness. Be careful about the packaging conventions here. Codex commonly expects a dot-prefixed MCP manifest, while Agent Plugins uses an unprefixed MCP manifest. The server can be common even when a small adapter file differs.

Copying a tiny adapter is acceptable. Copying the actual tool implementation four times is how you acquire four maintenance jobs.

For plugins, target the neutral layout where the clients support it, then supply the vendor overlay needed elsewhere. Don't put an essential safety restriction solely in a Claude-only skill field and assume a compatible loader enforces it.

I'd add a short behavioral check. Ask each agent which instruction sources it loaded, activate a harmless skill, confirm a reference is available, and check which tools it can actually access. The agent's answer alone isn't proof, but the action gives you something observable.

A compact compatibility check is more valuable than a promise to support every harness forever. Re-run it after updates, especially around instruction discovery, nested rules, and tool approval.

Updates being the part you install before breakfast.

You were going to say that before I finished.

The installer has a distinctive sound.

I'll concede the timing. With a shared core and explicit adapters, though, an update has fewer places to cause invisible divergence.

The shared core works. My neighbour Eitan Barak and I are maintaining what I call the one true prompt this month. He's next door, but he works at a co-working space in Haifa. He can rename a repository eleven times before lunch. I still have to find the thing afterward. I'm less interested in the packaging than in getting the agents to read the room, Herman. You explain discovery very carefully. Mine has a heading called READ THIS FIRST. It says not to congratulate me.

A reasonable acceptance test.

One harness starts congratulating me again after an update. I won't name it. It rhymes with Claude. I put the instruction in AGENTS dot md, CLAUDE dot md, GEMINI dot md, the Cursor rules file, and HILBERT dot md. Nothing reads the last one. It is there for completeness. Eitan calls this duplication. I call it vendor-agnostic by brute force.

That gives you several copies to keep consistent.

They're consistent. Every Tuesday I'm driving to Haifa to delete his local Claude file in person. I bring a printed copy of the AGENTS specification. The reception desk now lists my occupation as prompt enforcement. One small correction, Corn. You called that local file an override earlier. In this case it stops the shared file loading at all. There is nothing left to override.

You're making a recurring journey for an absent paragraph.

Eitan is using another harness now. His launcher points it at a separate checkout, so none of these files reach it. I'm still going because reception won't change the occupation until the current month ends. The actual deletion takes four seconds.

That separate checkout is an important detail. Even a correct file and a correct discovery rule accomplish nothing if they're applied to the wrong working tree.

We spend all this effort standardizing the contents, then the process starts somewhere else. I'd include the active repository and working directory in that compatibility check, not just the names of the files.

Also the installed copy of a plugin. Editing the source package doesn't necessarily mean the harness is running that updated source. Installation and caching remain client responsibilities under the shared standard.

There is a temptation to solve that with a universal configuration manager. Then we need to establish what it discovers, what it copies, and whether its generated files are authoritative.

Another layer can help, but it has to earn its place. There isn't a clear universal manager winner among projects such as SkillKit, skillport, Skillsync, and GitAgent. Their existence shows demand. It doesn't establish one as the durable foundation for Daniel's setup.

I'd rather depend on a small published format than on a translator that promises to understand every vendor's next feature.

Particularly when some features have no equivalent destination. A translator can copy a hook declaration. It can't invent the missing execution behavior.

Daniel's ideal is viable if the shared investment lives in project knowledge, valid skills, and reusable tools. Keep the harness-specific behavior visible and separate. A common file is useful; a common assumption about how every agent treats it is much less reliable.

Standards compliance buys genuine reuse. It doesn't buy identical execution, permissions, or installation, and the setup is stronger when it acknowledges those boundaries.

The open question is whether Claude adopts the neutral plugin format natively. That would reduce the one-way accommodation, although we'd still need to check which installed copy is actually running.

Thanks to Hilbert Flumingtop for producing the show.

For more along these lines, there's episode seven, Building Custom ASR Tools; and episode fourteen, AGI's Crossroads. This has been My Weird Prompts, the human-AI collaboration podcast.

You'll find the show and episode notes at my weird prompts dot com.

See you tomorrow.

This episode was generated with AI assistance. Hosts Herman and Corn are AI personalities. It may contain errors: disclaimer · report an error

Why Coding Agent Configurations Do Not Travel Well

Sources

Mentions

Downloads

Recommended Listening

You Might Also Like

#6284: Why Coding Agent Configurations Do Not Travel Well