Feature Suggestion: User Controlled Project Rules & Canon Notes
User-Controlled Project Rules & Canon Notes
One-Sentence Summary
ChatGPT Projects would become more reliable for long-term work if users could define, review, lock, update, and source-check the project rules or canon that ChatGPT should follow across related threads.
Community Problem
Many ChatGPT users work on projects that depend on stable rules.
A developer may need ChatGPT to follow specific coding standards, dependency choices, architecture decisions, file naming rules, or deprecated-pattern warnings.
A writer may need ChatGPT to preserve character facts, timeline rules, worldbuilding canon, tone requirements, or continuity decisions.
A researcher may need ChatGPT to distinguish confirmed findings from hypotheses, discarded sources, and open questions.
A business team may need ChatGPT to follow brand voice, policy rules, approval standards, or formatting requirements.
Current project instructions are useful, but long-term projects often need a more structured source of truth than a single instruction field. As a project grows, users may need to manage dozens of active rules, outdated rules, exceptions, and confirmed decisions.
Without a visible rules/canon layer, users often have to repeat themselves:
Remember, we are not using Redux. Remember, that old API route is deprecated. Remember, this character does not know the secret yet. Remember, brainstorming notes are not approved canon. Remember, do not rename existing files without approval.
This creates correction fatigue and makes users feel like they must constantly police the project.
The problem is not only that ChatGPT needs instructions. The deeper need is for users to clearly mark:
This is the current rule of the project. Use it until I change it.
Suggested Improvement
Introduce a dedicated Project Rules & Canon Notes area inside ChatGPT Projects.
This feature would let users define and manage project-wide rules as individual, visible entries rather than one large block of text.
Each rule or canon note could include:
Title
Category
Status
Source
Priority
Version history
Created date
Last updated date
User confirmation status
Conflict behavior
Optional exceptions
Rules could have statuses such as:
Suggested
Draft
Active
Locked
Deprecated
Conflicting
Needs Review
Temporary Exception
ChatGPT could suggest new project rules based on repeated user corrections, but the user would approve, edit, or reject them before they become active project truth.
The key principle should be:
ChatGPT may suggest rules, but the user decides what becomes canon.
Example Use Case
A developer creates a ChatGPT Project called Mobile Game App.
They open the Project Rules area and add:
Rule 1:
All UI components must use Tailwind utility classes. Do not use raw CSS unless explicitly approved.
Rule 2:
State management must use Zustand. Do not introduce Redux.
Rule 3:
Deployment target remains iOS 15+ unless this rule is updated.
Rule 4:
Do not replace existing architecture patterns without explaining migration risk first.
Later, in a separate thread called Shopping Cart Screen , the user asks:
Build a state machine for the checkout button.
ChatGPT follows the active project rules and uses Zustand without the user needing to repeat the instruction.
If the user later asks:
Can you redo this with Redux?
ChatGPT does not silently ignore the project rule. It shows a conflict:
This may conflict with an active project rule:
“State management must use Zustand. Do not introduce Redux.”
How would you like to proceed?
Follow the project rule
Allow Redux once for comparison
Update the project rule
Ignore this warning
This keeps the user in control while preventing accidental drift.
Creative Use Case
A writer creates a ChatGPT Project for a novel.
They add canon notes:
Canon Rule 1:
The protagonist is colorblind.
Canon Rule 2:
The city has no public magic system.
Canon Rule 3:
The villain’s identity is not revealed until Chapter 8.
Canon Rule 4:
Chapter drafts must preserve the established timeline unless the user asks for an alternate version.
Later, while drafting Chapter 5, ChatGPT writes a paragraph where the protagonist recognizes the villain too early.
The system can flag:
Canon conflict:
This paragraph reveals information the protagonist should not know until Chapter 8.
Would you like me to rewrite the scene while preserving the canon note?
This protects continuity without blocking creativity.
Why This Helps Users
Developers
Developers could preserve architecture rules, package choices, coding standards, version constraints, deprecated APIs, and “do not rename without approval” instructions across many threads.
Writers and Creators
Writers could maintain canon, timelines, character constraints, tone rules, worldbuilding decisions, and style guides.
Researchers
Researchers could distinguish confirmed findings from theories, outdated sources, open questions, and discarded conclusions.
Students and Educators
Students could preserve rubric requirements, citation rules, assignment instructions, and teacher feedback.
Businesses and Teams
Teams could manage brand voice, documentation standards, policy rules, approval requirements, and shared workspace expectations.
Accessibility and Cognitive Load
Users managing complex or interrupted work would not have to constantly remember and restate every important rule manually.
This would reduce correction loops and make long-term ChatGPT Projects more dependable.
Privacy, Safety, and User Control
Project Rules & Canon Notes should be built around transparency and user ownership.
Recommended guardrails:
User-approved rules should be clearly separate from ChatGPT-suggested rules.
Locked rules should not override platform safety policies.
Users should be able to edit, delete, deprecate, or restore rules.
Rules should show where they came from when possible.
ChatGPT should not silently turn every repeated user statement into a locked rule.
Suggested rules should require user approval before becoming active.
Shared projects should show who created or changed a rule.
Temporary chats should not automatically update durable project rules.
Users should be able to create one-time exceptions.
Rule conflicts should be surfaced clearly instead of silently resolved.
Users should be able to disable strict rule checking during brainstorming.
The system should support structure without making the user feel trapped by old decisions.
Small MVP Version
A useful first version could include:
A Project Rules tab or panel
Individual rule entries instead of one large instruction block
Active / Deprecated / Locked status labels
Source links to chats or files where rules were created
User approval before suggested rules become active
Warning when a prompt conflicts with an active locked rule
Simple version history for edited rules
A one-time exception option
This MVP would immediately improve reliability for long-term projects without requiring a full memory redesign.
Relationship to Broader Workspace Improvements
This proposal is designed to stand on its own. However, it also fits naturally within a broader set of improvements around project memory, continuity, navigation, user-controlled rules and canon, constructive feedback, drift prevention, and long-term workspace organization. Each feature would provide value independently, while together they would make ChatGPT a more trustworthy long-term workspace.
Closing Line
User-Controlled Project Rules & Canon Notes is not only an instruction feature.
It is a project truth feature.
For ChatGPT to support serious long-term work, users need a clear way to say:
This is the current rule of the project. Use it until I change it.
Discussion in the ATmosphere