Standardizing projects for development with AI agents
How to establish shared instructions, autonomy policies, and technical controls to standardize projects developed with AI agents.
Updated: November 14, 2026
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:
- Propose changes to standards.
- Assess impacts and obtain necessary approvals.
- Update related documentation and configurations.
- Verify that different agents can comply with the new rules.
- 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.
Related articles
Share this article
Sources & further reading
This note is a practical introduction, not a substitute for the original documentation. Check source dates and implementation details before making technical decisions.