Home Welcome Projects Homelab API Contact Dark Mode Toggle

Introducing AI Code Rating

These days when I come across a new open source project, there's a question that's getting harder and harder to answer just by looking at it. How much of this code was written by AI, and did anyone actually check it?

Some projects mention it in their README, some leave clues in their commit messages, and most don't say anything at all, so you're left digging through the git history or just taking a guess. I wanted a quick and consistent way to answer that question, and I thought others might as well, so I started a new project called AI Code Rating (or ACR for short).

In a nutshell, AI Code Rating is a three-character rating, like A2b, that a project publishes in an ACR.md file at the root of its repository. Each character answers a different question.

1. Maintainer Expertise (A to E) -- How experienced is the person responsible for the code? In a solo project that's you, and on a team it's whoever approves changes before they're merged.

2. AI Share (0 to 4) -- How much of the code was written by AI?

3. Oversight (a to e) -- How carefully did a person check the AI-written code before it was merged?

So A2b means the project has an expert maintainer, 26–50% of the code was written by AI, and every AI change was read by a person before it was merged.

When you write a rating out in text, you put "ACR" in front of it, like ACR A2b. A three-character code on its own is easy to miss and hard to search for, and some of them even look like other things (B2b looks an awful lot like B2B), so the prefix makes it obvious what you're looking at.

But why three characters? Wouldn't one be simpler?

It would be, and most of the other AI disclosure standards I looked at do use a single level, something like "none", "some", or "a lot", the problem is that one level can mean very different things to the person reading it.

An expert who uses AI to write most of a project, and reads every single line it writes, is in a completely different situation than someone who can't read code at all and commits whatever the AI hands them. Technically both of those projects are "mostly AI", but I'm guessing you wouldn't trust them the same way.

So, ACR keeps the three things separate. AI Share tells you how the code was made, Oversight tells you whether anyone checked it, and Maintainer Expertise tells you how well the people checking it could actually judge it.

And just to be clear, a higher AI Share doesn't mean a worse project, the rating describes how the code was made, not how good it is. An ACR A3a project, where an expert wrote most of the code with AI and checked every change, could easily be stronger than an ACR C1e project with very little AI code that nobody bothered to check.

Here's a quick rundown of all the levels.

Maintainer Expertise

This rates the person responsible for the code, not every single contributor. If it's a team project, go with the least experienced person who can approve a change without someone more experienced also approving it, since their judgement could be the last check before it ships.

AI Share

This is the share of the project's code that was written by AI. Most projects are only going to be able to estimate this, which is why each band covers a quarter.

Oversight

This is how carefully a person checked the AI-written code before it was merged. Only checks done by actual people count, so having AI review the code doesn't bump you up a level, and testing on its own will only get you as far as d.

If a project doesn't have any AI code at all, it gets an a for Oversight, since there's no AI code that went unchecked.

The ACR.md File

The rating itself lives in a small Markdown file called ACR.md in the root of your repository. The front matter at the top is for tools to read, and the text underneath is for people. This is what one looks like.

---
rating: A2b
spec: "0.1"
updated: 2026-10-05
---

# AI Code Rating

**ACR A2b** (Maintainer: Expert · AI Share: 26–50% · Oversight: Reviewed)

This project is rated with [AI Code Rating](https://aicoderating.com/spec/0.1/), spec version 0.1.

## How AI Was Used

We use AI to write tests and some features, alongside code we write
ourselves. Every AI change goes through the same pull request review
as code written by people.

The "How AI Was Used" section is where you explain your rating in plain English. It's also a good spot to mention anything the three characters don't cover, like if you use AI for planning or code review, or if one part of the project was built differently than the rest.

And since the file lives in the repository, every branch, tag, and release carries its own rating, so an older release keeps whatever rating it shipped with.

If you want to show off your rating, you can also add a badge to your README that links to the file.

[![ACR A2b](https://img.shields.io/badge/ACR-A2b-2140B5)](ACR.md)

How My Projects Rate

I've already added ACR.md files to a few of my own projects, and so far they fall into two camps, the ones I wrote entirely by hand, and the ones where AI did nearly all of the typing.

• DomainMOD is rated ACR B0a. I've been writing and maintaining it by hand since 2010, and none of its code was written by AI.

• HomelabAPI is also rated ACR B0a.

• Email Health Check is rated ACR B4c. AI wrote nearly all of the code, including the tests. I spot-check the changes, and whatever I don't read gets checked by running the app and its test suite. The code is also reviewed by a second AI, and the two go back and forth until it doesn't find any more issues.

• aicoderating.com itself is rated ACR B4c. AI writes nearly all of the code and drafts most of the text, and I come up with the ideas, make the calls on the levels, wording, and design, and direct every change. Same deal on the checking side, I spot-check the changes, and the validator has its own tests to make sure it's catching what it should. And just like Email Health Check, all of the code is reviewed by a second AI, going back and forth until it doesn't find any more issues.

That second AI review doesn't bump up the Oversight level though, since ACR only counts checks done by actual people.

Rating Your Own Project

If you want to rate one of your own projects, the website should have everything you need.

• The rating form on the home page walks you through each position and builds your ACR.md file for you.

• The rating examples show a bunch of common setups and the rating each one gets, along with the reasoning behind them.

• The validator checks your ACR.md file right in your browser and tells you if anything's wrong.

• The GitHub Action runs the same checks on every push and pull request, and it'll even warn you if the badge in your README doesn't match the rating in the file.

• The FAQ covers the trickier stuff, like what counts as code, what to do about autocomplete, and how to estimate your AI Share.

Can't people just give themselves a better rating than they deserve?

You're absolutely right! Ratings are self-reported, so there's nothing stopping someone from fudging theirs a bit. That said, a project's commit history, pull requests, and issues show how it really works, and a rating that doesn't line up with them is going to cost the project some trust. An honest ACR D4c tells people a lot more than a questionable ACR B4b.

It's also worth mentioning that the spec is still a draft (version 0.1), so anything in it could change before 1.0. There are a few open questions I haven't settled on yet, like whether there should be a way to show that AI was used for planning or review but didn't write any of the code, and whether different parts of a repository (like the docs, or one package in a monorepo) should be able to get their own ratings.

If you have any feedback or ideas, or you've rated a project and want it added to the list of rated projects on the site, feel free to open an issue on GitHub, I'd love to hear what you think!

Visit AI Code Rating