You Already Know What Your First AI Rule Should Be. You Just Have Not Written It Down Yet.

Every developer who works with AI regularly has a list of corrections they make.

Not a written list. A mental one. The things they fix after every session. The patterns the AI gets wrong consistently. The naming that never quite matches. The component that always ends up doing too much. The state that keeps ending up in the wrong place.

Those corrections are not random. They are consistent. And consistent corrections are rules that have not been written down yet.

You already know what your first rule should be. You have been communicating it to the AI through corrections for months. You just have not written it down where the AI can follow it before it makes the mistake.

Why the first rule is the hardest

Starting a rule system feels like a big decision.

Where do the rules live? How many do you need? What format should they be in? Do you need a whole system before you start? Do you need to cover every case before the rules are useful?

The answer to all of those questions is the same. You do not need to answer them before you write the first rule.

The first rule does not need to be part of a system. It does not need a format. It does not need to be comprehensive. It just needs to exist somewhere the AI can see it before the session starts.

One rule. The thing you correct most often. Written down. Given to the AI before the next session.

That is the entire starting point.

What the first rule usually is

The first rule is almost always the same category of thing across different developers.

It is the correction that happens in nearly every session. The one that takes two minutes to fix but has been taking two minutes every session for six months. The one that feels too obvious to write down because surely the AI should just know.

It does not just know. It cannot. It has no memory of the last correction. It has no definition of what the standard is. It generates based on what it receives and then you correct what it got wrong.

For most React developers the first rule falls into one of three categories. Component boundaries. State placement. Naming conventions. Not because those are the most important rules. Because those are the decisions the AI gets wrong most consistently when no constraints exist.

Here is what writing that first rule actually looks like:

The first rule for most React developers:
Every component has exactly one responsibility.
If it renders UI and manages state and handles data fetching,
it is three components pretending to be one.
Split before continuing.

One rule. Specific enough to follow. The AI stops making that particular decision on its own.

What happens after the first rule

The first rule does two things.

It reduces the correction it covers. That session, the component is already the right size, or the state is already in the right place, or the naming already follows the convention. The specific correction the rule addressed does not appear.

And it shows you that the system works. That writing a rule down and giving it to the AI actually changes the output. That the problem was never the AI. It was the missing constraint.

That realization is what leads to the second rule. And the third. Not because you planned a system. Because you experienced the result of one rule and wanted more of it.

The system grows from evidence, not from planning.

The rule you keep not writing

Most developers who work with AI regularly have a correction they make so often it has become automatic.

They do it without thinking. They barely notice anymore. It is just part of the workflow.

That correction is a rule. A rule the AI has never been given. A rule that has been communicated through corrections hundreds of times and has never transferred because corrections do not transfer between sessions.

Writing it down takes less time than making the correction one more time.

The prompt does not matter. The rules do.

You do not need a complete system to start. You do not need a format. You do not need to know where this is going.

You need one rule. The one you already know. The one you have been communicating through corrections for months.

Write it down. Give it to the AI before the next session. See what happens.

Everything after that is just doing it again.

Want help identifying what your first rule should be?

I built a free 24 point checklist that helps you find exactly that. The corrections you keep making that are waiting to become rules.

→ Get the React AI Clean Code Checklist — free

→ Avery Code React AI Engineering System