Skip to main content

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.

  1. 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.

  2. 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.

  3. 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.

A copy of the standards in each repository compared with one Vindex catalog
What you compareA copy in each repositoryOne Vindex catalog
Changing a standardA pull request in each repository that carries a copyOne new version, made active once
What an agent starts fromWhichever copy that repository hasThe active version, the same for each team
Which version is in forceDepends on the repository you openOne active version of each document. Earlier versions stay readable
A new team or repositoryCopy the files again and hope they are currentName the set in the repository's agent instructions
A draft still being arguedIn the file as soon as it is mergedStays a draft. Agents are handed active versions only
What it costsEngineering time on each change, in each repositoryNo 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.

In CLAUDE.md, AGENTS.md, or .cursor/rules
markdown
## 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 works

Your 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.

Put the standards where the agents start.

Upload one document, connect one agent, and see it read the standard before it writes.