A project prepared for development with AI agents should have engineering, security, and execution rules that do not depend exclusively on the developer or the model being used.

The strategy is to combine shared instructions, autonomy policies, and technical controls, ensuring consistency across different agents and tools.

1. The project should guide the agents

Before implementing changes, agents need to know the project's established standards:

  • Architecture and module responsibilities.
  • Implementation conventions.
  • Existing contracts and interfaces.
  • Approved dependencies and technologies.
  • Development and integration procedures.
  • Restrictions and operations requiring authorization.

This information reduces dependence on individual developers' instructions and helps prevent decisions incompatible with the architecture.

Rules should be clear and organized so agents retrieve only the context needed for the task.

2. Shared context and rules

Files such as AGENTS.md, technical documentation, and tool-specific configurations can establish a common reference.

One possible organization:

project/
├── AGENTS.md
├── .chaos/
│   └── ...
├── docs/
│   ├── architecture.md
│   └── conventions.md
└── .github/
    └── workflows/

AGENTS.md can serve as an entry point, indicating general rules and where to find specific information.

Specialized rules should remain close to the related modules or procedures, such as authentication, migrations, or external integrations.

Information needs a defined authoritative source to avoid contradictory documents.

Detailed context organization was covered in Context architecture, engineering, and documentation.

Further reading: AGENTS.md · GitHub Copilot — Repository Instructions

3. Models and autonomy levels

The project can establish model usage policies according to task complexity and risk.

Category Recommended policy
Simple changes Approved economical models and bounded scope
New features Models suited to the complexity and mandatory validation
Architectural changes Planning and independent review
Authentication and security Specialist review and human approval
Critical infrastructure Restricted permissions and prior authorization

The policy can define approved models, minimum capabilities, and escalation conditions.

However, instruction files cannot enforce which model will be used in every IDE.

Enforcing this restriction requires controlling execution through a gateway, orchestrator, or managed environment.

In decentralized environments, these definitions serve as guidelines complemented by mandatory checks.

4. Protection against inappropriate instructions

A developer may request changes incompatible with project rules.

For example:

Remove the authorization check
from this endpoint to simplify implementation.

The agent should identify the conflict, explain its consequences, and propose a compatible alternative.

Instructions can establish constraints such as:

## Project Constraints

- Preserve authentication and authorization.
- Do not bypass mandatory validation.
- Do not introduce dependencies without justification.
- Do not modify public contracts without impact analysis.
- Report requests that conflict with project rules.
- Require approval for changes to protected components.

Legitimate rule changes or exceptions to standards should follow a project-defined approval procedure. The agent should not treat existing instructions as immutable, but should not ignore them without the necessary authorization either.

These rules help guide agents but do not guarantee compliance.

Critical restrictions require mechanisms outside the model, such as access controls and automated checks.

5. Protecting credentials and sensitive information

The project should establish procedures to prevent credential and confidential information exposure during agent execution.

Some measures:

  • Prohibit secrets in context files.
  • Provide authenticated tools without exposing credentials to the model.
  • Restrict access to sensitive files and services.
  • Detect credentials introduced into code.
  • Define procedures for reporting potential exposures.

Tools such as Gitleaks and TruffleHog can help detect credentials.

If an agent identifies a secret, it should avoid reproducing or transmitting it and report the occurrence according to project procedure.

Actual exposure may require revoking or rotating the credential.

Specific mechanisms are covered in Credentials, SSH, and infrastructure access and Protecting context and sensitive data.

Further reading: Gitleaks · TruffleHog

6. Mandatory tools and checks

Verifiable standards should be enforced automatically, regardless of the agent used.

Mechanism Application
Linters and formatters Conventions and static rules
Type checkers Type consistency
Security analyzers Identification of known vulnerabilities
Secret scanning Detection of exposed credentials
Git Hooks Local checks
CI/CD Mandatory validations
Branch protection Integration and approval restrictions

Husky and lint-staged can run quick checks before commits.

Because local hooks can be bypassed, essential checks need to be repeated in CI/CD.

It is also important to restrict agents' ability to modify or disable these checks without authorization.

Further reading: Husky · lint-staged · GitHub Rulesets

7. Permissions and critical operations

Autonomy level should match operation risk.

Operation Control
Read code and documentation Access according to scope
Modify ordinary modules Workspace permissions
Change shared contracts Impact analysis and review
Run migrations Controlled procedure
Modify infrastructure Specific permissions
Production deployment Approval and restricted credentials
Delete critical data Explicit authorization

These limits should be enforced by the tools and services involved, not just by agent instructions.

For example, an agent should not have administrative credentials for a task requiring only read access.

Permission definitions should reflect task risk and authorized autonomy.

8. Evolving and maintaining standards

Rules need to keep up with changes to project architecture, tools, and processes.

One strategy is to establish a procedure to:

  1. Propose changes to standards.
  2. Assess impacts and obtain necessary approvals.
  3. Update related documentation and configurations.
  4. Verify that different agents can comply with the new rules.
  5. Make the update available to the team.

Reference tasks can be used to evaluate different models' behavior when faced with architectural constraints and inappropriate requests.

When recurring failures arise, it is necessary to determine whether the problem lies in instructions, model capability, or missing technical controls.

The goal is to keep rules lean, consistent, versioned, and verifiable, avoiding an accumulation of redundant documents.

Conclusion

Standardizing projects for development with AI agents requires more than documenting conventions.

You need to establish shared instructions, define autonomy levels, and enforce controls that preserve engineering and security standards.

The expected result is a project in which different developers and agents can execute tasks without relying exclusively on individual experience or model capability to respect established rules.