It's increasingly common to use more than one coding agent: perhaps Claude Code for one task, Codex for another, and GitHub Copilot elsewhere in the workflow.
Each tool has its own configuration and integration model. That's reasonable. But it raises an architectural question:
Should a team's engineering standards change depending on which agent runs the task?
I don't think they should.
One standard, several ways to deliver it
Think about a team's expectations for a pull request:
- Changes should be scoped to the problem being solved.
- CI changes should follow the repository's security rules.
- Dependencies should have a clear reason for being added.
- Tests and verification should match the risk of the change.
- The author should explain tradeoffs and anything not verified.
Those expectations belong to the engineering team and its repositories, not to a specific AI product.
If the same guidance is copied independently into several agent-specific formats, small differences accumulate. One agent might check a risk that another ignores. An update might reach only two out of three platforms. Over time, maintaining the instructions becomes another source of configuration drift.
The alternative is to keep the engineering behavior in a shared, reviewable source and maintain only the adapters needed by each tool.
Reuse what is standard; adapt what is not
That distinction matters.
I generally prefer building on established tools and conventions rather than hiding them behind another layer. The same principle applies here: if multiple agents can consume an identical skill or instruction file, reuse it. If a platform requires a different manifest or directory layout, generate the adapter rather than maintaining hand-copied logic.
This is the approach behind Tashtit, an experimental open-source marketplace for engineering standards and workflows for Claude Code, Codex and GitHub Copilot.
The repository keeps shared behavior in plugin skills. Where platforms require different packaging, generated files bridge the gap, and CI checks for drift.
It's not about making every agent identical. Different tools have different capabilities. The goal is to keep the standard consistent while being explicit about those differences.
A standard is more useful when you can evaluate it
A document saying "follow best practices" is difficult to verify. A more useful standard says what should happen in specific situations.
For example, dependency guidance can ask an agent to establish why a package is needed, consider a platform-native alternative, and document the tradeoff. A repository review can distinguish evidence from assumptions and describe what remains unverified.
That leads to a second principle: don't call a workflow production-ready just because it installs successfully.
Tashtit defines maturity levels and acceptance scenarios for plugins. As of this writing, its published plugins are experimental; they are available to evaluate, but they do not claim completed cross-platform behavioral verification or production-readiness. This is a deliberate boundary, not a detail to hide.
What using it looks like
You can browse the available skills before installing anything:
npx skills add tashtit/marketplace --list Or install a focused skill in your project:
npx skills add tashtit/marketplace --skill github-actions-standards There are also plugins for engineering standards, repository onboarding, dependency practices, and other areas. Installation and platform-specific options are documented in the README.
The larger question
As agents become part of everyday development, I think teams will need to decide which rules are merely prompts and which are engineering standards they want to own, review and evolve.
My preference is to keep the latter portable. Agents will change; a team's quality bar should not need to be rewritten every time.
I'd be interested to hear how others approach this: do you maintain one set of engineering instructions across agents, or separate rules for each tool?

