Every experienced React developer has a standard.
You know what a good component looks like. You know where state belongs. You know how to name things so they make sense six months later. You know when a file is getting too large and needs to be split.
You have been building this knowledge for years. It lives in every decision you make, every refactor you initiate, every pull request comment you write.
And GitHub Copilot has no idea any of it exists.
The standard that never left your head
Most developers never write their standards down. There is no need to when you are the one applying them. The knowledge is there. The decisions get made. The code stays clean.
Then you start using GitHub Copilot to move faster.
And Copilot generates code that works but misses everything you know. The component is too large. The state is in the wrong place. The naming does not follow the pattern you have used for years. The structure makes sense in isolation but does not fit anything around it.
You correct it. You move on. The next session starts exactly the same way.
The standard is still in your head. Copilot still cannot reach it.
Why unwritten rules do not transfer
When you work alone without AI, unwritten rules work fine. You apply them unconsciously. Every decision reflects them. The codebase stays consistent because you are the only one making decisions.
The moment GitHub Copilot starts making decisions, that changes.
Copilot generates based on what it can see and what constraints exist. It cannot infer your unwritten standard from the codebase because your codebase is a result of your standard, not a definition of it. The difference is subtle but critical.
A codebase built by someone who knows the rules looks consistent. But consistency is not the same as documentation. Copilot cannot reverse-engineer your standard from the output it produced. It needs the input.
What happens when you finally write them down
Writing down a standard that lives in your head is a strange experience.
It feels obvious. Of course components should have one responsibility. Of course state belongs in hooks. Of course imports should go through the feature index file. You have known this for years.
But obvious to you is invisible to Copilot. The moment you write it down and give it to the AI, the output changes. Not because the rules are new. Because they finally exist somewhere the AI can follow them.
Here is what that looks like in practice:
Rules I had in my head for years:
1. Components are presentational or container. Never both.
2. Custom hooks own all state logic for a feature. No exceptions.
3. File names match the component or hook they export. Always.
Three rules. Years of implicit knowledge. One session to write them down. Every Copilot session after that follows them automatically.
The team version of this problem
For solo developers the unwritten standard creates inconsistency across sessions.
For teams it creates something worse. Every developer has their own unwritten standard. Five developers. Five invisible rule sets. No shared definition of what the codebase should look like.
GitHub Copilot picks up signals from whichever developer is running the session. The output reflects their implicit standard, not the team's. And the codebase accumulates five different invisible standards at once.
Writing the rules down does not just help the AI. It forces the conversation about what the shared standard actually is.
The prompt does not matter. The rules do.
Your React standard is real. It is valuable. It is the result of years of experience.
It is also completely inaccessible to GitHub Copilot until you write it down.
Write it down. Give it to the AI. And stop watching Copilot ignore a standard it never had a chance to follow.
Want to find which of your unwritten rules are missing from your React project?
I built a free 24 point checklist that helps you find exactly that. The gaps between what you know and what your AI has been given to follow.
Top comments (1)
Spent years building up instincts for what good React code looks like. Never wrote any of it down because I never had to. Then Copilot started making decisions and I realized my entire standard was invisible to the one tool that needed it most. Anyone else had that realization?