Skip to main content
Beta Get Rules is one of the tools in the Qodo Agentic Toolbox. It enables your coding agent to retrieve the coding rules and guardrails that apply to a task before implementation begins. Instead of discovering standards during code review, your agent loads the relevant rules upfront and uses them while generating code. Get Rules combines global rules, repository-specific rules, and contextual guidance to provide your agent with the standards required for the current task. The agent uses these rules as guardrails from the first line of code, helping teams enforce engineering standards during authoring rather than after changes are completed.

​
Supported interfaces

​
What you can do

With Get Rules, you can:
  • Provide agents with the rules that apply to the current task.
  • Include global standards alongside repository-specific guidance.
  • Apply engineering conventions before code is written.
  • Reduce review findings caused by missing standards.
  • Keep implementation aligned with team requirements.
  • Ensure agents follow the same guardrails used across projects.

​
Common use cases

​
Apply rules before writing code

Give your agent the relevant standards before implementation starts. Use it to:
  • Load applicable rules for a task.
  • Understand required conventions before making changes.
  • Guide implementation decisions from the beginning.
  • Avoid introducing issues that would later be caught during review.
Example questions
  • What rules apply to this task?
  • Load the relevant guidelines before implementing this change.
  • What standards should I follow for this feature?
Example workflow

​
Apply organization-wide standards

Ensure agents follow global engineering requirements across repositories. Use it to:
  • Apply shared coding standards.
  • Enforce organization-level practices.
  • Keep implementations consistent across teams.
  • Avoid relying only on repository-local instructions.
Example questions
  • What global rules apply here?
  • Which organization standards should I follow?
  • Are there any required practices for this change?

​
Follow repository-specific conventions

Use repository context to apply local implementation requirements. Use it to:
  • Load repository-specific rules.
  • Follow existing project conventions.
  • Match patterns already used in the codebase.
  • Reduce inconsistency between changes.
Example questions
  • What rules apply to this repository?
  • What conventions should I follow for this service?
  • Load the repository guidelines before making this change.

​
Build with context-specific guardrails

Ensure the agent receives rules that match the current task. Use it to:
  • Combine multiple rule sources.
  • Apply only relevant guidance.
  • Adapt implementation based on the task context.
  • Keep standards available during development.
Example questions
  • Which rules apply to adding this API endpoint?
  • What guardrails should I consider for database changes?
  • What standards apply to this component?

​
Frequently asked questions

​
What information does Get Rules use?

Get Rules uses the available rule sources, including global rules, repository rules, and task-specific context, to provide the agent with applicable guidance.

​
Does Get Rules only retrieve repository rules?

No. Get Rules includes applicable global rules in addition to repository-specific rules, ensuring that organization-wide standards are applied.

​
When are rules loaded?

Rules are loaded before implementation begins, allowing the agent to use them while generating code rather than discovering issues during review.

​
Does Get Rules replace code review?

No. Get Rules helps prevent issues by guiding implementation. Code review continues to validate changes and identify additional concerns.

​
Does Get Rules modify code?

No. Get Rules provides the agent with applicable guidance. The agent uses this context when performing the requested task.

​
Additional resources