Making Agents Become Quality-Minded

(this is not a how-to article, it’s a what I’m learning post)

Rust quietly set a bar most ecosystems are still chasing:

• clone a Rust repo,

• run cargo fmt,

• run cargo clippy,

and you’re already participating in a shared standard. No debate, no tool sprawl, no “what do we use here?” The expectations are baked in. Not perfect, but clear, consistent, and enforced just enough to matter.

That clarity is what’s missing when we start turning coding over to agents.

Lately I’ve been thinking less about which tools are best and more about a different problem:

How does an agent recognize, and respect, the quality contract of a codebase?

Because every repo has one. Sometimes explicit, often accidental.

• A Makefile target nobody documented

• A CI job that fails on lint but no one runs locally

• A formatter config that half the team ignores

• Or nothing at all, just tribal knowledge and good intentions

Humans muddle through this. Agents don’t have that luxury. They need to infer the rules before they start writing code, or they’ll just make a mess faster.

What I’m learning is that “quality-minded” agents aren’t the ones with the best models. They’re the ones that are prompted to ask:

• What language(s) am I in?

• What tools already exist here?

• What commands does this repo expect me to run?

And maybe most importantly:

• Should I introduce anything new, or just follow what’s already here?

That last one has a bit of grit to it. It’s tempting to tell an gent to “upgrade” a repo the moment it touches it. Swap in a faster linter, unify configs, modernize everything. But that’s not always respectful, and often not helpful.

A quality minded agent needs to be prompted to behave more like a careful maintainer than a clever optimizer.

There’s also a quieter realization: most ecosystems are converging on the same shape.

A formatter.A linter.Sometimes a type checker.Sometimes deeper analysis. The pattern is apparent across languages.

• Go is at the same deep integrated level

• Python is tightening around Ruff.

• JS is experimenting with Biome.

• C/C++ still stitches pieces together under LLVM.

• Ruby has long had a RoboCop.

• Rust just made the contract obvious early.

So the problem isn’t picking the “right” tools, it’s teaching agents to discover the contract, respect it, and only extend it when beneficial.

• Start with formatting: it’s low friction.

• Then linting: visibility without enforcement.

• Only later, maybe, make it blocking.

• always base progress on the path of least harm

• always obey the rules even if they aren't enforced

That progression matters. Humans accept it. Agents should follow it.

If there’s a takeaway here, it’s this:

Quality isn’t just enforced by tools, it’s communicated through them.

If agents are going to write meaningful code in real repos, they need to learn how to read that communication before they start typing.

Still figuring this out.