Agent Reflection · Engineering standards
Your coding agents never read your standards. Hand them the approved version before they write a line.
Hundreds of developers, each with an agent, each agent starting from whatever its repository happens to say. Keep your coding standards, architecture guidelines, and security requirements in one private Vindex catalog. A coding agent reads the active version before a task starts, so the code begins from what your architects approved.
Storing and reading your standards uses no critique credits. They are always private to your company.
Sample standards. Illustrative documents written by Vindex. Not a customer's content.
What a coding agent is handed before it writes code
get_non_functional_rules · slug backend-standards
3 non-functional rules returned, from the set Backend standards.
- Python styleversion 4
# Python style Use type hints on every public function. Raise a domain error, never a bare Exception.
- API conventionsversion 2
# API conventions Version every route under /v1. Return errors in the shared error shape.
- Logging and PIIversion 6
# Logging and PII Never log a request body. Put the request id on every log line.
The standards are written. The agents never see them.
An agent writes good code against the context it has. Across a large engineering group, that context is different in each repository. Vindex gives the standards one home and puts them in front of the agent before the first line.
The standard lives where no agent looks
The architecture guidelines sit in a wiki or a slide deck. A coding agent starts from the repository and the prompt, and neither one carries them.
Each repository has its own copy
Someone pasted the standards into an instructions file last spring. The standards moved on. The copy did not, and no one can say which repositories are current.
The gap shows up in review
The code runs and the tests pass. It also logs a request body and skips the shared error shape. A reviewer catches it, or the next incident does.
From a document on a wiki to the first thing an agent reads.
In Vindex, a standard your agents read is a non-functional rule. It sits in the same catalog as the rules your agents are checked against, with the same versions.
- 01
Upload the standards you already have
Coding standards, architecture constraints, security requirements, naming conventions. Each one is a Markdown document, saved as it is written. There is no format to follow and nothing to wait for.
- 02
Group them for each codebase
A rule set such as Backend standards holds the documents one kind of codebase needs, and a set can hold other sets.
- 03
Your coding agents read them first
Before a task starts, the agent asks Vindex for the set and gets each document's active version in one call. The code starts from what your architects wrote.
Upload in Agent Rules in your portal, or ask your agent to do it. Read the reference.
One approved starting point, for each developer and each agent.
Writing a standard is the cheap part. Getting it in front of the work, in each repository, and keeping it current is what costs.
One starting point for a large team
A developer in their first week and a principal engineer start their agents from the same documents. The standard no longer depends on who wrote the prompt.
Agents start from the approved version
A new version is a draft until someone makes it active. Agents are handed active versions only, so a proposal under review never reaches the code.
A change lands once
Make the new version active and each agent gets it the next time it reads. No repository-by-repository rollout, and no stale copy left behind.
It costs no credits
Storing, managing, and reading your standards use no critique credits. Credits pay for critiques, and reading is not a critique.
| What you compare | A copy in each repository | One Vindex catalog |
|---|---|---|
| Changing a standard | A pull request in each repository that carries a copy | One new version, made active once |
| What an agent starts from | Whichever copy that repository has | The active version, the same for each team |
| Which version is in force | Depends on the repository you open | One active version of each document. Earlier versions stay readable |
| A new team or repository | Copy the files again and hope they are current | Name the set in the repository's agent instructions |
| A draft still being argued | In the file as soon as it is merged | Stays a draft. Agents are handed active versions only |
| What it costs | Engineering time on each change, in each repository | No critique credits to store, manage, or read |
Each repository names its set. The standards stay in one place.
The Vindex MCP server tells a connected agent to read your standards before it writes or changes code. An agent decides what it calls, so say it in the repository too: add these lines to the file your client reads for standing instructions, with the set for that codebase.
That is the only copy a repository keeps. It names the set and never repeats what is in it, so it does not go stale when a standard changes.
Works in Claude Code, Codex, Cursor, GitHub Copilot, and any other MCP client. Connect yours.
## Engineering standards
Before you write or change code in this repository, call
get_non_functional_rules with slug "backend-standards" and follow
what it returns while you work.
These are requirements to read. Do not pass them to validate.Read before the work. Checked after it.
One catalog holds both kinds of rule, and an agent meets them at different moments.
Before the work
Non-functional rules
The standards a coding agent reads before it starts. Vindex hands them over as written and checks nothing against them. Always private. No credits.
After the work
Rules and rule sets
The requirements a finished output is checked against, such as release notes or an API description. Each rule gets a pass or fail, and a critique uses credits.
How a critique worksYour architecture is nobody else’s business.
Standards describe how your systems are built. They are kept the way that deserves.
- Private, with no public option
- A non-functional rule cannot be published. It never appears in the Rules marketplace, and no other company can add it to its catalog.
- Returned to your company only
- The company comes from the sign-in or the key, never from the request. To any other company, your standards do not exist.
- Vindex runs no model on them
- Vindex stores each document and hands it to your own agents. It is not sent to a model for preparation or review.
Questions
- How do you give AI coding agents your company's coding standards?
- Keep each standard as a Markdown document in your Vindex catalog, as a non-functional rule, and group the documents into a set for each kind of codebase. A coding agent connected to the Vindex MCP server reads the set before it writes code, so its work starts from the active version of each standard.
- What is a non-functional rule?
- A document your agents read before they start work: a coding standard, an architecture constraint, a security requirement, a naming convention. Vindex stores it and hands it to your agents as it is written. It is never checked and never public.
- What can go in one?
- Any Markdown. There is no format to follow and no pass bar to set, so the standards you already have can go in as they are.
- What does it cost?
- Nothing. Storing, managing, and reading non-functional rules use no critique credits.
- Can anyone outside the company see the standards?
- No. A non-functional rule is always private. It cannot be published, it never appears in the Rules marketplace, and another company cannot find it or read it.
- Does Vindex check the code against the standards?
- No. A non-functional rule is read before the work, and nothing is checked against it. For a standard you want checked on what an agent writes, such as release notes or an API description, write a rule for it and run a critique.
- How does an agent know which standards apply to a codebase?
- Name the set. The repository's agent instructions file names a set such as backend-standards, and the agent asks for it. An agent can also ask for the documents carrying given tags, for everything active, or list the titles and choose.
- What happens when a standard changes?
- Upload the new version and make it active. The earlier version is archived and stays readable, and each agent gets the new one the next time it reads.
- Which coding agents does it work with?
- Any client that connects to the Vindex MCP server, including Claude Code, Codex, Cursor, and GitHub Copilot. It is the same connection that runs critiques.
